CCEffects - Fixes for environment mapping effects and CCRenderTexture

The previous method of finding the transform from an effect to its environment via the
root of the scene did not work when the node and environment were children of a
CCRenderTexture or when they were being manually rendered to a CCRendertTexture
(with direct calls to begin / visit / end). Instead find the transform from the node to its environment
via their closest common ancestor.

This approach is compatible with CCRenderTexture so long as that common ancestor
is a descendant of the render texture (either explicitly via the node graph or implicitly via the
rendering of a node subtree via manual begin / visit / end). If instead the render texture
is a descendant of the common ancestor then there is no way to always find a valid
transform from the node to its environment.

Author: Thayer J Andrews

cocos2d/CCEffectGlass.m

@@ -230,30 +230,53 @@ -(void)buildRenderPasses
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_refractEnvMap"]] = weakSelf.refractionEnvironment.texture ?: [CCTexture none];
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_reflectEnvMap"]] = weakSelf.reflectionEnvironment.texture ?: [CCTexture none];
 
-        // Setup the NDC space to refract environment space matrix.
-        CGAffineTransform worldToRefractEnvTexture =  CCEffectUtilsWorldToEnvironmentTransform(weakSelf.refractionEnvironment);
-        GLKMatrix4 ndcToRefractEnvTextureMat = GLKMatrix4Multiply(CCEffectUtilsMat4FromAffineTransform(worldToRefractEnvTexture), pass.ndcToWorld);
-        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToRefractEnv"]] = [NSValue valueWithGLKMatrix4:ndcToRefractEnvTextureMat];
 
-        // Setup the NDC space to reflect environment space matrix.
-        CGAffineTransform worldToReflectEnvTexture = CCEffectUtilsWorldToEnvironmentTransform(weakSelf.reflectionEnvironment);
-        GLKMatrix4 ndcToReflectEnvTextureMat = GLKMatrix4Multiply(CCEffectUtilsMat4FromAffineTransform(worldToReflectEnvTexture), pass.ndcToWorld);
-        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToReflectEnv"]] = [NSValue valueWithGLKMatrix4:ndcToReflectEnvTextureMat];
+        
+        // Get the transform from the affected node's local coordinates to the environment node.
+        GLKMatrix4 effectNodeToRefractEnvNode = CCEffectUtilsTransformFromNodeToNode(pass.node, weakSelf.refractionEnvironment, nil);
+        
+        // Concatenate the node to environment transform with the environment node to environment texture transform.
+        // The result takes us from the affected node's coordinates to the environment's texture coordinates. We need
+        // this when computing the tangent and normal vectors below.
+        GLKMatrix4 effectNodeToRefractEnvTexture = GLKMatrix4Multiply(CCEffectUtilsMat4FromAffineTransform(weakSelf.refractionEnvironment.nodeToTextureTransform), effectNodeToRefractEnvNode);
+        
+        // Concatenate the node to environment texture transform together with the transform from NDC to local node
+        // coordinates. (NDC == normalized device coordinates == render target coordinates that are normalized to the
+        // range 0..1). The shader uses this to map from NDC directly to environment texture coordinates.
+        GLKMatrix4 ndcToRefractEnvTexture = GLKMatrix4Multiply(effectNodeToRefractEnvTexture, pass.ndcToNodeLocal);
+        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToRefractEnv"]] = [NSValue valueWithGLKMatrix4:ndcToRefractEnvTexture];
 
         // Setup the tangent and binormal vectors for the refraction environment
-        GLKVector4 refractTangent = CCEffectUtilsTangentInEnvironmentSpace(pass.transform, CCEffectUtilsMat4FromAffineTransform(worldToRefractEnvTexture));
+        GLKVector4 refractTangent = GLKVector4Normalize(GLKMatrix4MultiplyVector4(effectNodeToRefractEnvTexture, GLKVector4Make(1.0f, 0.0f, 0.0f, 0.0f)));
         GLKVector4 refractNormal = GLKVector4Make(0.0f, 0.0f, 1.0f, 1.0f);
         GLKVector4 refractBinormal = GLKVector4CrossProduct(refractNormal, refractTangent);
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_refractTangent"]] = [NSValue valueWithGLKVector2:GLKVector2Make(refractTangent.x, refractTangent.y)];
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_refractBinormal"]] = [NSValue valueWithGLKVector2:GLKVector2Make(refractBinormal.x, refractBinormal.y)];
 
