Merge lp:~unity-team/nux/nux.fix-839476 into lp:nux/2.0

[Mirco Müller]

Added an rendering-method to allow masking out portions of an image-texture using the alpha-channel of a second texture. Both textures can be modulated by a color if needed.

[lp:~unity-team/nux/nux.fix-839476]

585. By Jay Taoko on 2012-02-25

* Fix to QRP_TexMaskTexAlpha shader in GLSL.

586. By Mirco Müller on 2012-03-27

Re-merge with nux trunk

587. By Mirco Müller on 2012-03-27

Needed to update a vertex- and fragment-program definition

[Mirco Müller (macslow)]

Marked it as "Rejected" as we don't longer need this. A unity-only solution was found and implemented.

Unmerged revisions

587. By Mirco Müller on 2012-03-27

Needed to update a vertex- and fragment-program definition

586. By Mirco Müller on 2012-03-27

Re-merge with nux trunk

585. By Jay Taoko on 2012-02-25

* Fix to QRP_TexMaskTexAlpha shader in GLSL.

584. By Mirco Müller on 2012-02-23

Fixed stupid crash because of calling wrong shader-program. Renamed member for masking-shader.

583. By Mirco Müller on 2012-02-23

Added GLSL- and shader-assembly for QRP_TexMaskTexAlpha()

582. By Mirco Müller on 2012-02-21

Added a color-parameter to each texture for cases when you want to modulate the image-/alpha-texture

581. By Mirco Müller on 2012-02-21

Trying to implement new drawing method for rendering an image-textures masked by an alpha-texture

=== modified file 'NuxGraphics/GraphicsEngine.h'
--- NuxGraphics/GraphicsEngine.h	2012-03-13 02:50:57 +0000
+++ NuxGraphics/GraphicsEngine.h	2012-03-27 15:45:29 +0000
@@ -194,6 +194,14 @@
     void QRP_ColorModTexAlpha(int x, int y, int width, int height,
       ObjectPtr<IOpenGLBaseTexture> DeviceTexture, TexCoordXForm& texxform0, const Color& color);
 
+    void QRP_TexMaskTexAlpha (int x, int y, int width, int height,
+                              ObjectPtr<IOpenGLBaseTexture> ImageTexture,
+                              TexCoordXForm& texxformImage,
+                              const Color& colorImage,
+                              ObjectPtr<IOpenGLBaseTexture> AlphaTexture,
+                              TexCoordXForm& texxformAlpha,
+                              const Color& colorAlpha);
+
     void QRP_2Tex(int x, int y, int width, int height,
       ObjectPtr<IOpenGLBaseTexture> DeviceTexture0, TexCoordXForm& texxform0, const Color& color0,
       ObjectPtr<IOpenGLBaseTexture> DeviceTexture1, TexCoordXForm& texxform1, const Color& color1);
@@ -267,6 +275,18 @@
     void QRP_ASM_ColorModTexAlpha(int x, int y, int width, int height,
                                ObjectPtr<IOpenGLBaseTexture> DeviceTexture, TexCoordXForm& texxform0, const Color& color);
 
+    //! Mask a texture with another texture's alpha.
+    void QRP_ASM_TexMaskTexAlpha(int x,
+                                 int y,
+                                 int width,
+                                 int height,
+                                 ObjectPtr<IOpenGLBaseTexture> imageTexture,
+                                 TexCoordXForm& texxformImage,
+                                 const Color& colorImage,
+                                 ObjectPtr<IOpenGLBaseTexture> alphaTexture,
+                                 TexCoordXForm& texxformAlpha,
+                                 const Color& colorAlpha);
+
     void QRP_ASM_2Tex(int x, int y, int width, int height,
                    ObjectPtr<IOpenGLBaseTexture> DeviceTexture0, TexCoordXForm& texxform0, const Color& color0,
                    ObjectPtr<IOpenGLBaseTexture> DeviceTexture1, TexCoordXForm& texxform1, const Color& color1);
@@ -385,6 +405,18 @@
     void QRP_GLSL_Color(int x, int y, int width, int height, const Color& c0, const Color& c1, const Color& c2, const Color& c3);
     void QRP_GLSL_ColorModTexAlpha(int x, int y, int width, int height,
                                     ObjectPtr<IOpenGLBaseTexture> DeviceTexture, TexCoordXForm& texxform0, const Color& color);
