void cambiaColorPin(int i)
{
int x = 0.0;
int y = 0.0;
glPushMatrix();
glEnable(GL_BLEND); // Activamos la transparencia
glBlendFunc(GL_SRC_ALPHA, GL_SRC_COLOR); //funcion de blending //GL_ONE_MINUS_SRC_ALPHA GL_SRC_COLOR
glEnable(GL_TEXTURE_2D);
//glBindTexture(GL_TEXTURE_2D, texName[12]); //3
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glBindTexture(GL_TEXTURE_2D, texName[3]); //3
glPushMatrix();
// switch (currentIndex) {
// case 1: //America
// //posiciones de los pines
// x = continente -> _america[i].posX;
// cout << "La x es: "<< continente -> _america[i].posX << "\n";
// y = continente -> _america[i].posY;
// cout << "La y es: "<< continente -> _america[i].posY << "\n";
// break;
// case 2: //Asia
// //posiciones de los pines
// posX = continente -> _asia[i].posX;
// posY = continente -> _asia[i].posY;
// break;
// case 3: //Europa
// posX = continente -> _europa[i].posX;
// posY = continente -> _europa[i].posY;
// break;
// case 0: //Africa
// posX = continente -> _africa[i].posX;
// posY = continente -> _africa[i].posY;
// break;
// default:
// break;
// }
cout << "La x es: "<< continente -> _america[5].posX << "\n";
cout << "La y es: "<< continente -> _america[5].posY << "\n";
//glTranslatef(continente -> _america[5].posX, continente -> _america[5].posY, 0);
//glColor3f(0.0f, 0.0f, 0.0f);
glColor4f(1.0, 1.0, 1.0, 0.1); //color y alpha del cubo
glutSolidSphere(.1, 20, 20);
glPopMatrix();
glPopMatrix();
glDisable(GL_BLEND); //para desactivarlo.
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glutPostRedisplay();
}
int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
if (!LoadGLTextures()) // If Loading The Textures Failed
{
return FALSE; // Return False
}
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.2f, 0.5f, 1.0f, 1.0f); // Background
glClearDepth(1.0f); // Depth Buffer Setup
glClearStencil(0); // Clear The Stencil Buffer To 0
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
glEnable(GL_TEXTURE_2D); // Enable 2D Texture Mapping
glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmb); // Set The Ambient Lighting For Light0
glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDif); // Set The Diffuse Lighting For Light0
glLightfv(GL_LIGHT0, GL_POSITION, LightPos); // Set The Position For Light0
glEnable(GL_LIGHT0); // Enable Light 0
glEnable(GL_LIGHTING); // Enable Lighting
q = gluNewQuadric(); // Create A New Quadratic
gluQuadricNormals(q, GL_SMOOTH); // Generate Smooth Normals For The Quad
gluQuadricTexture(q, GL_TRUE); // Enable Texture Coords For The Quad
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping
return TRUE; // Initialization Went OK
}
/*-- -------------------------------------------------------------------*/
void Texture::aplica( void )
{
glPushAttrib( GL_TEXTURE_BIT ) ;
if( material )
material->aplica( ) ;
if( !criada )
{
cria() ;
criada = true ;
}
glEnable( GL_TEXTURE_2D ) ;
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (float)modo ) ;
glBindTexture( GL_TEXTURE_2D, id ) ;
if( coord_automatica )
{
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, modo_geracao_s ) ;
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, modo_geracao_t ) ;
glTexGenfv( GL_S, plano_s, vetor_s ) ;
glTexGenfv( GL_T, plano_t, vetor_t ) ;
glEnable( GL_TEXTURE_GEN_S );
glEnable( GL_TEXTURE_GEN_T );
}
else
{
glEnableClientState( GL_TEXTURE_COORD_ARRAY ) ;
glTexCoordPointer( 2, GL_FLOAT, 2*sizeof(GLfloat), coordenadas ) ;
}
}
int main (int narg, char ** args)
{
unsigned char total_texture[4 * 256 * 256];
unsigned char alpha_texture[256 * 256];
unsigned char caustic_texture[3 * 256 * 256];
unsigned int i;
InitNoise ();
/* Creation of the window */
glutInit (&narg, args);
glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize (500, 500);
glutCreateWindow ("Water");
/* OpenGL settings */
glClearColor (0, 0, 0, 0);
glEnable (GL_DEPTH_TEST);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
/* Texture loading */
glGenTextures (1, &texture);
if (load_texture ("alpha.jpg", alpha_texture, GL_ALPHA, 256) != 0 ||
load_texture ("reflection.jpg", caustic_texture, GL_RGB, 256) != 0)
return 1;
for (i = 0; i < 256 * 256; i++)
{
total_texture[4 * i] = caustic_texture[3 * i];
total_texture[4 * i + 1] = caustic_texture[3 * i + 1];
total_texture[4 * i + 2] = caustic_texture[3 * i + 2];
total_texture[4 * i + 3] = alpha_texture[i];
}
glBindTexture (GL_TEXTURE_2D, texture);
gluBuild2DMipmaps (GL_TEXTURE_2D, GL_RGBA, 256, 256, GL_RGBA,
GL_UNSIGNED_BYTE, total_texture);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glEnable (GL_TEXTURE_GEN_S);
glEnable (GL_TEXTURE_GEN_T);
glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
/* Declaration of the callbacks */
glutDisplayFunc (&DisplayFunc);
glutReshapeFunc (&ReshapeFunc);
glutKeyboardFunc (&KeyboardFunc);
glutMouseFunc (&MouseFunc);
glutMotionFunc (&MotionFunc);
/* Loop */
glutMainLoop ();
/* Never reached */
return 0;
}
void TextureMain::loadLightMapTexture(Model_IMG* model, string file) {
GLfloat eyePlaneS[] = {1.0f, 0.0f, 0.0f, 0.0f};
GLfloat eyePlaneT[] = {0.0f, 1.0f, 0.0f, 0.0f};
GLfloat eyePlaneR[] = {0.0f, 0.0f, 1.0f, 0.0f};
GLfloat eyePlaneQ[] = {0.0f, 0.0f, 0.0f, 1.0f};
GLfloat borderColor[] = {1.f, 1.f, 1.f, 1.0f};
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGenfv(GL_S,GL_EYE_PLANE,eyePlaneS);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGenfv(GL_T,GL_EYE_PLANE,eyePlaneT);
glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGenfv(GL_R,GL_EYE_PLANE,eyePlaneR);
glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGenfv(GL_Q,GL_EYE_PLANE,eyePlaneQ);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_GEN_Q);
model->Load(file);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0x812D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 0x812D);
glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_BORDER_COLOR,borderColor);
gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGB,model->Width,model->Height,GL_RGB,GL_UNSIGNED_BYTE,model->Pixels);
}
void Balloon::initBalloon(float terrainHeight)
{
position = VECTOR3D(0.0f, terrainHeight+10.0, 0.0f);
GLfloat planes[] = {0.0, 0.0, 0.3, 0.0};
GLfloat planet[] = {0.0, 0.3, 0.0, 0.0};
// Setup Texture Mapping
balloon_pix[0].readBMPFile("textures/balloon_top.bmp");
balloon_pix[1].readBMPFile("textures/balloon_rope.bmp");
balloon_pix[2].readBMPFile("textures/balloon_basket.bmp");
glGenTextures(3, balloon_tex);
// Texture Properties
for(int i = 0; i < 3; ++i)
{
glBindTexture(GL_TEXTURE_2D, balloon_tex[i]);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_S, GL_OBJECT_PLANE, planes);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_T, GL_OBJECT_PLANE, planet);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, balloon_pix[i].nCols, balloon_pix[i].nRows, 0, GL_RGB, GL_UNSIGNED_BYTE, balloon_pix[i].pixel);
}
}
/*ARGSUSED1*/
void
key(unsigned char key, int x, int y) {
static int wire;
switch(key)
{
case 'o':
/* toggle object type */
object++;
if(object > maxobject)
object = 1;
glutPostRedisplay();
break;
case 'w':
if (wire ^= 1)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glutPostRedisplay();
break;
case 's':
glDisable(GL_LIGHTING);
glBindTexture(GL_TEXTURE_2D, 1);
glEnable(GL_TEXTURE_2D);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glutPostRedisplay();
break;
case 'n':
glEnable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glutPostRedisplay();
break;
case 'c':
glBindTexture(GL_TEXTURE_2D, 2);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
#if 0
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
#else
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
#endif
glutPostRedisplay();
break;
case '\033':
exit(0);
break;
default:
help();
break;
}
}
void GLSLShaderMaterial::SetupShadowMap( int lightNum, GLuint texID, float *matrix )
{
char mapName[32];
GLenum texUnit = GL_TEXTURE7-lightNum;
sprintf( mapName, "shadowMap%d", lightNum ); // 7 = shadowMap0, 6 = shadowMap1, 5 = shadowMap2
shader->BindAndEnableTexture( mapName, texID, texUnit, GL_TEXTURE_2D );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE );
//shader->SetParameterv( "epS", 4, &matrix[0] );
//shader->SetParameterv( "epT", 4, &matrix[4] );
//shader->SetParameterv( "epR", 4, &matrix[8] );
//shader->SetParameterv( "epQ", 4, &matrix[12] );
glPushMatrix();
glLoadIdentity();
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGenfv( GL_S, GL_EYE_PLANE, &matrix[0] );
glTexGenfv( GL_T, GL_EYE_PLANE, &matrix[4] );
glTexGenfv( GL_R, GL_EYE_PLANE, &matrix[8] );
glTexGenfv( GL_Q, GL_EYE_PLANE, &matrix[12] );
glEnable( GL_TEXTURE_GEN_S );
glEnable( GL_TEXTURE_GEN_T );
glEnable( GL_TEXTURE_GEN_R );
glEnable( GL_TEXTURE_GEN_Q );
glPopMatrix();
shader->SetParameter( "useShadowMap", 1 );
}
void Environment::enableEvironmentMapping(GLfloat* reflectivity,
unsigned int textureUnitOffset)
{
if(!GLEW_VERSION_1_3)
return;
glActiveTexture(GL_TEXTURE0 + ++textureUnitOffset);
setInvMVMatrixAsTextureMatrix();
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, reflectivity);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_CONSTANT);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, cubeMapGenMode);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, cubeMapGenMode);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, cubeMapGenMode);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_CUBE_MAP);
glActiveTexture(GL_TEXTURE0 + --textureUnitOffset);
}
void opengl_texture_state::init(GLuint n_units)
{
Assert( n_units > 0 );
units = (opengl_texture_unit*) vm_malloc(n_units * sizeof(opengl_texture_unit));
num_texture_units = n_units;
for (unsigned int unit = 0; unit < num_texture_units; unit++) {
units[unit].active = GL_FALSE;
units[unit].enabled = GL_FALSE;
units[unit].used = GL_FALSE;
default_values(unit);
glActiveTexture(GL_TEXTURE0 + unit);
if (unit < (GLuint)GL_supported_texture_units) {
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
}
units[unit].texgen_S = GL_FALSE;
units[unit].texgen_T = GL_FALSE;
units[unit].texgen_R = GL_FALSE;
units[unit].texgen_Q = GL_FALSE;
if (unit < (GLuint)GL_supported_texture_units) {
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
}
units[unit].texgen_mode_S = GL_EYE_LINEAR;
units[unit].texgen_mode_T = GL_EYE_LINEAR;
units[unit].texgen_mode_R = GL_EYE_LINEAR;
units[unit].texgen_mode_Q = GL_EYE_LINEAR;
if (unit < (GLuint)GL_supported_texture_units) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
}
units[unit].env_mode = GL_MODULATE;
units[unit].env_combine_rgb = GL_MODULATE;
units[unit].env_combine_alpha = GL_MODULATE;
if (unit < (GLuint)GL_supported_texture_units) {
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 1.0f);
glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0f);
}
units[unit].rgb_scale = 1.0f;
units[unit].alpha_scale = 1.0f;
}
DisableAll();
}
void c_textura_2D::activa_ST( void ) {
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, Modo_ST );
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, Modo_ST );
glTexGenfv( GL_S, GL_OBJECT_PLANE, Plano_S );
glTexGenfv( GL_T, GL_OBJECT_PLANE, Plano_T );
glEnable( GL_TEXTURE_GEN_S );
glEnable( GL_TEXTURE_GEN_T );
}
Torus::Torus(string id, float inner, float outer, int slices, int loops) : Primitive(id) {
this->inner = inner;
this->outer = outer;
this->slices = slices;
this->loops = loops;
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
}
void glInit() {
/* Init glut */
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Trick Cannon");
/* Textures */
texture_dirt = LoadBitmap("images/dirt.bmp");
texture_mars = LoadBitmap("images/MarsMap.bmp");
texture_granite = LoadBitmap("images/granite.bmp");
/* Quadric for ball */
q_ball = gluNewQuadric();
//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
// Here is the light/shading init
light_position[0] = 4.0 ;
light_position[1] = 0.0 ;
light_position[2] = 0.0 ;
light_position[3] = 1.0 ;
GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
glClearColor (0.0, 0.0, 0.0, 1.0);
glShadeModel (GL_SMOOTH);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// Fog
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP2) ;
glFogfv(GL_FOG_COLOR, fog_color);
glFogf(GL_FOG_DENSITY, 0.005) ;
glFogf(GL_FOG_START, 10.0);
glFogf(GL_FOG_END, 10.0);
// Add specular effect -after- texturing calculations
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,
GL_SEPARATE_SPECULAR_COLOR);
/* Call backs */
glutDisplayFunc(display);
glutReshapeFunc(reshape);
}
void GL_BuildShadowTextureMatrix(camera_t *viewer)
{
float tmpMatrix[16] = {1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1};
float bias[16] = {0.5,0,0,0,0,0.5,0,0,0,0,0.5,0,0.5,0.5,gfx_shadowBias.value,1};
//GL setup
GL_MatrixMode(GL_TEXTURE);
if(gfx_shadowQuality.integer <= 1) {
glLoadMatrixf(bias);
glMultMatrixf(lightPerspective[0].matrix);
Cam_ConstructOpenGLMat44(scene_cam, &transM);
M_InvertMatrix44(&transM, &transM);
glMultMatrixf(transM.matrix);
} else if (gfx_shadowQuality.integer > 1 ) {
for(int i=0;i<gfx_shadowQuality.integer;i++) {
GL_SwitchTexUnit(GL_TEXTURE4_ARB+i);
glMatrixMode(GL_TEXTURE); //one can never be too sure
//our bias
glLoadMatrixf(bias);
glMultMatrixf(lightPerspective[i].matrix);
Cam_ConstructOpenGLMat44(scene_cam, &transM);
M_InvertMatrix44(&transM, &transM);
glMultMatrixf(transM.matrix);
}
}
GL_MatrixMode(GL_MODELVIEW);
GL_SwitchTexUnit(GL_TEXTURE1_ARB);
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL );
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE );
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE );
//EYE SPACE
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGenfv( GL_S, GL_EYE_PLANE, &tmpMatrix[0] );
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGenfv( GL_T, GL_EYE_PLANE, &tmpMatrix[4] );
glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGenfv( GL_R, GL_EYE_PLANE, &tmpMatrix[8] );
glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
glTexGenfv( GL_Q, GL_EYE_PLANE, &tmpMatrix[12] );
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_GEN_Q);
}
void init(void) {
int width, height, components;
GLubyte *image;
float density, fog_density, far_cull;
glClearColor (0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
if (!(image = (GLubyte *)read_texture("data/sea.rgb", &width, &height, &components))) {
perror("sea.rgb");
exit(EXIT_FAILURE);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, image);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glFrontFace(GL_CW);
glCullFace(GL_BACK);
glMaterialf (GL_FRONT, GL_SHININESS, 64.0);
{ int e; if (e = glGetError()) printf("error %x\n", e); }
density = 1.- expf(-5.5 * fog_density * fog_density *
far_cull * far_cull);
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
density = MAX(MIN(density, 1.), 0.);
glClearColor(.09f,.18f,.18f,1.f);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, fog_params[0]);
glFogfv(GL_FOG_COLOR, fog_params+1);
glEnable(GL_FOG);
{
GLfloat pos[] = {0.,150.,1.,1.};
glLightfv(GL_LIGHT0, GL_POSITION, pos);
}
}
void LLDrawPoolTerrain::renderSimple()
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
LLVector4 tp0, tp1;
//----------------------------------------------------------------------------
// Pass 1/1
// Stage 0: Base terrain texture pass
mTexturep->addTextureStats(1024.f*1024.f);
mTexturep->bind(0);
glActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_2D); // Texture unit 2
glClientActiveTextureARB(GL_TEXTURE0_ARB);
LLVector3 origin_agent = mDrawFace[0]->getDrawable()->getVObj()->getRegion()->getOriginAgent();
F32 tscale = 1.f/256.f;
tp0.setVec(tscale, 0.f, 0.0f, -1.f*(origin_agent.mV[0]/256.f));
tp1.setVec(0.f, tscale, 0.0f, -1.f*(origin_agent.mV[1]/256.f));
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0.mV);
glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1.mV);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
drawLoop();
//----------------------------------------------------------------------------
// Restore Texture Unit 0 defaults
LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
glClientActiveTextureARB(GL_TEXTURE0_ARB);
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
// Restore non Texture Unit specific defaults
glDisableClientState(GL_NORMAL_ARRAY);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
void CPlyRender::InitCubeMapping(void)
{
GLenum target[]={
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
};
stringstream filename;
glGenTextures(1, &mTexId[CUBEMAP]);
glBindTexture(GL_TEXTURE_CUBE_MAP, mTexId[CUBEMAP]);
for(int i=0;i<6;i++){
filename.str("");
filename << "../data/cubemap/" << CUBENAME << "/" << CUBEMAP_IMAGE_NAMES[i] << ".jpg";
cv::Mat img = cv::imread(filename.str().c_str());
cv::flip(img, img, 0);
if (img.data == nullptr) {
tr2::sys::path mypath;
cout << "current directory:" << tr2::sys::current_path().string() << endl;
cout << "tried to open file:" << filename.str() << endl;
assert(!"cubemap image not found");
}
glTexImage2D ( target[i], 0, GL_RGB, img.size().width,img.size().height, 0, GL_RGB, GL_UNSIGNED_BYTE, img.data);
}
/* glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glfwFreeImage(&img);
return true;
}*/
// テクスチャを拡大・縮小する方法の指定
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// テクスチャの繰り返し方法の指定
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_REPEAT);
// キューブマッピング用のテクスチャ座標を生成する
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
/* 設定対象を無名テクスチャに戻す */
glBindTexture(GL_TEXTURE_2D, 0);
GetGLError("teximage2d");
}
void
smapRenderSphereMappedObj(SphereMap *smap)
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, smap->smapTexObj);
}
void enable_reflection_str(void)
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
}
inline void Texture2::enableSphereMapping(void)
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
void InitAutoTex()
{
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
}
void CubeMap::enableFixedMapping()
{
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP );
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP );
glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP );
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable( GL_TEXTURE_CUBE_MAP );
}
void redraw_water() {
// test code for water ripples
int w,h;
// note: intead of loading each time, just switch back and forth
// using the texture integer lols
loadTexture(std::string("data/sky.png"), w,h);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
// apply UI transformation
glPushMatrix();
ui->applyViewingTransformation();
glTranslatef(0, -2.5, -5);
glTranslatef(ui->final_tx, -1*ui->final_ty, ui->final_tz);
glRotatef(ui->final_rd, ui->final_rx,ui->final_ry,0);
Matrix<float,3,1> N1,N2;
Matrix<float,3,1> N3,N4;
float prev_y = ymin;
// loop to make plane out of triangle strips
// this is very inefficient, don't use immediate mode after debug...
for(float y=ymin; y<ymax; y+=dy) {
glBegin(GL_TRIANGLE_STRIP);
for(float x=xmin; x<xmax; x+=dx) {
// calculate ripply normals
N1[0] = 2.*x*sin(x*x + y*y - water_time);
N1[1] = 2.*y*sin(x*x + y*y - water_time);
N1[2] = 1;
N1 = N1.normalize();
N2[0] = 2.*x*sin(x*x + prev_y*prev_y - water_time);
N2[1] = 2.*prev_y*sin(x*x + prev_y*prev_y - water_time);
N2[2] = 1;
N2 = N2.normalize();
// set vertices and texcoords
glNormal3f(N1[0], N1[1], N1[2]); glVertex3f(y, 0, x);
glNormal3f(N2[0], N2[1], N2[2]); glVertex3f(prev_y, 0, x);
}
glEnd();
prev_y = y; // could just subtract dy...
}
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glPopMatrix();
glutSwapBuffers();
}
// Draw calls
void DrawBall(GLboolean isProjection)
{
glColor3f(1, 1, 1);
glPushMatrix();
if (!isProjection)
{
glBindTexture(GL_TEXTURE_2D, otherTextures[BALL]);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
}
run ? glTranslatef(X, Y, Z)
: glTranslatef(reflectorX, reflectorY, ROOM_HALF_LENGTH - BALL_DIAMETER);
glutSolidSphere(BALL_DIAMETER / 2.0, 10.0, 10.0);
if (!isProjection)
{
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
glPopMatrix();
if (!isProjection)
{
if (run)
{
X += Xdir;
Y += Ydir;
Z += Zdir;
leftCP += Xdir;
rightCP += Xdir;
upCP += Ydir;
downCP += Ydir;
backCP += Zdir;
frontCP += Zdir;
}
else
{
X = reflectorX;
Y = reflectorY;
Z = ROOM_HALF_LENGTH - BALL_DIAMETER;
leftCP = X - BALL_DIAMETER / 2.0;
rightCP = X + BALL_DIAMETER / 2.0;
downCP = Y - BALL_DIAMETER / 2.0;
upCP = Y + BALL_DIAMETER / 2.0;
backCP = Z - BALL_DIAMETER / 2.0;
frontCP = Z + BALL_DIAMETER / 2.0;
}
}
}
/* general OpenGL initialization function */
int initGL()
{
/* Load in the texture */
if ( !LoadGLTextures( ) )
return FALSE;
/* Enable Texture Mapping ( NEW ) */
glEnable( GL_TEXTURE_2D );
/* Enable smooth shading */
glShadeModel( GL_SMOOTH );
/* Set the background black */
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
/* Depth buffer setup */
glClearDepth( 1.0f );
/* Enables Depth Testing */
glEnable( GL_DEPTH_TEST );
/* The Type Of Depth Test To Do */
glDepthFunc( GL_LEQUAL );
/* Really Nice Perspective Calculations */
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
/* Setup The Ambient Light */
glLightfv( GL_LIGHT1, GL_AMBIENT, LightAmbient );
/* Setup The Diffuse Light */
glLightfv( GL_LIGHT1, GL_DIFFUSE, LightDiffuse );
/* Position The Light */
glLightfv( GL_LIGHT1, GL_POSITION, LightPosition );
/* Enable Light One */
glEnable( GL_LIGHT1 );
/* Set The Texture Generation Mode For S To Sphere Mapping */
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
/* Set The Texture Generation Mode For T To Sphere Mapping */
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
/* Create A Pointer To The Quadric Object */
quadratic = gluNewQuadric( );
/* Create Smooth Normals */
gluQuadricNormals( quadratic, GLU_SMOOTH );
/* Create Texture Coords */
gluQuadricTexture( quadratic, GL_TRUE );
return( TRUE );
}
void Sphere::initQuad(bool inside){
_quad = gluNewQuadric();
gluQuadricTexture(_quad, GL_TRUE);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
//gluQuadricDrawStyle(_quad,GLU_POINT);
if(inside)gluQuadricOrientation(_quad,GLU_INSIDE);
else gluQuadricOrientation(_quad,GLU_OUTSIDE);
}
////////////////////////////////////////////////////////
// render
//
/////////////////////////////////////////////////////////
void pix_cubemap :: render(GemState *state) {
m_didTexture=false;
pushTexCoords(state);
if(!m_textureOnOff)return;
/* here comes the work: a new image has to be transfered from main memory to GPU and attached to a texture object */
if(state) {
pixBlock*img=NULL;
state->get(GemState::_PIX, img);
if(img) {
if(img->newimage)
m_img[0]=&img->image;
}
}
if(GLEW_VERSION_1_3) {
glActiveTexture(GL_TEXTURE0_ARB + m_texunit);
}
glEnable(m_textureType);
glBindTexture(m_textureType, m_textureObj);
int i=0;
for(i=0; i<6; i++) {
applyTex(GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, m_img[i]);
m_img[i]=NULL;
}
int mode = GL_NORMAL_MAP;
switch(m_map) {
case 0: mode = GL_NORMAL_MAP; break;
case 1: mode = GL_REFLECTION_MAP; break;
case 2: mode = GL_SPHERE_MAP; break;
default: mode=m_map;
}
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, mode);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, mode);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, mode);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
/* cleanup */
m_rebuildList = 0;
m_didTexture=true;
state->set(GemState::_GL_TEX_UNITS, m_numTexUnits);
state->set(GemState::_GL_TEX_TYPE, 0); // ?
// sendExtTexture(m_textureObj, m_xRatio, m_yRatio, m_textureType, upsidedown);
}
void desplieganuevopin(int i)
{
if (pinSelecc < 100 ) {
glPushMatrix();
glEnable(GL_BLEND); // Activamos la transparencia
glBlendFunc(GL_ONE_MINUS_SRC_COLOR, GL_SRC_COLOR); //funcion de blending //GL_ONE_MINUS_SRC_ALPHA GL_SRC_COLOR
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glBindTexture(GL_TEXTURE_2D, texName[3]); //pin rojo
glPushMatrix();
switch (currentIndex) {
case 1: //America
//posiciones de los pines
posX = continente -> _america[i].posX;
posY = continente -> _america[i].posY;
break;
case 2: //Asia
//posiciones de los pines
posX = continente -> _asia[i].posX;
posY = continente -> _asia[i].posY;
break;
case 3: //Europa
posX = continente -> _europa[i].posX;
posY = continente -> _europa[i].posY;
break;
case 0: //Africa
posX = continente -> _africa[i].posX;
posY = continente -> _africa[i].posY;
break;
default:
break;
}
glTranslatef(posX, posY, 0);
glColor4f(1.0, 1.0, 1.0, 0.1); //color y alpha del cubo
glutSolidSphere(.05, 20, 20);
glPopMatrix();
glPopMatrix();
glDisable(GL_BLEND); //para desactivarlo.
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glutPostRedisplay();
}
}
void LLDrawPoolTerrain::renderSimple()
{
LLVector4 tp0, tp1;
//----------------------------------------------------------------------------
// Pass 1/1
// Stage 0: Base terrain texture pass
mTexturep->addTextureStats(1024.f*1024.f);
gGL.getTexUnit(0)->activate();
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
gGL.getTexUnit(0)->bind(mTexturep);
LLVector3 origin_agent = mDrawFace[0]->getDrawable()->getVObj()->getRegion()->getOriginAgent();
F32 tscale = 1.f/256.f;
tp0.setVec(tscale, 0.f, 0.0f, -1.f*(origin_agent.mV[0]/256.f));
tp1.setVec(0.f, tscale, 0.0f, -1.f*(origin_agent.mV[1]/256.f));
if (LLGLSLShader::sNoFixedFunction)
{
sShader->uniform4fv("object_plane_s", 1, tp0.mV);
sShader->uniform4fv("object_plane_t", 1, tp1.mV);
}
else
{
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0.mV);
glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1.mV);
}
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_VERT_COLOR);
drawLoop();
//----------------------------------------------------------------------------
// Restore Texture Unit 0 defaults
gGL.getTexUnit(0)->activate();
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
if (!LLGLSLShader::sNoFixedFunction)
{
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
gGL.matrixMode(LLRender::MM_TEXTURE);
gGL.loadIdentity();
gGL.matrixMode(LLRender::MM_MODELVIEW);
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
}
static void cd_animation_render_capsule (Icon *pIcon, CairoDock *pDock, gboolean bInvisibleBackground)
{
glEnable(GL_DEPTH_TEST);
glEnable (GL_BLEND);
/*if (bInvisibleBackground)
_cairo_dock_set_blend_alpha (); // to have a transparency capsule.
else
glBlendFunc (GL_SRC_ALPHA, GL_ONE); // the capsule "erase" the background.*/
glEnable(GL_TEXTURE);
_cairo_dock_set_blend_alpha ();
glActiveTexture(GL_TEXTURE0); // Active multitexturing for the 1st time
glEnable(GL_TEXTURE_2D); // Enable texturing for this time
glBindTexture(GL_TEXTURE_2D, myData.iChromeTexture);
glEnable(GL_TEXTURE_GEN_S); // yes, we want a S generation
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // generation's type of coordinates for the texture
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // for textures that are too large
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE1); // Active multitexturing for the 2d time
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, pIcon->image.iTexture);
//glColor4f(1., 1., 1., pIcon->fAlpha);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); // we want a classical mapping
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // for textures that are too large
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexGenfv(GL_S, GL_OBJECT_PLANE, fCapsuleObjectPlaneS); // we move the texture
glTexGenfv(GL_T, GL_OBJECT_PLANE, fCapsuleObjectPlaneT);
glEnable(GL_TEXTURE_GEN_S); // texture's generation in S
glEnable(GL_TEXTURE_GEN_T); // and T
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); // combination's mode of the textures
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD); /// it saturates ...
//glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
//glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 1.3); // boost the combination
glPolygonMode (GL_FRONT, GL_FILL);
glCallList (myData.iCallList[CD_CAPSULE_MESH]);
glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 1.);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable (GL_DEPTH_TEST);
glDisable (GL_BLEND);
}