-        // Setup the tangent and binormal vectors for the reflection environment.
-        GLKVector4 reflectTangent = CCEffectUtilsTangentInEnvironmentSpace(pass.transform, CCEffectUtilsMat4FromAffineTransform(worldToReflectEnvTexture));
+        
+        
+        // Get the transform from the affected node's local coordinates to the environment node.
+        GLKMatrix4 effectNodeToReflectEnvNode = CCEffectUtilsTransformFromNodeToNode(pass.node, weakSelf.reflectionEnvironment, nil);
+        
+        // Concatenate the node to environment transform with the environment node to environment texture transform.
+        // The result takes us from the affected node's coordinates to the environment's texture coordinates. We need
+        // this when computing the tangent and normal vectors below.
+        GLKMatrix4 effectNodeToReflectEnvTexture = GLKMatrix4Multiply(CCEffectUtilsMat4FromAffineTransform(weakSelf.reflectionEnvironment.nodeToTextureTransform), effectNodeToReflectEnvNode);
+        
+        // Concatenate the node to environment texture transform together with the transform from NDC to local node
+        // coordinates. (NDC == normalized device coordinates == render target coordinates that are normalized to the
+        // range 0..1). The shader uses this to map from NDC directly to environment texture coordinates.
+        GLKMatrix4 ndcToReflectEnvTexture = GLKMatrix4Multiply(effectNodeToReflectEnvTexture, pass.ndcToNodeLocal);
+        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToReflectEnv"]] = [NSValue valueWithGLKMatrix4:ndcToReflectEnvTexture];
+        
+        // Setup the tangent and binormal vectors for the reflection environment
+        GLKVector4 reflectTangent = GLKVector4Normalize(GLKMatrix4MultiplyVector4(effectNodeToReflectEnvTexture, GLKVector4Make(1.0f, 0.0f, 0.0f, 0.0f)));
         GLKVector4 reflectNormal = GLKVector4Make(0.0f, 0.0f, 1.0f, 1.0f);
         GLKVector4 reflectBinormal = GLKVector4CrossProduct(reflectNormal, reflectTangent);
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_reflectTangent"]] = [NSValue valueWithGLKVector2:GLKVector2Make(reflectTangent.x, reflectTangent.y)];
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_reflectBinormal"]] = [NSValue valueWithGLKVector2:GLKVector2Make(reflectBinormal.x, reflectBinormal.y)];
-
+        
+        
     } copy]];
 
     self.renderPasses = @[pass0];

cocos2d/CCEffectReflection.m

@@ -139,8 +139,8 @@ -(void)buildFragmentFunctions
 
                                    float fresnel = max(u_fresnelBias + (1.0 - u_fresnelBias) * pow((1.0 - nDotV), u_fresnelPower), 0.0);
 
-                                   // If the refracted texture coordinates are within the bounds of the environment map
-                                   // blend the primary color with the refracted environment. Multiplying by the normal
+                                   // If the reflected texture coordinates are within the bounds of the environment map
+                                   // blend the primary color with the reflected environment. Multiplying by the normal
                                    // map alpha also allows the effect to be disabled for specific pixels.
                                    primaryColor += normalMap.a * fresnel * u_shininess * texture2D(u_envMap, reflectTexCoords);
                                    return primaryColor;
@@ -198,26 +198,28 @@ -(void)buildRenderPasses
 
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_envMap"]] = weakSelf.environment.texture ?: [CCTexture none];
 
-        // Get the transform from world space to environment texture space. This is
-        // concatenated with the current transform to move from local node space to
-        // environment texture space.
-        CGAffineTransform worldToReflectEnvTexture =  CCEffectUtilsWorldToEnvironmentTransform(weakSelf.environment);
 