+		  
+    //! Mask a texture with another texture's alpha.
+    void QRP_GLSL_TexMaskTexAlpha(int x,
+                                  int y,
+                                  int width,
+                                  int height,
+                                  ObjectPtr<IOpenGLBaseTexture> imageTexture,
+                                  TexCoordXForm& texxformImage,
+                                  const Color& colorImage,
+                                  ObjectPtr<IOpenGLBaseTexture> alphaTexture,
+                                  TexCoordXForm& texxformAlpha,
+                                  const Color& colorAlpha);
 
     void QRP_GLSL_2Tex(int x, int y, int width, int height,
                         ObjectPtr<IOpenGLBaseTexture> DeviceTexture0, TexCoordXForm& texxform0, const Color& color0,
@@ -829,6 +861,12 @@
     ObjectPtr<IOpenGLAsmShaderProgram> m_AsmColorModTexMaskAlpha;
     ObjectPtr<IOpenGLAsmShaderProgram> m_AsmColorModTexRectMaskAlpha;
 
+    //! Shader function: Mask a texture with another texture's alpha.
+    void InitAsmTexMaskTexAlpha();
+    //! Render polygons with an image-texture, which is masked out by an
+    //! alpha-texture, with each texture being modulated by a color.
+    ObjectPtr<IOpenGLAsmShaderProgram> m_AsmTexMaskTexAlpha;
+
     void InitAsm2TextureAdd();
     //! Render polygons with 2 textures, each modulated by a color, and added together.
     ObjectPtr<IOpenGLAsmShaderProgram> m_Asm2TextureAdd;
@@ -905,6 +943,11 @@
     ObjectPtr<IOpenGLShaderProgram> m_SlColorModTexMaskAlpha;
     ObjectPtr<IOpenGLShaderProgram> m_SlColorModTexRectMaskAlpha;
 
+    void InitSlTextureMasking();
+    //! Render polygons with 1 image-texture, masked by 1 alpha-texture, each texture modulated by a color.
+    //! result = (image*col0)*(alpha.a*col1)
+    ObjectPtr<IOpenGLShaderProgram> m_SlTextureMasking;
+
     void InitSl2TextureAdd();
     //! Render polygons with 2 textures, each modulated by a color, and added together.
     //! result = (tex0*color0)+(tex1*color1)
@@ -915,7 +958,6 @@
     //! result = (tex1(coord1.xy + tex0.xy)*color1)
     ObjectPtr<IOpenGLShaderProgram> m_Sl2TextureDepRead;
 
-
     void InitSl2TextureMod();
     //! Render polygons with 2 textures, each modulated by a color, and then multiplied together.
     //! result = (tex0*color0)*(tex1*color1)

=== modified file 'NuxGraphics/RenderingPipe.cpp'
--- NuxGraphics/RenderingPipe.cpp	2012-03-21 20:37:17 +0000
+++ NuxGraphics/RenderingPipe.cpp	2012-03-27 15:45:29 +0000
@@ -395,6 +395,28 @@
 #endif
   }
 
+  // Render the image-texture masked by the alpha-texture.
+  void GraphicsEngine::QRP_TexMaskTexAlpha (int x,
+                                            int y,
+                                            int width,
+                                            int height,
+                                            ObjectPtr<IOpenGLBaseTexture> imageTexture,
+                                            TexCoordXForm& texxformImage,
+                                             const Color &colorImage,
+                                            ObjectPtr<IOpenGLBaseTexture> alphaTexture,
+                                            TexCoordXForm& texxformAlpha,
+                                             const Color &colorAlpha)
+  {
+#ifndef NUX_OPENGLES_20
+    if (UsingGLSLCodePath())
+      QRP_GLSL_TexMaskTexAlpha (x, y, width, height, imageTexture, texxformImage, colorImage, alphaTexture, texxformAlpha, colorAlpha);
+    else
+      QRP_ASM_TexMaskTexAlpha (x, y, width, height, imageTexture, texxformImage, colorImage, alphaTexture, texxformAlpha, colorAlpha);
+#else
+    QRP_GLSL_TexMaskTexAlpha (x, y, width, height, imageTexture, texxformImage, colorImage, alphaTexture, texxformAlpha, colorAlpha);
+#endif
+  }
+
   // Blend 2 textures together
   void GraphicsEngine::QRP_2Tex(int x, int y, int width, int height,
     ObjectPtr<IOpenGLBaseTexture> DeviceTexture0, TexCoordXForm &texxform0, const Color &color0,

=== modified file 'NuxGraphics/RenderingPipeAsm.cpp'
--- NuxGraphics/RenderingPipeAsm.cpp	2011-10-19 20:32:38 +0000
+++ NuxGraphics/RenderingPipeAsm.cpp	2012-03-27 15:45:29 +0000
@@ -219,6 +219,43 @@
     m_AsmColorModTexRectMaskAlpha->Link();
   }
 
