How to Handle RGBA Color Format in OpenGL

Discussion in 'Game Programming' started by david_BS, Mar 19, 2013.

  1. david_BS

    david_BS New Member

    Joined:
    Apr 5, 2012
    Messages:
    17
    Likes Received:
    3
    Trophy Points:
    3
    I did a sample program that shows how you can handle colors in RGBA format with the purpose of using them in an Opengl32 program, by the way, the sample program is itself the Opengl32 program and it'll show the results of managing different colors.

    First, you would like to read this manual - http://mediafire.com/view/?n4n9zyzo0uda7ci

    It's brief, then I say some words about how a color is represented in programming.

    A color is represented as a 32 bit value, which its 24 first bits are for colors red, green and blue, and the remaining 8 are for the transparency (known as 'alpha'). For example, we take color 'White' in integer mode it is:
    Code:
     255, 255, 255, 255
    remember it means, red , green, blue, alpha

    In floating point it is the same:
    Code:
    255.0, 255.0, 255.0, 255.0
    But, Opengl32 functions (at least the ones I tested), have float type arguments, and a color could be from 0.0 to 1.0 so all this involves the need of a conversion. But still is needed to mention another mode of representation, the hexadecimal:

    Code:
    DWORD cWhite = 0xFFFFFFFF;
    This means, you have one color in one variable (32 bits variable). As you know the byte FF is 255 in integer mode. so it's the same, but in one variable.

    Well, I am not the expert, so I just tell you that I wrote 4 functions to handle the conversion from one mode to another. I mean by 'mode' either the color is represented in 4 integers , 4 floats, or just 1 variable that has a hexadecimal value.

    What I know, is that the integer mode is used to load colors from a configuration file or maybe to load them in memory by user input. Floating point mode is for the Opengl32 arguments in some functions. They are just a way to handle each of the 4 components individually.

    I used a table with 15 colors so when you run the program you can check them.

    Now let's see the code:

    main.cpp

    Code:
    
    //
    // By 85
    // Credits: OGC, opengl.org
    // boyscout_etk@hotmail.com
    // etalking.com.ar
    // 2013
    //
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    #pragma comment (lib, "opengl32.lib")
    #pragma comment (lib, "GLUT32/glut32.lib")
    #include<windows.h>
    #include<stdio.h>
    
    #include "GLUT32/glut.h"
    #include <gl\gl.h>
    #include <gl\glu.h>
    
    #include "rgba_funcs.h"
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    static float scale = 1.4;
    static float transx, transy, rotx, roty;
    
    int CURCOLOR =0;//Color actual (Se cambia con el teclado)
    int TablaRGBA[15][4] = {//Tabla con 15 colores diferentes en RGBA
    
    	{80,150, 30, 110},
    	{255, 40, 40,200},
    	{40, 80,255,200},
    	{250,250, 22, 254},
    	{0,  0,  0, 128},
    	{80,150, 30, 110},
    	{255,255,255,255},
    	{15, 50,255, 50},//Consola del Hurricane XD
    	{220,220,220,200},
    	{0,128,0,200},
    	{255,255,255,255},
    	{220,220,220,200},
    	{100,255,160,200},
    	{100,255,160,200},
    	{51,51,204,180},//Menu del Hurricane XD
    };
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void bfunc(void)
    {
    	static int state;
    	if(state ^= 1) 
    	{
    		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    		glEnable(GL_BLEND);
    	}
    	else 
    	{
    		glDisable(GL_BLEND);
    	}
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void init(char* filename)
    {
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void TestPluginRGBAfuncs(){// Probando el plugin
    
    	int v1[4] = {51,51,204,180};
    	float v2[4] = {0,0,0,0};
    	rgbaInt_a_rgbaFloat(v1,v2);
    	printf("%f %f %f %f\n", v2[0], v2[1], v2[2], v2[3]);
    	system("pause");
    
    	//=================================
    
    	int vec1[4] = {51,51,204,180};
    	DWORD color1 = 0xFFFFFFFF;
    	color1=rgbaInt_a_rgbaHex(vec1);
    	printf("0x%X\n", color1);
    	system("pause");
    
    	//=================================
    
    	int vecca[4] = {51,51,204,180};
    	int* vec2 = (int*)&vecca[0];
    	DWORD color2 = 0x336699FF;
    	vec2 = rgbaHex_a_rgbaInt(color2);
    	printf("%d %d %d %d\n", vec2[0], vec2[1], vec2[2], vec2[3]);
    	system("pause");
    
    	//=================================
    
    	DWORD color3 = 0xFFFFFF33;
    	color3 = ComplementoAlpha(color3,85);
    	printf("0x%X\n", color3);
    	system("pause");
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void display(void)
    {
    	glClear(GL_COLOR_BUFFER_BIT);
    	glTranslatef(transx, transy, 0.f);
    	glRotatef(rotx, 0., 1., 0.);
    	glRotatef(roty, 1., 0., 0.);
    	glScalef(scale, scale, 0.);
    	glLineWidth(5.5);
    	////////////////////////////////////////////////////
    	////////////////////////////////////////////////////
    	float r = float(TablaRGBA[CURCOLOR][0])/255.0;
    	float g = float(TablaRGBA[CURCOLOR][1])/255.0;
    	float b = float(TablaRGBA[CURCOLOR][2])/255.0;
    	float a = float(TablaRGBA[CURCOLOR][3])/255.0;
    	glClearColor(r,g,b,a);
    	glColor3f(TablaRGBA[CURCOLOR][0],TablaRGBA[CURCOLOR][1],TablaRGBA[CURCOLOR][2]);
    	glBegin(GL_LINES);
    	glVertex3f(0.0, 0.0, 0.0);
    	glVertex3f(15, 0, 0);
    	glEnd();
    	glutSwapBuffers();
    	//glFlush();
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void reshape(int w, int h)
    {
    	glViewport(-50, -50, w+120, h+120);
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void key(unsigned char key, int x, int y)
    {
    	if (key=='\033') exit(0);
    
    	bfunc();
    	glutPostRedisplay();
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void special(int key, int x, int y)
    {
      switch (key) {
      case GLUT_KEY_UP:
    	  {
    		if(CURCOLOR==14) CURCOLOR=0;
    		else CURCOLOR++;
    	  }
        break;
      case GLUT_KEY_DOWN:
    	  {
    		if(CURCOLOR==0) CURCOLOR=14;
    		else CURCOLOR--;
    	  }
        break;
      default:
        return;
      }
      glutPostRedisplay();
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void tick(void)
    {
    	glutPostRedisplay();
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    int main(int argc, char** argv){
    
    	SetConsoleTitle("glTest2");
    	TestPluginRGBAfuncs();
    
    	////////////////////////////////////////////
    
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    	glutInitWindowSize(450, 450);
    	glutCreateWindow("SHOW COLORES");
    //	glutFullScreen();
    	init(argv[1]);
    	glutDisplayFunc(display);
    	glutKeyboardFunc(key);
    	glutSpecialFunc(special);
    	glutReshapeFunc(reshape);
    	glutIdleFunc(tick);
    //	SetActiveWindow(FindWindow(0,"SHOW COLORES"));
    	SetForegroundWindow(FindWindow(0,"SHOW COLORES"));//Para que quede en primer plano ;D
    	glutMainLoop();
    	system("pause");
    	return 0;
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    These are the 4 functions. Note that the 4th function is actually not making a conversion, instead it sets the transparency atribute to a color.

    rgba_funcs.cpp

    Code:
    //
    // By 85
    // Credits: OGC, opengl.org
    // boyscout_etk@hotmail.com
    // etalking.com.ar
    // 2013
    //
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    #pragma warning(disable: 4244)
    typedef unsigned long DWORD;
    int idef[4]={255,255,255,255};
    float fdef[4]={255.0,255.0,255.0,255.0};
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    //Para Opengl32 (Valores de 0.0 a 1.0)
    void rgbaInt_a_rgbaFloat(int iVecRGBA[4]=reinterpret_cast<int*>(idef),
    						 float fVecRGBA[4]=reinterpret_cast<float*>(fdef)){
    
    	float red = float(iVecRGBA[0])/255.0;
    	float green = float(iVecRGBA[1])/255.0;
    	float blue = float(iVecRGBA[2])/255.0;
    	float alpha = float(iVecRGBA[3])/255.0;
    	fVecRGBA[0]=red;
    	fVecRGBA[1]=green;
    	fVecRGBA[2]=blue;
    	fVecRGBA[3]=alpha;
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    DWORD rgbaInt_a_rgbaHex(int vecRGBA[4]=reinterpret_cast<int*>(idef)){
    
    	int red=vecRGBA[0];
    	int green=vecRGBA[1];
    	int blue=vecRGBA[2];
    	int alpha=vecRGBA[3];
    	return ((red<<24) + (green<<16) + (blue<<8) + alpha);
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    int* rgbaHex_a_rgbaInt(DWORD color= 0xFFFFFFFF){
    
    	int red   = (color>>24);
    	int green = (color>>16)&0xFF;
    	int blue  = (color>>8)&0xFF;
    	int alpha = (color)&0xFF;
    	static int vecRGBA[4];
    	vecRGBA[0]=red;
    	vecRGBA[1]=green;
    	vecRGBA[2]=blue;
    	vecRGBA[3]=alpha;
    	return vecRGBA;
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    DWORD ComplementoAlpha(DWORD color= 0xFFFFFFFF, int alpha=255){
    
    	color &= 0xFFFFFF00;//Quita					
    	color += alpha;//Pone
    	return color;
    }
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    
    The program opens 2 windows, the console window will only show you the result of some tests on the 4 functions before mentioned. ignore it if you want.

    The other window is the Opengl32 application window, which will show you a background color , a background color which you can change by pressing arrow keys UP and DOWN.

    [​IMG]

    See attachment for full project.
     

    Attached Files:

    • RGBA.rar
      File size:
      329.1 KB
      Views:
      867
    Last edited by a moderator: Jan 21, 2017
    shabbir likes this.

Share This Page

  1. This site uses cookies to help personalise content, tailor your experience and to keep you logged in if you register.
    By continuing to use this site, you are consenting to our use of cookies.
    Dismiss Notice