glTest2: Formato RGBA para manejar colores

[85]

En base a un código fuente de ejemplo de un programa simple que usa Opengl32, decidí hacer unas pruebas sobre tal código. Unas pruebas con referencia al manejamiento de los colores para Opengl32.
Lo primero que hice fue mirar un manual, y luego revisar el código fuente de OGC que incluye un plugin para administrar los colores.
Si les interesa algo de esto pueden leer este pequeño manual:
http://www.mediafire.com/view/?n4n9zyzo0uda7ci

El programa es el mismo que el de mi anterior tema sobre Opengl32:
http://foro.elhacker.net/programacion_cc/gltest_1_interceptar_opengl32_con_gpa-t384878.0.html

Pero lo modifiqué porque mi intención era manejar los colores y mostrarlos por pantalla a modo de líneas de colores y color de fondo. No me importaba dibujar nada en la pantalla (aparte que tengo la mínima idea de Opengl32 XD). Pero de nuevo, lo que me interesaba era como se manejaban los colores.

Lo que es importante destacar, es que un color se representa con 32 bits, de los cuales 24 bits son para rojo, verde y azul, y los 8 restantes son para
la transparencia. Lean el manual cualquier koza.

Ahora voy a poner el código fuente de lo que hice, se compone de dos partes. La primera sería el programa Opengl32 modificado por mi para que muestre 15 colores de fondo de ventana y unas líneas, el tema es que se pueden cambiar los colores con el teclado (Flecha arriba y abajo).
La segunda parte viene a ser un plugin que hice en base al plugin existente en OGC llamado 'Color manager'. Se trata de 4 funciones específicas que manejan la conversión del formato RGBA. Hablando de esto, veamos algo..

Por ejemplo, el color blanco en formato entero (32 bits) es:

Código [Seleccionar] Expandir

255, 255, 255, 255

los primeros 8 son rojo, luego verde, luego azul y luego transparencia (alpha).

en modo de punto flotante, lo mismo

Código [Seleccionar] Expandir

255.0, 255.0, 255.0, 255.0

lo que pasa que las funciones de Opengl32 reciben los parámetros como de punto flotante, por la precisión del color. Sin mencionar que se toma como que un color va de 0.0 a 1.0.

no conozco todas las funciones Opengl32, sólo estuve usando algunas.

La otra forma de representar el RGBA es en hexadecimal, para el blanco
viene a ser:

Código [Seleccionar] Expandir

0xFFFFFFFF

es lo mismo que decir 255,255,255,255 pero todo junto en una variable.
por ejemplo:

Código [Seleccionar] Expandir

DWORD colorBlanco = 0xFFFFFFFF;

En cambio en modo entero se usa para poder manejar los colores desde una panel por ejemplo, o agregarlos desde un archivo de configuración.

Bueno, el tema es que las funciones que hice hacen todo este intercambio de los formatos.

Aunque la función 4 no pasa de formato a formato sino que establece un valor para la transparencia.

En lo que respecta al código, en mis 4 funciones fuí muy explícito con las variables locales, ya que en cada una fuí específico de dejar en claro cuando se trata del color rojo, cuando del verde y cuando del azul, y lo mismo para la transparencia. Es para que quede claro y no se pase por alto.

main.cpp

Código (cpp) [Seleccionar] Expandir



//
// 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;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




rgba_funcs.cpp

Código (cpp) [Seleccionar] Expandir



//
// 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;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



Cuando abren el programa aparecen dos ventanas, la de la consola
va a mostrar el resultado de las pruebas de conversión.
La otra es la ventana de la aplicación Opengl32, muestra un color
de fondo que se puede cambiar con las flechas arriba abajo


Proyecto en MSVCPP6
http://www.mediafire.com/?49xkm41pswptcby

8ye8ye

[macross255]

gracias cs_85 me viene de 10 el manual y la demo, estoy aprendiendo del tema así q se valoran estos aportes