Beispiel #1
0
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 );
}
	virtual void onCreate() {
		
		// create cubemap texture:
		glGenTextures(1, (GLuint *)&mID);
		glBindTexture(mTarget, mID);
		// each cube face should clamp at texture edges:
		glTexParameteri(mTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(mTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(mTarget, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		// normal filtering
		glTexParameteri(mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		// no mipmapping:
		//glTexParameteri(mTarget, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap
		//glTexParameterf(mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		
		// Domagoj also has:
		glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
		glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
		glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
		float X[4] = { 1,0,0,0 };
		float Y[4] = { 0,1,0,0 };
		float Z[4] = { 0,0,1,0 };
		glTexGenfv( GL_S, GL_OBJECT_PLANE, X );
		glTexGenfv( GL_T, GL_OBJECT_PLANE, Y );
		glTexGenfv( GL_R, GL_OBJECT_PLANE, Z );
	
		submit();
		
		// clean up:
		glBindTexture(mTarget, 0);
		Graphics::error("creating cubemap texture");
	
		//printf("created CubeMapTexture %dx%d\n", mResolution, mResolution);
	}
Beispiel #3
0
  void Textura::Activar(){
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D,id_text);


    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
    if (mgct!=0){

    glEnable( GL_TEXTURE_GEN_S ); // desactivado inicialmente
    glEnable( GL_TEXTURE_GEN_T ); // desactivado inicialmente
    if(mgct==1){
      glTexGenfv( GL_S, GL_OBJECT_PLANE, cs ) ;
      glTexGenfv( GL_T, GL_OBJECT_PLANE, ct ) ;
    }
    else if(mgct==2){
      glTexGenfv( GL_S, GL_EYE_PLANE, cs ) ;
      glTexGenfv( GL_T, GL_EYE_PLANE, ct ) ;
    }
  }
  else{
     glDisable(GL_TEXTURE_GEN_S);
     glDisable(GL_TEXTURE_GEN_T);
  }
}
Beispiel #4
0
void
drawObject(void *context)
{
        static GLfloat xplane[4] = { 1, 0, 0, 0 };
        static GLfloat zplane[4] = { 0, 1, 0, 0 };

        if (!cullBackFaces) {
                glEnable(GL_CULL_FACE);
                glCullFace(GL_FRONT);
        }

	glPushMatrix();
                glTranslatef(obj[0], obj[1], obj[2]);
                if (doSphereMap) {
		        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, 7);
		        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
			GL_REPLACE);
                } else {
                        glTexGenfv(GL_S, GL_OBJECT_PLANE, xplane);
                        glTexGenfv(GL_T, GL_OBJECT_PLANE, zplane);
                        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);
		        glEnable(GL_TEXTURE_2D);
                        glBindTexture(GL_TEXTURE_2D, 100);
                        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
			GL_REPLACE);
                }

		glColor3f(1.0, 1.0, 1.0);
		switch (object) {
		case 0:
			glutSolidSphere(3.0, 20, 20);
			break;
		case 1:
			glScalef(3.0, 3.0, 3.0);
			glRotatef(30.0, 1.0, 1.0, 0.0);
			glutSolidIcosahedron();
			break;
		case 2:
			glFrontFace(GL_CW);
			glutSolidTeapot(3.0);
			glFrontFace(GL_CCW);
			break;
		}

	        glDisable(GL_TEXTURE_GEN_S);
       		glDisable(GL_TEXTURE_GEN_T);
	glPopMatrix();

        if (!cullBackFaces) {
                glCullFace(GL_BACK);
        }
}
Beispiel #5
0
void Textura::activar(){
  glEnable(GL_TEXTURE_2D);

  glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,img->tamX(),img->tamY(),0,GL_RGB,GL_UNSIGNED_BYTE,img->leerPixels());
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

  if(mgct != 0){
    glEnable(GL_TEXTURE_GEN_S); //Para generar las cc.tt. en cada pixel
    glEnable(GL_TEXTURE_GEN_T); //Para generar las cc.tt. en cada pixel
    if(mgct == 1){
      glTexGenfv(GL_S, GL_OBJECT_PLANE, cs);
      glTexGenfv(GL_T, GL_OBJECT_PLANE, ct);
    }else{
      glTexGenfv(GL_S, GL_EYE_PLANE, cs);
      glTexGenfv(GL_T, GL_EYE_PLANE, ct);
    }
  }
  else{
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);
  }
  // activa textura en el cauce fijo de OpenGL
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
void cTexture::load(bool canvasTex)
{
#ifndef _EXPANF_DLL_
	if(!texId)
		return;

	glPushAttrib(/*GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT | */GL_TEXTURE_BIT); 

	glEnable(tex_format);

	if(canvasTex)
		glBindTexture(tex_format, texCanvasId);
	else
		glBindTexture(tex_format, texId);

	glTexParameteri(tex_format, GL_TEXTURE_WRAP_S, tex_wrap);
	glTexParameteri(tex_format, GL_TEXTURE_WRAP_T, tex_wrap);
	glTexParameteri(tex_format, GL_TEXTURE_MAG_FILTER, tex_filter);
	glTexParameteri(tex_format, GL_TEXTURE_MIN_FILTER, tex_filter);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, tex_mode);

	if(m_tex_coord_type == AUTOMATIC_COORD)
	{
		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, m_s_eq);
		glTexGenfv(GL_T, GL_OBJECT_PLANE, m_t_eq);
	}
