Category Archives: C++

VS 2015 – fix toolbox with COM components.

24/09/2015 by admin · Leave a comment

Today I will show you how to add COM components to your Visual Studio 2015 toolbox.
In this example I add the Windows Media Player COM component.
To do this you need to use this Right Click – mouse within the Toolbox, and then select Choose Items.

See image:
VS_2015_toolbox_com_001
After that will see this window and just click on COM Components tab.
VS_2015_toolbox_com_002
Use your mouse to select Windows Media Player.
If you want to use another COM component or your DLL file then you need to use Browse… button to add it.
This will should be in the Windows\System32 folder…
Now you can see your COM component into Toolbox:
VS_2015_toolbox_com_003

Posted in All, C#, C++, Programming, Windows 10, Windows 8. Tagged with , , , , , , .

Export your project from Netbeans like RPM package.

03/06/2013 by admin · Leave a comment

I told you in this tutorial about how to make RPM package.

Also I told you how to use Netbeans IDE.

Today I will show how to make this settings.

First you will need make the application working well.

Then you need to go on to project and press click right with your mouse.

Set your package like in the next image:

cp006

Now you can build your RPM package for your distro , see the next image:

cp007

Posted in All, C++, Linux, Programming. Tagged with , , .

Create HTML5 template with C++ .

20/05/2013 by admin · Leave a comment

It’s a simple console C++ program that makes default html5 page with one table.

You can change the source code to create more template for your source code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<XMP>
/*
* File:   main.cpp
* Author: free-tutorials
*
* Created on May 20, 2013, 6:01 PM
*/
 
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <fstream>
using namespace std;
 
int main(){
 
srand(time(NULL));
ofstream page("default-html5.html");
int rows, cols; int i,j;
int number=0;
 
cout<<"Input the number of rows:"<<endl; cin>>rows;
cout<<endl<<"Input the number of cols :"<<endl; cin>>cols;
page << " <!DOCTYPE HTML><html><head><title>My Page</title></head><body>";
page << " <html><html><head><title>Random Color Table</title></head><body><table border='1' align='center'>";
for(i=0; i<rows; i++){
        page<<"<tr>";
for(j=0; j<cols; j++){
        page<<"<td>"<<number<<"</td>";
cout<<"Cell number"<<number<<endl;
number++;
}
}
 
page<<"</table></body></html>";
 
return 0;}</XMP>

Posted in All, C++, HTML 5, Programming. Tagged with , , , .

Working with GLFW library under Fedora.

17/05/2013 by admin · Leave a comment

Today I will try to use GLFW library.

GLFW is a C library that lets you using an OpenGL context and window, display modes and inputs like keyboard, mouse, joystick and time.

GLFW supports Windows, Mac OS X and Unix, Linux and FreeBSD and any operating systems with the X Window System.

Also you can read more about this library here.

First install the library using root account.

1
<XMP># yum install libglfw-devel.i386</XMP>

Now let’s see the source code.

First I includes all librarys I need.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<XMP>/*
* File:   main.cpp
* Author: free-tutorials.org
*
* Created on May 15, 2013, 2:54 PM
*/
 
#include <cstdlib>
// my c++ include headers
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include <GL/glfw.h>
using namespace std;</XMP>

In the main function I start to see if the library is working.

1
2
3
4
5
6
<XMP>int main() {
if( !glfwInit() )
{
    fprintf( stderr, "Failed to initialize GLFW Init \n" );
    return -1;
}</XMP>

The next step is to set some settings, see:

1
2
<XMP>// 4x antialiasing because I use NVIDIA FX5500
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); </XMP>

… and also testing the desktop settings.

1
2
3
<XMP>// get infos about desktop
GLFWvidmode desktop;
glfwGetDesktopMode( &desktop );</XMP>

The settings it’s show on console with cout function.

1
2
3
4
5
6
<XMP>// show infos about your desktop
cout << "Width : " << desktop.Width << "\n";
cout << "Height : " << desktop.Height << "\n";
cout << "RedBits : " << desktop.RedBits << "\n";
cout << "GreenBits : " << desktop.GreenBits << "\n";
cout << "BlueBits : " << desktop.BlueBits << "\n";</XMP>

Now I make the window context using fullscreen option.

1
2
3
4
5
6
7
8
9
10
11
12
13
<XMP>if ( !glfwOpenWindow(
    desktop.Width,
    desktop.Height,
    desktop.RedBits,
    desktop.GreenBits,
    desktop.BlueBits,
    32,          // alpha bits
    32,         // depth bits
    0,          // stencil bits
    GLFW_FULLSCREEN
) ) {
    // error if failed
}</XMP>