+  void GraphicsEngine::InitAsmTexMaskTexAlpha()
+  {
+    NString AsmVtx = 
+        "!!ARBvp1.0                                             \n\
+        ATTRIB iPos         = vertex.position;                  \n\
+        OUTPUT oPos         = result.position;                  \n\
+        OUTPUT oTexCoord0   = result.texcoord[0];               \n\
+        OUTPUT oTexCoord1   = result.texcoord[1];               \n\
+        # Transform the vertex to clip coordinates.             \n\
+        DP4   oPos.x, state.matrix.mvp.row[0], vertex.position; \n\
+        DP4   oPos.y, state.matrix.mvp.row[1], vertex.position; \n\
+        DP4   oPos.z, state.matrix.mvp.row[2], vertex.position; \n\
+        DP4   oPos.w, state.matrix.mvp.row[3], vertex.position; \n\
+        MOV   oTexCoord0, vertex.attrib[8];                     \n\
+        MOV   oTexCoord1, vertex.attrib[9];                     \n\
+        END";
+
+    NString AsmFrg = 
+        "!!ARBfp1.0                                     \n\
+        PARAM color0 = program.local[0];                \n\
+        PARAM color1 = program.local[1];                \n\
+        TEMP tex0;                                      \n\
+        TEMP tex1;                                      \n\
+        TEMP temp;                                      \n\
+        TEX tex0, fragment.texcoord[0], texture[0], 2D; \n\
+        MUL temp, color0, tex0;                         \n\
+        TEX tex1, fragment.texcoord[1], texture[1], 2D; \n\
+        MAD temp, color1, tex1, temp;                   \n\
+        MOV result.color, temp;                         \n\
+        END";
+
+    m_AsmTexMaskTexAlpha = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
+    m_AsmTexMaskTexAlpha->LoadVertexShader(AsmVtx.GetTCharPtr());
+    m_AsmTexMaskTexAlpha->LoadPixelShader(AsmFrg.GetTCharPtr());
+    m_AsmTexMaskTexAlpha->Link();
+  }
+
   void GraphicsEngine::InitAsm2TextureAdd()
   {
     NString AsmVtx = 
@@ -746,6 +783,81 @@
     shader_program->End();
   }
 