#endif
}
Beispiel #7
0
// Dibuix de la llanta de la roda
// llanta: Paràmetres:
//    - textur: Flag de textures activades o no.
//    - VTextur: Vector d'imatges textura.
void Model::llanta(bool textur)
{

// Crear quàdrica per la llanta
    GLUquadricObj *tapacub;
    tapacub = gluNewQuadric();

// Textura de la llanta
    if (textur)
        {	GLfloat sPlane[4] = { 0.0f, -0.1f, 0.5f, 0.5f };
            GLfloat tPlane[4] = { 0.1f, 0.0f, 0.5f, 0.5f };
// Activar la textura
            glBindTexture(GL_TEXTURE_2D,textures[2]) ;
            glEnable(GL_TEXTURE_2D) ;

            glTexGenfv(GL_S, GL_OBJECT_PLANE, sPlane);
            glTexGenfv(GL_T, GL_OBJECT_PLANE, tPlane);

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

// Dibuix de la llanta (disc de radi 5 de color clar)
    glColor4f(0.7f,0.7f,0.7f,0.5f);
    gluDisk(tapacub, 0.0f, 5.0f, RESOLUCIO_RODA, 1);

// Alliberar quàdrica
    gluDeleteQuadric(tapacub);

}
Beispiel #8
0
/*--    -------------------------------------------------------------------*/
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 ) ; 
   }   
}
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);
    }
}
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);
}
Beispiel #11
0
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 );
}
Beispiel #12
0
void setup_course_tex_gen()
{
    static GLfloat xplane[4] = { 1.0 / TEX_SCALE, 0.0, 0.0, 0.0 };
    static GLfloat zplane[4] = { 0.0, 0.0, 1.0 / TEX_SCALE, 0.0 };
    
    glTexGenfv( GL_S, GL_OBJECT_PLANE, xplane );
    glTexGenfv( GL_T, GL_OBJECT_PLANE, zplane );
}
Beispiel #13
0
static void do_test_texgen_eye(const char* testname)
{
	static GLfloat sPlane1[4] = { 1.0, 0.0, 0.0, 0.25 };
	static GLfloat sPlane2[4] = { 1.0, 0.0, 0.0, -0.25 };
	static GLfloat sPlane3[4] = { -1.0, 0.0, 0.0, 1.25 };
	int x, y;

	glClearColor(0.5, 0.5, 0.5, 1.0);
	glClear(GL_COLOR_BUFFER_BIT);

	// Note: Modelview matrix is identity
	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	glTexGenfv(GL_S, GL_EYE_PLANE, sPlane1);
	glEnable(GL_TEXTURE_GEN_S);

	// Draw lower left quad
	glBegin(GL_QUADS);
		glTexCoord2f(0, 0.25); glVertex2f(0.0, 0.0);
		glTexCoord2f(0, 0.25); glVertex2f(0.5, 0.0);
		glTexCoord2f(0, 0.75); glVertex2f(0.5, 0.5);
		glTexCoord2f(0, 0.75); glVertex2f(0.0, 0.5);
	glEnd();

	// Draw lower right quad
	glTexGenfv(GL_S, GL_EYE_PLANE, sPlane2);
	glPushMatrix();
	glTranslatef(0.5, -0.5, 0.0);
	glScalef(2.0, 1.0, 1.0);
	glBegin(GL_QUADS);
		glTexCoord2f(0, 0.25); glVertex2f(0.0,  0.5);
		glTexCoord2f(0, 0.25); glVertex2f(0.25, 0.5);
		glTexCoord2f(0, 0.75); glVertex2f(0.25, 1.0);
		glTexCoord2f(0, 0.75); glVertex2f(0.0,  1.0);
	glEnd();
	glPopMatrix();

	// Draw upper left quad
	glPushMatrix();
	glTranslatef(1.0, 0.5, 0.0);
	glScalef(-1.0, 1.0, 1.0);
	glTexGenfv(GL_S, GL_EYE_PLANE, sPlane3);
	glBegin(GL_QUADS);
		glTexCoord2f(0, 0.25); glVertex2f(1.0, 0.0);
		glTexCoord2f(0, 0.25); glVertex2f(0.5, 0.0);
		glTexCoord2f(0, 0.75); glVertex2f(0.5, 0.5);
		glTexCoord2f(0, 0.75); glVertex2f(1.0, 0.5);
	glEnd();
	glPopMatrix();

	glDisable(GL_TEXTURE_GEN_S);

	for(y = 0; y < 2; ++y) {
		for(x = 0; x < 2; ++x)
			probe_cell(testname, x, y, TextureData[y+1][x+1]);
	}

	piglit_present_results();
}
Beispiel #14
0
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);
}
Beispiel #15
0
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);
    }
}
Beispiel #16
0
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);
}
Beispiel #17
0
void glTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
    if (pname == GL_TEXTURE_GEN_MODE) {
        GLfloat tmp = *params;
        glTexGenfv(coord, pname, &tmp);
    } else {
        constArrayToFloat(params, 4);
        glTexGenfv(coord, pname, s);
    }
}
Beispiel #18
0
	void BaseTexture::SetupTexGen()
	{
		float tgv[4];
		CalcTexGenVector(tgv);

		Plane s(tgv[0], 0, 0, tgv[2]);
		glTexGenfv(GL_S, GL_OBJECT_PLANE, (float*)&s);
		Plane t(0, 0, tgv[1], tgv[3]);
		glTexGenfv(GL_T, GL_OBJECT_PLANE, (float*)&t);
	}
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);
}
Beispiel #21
0
//MB-TEXTURE
//------------------------------------------------------------------------------
void npGLTexture (pNPnode node, void* dataRef)
{
//	const GLfloat sgenparams[] = { 1.0f, 0.0f, 0.0f, 0.0f };
//	const GLfloat tgenparams[] = { 0.0f, 1.0f, 0.0f, 0.0f };
	const GLfloat sgenparams[] = { 1.0f, 0.0f, 0.0f, 0.0f };
	const GLfloat tgenparams[] = { 0.0f, 1.0f, 0.0f, 0.0f };

	pData data = (pData) dataRef;

	//exit if no texture or pickPass, picking requires no texture mapping
	if (!node->textureID || data->io.gl.pickPass)
		return;

	glEnable ( GL_TEXTURE_2D );
	glBindTexture ( GL_TEXTURE_2D, node->textureID );

	//use different texturing for the gluSphere
	if ( node->geometry == kNPgeoSphere // || geometry == kNPgeoSphereWire		//zz debug
		|| node->geometry == kNPgeoCylinder ) // || geometry == kNPgeoCylinderWire
	{
		glDisable( GL_TEXTURE_GEN_S );	//prevents intermittent texture anomally
		glDisable( GL_TEXTURE_GEN_T );
	}
	else
	{
		glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

		glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
		glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
			// metal appearance
			// 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 );

		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );

			//rather sharp setting, but probably best for mapping
			//for video use GL_LINEAR_MIPMAP_NEAREST when the angle is close 
			//to perpendicular less artifacts and a bit more blurry
	//		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);		//zz debug, add mipmapping...
	//		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);

	//	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);		//zz debug, add mipmapping...
	//	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

		glTexGenfv( GL_S, GL_OBJECT_PLANE, sgenparams );
		glTexGenfv( GL_T, GL_OBJECT_PLANE, tgenparams );
	}
}
Beispiel #22
0
	void SetTexCoordGen(float* tgv)
	{
		glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
		glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

		Plane s(tgv[0], 0, 0, tgv[2]);
		glTexGenfv(GL_S, GL_OBJECT_PLANE, (float*)&s);
		Plane t(0, 0, tgv[1], tgv[3]);
		glTexGenfv(GL_T, GL_OBJECT_PLANE, (float*)&t);

		glEnable(GL_TEXTURE_GEN_S);
		glEnable(GL_TEXTURE_GEN_T);
	}
