static int setActiveTexture (int c, GLfloat thisTransparency, GLint *texUnit, GLint *texMode) { ttglobal tg = gglobal(); /* which texture unit are we working on? */ /* tie each fw_TextureX uniform into the correct texture unit */ /* here we assign the texture unit to a specific number. NOTE: in the current code, this will ALWAYS * be [0] = 0, [1] = 1; etc. */ texUnit[c] = c; #ifdef TEXVERBOSE if (getAppearanceProperties()->currentShaderProperties != NULL) { printf ("setActiveTexture %d, boundTextureStack is %d, sending to uniform %d\n",c, tg->RenderFuncs.boundTextureStack[c], getAppearanceProperties()->currentShaderProperties->TextureUnit[c]); } else { printf ("setActiveTexture %d, boundTextureStack is %d, sending to uniform [NULL--No Shader]\n",c, tg->RenderFuncs.boundTextureStack[c]); } #endif /* is this a MultiTexture, or just a "normal" single texture? When we * bind_image, we store a pointer for the texture parameters. It is * NULL, possibly different for MultiTextures */ if (tg->RenderTextures.textureParameterStack[c].multitex_mode == INT_ID_UNDEFINED) { #ifdef TEXVERBOSE printf ("setActiveTexture - simple texture NOT a MultiTexture \n"); #endif /* should we set the coloUr to 1,1,1,1 so that the material does not show * through a RGB texture?? */ /* only do for the first texture if MultiTexturing */ if (c == 0) { #ifdef TEXVERBOSE printf ("setActiveTexture - firsttexture \n"); #endif texMode[c]= GL_MODULATE; } else { texMode[c]=GL_ADD; } } else { /* printf ("muititex source for %d is %d\n",c,tg->RenderTextures.textureParameterStack[c].multitex_source); */ if (tg->RenderTextures.textureParameterStack[c].multitex_source != MTMODE_OFF) { } else { glDisable(GL_TEXTURE_2D); /* DISABLE_TEXTURES */ return FALSE; } } PRINT_GL_ERROR_IF_ANY(""); return TRUE; }
static bool setupShader() { ppRenderFuncs p = (ppRenderFuncs)gglobal()->RenderFuncs.prv; s_shader_capabilities_t *mysp = getAppearanceProperties()->currentShaderProperties; if (mysp != NULL) { /* if we had a shader compile problem, do not draw */ if (!(mysp->compiledOK)) { #ifdef RENDERVERBOSE printf ("shader compile error\n"); #endif return false; } #ifdef RENDERVERBOSE printf ("we have Normals %d Vertices %d Colours %d TexCoords %d \n", mysp->Normals, mysp->Vertices, mysp->Colours, mysp->TexCoords); if (p->shaderNormalArray) printf ("p->shaderNormalArray TRUE\n"); else printf ("p->shaderNormalArray FALSE\n"); if (p->shaderVertexArray) printf ("shaderVertexArray TRUE\n"); else printf ("shaderVertexArray FALSE\n"); if (p->shaderColourArray) printf ("shaderColourArray TRUE\n"); else printf ("shaderColourArray FALSE\n"); if (p->shaderTextureArray) printf ("shaderTextureArray TRUE\n"); else printf ("shaderTextureArray FALSE\n"); #endif /* send along lighting, material, other visible properties */ sendMaterialsToShader(mysp); sendMatriciesToShader(mysp); if (mysp->Normals != -1) { if (p->shaderNormalArray) glEnableVertexAttribArray(mysp->Normals); else glDisableVertexAttribArray(mysp->Normals); } if (mysp->Vertices != -1) { if (p->shaderVertexArray) glEnableVertexAttribArray(mysp->Vertices); else glDisableVertexAttribArray(mysp->Vertices); } if (mysp->Colours != -1) { if (p->shaderColourArray) glEnableVertexAttribArray(mysp->Colours); else glDisableVertexAttribArray(mysp->Colours); } if (mysp->TexCoords != -1) { if (p->shaderTextureArray) glEnableVertexAttribArray(mysp->TexCoords); else glDisableVertexAttribArray(mysp->TexCoords); } } return true; }
void enableGlobalShader(s_shader_capabilities_t *myShader) { //ConsoleMessage ("enableGlobalShader, have myShader %d",myShader->myShaderProgram); if (myShader == NULL) { TURN_GLOBAL_SHADER_OFF; return; }; getAppearanceProperties()->currentShaderProperties = myShader; USE_SHADER(myShader->myShaderProgram); }
/* finished rendering thisshape. */ void turnGlobalShaderOff(void) { ppRenderFuncs p = (ppRenderFuncs)gglobal()->RenderFuncs.prv; /* get rid of the shader */ getAppearanceProperties()->currentShaderProperties = NULL; USE_SHADER(0); /* set array booleans back to defaults */ p->shaderNormalArray = TRUE; p->shaderVertexArray = TRUE; p->shaderColourArray = FALSE; p->shaderTextureArray = FALSE; }
OLDCODE#include "../scenegraph/Component_Shape.h" OLDCODE OLDCODE/* for OpenGL ES, we mimic the old glColor stuff from fixed functionality */ OLDCODE#ifdef GL_ES_VERSION_2_0 OLDCODEvoid glColor3d (double r, double g, double b) { OLDCODE float cols[3]; OLDCODE cols[0] = (float)r; OLDCODE cols[1] = (float)g; OLDCODE cols[2] = (float)b; OLDCODE OLDCODE//printf ("... active shader %d, for ",getAppearanceProperties()->currentShader); OLDCODE//printf ("glColor3d %lf %lf %lf\n",r,g,b); OLDCODE s_shader_capabilities_t *me = getAppearanceProperties()->currentShaderProperties; OLDCODE OLDCODE if (me != NULL) { OLDCODE if (me->myMaterialColour != -1) { OLDCODE GLUNIFORM3FV(me->myMaterialColour,1,cols); OLDCODE } else {
void sendClientStateToGPU(int enable, int cap) { ppRenderFuncs p = (ppRenderFuncs)gglobal()->RenderFuncs.prv; if (getAppearanceProperties()->currentShaderProperties != NULL) { switch (cap) { case GL_NORMAL_ARRAY: p->shaderNormalArray = enable; break; case GL_VERTEX_ARRAY: p->shaderVertexArray = enable; break; case GL_COLOR_ARRAY: p->shaderColourArray = enable; break; case GL_TEXTURE_COORD_ARRAY: p->shaderTextureArray = enable; break; default : {printf ("sendClientStateToGPU, unknown type in shader\n");} } #ifdef RENDERVERBOSE printf ("sendClientStateToGPU: getAppearanceProperties()->currentShaderProperties %p \n",getAppearanceProperties()->currentShaderProperties); if (p->shaderNormalArray) printf ("enabling Normal\n"); else printf ("disabling Normal\n"); if (p->shaderVertexArray) printf ("enabling Vertex\n"); else printf ("disabling Vertex\n"); if (p->shaderColourArray) printf ("enabling Colour\n"); else printf ("disabling Colour\n"); if (p->shaderTextureArray) printf ("enabling Texture\n"); else printf ("disabling Texture\n"); #endif } else { #ifndef GL_ES_VERSION_2_0 if (enable) glEnableClientState(cap); else glDisableClientState(cap); #else //printf ("sendClientStateToGPU - currentShaderProperties not set\n"); #endif } }
static void passedInGenTex(struct textureVertexInfo *genTex) { int c; int i; GLint texUnit[MAX_MULTITEXTURE]; GLint texMode[MAX_MULTITEXTURE]; ttglobal tg = gglobal(); s_shader_capabilities_t *me = getAppearanceProperties()->currentShaderProperties; #ifdef TEXVERBOSE printf ("passedInGenTex, using passed in genTex, textureStackTop %d\n",tg->RenderFuncs.textureStackTop); printf ("passedInGenTex, cubeFace %d\n",getAppearanceProperties()->cubeFace); #endif /* simple shapes, like Boxes and Cones and Spheres will have pre-canned arrays */ if (genTex->pre_canned_textureCoords != NULL) { // printf ("passedInGenTex, A\n"); for (c=0; c<tg->RenderFuncs.textureStackTop; c++) { //printf ("passedInGenTex, c= %d\n",c); /* are we ok with this texture yet? */ if (tg->RenderFuncs.boundTextureStack[c]!=0) { //printf ("passedInGenTex, B\n"); if (setActiveTexture(c,getAppearanceProperties()->transparency,texUnit,texMode)) { struct X3D_Node *tt = getThis_textureTransform(); //printf ("passedInGenTex, C\n"); if (tt!=NULL) do_textureTransform(tt,c); SET_TEXTURE_UNIT_AND_BIND(getAppearanceProperties()->cubeFace,c,tg->RenderFuncs.boundTextureStack[c]); FW_GL_TEXCOORD_POINTER (2,GL_FLOAT,0,genTex->pre_canned_textureCoords); } } } } else { //printf ("passedInGenTex, B\n"); for (c=0; c<tg->RenderFuncs.textureStackTop; c++) { //printf ("passedInGenTex, c=%d\n",c); /* are we ok with this texture yet? */ if (tg->RenderFuncs.boundTextureStack[c]!=0) { //printf ("passedInGenTex, C, boundTextureStack %d\n",tg->RenderFuncs.boundTextureStack[c]); if (setActiveTexture(c,getAppearanceProperties()->transparency,texUnit,texMode)) { //printf ("passedInGenTex, going to bind to texture %d\n",tg->RenderFuncs.boundTextureStack[c]); struct X3D_Node *tt = getThis_textureTransform(); if (tt!=NULL) do_textureTransform(tt,c); SET_TEXTURE_UNIT_AND_BIND(getAppearanceProperties()->cubeFace,c,tg->RenderFuncs.boundTextureStack[c]); FW_GL_TEXCOORD_POINTER (genTex->TC_size, genTex->TC_type, genTex->TC_stride, genTex->TC_pointer); } } } } /* set up the selected shader for this texture(s) config */ if (me != NULL) { //printf ("passedInGenTex, we have tts %d tc %d\n",tg->RenderFuncs.textureStackTop, me->textureCount); if (me->textureCount != -1) glUniform1i(me->textureCount, tg->RenderFuncs.textureStackTop); for (i=0; i<tg->RenderFuncs.textureStackTop; i++) { //printf (" sending in i%d tu %d mode %d\n",i,i,tg->RenderTextures.textureParameterStack[i].multitex_mode); glUniform1i(me->TextureUnit[i],i); glUniform1i(me->TextureMode[i],tg->RenderTextures.textureParameterStack[i].multitex_mode); } #ifdef TEXVERBOSE } else { printf (" NOT sending in %d i+tu+mode because currentShaderProperties is NULL\n",tg->RenderFuncs.textureStackTop); #endif } PRINT_GL_ERROR_IF_ANY(""); }
/* send in vertices, normals, etc, etc... to either a shader or via older opengl methods */ void sendAttribToGPU(int myType, int dataSize, int dataType, int normalized, int stride, float *pointer, char *file, int line){ s_shader_capabilities_t *me = getAppearanceProperties()->currentShaderProperties; #ifdef RENDERVERBOSE printf ("sendAttribToGPU, getAppearanceProperties()->currentShaderProperties %p\n",getAppearanceProperties()->currentShaderProperties); printf ("myType %d, dataSize %d, dataType %d, stride %d\n",myType,dataSize,dataType,stride); if (me != NULL) { switch (myType) { case FW_NORMAL_POINTER_TYPE: printf ("glVertexAttribPointer Normals %d at %s:%d\n",me->Normals,file,line); break; case FW_VERTEX_POINTER_TYPE: printf ("glVertexAttribPointer Vertexs %d at %s:%d\n",me->Vertices,file,line); break; case FW_COLOR_POINTER_TYPE: printf ("glVertexAttribPointer Colours %d at %s:%d\n",me->Colours,file,line); break; case FW_TEXCOORD_POINTER_TYPE: printf ("glVertexAttribPointer TexCoords %d at %s:%d\n",me->TexCoords,file,line); break; default : {printf ("sendAttribToGPU, unknown type in shader\n");} } } #endif if (getAppearanceProperties()->currentShaderProperties != NULL) { switch (myType) { case FW_NORMAL_POINTER_TYPE: if (me->Normals != -1) { glEnableVertexAttribArray(me->Normals); glVertexAttribPointer(me->Normals, 3, dataType, normalized, stride, pointer); } break; case FW_VERTEX_POINTER_TYPE: if (me->Vertices != -1) { glEnableVertexAttribArray(me->Vertices); glVertexAttribPointer(me->Vertices, dataSize, dataType, normalized, stride, pointer); } break; case FW_COLOR_POINTER_TYPE: if (me->Colours != -1) { glEnableVertexAttribArray(me->Colours); glVertexAttribPointer(me->Colours, dataSize, dataType, normalized, stride, pointer); } break; case FW_TEXCOORD_POINTER_TYPE: if (me->TexCoords != -1) { glEnableVertexAttribArray(me->TexCoords); glVertexAttribPointer(me->TexCoords, dataSize, dataType, normalized, stride, pointer); } break; default : {printf ("sendAttribToGPU, unknown type in shader\n");} } /* not shaders; older style of rendering */ } else { #ifndef GL_ES_VERSION_2_0 switch (myType) { case FW_VERTEX_POINTER_TYPE: glVertexPointer(dataSize, dataType, stride, pointer); break; case FW_NORMAL_POINTER_TYPE: glNormalPointer(dataType,stride,pointer); break; case FW_COLOR_POINTER_TYPE: glColorPointer(dataSize, dataType, stride, pointer); break; case FW_TEXCOORD_POINTER_TYPE: glTexCoordPointer(dataSize, dataType, stride, pointer); break; default : {printf ("sendAttribToGPU, unknown type in shader\n");} } #else printf ("not shaders for pointers\n"); #endif } }