+  // Render the image-texture masked by the alpha-texture.
+  void GraphicsEngine::QRP_ASM_TexMaskTexAlpha (int x,
+                                                int y,
+                                                int width,
+                                                int height,
+                                                ObjectPtr<IOpenGLBaseTexture> imageTexture,
+                                                TexCoordXForm& texxformImage,
+                                                const Color &colorImage,
+                                                ObjectPtr<IOpenGLBaseTexture> alphaTexture,
+                                                TexCoordXForm& texxformAlpha,
+                                                const Color &colorAlpha)
+  {
+    QRP_Compute_Texture_Coord(width, height, imageTexture, texxformImage);
+    QRP_Compute_Texture_Coord(width, height, alphaTexture, texxformAlpha);
+
+    /*float fx = x, fy = y;
+    float VtxBuffer[] =
+    {
+      fx,          fy,          0.0f, 1.0f, texxformImage.u0, texxformImage.v0, 0.0f, 1.0f, texxformAlpha.u0, texxformAlpha.v0, 0.0f, 1.0f,
+      fx,          fy + height, 0.0f, 1.0f, texxformImage.u0, texxformImage.v1, 0.0f, 1.0f, texxformAlpha.u0, texxformAlpha.v1, 0.0f, 1.0f,
+      fx + width,  fy + height, 0.0f, 1.0f, texxformImage.u1, texxformImage.v1, 0.0f, 1.0f, texxformAlpha.u1, texxformAlpha.v1, 0.0f, 1.0f,
+      fx + width,  fy,          0.0f, 1.0f, texxformImage.u1, texxformImage.v0, 0.0f, 1.0f, texxformAlpha.u1, texxformAlpha.v0, 0.0f, 1.0f,
+    };
+
+    CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+    CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+
+    ObjectPtr<IOpenGLAsmShaderProgram> shader_program = m_AsmTexMaskTexAlpha;
+    shader_program->Begin();
+
+    SetTexture(GL_TEXTURE0, imageTexture);
+    SetTexture(GL_TEXTURE1, alphaTexture);
+
+    CHECKGL(glMatrixMode(GL_MODELVIEW));
+    CHECKGL(glLoadIdentity());
+    CHECKGL(glLoadMatrixf((FLOAT *) GetOpenGLModelViewMatrix().m));
+    CHECKGL(glMatrixMode(GL_PROJECTION));
+    CHECKGL(glLoadIdentity());
+    CHECKGL(glLoadMatrixf((FLOAT *) GetOpenGLProjectionMatrix().m));
+
+    int VertexLocation          = VTXATTRIB_POSITION;
+    int TextureCoord0Location   = VTXATTRIB_TEXCOORD0;
+    int TextureCoord1Location   = VTXATTRIB_TEXCOORD1;
+
+    CHECKGL(glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, colorImage.red, colorImage.green, colorImage.blue, colorImage.alpha ));
+    CHECKGL(glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, colorAlpha.red, colorAlpha.green, colorAlpha.blue, colorAlpha.alpha ));
+
+    CHECKGL(glEnableVertexAttribArrayARB(VertexLocation));
+    CHECKGL(glVertexAttribPointerARB((GLuint) VertexLocation, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer));
+
+    if (TextureCoord0Location != -1)
+    {
+      CHECKGL(glEnableVertexAttribArrayARB(TextureCoord0Location));
+      CHECKGL(glVertexAttribPointerARB((GLuint) TextureCoord0Location, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer + 4));
+    }
+
+    if (TextureCoord1Location != -1)
+    {
+      CHECKGL(glEnableVertexAttribArrayARB(TextureCoord1Location));
+      CHECKGL(glVertexAttribPointerARB((GLuint) TextureCoord1Location, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer + 8));
+    }
+
+    CHECKGL(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
+
+    CHECKGL(glDisableVertexAttribArrayARB(VertexLocation));
+
+    if (TextureCoord0Location != -1)
+      CHECKGL(glDisableVertexAttribArrayARB(TextureCoord0Location));
+
+    if (TextureCoord1Location != -1)
+      CHECKGL(glDisableVertexAttribArrayARB(TextureCoord1Location));
+
+    shader_program->End();*/
+  }
+
   void GraphicsEngine::QRP_ASM_2Tex(int x, int y, int width, int height,
                                   ObjectPtr<IOpenGLBaseTexture> device_texture0, TexCoordXForm &texxform0, const Color &color0,
                                   ObjectPtr<IOpenGLBaseTexture> device_texture1, TexCoordXForm &texxform1, const Color &color1)

=== modified file 'NuxGraphics/RenderingPipeGLSL.cpp'
--- NuxGraphics/RenderingPipeGLSL.cpp	2012-03-10 00:16:40 +0000
+++ NuxGraphics/RenderingPipeGLSL.cpp	2012-03-27 15:45:29 +0000
@@ -166,6 +166,61 @@
     m_SlColorModTexMaskAlpha->Link();
   }
 