Beispiel #23
0
void SetTexGen(const float& scaleX, const float& scaleZ, const float& offsetX, const float& offsetZ)
{
	const GLfloat planeX[] = {scaleX, 0.0f,   0.0f,  offsetX};
	const GLfloat planeZ[] = {  0.0f, 0.0f, scaleZ,  offsetZ};

	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	glTexGenfv(GL_S, GL_EYE_PLANE, planeX);
	glEnable(GL_TEXTURE_GEN_S);

	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	glTexGenfv(GL_T, GL_EYE_PLANE, planeZ);
	glEnable(GL_TEXTURE_GEN_T);
}
Beispiel #24
0
void
drawScene(int pass)
{
  /* The 0.03 in the Y column is just to shift the texture coordinates
     a little based on Y (depth in the water) so that vertical faces
     (like on the cube) do not get totally vertical caustics. */
  GLfloat sPlane[4] = { 0.05, 0.03, 0.0, 0.0 };
  GLfloat tPlane[4] = { 0.0, 0.03, 0.05, 0.0 };

  /* The causticScale determines how large the caustic "ripples" will
     be.  See the "Increate/Decrease ripple size" menu options. */

  sPlane[0] = 0.05 * causticScale;
  sPlane[1] = 0.03 * causticScale;

  tPlane[1] = 0.03 * causticScale;
  tPlane[2] = 0.05 * causticScale;

  if (pass == PASS_CAUSTIC) {
    /* Set current color to "white" and disable lighting
       to emulate OpenGL 1.1's GL_REPLACE texture environment. */
    glColor3f(1.0, 1.0, 1.0);
    glDisable(GL_LIGHTING);

    /* Generate the S & T coordinates for the caustic textures
       from the object coordinates. */

    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, sPlane);
    glTexGenfv(GL_T, GL_OBJECT_PLANE, tPlane);
    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);

    if (HaveTexObj) {
      glBindTexture(GL_TEXTURE_2D, currentCaustic+1);
    } else {
      glCallList(currentCaustic+101);
    }
  }

  drawFloor(pass);
  drawObject(pass);

  if (pass == PASS_CAUSTIC) {
    glEnable(GL_LIGHTING);
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);
  }
}
Beispiel #25
0
void CRefractWater::SetupWaterDepthTex()
{
	glActiveTextureARB(GL_TEXTURE3_ARB);
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, readmap->GetShadingTexture()); // the shading texture has water depth encoded in alpha
	glEnable(GL_TEXTURE_GEN_S);
	float splane[] = { 1.0f / (gs->pwr2mapx * SQUARE_SIZE), 0.0f, 0.0f, 0.0f }; 
	glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
	glTexGenfv(GL_S,GL_OBJECT_PLANE,splane);

	glEnable(GL_TEXTURE_GEN_T);
	float tplane[] = { 0.0f, 0.0f, 1.0f / (gs->pwr2mapy * SQUARE_SIZE), 0.0f};
	glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
	glTexGenfv(GL_T,GL_OBJECT_PLANE,tplane);
}
Beispiel #26
0
	void renderShadowStage ( int n, float* vmat )
	{
		GLfloat pos[4];
		GLfloat row[4];

		computeLightMatrix ( n, TEX_SIZE, TEX_SIZE );
		if ( n == 0 ) {
			glActiveTextureARB( GL_TEXTURE1_ARB );			// TEXTURE1 = shadow map stage #1
		} else {
			glActiveTextureARB( GL_TEXTURE2_ARB );			// TEXTURE2 = shadow map stage #2
		}
		glEnable ( GL_TEXTURE_2D );   
		if ( n == 0 )	glBindTexture ( GL_TEXTURE_2D, shadow1_id );
		else			glBindTexture ( GL_TEXTURE_2D, shadow2_id );	

		glMatrixMode( GL_MODELVIEW );	
		glLoadMatrixf ( vmat );

		row[0] = light_proj[0]; row[1] = light_proj[4]; row[2] = light_proj[8]; row[3] = light_proj[12];
		glTexGenfv(GL_S, GL_EYE_PLANE, &row[0] );
		row[0] = light_proj[1]; row[1] = light_proj[5]; row[2] = light_proj[9]; row[3] = light_proj[13];
		glTexGenfv(GL_T, GL_EYE_PLANE, &row[0] );
		row[0] = light_proj[2]; row[1] = light_proj[6]; row[2] = light_proj[10]; row[3] = light_proj[14];
		glTexGenfv(GL_R, GL_EYE_PLANE, &row[0] );
		row[0] = light_proj[3]; row[1] = light_proj[7]; row[2] = light_proj[11]; row[3] = light_proj[15];
		glTexGenfv(GL_Q, GL_EYE_PLANE, &row[0] );
		glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
		glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
		glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
		glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
		glEnable(GL_TEXTURE_GEN_S);    
		glEnable(GL_TEXTURE_GEN_T);
		glEnable(GL_TEXTURE_GEN_R);
		glEnable(GL_TEXTURE_GEN_Q);	

		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
		
		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE ) ;
		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE ) ;
		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS ) ;
		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT ) ;
			
		pos[0] = 0.50;
		pos[1] = 0.50;
		pos[2] = 0.50;
		pos[3] = 0.50;
		glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &pos[0] );
	}