-        // Setup the tangent and binormal vectors for the refraction environment
-        GLKVector4 reflectTangent = CCEffectUtilsTangentInEnvironmentSpace(pass.transform, CCEffectUtilsMat4FromAffineTransform(worldToReflectEnvTexture));
+        // Get the transform from the affected node's local coordinates to the environment node.
+        GLKMatrix4 effectNodeToReflectEnvNode = CCEffectUtilsTransformFromNodeToNode(pass.node, weakSelf.environment, nil);
+        
+        // Concatenate the node to environment transform with the environment node to environment texture transform.
+        // The result takes us from the affected node's coordinates to the environment's texture coordinates. We need
+        // this when computing the tangent and normal vectors below.
+        GLKMatrix4 effectNodeToReflectEnvTexture = GLKMatrix4Multiply(CCEffectUtilsMat4FromAffineTransform(weakSelf.environment.nodeToTextureTransform), effectNodeToReflectEnvNode);
+        
+        // Concatenate the node to environment texture transform together with the transform from NDC to local node
+        // coordinates. (NDC == normalized device coordinates == render target coordinates that are normalized to the
+        // range 0..1). The shader uses this to map from NDC directly to environment texture coordinates.
+        GLKMatrix4 ndcToReflectEnvTexture = GLKMatrix4Multiply(effectNodeToReflectEnvTexture, pass.ndcToNodeLocal);
+        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToEnv"]] = [NSValue valueWithGLKMatrix4:ndcToReflectEnvTexture];
+        
+        // Setup the tangent and binormal vectors for the reflection environment
+        GLKVector4 reflectTangent = GLKVector4Normalize(GLKMatrix4MultiplyVector4(effectNodeToReflectEnvTexture, GLKVector4Make(1.0f, 0.0f, 0.0f, 0.0f)));
         GLKVector4 reflectNormal = GLKVector4Make(0.0f, 0.0f, 1.0f, 1.0f);
         GLKVector4 reflectBinormal = GLKVector4CrossProduct(reflectNormal, reflectTangent);
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_tangent"]] = [NSValue valueWithGLKVector2:GLKVector2Make(reflectTangent.x, reflectTangent.y)];
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_binormal"]] = [NSValue valueWithGLKVector2:GLKVector2Make(reflectBinormal.x, reflectBinormal.y)];
 
-        // Setup the transform from normalized device coordinates (NDC, which is the space our vertex
-        // positions are in) to environment texture space. We use this to compute environment texture
-        // coordinates in the vertex shader.s
-        GLKMatrix4 worldToReflectEnvTextureMat = CCEffectUtilsMat4FromAffineTransform(worldToReflectEnvTexture);
-        GLKMatrix4 ndcToReflectEnvTextureMat = GLKMatrix4Multiply(worldToReflectEnvTextureMat, pass.ndcToWorld);
-
-        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToEnv"]] = [NSValue valueWithGLKMatrix4:ndcToReflectEnvTextureMat];
-        
     } copy]];
 
     self.renderPasses = @[pass0];

cocos2d/CCEffectRefraction.m

@@ -161,26 +161,27 @@ -(void)buildRenderPasses
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_refraction"]] = [NSNumber numberWithFloat:weakSelf.conditionedRefraction];
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_envMap"]] = weakSelf.environment.texture ?: [CCTexture none];
 
-        // Get the transform from world space to environment texture space. This is
-        // concatenated with the current transform to move from local node space to
-        // environment texture space.
-        CGAffineTransform worldToRefractEnvTexture =  CCEffectUtilsWorldToEnvironmentTransform(weakSelf.environment);
+        // Get the transform from the affected node's local coordinates to the environment node.
+        GLKMatrix4 effectNodeToRefractEnvNode = CCEffectUtilsTransformFromNodeToNode(pass.node, weakSelf.environment, nil);
+
+        // Concatenate the node to environment transform with the environment node to environment texture transform.
+        // The result takes us from the affected node's coordinates to the environment's texture coordinates. We need
+        // this when computing the tangent and normal vectors below.
+        GLKMatrix4 effectNodeToRefractEnvTexture = GLKMatrix4Multiply(CCEffectUtilsMat4FromAffineTransform(weakSelf.environment.nodeToTextureTransform), effectNodeToRefractEnvNode);
+
+        // Concatenate the node to environment texture transform together with the transform from NDC to local node
+        // coordinates. (NDC == normalized device coordinates == render target coordinates that are normalized to the
+        // range 0..1). The shader uses this to map from NDC directly to environment texture coordinates.
+        GLKMatrix4 ndcToRefractEnvTexture = GLKMatrix4Multiply(effectNodeToRefractEnvTexture, pass.ndcToNodeLocal);
+        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToEnv"]] = [NSValue valueWithGLKMatrix4:ndcToRefractEnvTexture];
 
         // Setup the tangent and binormal vectors for the refraction environment
-        GLKVector4 refractTangent = CCEffectUtilsTangentInEnvironmentSpace(pass.transform, CCEffectUtilsMat4FromAffineTransform(worldToRefractEnvTexture));
+        GLKVector4 refractTangent = GLKVector4Normalize(GLKMatrix4MultiplyVector4(effectNodeToRefractEnvTexture, GLKVector4Make(1.0f, 0.0f, 0.0f, 0.0f)));
         GLKVector4 refractNormal = GLKVector4Make(0.0f, 0.0f, 1.0f, 1.0f);
         GLKVector4 refractBinormal = GLKVector4CrossProduct(refractNormal, refractTangent);
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_tangent"]] = [NSValue valueWithGLKVector2:GLKVector2Make(refractTangent.x, refractTangent.y)];
         pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_binormal"]] = [NSValue valueWithGLKVector2:GLKVector2Make(refractBinormal.x, refractBinormal.y)];
 
