#5893: Basic cube map rendering is working now. The texture transform…

…ation applied in the OpenGLShaderPass has been moved to the shader.

install/gl/cubemap_fp.glsl

@@ -1,12 +1,17 @@
-#version 120
 
-uniform vec3 u_viewOrigin;
+uniform samplerCube u_cubemap;
+uniform vec3		u_view_origin;
 
-varying vec4 var_TexCoord0;
+varying vec3		var_dummy;
 
-void main()
+void	main()
 {
-    gl_FragColor = vec4(1,1,1,1);
-	//gl_FragColor.rgb = vec3(var_TexCoord0);
+    // Swap Y and Z coordinates
+    vec3 texcoord = vec3(var_dummy.x, var_dummy.z, var_dummy.y);
+
+    gl_FragColor = texture(u_cubemap, texcoord);
+
+	// compute final color
+    //gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);
 }
 

install/gl/cubemap_vp.glsl

@@ -1,21 +1,21 @@
-#version 120
 
-// vertex attributes
-attribute vec4 attr_Position;
-attribute vec4 attr_TexCoord0;
-attribute vec3 attr_Tangent;
-attribute vec3 attr_Bitangent;
-attribute vec3 attr_Normal;
+attribute vec4		attr_TexCoord0;
+attribute vec3		attr_Tangent;
+attribute vec3		attr_Bitangent;
+attribute vec3      attr_Normal;
 
-uniform vec3 u_viewOrigin;
+uniform vec3		u_view_origin;
 
-varying vec4 var_TexCoord0;
+varying vec3		var_dummy;
 
-void main()
+void	main()
 {
-    //var_TexCoord0 = attr_Position - vec4(u_viewOrigin, 1);
-    var_TexCoord0 = attr_TexCoord0;
+    var_dummy = gl_Vertex.xyz - u_view_origin;
 
-    gl_Position = attr_Position;
-    gl_FrontColor = gl_Color; // Pass through vertex colour
+	// transform vertex position into homogenous clip-space
+	gl_Position = ftransform();
+
+    // Pass through vertex colour
+    gl_FrontColor = gl_Color;
 }
+

radiantcore/rendersystem/backend/LightInteractions.cpp