I set the title of the window.

1
<XMP>glfwSetWindowTitle( "opengl-shader test" );</XMP>

I enable the keys.

1
<XMP>glfwEnable( GLFW_STICKY_KEYS );</XMP>

1
2
3
4
5
6
7
<XMP>do{
    // draw something sexy
    // Swap buffers need it
    glfwSwapBuffers();
}</XMP>

The next source code it’s close the window.

1
2
3
4
5
<XMP>// When ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
 
}</XMP>

Testing with time command to see how fast working.

1
2
3
4
5
6
7
8
9
10
<XMP>$ time ./opengl-shader
Width : 1280
Height : 1024
RedBits : 8
GreenBits : 8
BlueBits : 8
 
real 0m2.358s
user 0m0.341s
sys 0m1.240s</XMP>

The netbeans IDE make the package in this path.

1
<XMP>$cd /opengl-shader/dist/Debug/GNU-Linux-x86/package</XMP>

I make RPM package for Fedora distro.

1
2
3
<XMP># rpm -ivh opengl-shader-1.0-1.i386.rpm
Preparing...                ########################################### [100%]
   1:opengl-shader          ########################################### [100%]</XMP>

I test my example and working well.

Posted in 3D, All, C++, Linux, OpenGL, Programming. Tagged with , , , , , .

Writing a basic game with C++ and OpenGL libs – part 1 .

05/07/2012 by admin · Leave a comment

This is a first part tutorial about linux game using C++ and OpenGL libs.

Writing a C++ game can be difficult.

You will need to focus on program structure and then to know how to create the necessary classes.

Let’s see the files I used:

1
2
3
4
5
display.cpp
display.hpp
game.cpp
game.hpp
main.cpp

The main.cpp file is the main program.

This file will make the window program and will deal with the user.

Also this file use OpenGL libs.

Let’s see the source code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include "display.hpp"
#include "game.hpp"
#include &lt;GL/glut.h&gt;
 
Game game;
 
void display()
{
  glClear(GL_COLOR_BUFFER_BIT);
  Display d;
  game.draw(d);
  glutSwapBuffers();
}
 
int main(int argc, char **argv)
{
  glutInit(&amp;argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowSize(640 , 480);
  glutInitWindowPosition(100, 780);
  glutCreateWindow("simplegame");
  glClearColor(0, 0, 0, 1.0);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0, 640 , 480, 0,-1.0, 1.0);
  glutDisplayFunc(display);
  glutMainLoop();
}

The next two files : display.cpp and display.hpp is used to display the game objects.

I use just one class : Display.

Let’s see the header file display.hpp

1
2
3
4
5
6
7
8
#pragma once
 
class Display
{
public:
  void bar(int x1, int y1, int x2, int y2);
 
};

… and display.cpp.

1
2
3
4
5
6
7
8
9
10
11
12
13
#include "display.hpp"
#include &lt;GL/gl.h&gt;
 
void Display::bar(int x1, int y1, int x2, int y2)
{
  glColor3f(1, 1, 1);
  glBegin(GL_QUADS);
  glVertex2f(x1, y1);
  glVertex2f(x2, y1);
  glVertex2f(x2, y2);
  glVertex2f(x1, y2);
  glEnd();
}

You can see the OpenGL source code to make a rectangle.

The next files game.cpp and game.hpp is used to make all game engine working.

The header file game.hpp is:

1
2
3
4
5
6
7
8
9
#pragma once
 
class Display;
 
class Game
{
public:
  void draw(Display &amp;) const;
};

… and also game.cpp.

1
2
3
4
5
6
7
8
#include "game.hpp"
#include "display.hpp"
 
void Game::draw(Display &amp;d) const
{
//
d.bar(100,10,20,20);
}

Let’s make the Makefile.

This can done well if you know how working g++ compiler.

1
2
3
4
5
6
7
8
9
10
CPPFLAGS=-Wall -g
OBJECTS=main.o display.o  game.o
TARGET=simplegame
%.o: %.cpp
        g++ -c $(CPPFLAGS) -o $@ $&lt;
$(TARGET): $(OBJECTS)
        g++ $(OBJECTS) -o $(TARGET) -g -lglut
main.o: main.cpp display.hpp
display.o: display.cpp display.hpp
game.o: game.cpp game.hpp display.hpp

Use the command to make the binary file:

1
2
3
$ make
g++ -c -Wall -g -o main.o main.cpp
g++ main.o display.o  game.o -o simplegame -g -lglut

The resul is this:

simplegame tutorial c++

Posted in 3D, C++, Game engine, OpenGL, Programming. Tagged with , , , , .
12next →