-        // Setup the transform from normalized device coordinates (NDC, which is the space our vertex
-        // positions are in) to environment texture space. We use this to compute environment texture
-        // coordinates in the vertex shader.s
-        GLKMatrix4 worldToRefractEnvTextureMat = CCEffectUtilsMat4FromAffineTransform(worldToRefractEnvTexture);
-        GLKMatrix4 ndcToRefractEnvTextureMat = GLKMatrix4Multiply(worldToRefractEnvTextureMat, pass.ndcToWorld);
-        
-        pass.shaderUniforms[weakSelf.uniformTranslationTable[@"u_ndcToEnv"]] = [NSValue valueWithGLKMatrix4:ndcToRefractEnvTextureMat];
-
     } copy]];
 
     self.renderPasses = @[pass0];

cocos2d/CCEffectRenderer.m

@@ -11,8 +11,8 @@
 #import "CCDirector.h"
 #import "CCEffect.h"
 #import "CCEffectStack.h"
+#import "CCEffectUtils.h"
 #import "CCTexture.h"
-#import "ccUtils.h"
 
 #import "CCEffect_Private.h"
 #import "CCRenderer_Private.h"
@@ -249,6 +249,7 @@ -(void)drawSprite:(CCSprite *)sprite withEffect:(CCEffect *)effect uniforms:(NSM
         }
         renderPass.renderer = renderer;
         renderPass.renderPassId = i;
+        renderPass.node = sprite;
 
         if (fromIntermediate && (renderPass.indexInEffect == 0))
         {
@@ -288,10 +289,7 @@ -(void)drawSprite:(CCSprite *)sprite withEffect:(CCEffect *)effect uniforms:(NSM
         if (toFramebuffer)
         {
             renderPass.transform = *transform;
-
-            GLKMatrix4 ndcToWorldMat;
-            [renderer.globalShaderUniforms[CCShaderUniformProjectionInv] getValue:&ndcToWorldMat];
-            renderPass.ndcToWorld = ndcToWorldMat;
+            renderPass.ndcToNodeLocal = GLKMatrix4Invert(*transform, nil);
 
             [renderPass begin:previousPassTexture];
             [renderPass update];
@@ -305,15 +303,8 @@ -(void)drawSprite:(CCSprite *)sprite withEffect:(CCEffect *)effect uniforms:(NSM
             GLKMatrix4 invRenderTargetProjection = GLKMatrix4Invert(renderTargetProjection, &inverted);
             NSAssert(inverted, @"Unable to invert matrix.");
 
-            GLKMatrix4 invGlobalProjection;
-            [renderer.globalShaderUniforms[CCShaderUniformProjectionInv] getValue:&invGlobalProjection];
-            
-            GLKMatrix4 ndcToNodeMat = invRenderTargetProjection;
-            GLKMatrix4 nodeToWorldMat = GLKMatrix4Multiply(invGlobalProjection, *transform);
-            GLKMatrix4 ndcToWorldMat = GLKMatrix4Multiply(nodeToWorldMat, ndcToNodeMat);
-
             renderPass.transform = renderTargetProjection;
-            renderPass.ndcToWorld = ndcToWorldMat;
+            renderPass.ndcToNodeLocal = invRenderTargetProjection;
 
             CGSize rtSize = CGSizeMake((_contentSize.width + 2 * effect.padding.width) * _contentScale, (_contentSize.height + 2 * effect.padding.height) * _contentScale);
             rtSize.width = (rtSize.width <= 1.0f) ? 1.0f : rtSize.width;

cocos2d/CCEffectUtils.h

@@ -8,9 +8,8 @@
 
 #import "CCSprite.h"
 
+GLKMatrix4 CCEffectUtilsTransformFromNodeToNode(CCNode *first, CCNode *second, BOOL *isPossible);
 
-CGAffineTransform CCEffectUtilsWorldToEnvironmentTransform(CCSprite *environment);
-GLKVector4 CCEffectUtilsTangentInEnvironmentSpace(GLKMatrix4 effectToWorldMat, GLKMatrix4 worldToEnvMat);
 GLKMatrix4 CCEffectUtilsMat4FromAffineTransform(CGAffineTransform at);
 float CCEffectUtilsConditionRefraction(float refraction);
 float CCEffectUtilsConditionShininess(float shininess);