Beispiel #27
0
void KX_BlenderMaterial::setObjectMatrixData(int i, RAS_IRasterizer *ras)
{
	KX_GameObject *obj = 
		(KX_GameObject*)
		mScene->GetObjectList()->FindValue(mMaterial->mapping[i].objconame);

	if (!obj) return;

	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 );

	GLenum plane = GL_EYE_PLANE;

	// figure plane gen
	float proj[4] = {0.f,0.f,0.f,0.f};
	GetProjPlane(mMaterial, i, 0, proj);
	glTexGenfv(GL_S, plane, proj);
	
	GetProjPlane(mMaterial, i, 1, proj);
	glTexGenfv(GL_T, plane, proj);

	GetProjPlane(mMaterial, i, 2, proj);
	glTexGenfv(GL_R, plane, proj);

	glEnable(GL_TEXTURE_GEN_S);
	glEnable(GL_TEXTURE_GEN_T);
	glEnable(GL_TEXTURE_GEN_R);

	const MT_Matrix4x4& mvmat = ras->GetViewMatrix();

	glMatrixMode(GL_TEXTURE);
	glLoadIdentity();
	glScalef( 
		mMaterial->mapping[i].scale[0], 
		mMaterial->mapping[i].scale[1], 
		mMaterial->mapping[i].scale[2]
	);

	MT_Point3 pos = obj->NodeGetWorldPosition();
	MT_Vector4 matmul = MT_Vector4(pos[0], pos[1], pos[2], 1.f);
	MT_Vector4 t = mvmat*matmul;

	glTranslatef( (float)(-t[0]), (float)(-t[1]), (float)(-t[2]) );

	glMatrixMode(GL_MODELVIEW);

}
Beispiel #28
0
void texturegeneration::initializeGL()
{
    glClearColor (0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);
    makeStripeImage();
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glGenTextures(1, &texName);
    glBindTexture(GL_TEXTURE_1D, texName);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER,
    GL_LINEAR);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER,
    GL_LINEAR);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, stripeImageWidth, 0,
    GL_RGBA, GL_UNSIGNED_BYTE, stripeImage);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    currentCoeff = xequalzero;
    currentGenMode = GL_OBJECT_LINEAR;
    currentPlane = GL_OBJECT_PLANE;
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, currentGenMode);
    glTexGenfv(GL_S, currentPlane, currentCoeff);
    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_1D);
    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);
}
Beispiel #29
0
void GenerateContourMap()
{
	unsigned char CTexture[CONTOUR_WIDTH * 4];

	CoordGen[0] = 0.0f;
	CoordGen[1] = 0.25f;
	CoordGen[2] = 0.0f;
	CoordGen[3] = 0.0f;

	for (int i = 0; i<(CONTOUR_WIDTH * 4); ++i)
		CTexture[i] = 0;
	CTexture[3 + CONTOUR_WIDTH / 2] = 0xff;
	CTexture[7 + CONTOUR_WIDTH / 2] = 0xff;
	CTexture[11 + CONTOUR_WIDTH / 2] = 0xff;

	glGenTextures(1, &Contour);
	glBindTexture(GL_TEXTURE_2D, Contour);

	gluBuild2DMipmaps(GL_TEXTURE_2D, 4, CONTOUR_WIDTH, 1, GL_RGBA, GL_UNSIGNED_BYTE, CTexture);

	glEnable(GL_TEXTURE_GEN_S);
	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
	glTexGenfv(GL_S, GL_OBJECT_PLANE, CoordGen);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
}
Beispiel #30
0
void inittex(void)
{
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	texid = pngBind("terrain5.png", PNG_NOMIPMAP, PNG_SOLID, NULL, GL_CLAMP, GL_LINEAR, GL_LINEAR);

	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);

	float splanes[] = {1.0 / (MAX - MIN), 0, 0, -MIN / (MAX - MIN)};
	float tplanes[] = {0, 0, 1.0 / (MAX - MIN), -MIN / (MAX - MIN)};
	
	glTexGenfv(GL_S, GL_OBJECT_PLANE, splanes);
	glTexGenfv(GL_T, GL_OBJECT_PLANE, tplanes);
}