@@ -177,7 +177,7 @@ void LightInteractions::render(OpenGLState& state, RenderStateFlags globalFlagsM
 
                 for (auto object : objectList)
                 {
-                    if (state.glProgram && !state.testRenderFlag(RENDER_TEXTURE_CUBEMAP))
+                    if (state.glProgram)
                     {
                         OpenGLShaderPass::setUpLightingCalculation(state, &_light, worldToLight,
                             view.getViewer(), object.get().getObjectTransform(), renderTime, state.isColourInverted());

radiantcore/rendersystem/backend/OpenGLShader.cpp

@@ -681,6 +681,7 @@ void OpenGLShader::appendBlendLayer(const IShaderLayer::Ptr& layer)
         state.glProgram = _renderSystem.getGLProgramFactory().getBuiltInProgram(ShaderProgram::CubeMap);
         state.setRenderFlag(RENDER_PROGRAM);
         state.setRenderFlag(RENDER_TEXTURE_CUBEMAP);
+        state.clearRenderFlag(RENDER_TEXTURE_2D);
     }
     else
     {

radiantcore/rendersystem/backend/OpenGLShaderPass.cpp

@@ -221,6 +221,7 @@ void OpenGLShaderPass::setUpCubeMapAndTexGen(OpenGLState& current,
                                              unsigned requiredState,
                                              const Vector3& viewer)
 {
+#if 0
     if (requiredState & RENDER_TEXTURE_CUBEMAP)
     {
         // Copy cubemap mode enum to current state object
@@ -236,12 +237,12 @@ void OpenGLShaderPass::setUpCubeMapAndTexGen(OpenGLState& current,
 
         // Subtract the viewer position
         transform.translateBy(-viewer);
-
         // Apply to the texture matrix
         glMatrixMode(GL_TEXTURE);
         glLoadMatrixd(transform);
         glMatrixMode(GL_MODELVIEW);
     }
+#endif
 }
 
 // Apply own state to current state object
@@ -658,7 +659,7 @@ void OpenGLShaderPass::setUpLightingCalculation(OpenGLState& current,
     GLuint attenuation_z = lightMat->lightFalloffImage()->getGLTexNum();
 
     // Bind the falloff textures
-    assert(current.testRenderFlag(RENDER_TEXTURE_2D));
+    //assert(current.testRenderFlag(RENDER_TEXTURE_2D));
 
     setTextureState(
         current.texture3, attenuation_xy, GL_TEXTURE3, GL_TEXTURE_2D

radiantcore/rendersystem/backend/glprogram/GLSLCubeMapProgram.cpp

@@ -23,7 +23,6 @@ void GLSLCubeMapProgram::create()
     _programObj = GLProgramFactory::createGLSLProgram(VP_FILENAME, FP_FILENAME);
 
     // Bind vertex attribute locations and link the program
-    glBindAttribLocation(_programObj, GLProgramAttribute::Position, "attr_Position");
     glBindAttribLocation(_programObj, GLProgramAttribute::TexCoord, "attr_TexCoord0");
     glBindAttribLocation(_programObj, GLProgramAttribute::Tangent, "attr_Tangent");
     glBindAttribLocation(_programObj, GLProgramAttribute::Bitangent, "attr_Bitangent");
@@ -32,33 +31,55 @@ void GLSLCubeMapProgram::create()
     glLinkProgram(_programObj);
     debug::assertNoGlErrors();
 
-    _locViewOrigin = glGetUniformLocation(_programObj, "u_viewOrigin");
+    // Set the uniform locations to the correct bound values
+    _locViewOrigin = glGetUniformLocation(_programObj, "u_view_origin");
+
+    glUseProgram(_programObj);
+    debug::assertNoGlErrors();
+
+    GLint samplerLoc;
+
+    //samplerLoc = glGetUniformLocation(_programObj, "u_diffusemap");
+    //glUniform1i(samplerLoc, 0);
+    //
+    //samplerLoc = glGetUniformLocation(_programObj, "u_bumpmap");
+    //glUniform1i(samplerLoc, 1);
+    //
+    //samplerLoc = glGetUniformLocation(_programObj, "u_specularmap");
+    //glUniform1i(samplerLoc, 2);
+    //
+    //samplerLoc = glGetUniformLocation(_programObj, "u_attenuationmap_xy");
+    //glUniform1i(samplerLoc, 3);
+    //
+    //samplerLoc = glGetUniformLocation(_programObj, "u_attenuationmap_z");
+    //glUniform1i(samplerLoc, 4);
+
+    // Texture 0 => cubemap
+    samplerLoc = glGetUniformLocation(_programObj, "u_cubemap");
+    glUniform1i(samplerLoc, 0);
+
+    debug::assertNoGlErrors();
+    glUseProgram(0);
+
+    debug::assertNoGlErrors();
 }
 
 void GLSLCubeMapProgram::enable()
 {
     GLSLProgramBase::enable();
 
-    glEnableVertexAttribArrayARB(GLProgramAttribute::Position);
     glEnableVertexAttribArrayARB(GLProgramAttribute::TexCoord);
     glEnableVertexAttribArrayARB(GLProgramAttribute::Tangent);
     glEnableVertexAttribArrayARB(GLProgramAttribute::Bitangent);
     glEnableVertexAttribArrayARB(GLProgramAttribute::Normal);
 
-    glUniform3f(_locViewOrigin,
-        0,
-        0,
-        0
-    );
-
     debug::assertNoGlErrors();
 }
 
 void GLSLCubeMapProgram::disable()
 {
     GLSLProgramBase::disable();
 
-    glDisableVertexAttribArrayARB(GLProgramAttribute::Position);
     glDisableVertexAttribArrayARB(GLProgramAttribute::TexCoord);
     glDisableVertexAttribArrayARB(GLProgramAttribute::Tangent);
     glDisableVertexAttribArrayARB(GLProgramAttribute::Bitangent);
@@ -68,10 +89,43 @@ void GLSLCubeMapProgram::disable()
 }
 
 void GLSLCubeMapProgram::applyRenderParams(const Vector3& viewer,
-    const Matrix4& localToWorld,
-    const Params&)
+    const Matrix4& objectToWorld,
+    const Params& parms)
 {
+#if 0
+    debug::assertNoGlErrors();
 
+    Matrix4 worldToObject(objectToWorld);
+    worldToObject.invert();
+
+    // Calculate the light origin in object space
+    Vector3 localLight = worldToObject.transformPoint(parms.lightOrigin);
+
+    Matrix4 local2light(parms.world2Light);
+    local2light.multiplyBy(objectToWorld); // local->world->light
+#endif
+    // Set lighting parameters in the shader
+    glUniform3f(_locViewOrigin,
+        static_cast<float>(viewer.x()),
+        static_cast<float>(viewer.y()),
+        static_cast<float>(viewer.z())
+    );
+    debug::assertNoGlErrors();
+#if 0
+    glUniform1i(_locAmbientLight, parms.isAmbientLight);
+
+    // Set vertex colour parameters
+    glUniform1i(_locInvertVCol, parms.invertVertexColour);
+
+    glActiveTexture(GL_TEXTURE3);
+    glClientActiveTexture(GL_TEXTURE3);
+
+    glMatrixMode(GL_TEXTURE);
+    glLoadMatrixd(local2light);
+    glMatrixMode(GL_MODELVIEW);
+
+    debug::assertNoGlErrors();
+#endif
 }
 
 }