+  void GraphicsEngine::InitSlTextureMasking()
+  {
+    ObjectPtr<IOpenGLVertexShader> VS = _graphics_display.m_DeviceFactory->CreateVertexShader();
+    ObjectPtr<IOpenGLPixelShader> PS = _graphics_display.m_DeviceFactory->CreatePixelShader();
+    NString VSString;
+    NString PSString;
+
+    // For some strange reason, make sure that the attribute holding the vertex
+	// position has a name that comes first in alphabetic order before all other
+	// attributes. Otherwise you get a bug on NVidia! Why is that???
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+    VSString =        NUX_VERTEX_SHADER_HEADER
+    "uniform mat4 ViewProjectionMatrix;                    \n\
+    attribute vec4 AVertex;                                \n\
+    attribute vec4 imageTextureCoord;                      \n\
+    attribute vec4 alphaTextureCoord;                      \n\
+    varying vec4 varyImageTexCoord;                        \n\
+    varying vec4 varyAlphaTexCoord;                        \n\
+    void main()                                            \n\
+    {                                                      \n\
+      varyImageTexCoord = imageTextureCoord;                 \n\
+      varyAlphaTexCoord = alphaTextureCoord;                 \n\
+      gl_Position =  ViewProjectionMatrix * (AVertex);       \n\
+    }";
+
+    PSString =      NUX_FRAGMENT_SHADER_HEADER
+    "varying vec4 varyImageTexCoord;                         \n\
+    varying vec4 varyAlphaTexCoord;                          \n\
+    uniform vec4 colorImage;                                 \n\
+    uniform vec4 colorAlpha;                                 \n\
+    uniform sampler2D imageTexture;                          \n\
+    uniform sampler2D alphaTexture;                          \n\
+    vec4 SampleTexture(sampler2D TexObject, vec4 TexCoord)   \n\
+    {                                                        \n\
+      return texture2D(TexObject, TexCoord.st);              \n\
+    }                                                        \n\
+    void main()                                              \n\
+    {                                                        \n\
+      vec4 image = colorImage*SampleTexture(imageTexture, varyImageTexCoord); \n\
+      vec4 alpha = colorAlpha*SampleTexture(alphaTexture, varyAlphaTexCoord); \n\
+      gl_FragColor = vec4(image.rgb, alpha.a);               \n\
+    }";
+
+    m_SlTextureMasking = _graphics_display.m_DeviceFactory->CreateShaderProgram();
+    VS->SetShaderCode(TCHAR_TO_ANSI(*VSString));
+    PS->SetShaderCode(TCHAR_TO_ANSI(*PSString), "");
+
+    m_SlTextureMasking->ClearShaderObjects();
+    m_SlTextureMasking->AddShaderObject(VS);
+    m_SlTextureMasking->AddShaderObject(PS);
+    CHECKGL(glBindAttribLocation(m_SlTextureMasking->GetOpenGLID(), 0, "AVertex"));
+    m_SlTextureMasking->Link();
+  }
+
   void GraphicsEngine::InitSl2TextureAdd()
   {
     ObjectPtr<IOpenGLVertexShader> VS = _graphics_display.m_DeviceFactory->CreateVertexShader();
@@ -1060,6 +1115,90 @@
     ShaderProg->End();
   }
 
+  // Render the image-texture masked by the alpha-texture.
+  void GraphicsEngine::QRP_GLSL_TexMaskTexAlpha (int x,
+                                                 int y,
+                                                 int width,
+                                                 int height,
+                                                 ObjectPtr<IOpenGLBaseTexture> imageTexture,
+                                                 TexCoordXForm& texxformImage,
+                                                 const Color &colorImage,
+                                                 ObjectPtr<IOpenGLBaseTexture> alphaTexture,
+                                                 TexCoordXForm& texxformAlpha,
+                                                 const Color &colorAlpha)
+  {
+    if (!m_SlTextureMasking.IsValid())
+        InitSlTextureMasking();
+
+    ObjectPtr<IOpenGLShaderProgram> ShaderProg;
+    ShaderProg = m_SlTextureMasking;
+
+    QRP_Compute_Texture_Coord(width, height, imageTexture, texxformImage);
+    QRP_Compute_Texture_Coord(width, height, alphaTexture, texxformAlpha);
+
+    float fx = x, fy = y;
+    float VtxBuffer[] =
+    {
+      fx,          fy,          0.0f, 1.0f, texxformImage.u0, texxformImage.v0, 0.0f, 1.0f, texxformAlpha.u0, texxformAlpha.v0, 0.0f, 1.0f,
+      fx,          fy + height, 0.0f, 1.0f, texxformImage.u0, texxformImage.v1, 0.0f, 1.0f, texxformAlpha.u0, texxformAlpha.v1, 0.0f, 1.0f,
+      fx + width,  fy + height, 0.0f, 1.0f, texxformImage.u1, texxformImage.v1, 0.0f, 1.0f, texxformAlpha.u1, texxformAlpha.v1, 0.0f, 1.0f,
+      fx + width,  fy,          0.0f, 1.0f, texxformImage.u1, texxformImage.v0, 0.0f, 1.0f, texxformAlpha.u1, texxformAlpha.v0, 0.0f, 1.0f,
+    };
+
+    CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+    CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+    ShaderProg->Begin();
+
+    int imageTextureLoc = ShaderProg->GetUniformLocationARB("imageTexture");
+    int alphaTextureLoc = ShaderProg->GetUniformLocationARB("alphaTexture");
+    int VertexLocation = ShaderProg->GetAttributeLocation("AVertex");
+    int imageTextureCoordLoc = ShaderProg->GetAttributeLocation("imageTextureCoord");
+    int alphaTextureCoordLoc = ShaderProg->GetAttributeLocation("alphaTextureCoord");
+
+    int imageTextureCoefLoc = ShaderProg->GetUniformLocationARB("colorImage");
+    int alphaTextureCoefLoc = ShaderProg->GetUniformLocationARB("colorAlpha");
+
+    SetTexture(GL_TEXTURE0, imageTexture);
+    SetTexture(GL_TEXTURE1, alphaTexture);
+
+    CHECKGL(glUniform1iARB(imageTextureLoc, 0));
+    CHECKGL(glUniform1iARB(alphaTextureLoc, 1));
+
+    CHECKGL(glUniform4fARB(imageTextureCoefLoc, colorImage.red, colorImage.green, colorImage.blue, colorImage.alpha ));
+    CHECKGL(glUniform4fARB(alphaTextureCoefLoc, colorAlpha.red, colorAlpha.green, colorAlpha.blue, colorAlpha.alpha ));
+
+    int     VPMatrixLocation = ShaderProg->GetUniformLocationARB("ViewProjectionMatrix");
+    Matrix4 MVPMatrix = GetOpenGLModelViewProjectionMatrix();
+    ShaderProg->SetUniformLocMatrix4fv((GLint) VPMatrixLocation, 1, false, (GLfloat *) & (MVPMatrix.m));
+
+    CHECKGL(glEnableVertexAttribArrayARB(VertexLocation));
+    CHECKGL(glVertexAttribPointerARB((GLuint) VertexLocation, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer));
+
+    if (imageTextureCoordLoc != -1)
+    {
+      CHECKGL(glEnableVertexAttribArrayARB(imageTextureCoordLoc));
+      CHECKGL(glVertexAttribPointerARB((GLuint) imageTextureCoordLoc, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer + 4));
+    }
+
+    if (alphaTextureCoordLoc != -1)
+    {
+      CHECKGL(glEnableVertexAttribArrayARB(alphaTextureCoordLoc));
+      CHECKGL(glVertexAttribPointerARB((GLuint) alphaTextureCoordLoc, 4, GL_FLOAT, GL_FALSE, 48, VtxBuffer + 8));
+    }
+
+    CHECKGL(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
+
+    CHECKGL(glDisableVertexAttribArrayARB(VertexLocation));
+
+    if (imageTextureCoordLoc != -1)
+      CHECKGL(glDisableVertexAttribArrayARB(imageTextureCoordLoc));
+
+    if (alphaTextureCoordLoc != -1)
+      CHECKGL(glDisableVertexAttribArrayARB(alphaTextureCoordLoc));
+
+    ShaderProg->End();
+  }
+
 // Blend 2 textures together
   void GraphicsEngine::QRP_GLSL_2Tex(int x, int y, int width, int height,
                                        ObjectPtr<IOpenGLBaseTexture> DeviceTexture0, TexCoordXForm &texxform0, const Color &color0,