Changeset 1053 for OGRE/trunk/ogre_changes/Ogre1.2/OgreMain/src

Timestamp:

06/26/06 09:33:12 (18 years ago)

Author:

szirmay

Message:

 

Location:

OGRE/trunk/ogre_changes/Ogre1.2/OgreMain/src

Files:

• OgreMaterialSerializer.cpp (modified) (2 diffs)
• OgreParticleSystem.cpp (added)
• OgrePass.cpp (modified) (4 diffs)
• OgreSceneManager.cpp (modified) (1 diff)

OGRE/trunk/ogre_changes/Ogre1.2/OgreMain/src/OgreMaterialSerializer.cpp

@@ -248 +248 @@
 
     }
+
+#ifdef GAMETOOLS_ILLUMINATION_MODULE
+        
+        SceneBlendOperation convertBlendOperation(const String& param)
+    {
+        if (param == "add")
+            return SBOP_ADD;
+        else if (param == "subtract")
+                        return SBOP_SUBTRACT;
+        else if (param == "rev_subtract")
+            return SBOP_REVSUBTRACT;
+        else if (param == "min")
+                        return SBOP_MIN;
+        else if (param == "max")
+                        return SBOP_MAX;       
+        else
+        {
+            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid blend operation.", "convertBlendOperation");
+        }
+    }
+
+        bool parseSceneColorBlendOperation(String& params, MaterialScriptContext& context)
+    {
+                SceneBlendOperation op;
+                op = convertBlendOperation(params);
+                context.pass->setSceneBlendOperation(op);
+
+                return false;
+        }
+        bool parseSceneAlphaBlendOperation(String& params, MaterialScriptContext& context)
+        {
+                SceneBlendOperation op;
+                op = convertBlendOperation(params);
+                context.pass->setSceneAlphaBlendOperation(op);
+                context.pass->setSeparateAlphaBlend(true);
+
+                return false;
+        }
+        bool parseSceneAlphaBlend(String& params, MaterialScriptContext& context)
+    {           
+                StringUtil::toLowerCase(params);
+        StringVector vecparams = StringUtil::split(params, " \t");
+        // Should be 1 or 2 params 
+        if (vecparams.size() == 1)
+        {
+            //simple
+            SceneBlendType stype;
+            if (vecparams[0] == "add")
+                stype = SBT_ADD;
+            else if (vecparams[0] == "modulate")
+                stype = SBT_MODULATE;
+                        else if (vecparams[0] == "colour_blend")
+                                stype = SBT_TRANSPARENT_COLOUR;
+            else if (vecparams[0] == "alpha_blend")
+                stype = SBT_TRANSPARENT_ALPHA;
+            else
+            {
+                logParseError(
+                    "Bad scene_blend_alpha attribute, unrecognised parameter '" + vecparams[0] + "'",
+                    context);
+                return false;
+            }
+                        context.pass->setAlphaSceneBlending(stype);
+                        context.pass->setSeparateAlphaBlend(true);
+
+        }
+        else if (vecparams.size() == 2)
+        {
+            //src/dest
+            SceneBlendFactor src, dest;
+
+            try {
+                src = convertBlendFactor(vecparams[0]);
+                dest = convertBlendFactor(vecparams[1]);
+                context.pass->setAlphaSceneBlending(src, dest);
+                                context.pass->setSeparateAlphaBlend(true);
+            }
+            catch (Exception& e)
+            {
+                logParseError("Bad scene_blend_alpha attribute, " + e.getFullDescription(), context);
+            }
+
+        }
+        else
+        {
+            logParseError(
+                "Bad scene_blend_alpha attribute, wrong number of parameters (expected 1 or 2)", 
+                context);
+        }
+
+        return false;
+        }
+
+#endif
     //-----------------------------------------------------------------------
     bool parseSceneBlend(String& params, MaterialScriptContext& context)
@@ -2552 +2646 @@
 
                 mPassAttribParsers.insert(AttribParserList::value_type("IllumTechniques", (ATTRIBUTE_PARSER)parseIllumTechniques));
+                mPassAttribParsers.insert(AttribParserList::value_type("scene_blend_op", (ATTRIBUTE_PARSER)parseSceneColorBlendOperation));
+                mPassAttribParsers.insert(AttribParserList::value_type("scene_blend_op_alpha", (ATTRIBUTE_PARSER)parseSceneAlphaBlendOperation));
+                mPassAttribParsers.insert(AttribParserList::value_type("scene_blend_alpha", (ATTRIBUTE_PARSER)parseSceneAlphaBlend));
                 mIllumTechniqueParsers.insert(AttribParserList::value_type("RenderTechnique", (ATTRIBUTE_PARSER)parseIllumTechniqueParams));
 #endif

OGRE/trunk/ogre_changes/Ogre1.2/OgreMain/src/OgrePass.cpp

@@ -43 +43 @@
 #ifdef GAMETOOLS_ILLUMINATION_MODULE
                 mActive = true;
+                
+                mSeparateAlpha = false;
+                mAlphaSourceBlendFactor = SBF_ONE;    
+                mAlphaDestBlendFactor = SBF_ZERO;
+                mBlendOperation = SBOP_ADD;
+                mAlphaBlendOperation = SBOP_ADD;
 #endif
         // Default to white ambient & diffuse, no specular / emissive
@@ -107 +113 @@
 #ifdef GAMETOOLS_ILLUMINATION_MODULE
                 mActive = true;
+
+                mSeparateAlpha = false;
+                mAlphaSourceBlendFactor = SBF_ONE;    
+                mAlphaDestBlendFactor = SBF_ZERO;
+                mBlendOperation = SBOP_ADD;
+                mAlphaBlendOperation = SBOP_ADD;
 #endif
         *this = oth;
@@ -124 +136 @@
 #ifdef GAMETOOLS_ILLUMINATION_MODULE
                 mActive = oth.mActive;
+                mSeparateAlpha = oth.mSeparateAlpha;
+                mAlphaSourceBlendFactor = oth.mAlphaSourceBlendFactor;    
+                mAlphaDestBlendFactor = oth.mAlphaDestBlendFactor;
+                mBlendOperation = oth.mBlendOperation;
+                mAlphaBlendOperation = oth.mAlphaBlendOperation;
 
                 for(int i = 0; i < oth.illumTechniques.size(); i++ )
@@ -633 +650 @@
             mDestBlendFactor = destFactor;
     }
+
+#ifdef GAMETOOLS_ILLUMINATION_MODULE
+        void Pass::setAlphaSceneBlending(SceneBlendType sbt)
+    {
+            // Turn predefined type into blending factors
+            switch (sbt)
+            {
+            case SBT_TRANSPARENT_ALPHA:
+                    setAlphaSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
+                    break;
+            case SBT_TRANSPARENT_COLOUR:
+                    setAlphaSceneBlending(SBF_SOURCE_COLOUR, SBF_ONE_MINUS_SOURCE_COLOUR);
+                    break;
+                case SBT_MODULATE:
+                        setAlphaSceneBlending(SBF_DEST_COLOUR, SBF_ZERO);
+                        break;
+            case SBT_ADD:
+                    setAlphaSceneBlending(SBF_ONE, SBF_ONE);
+                    break;
+        case SBT_REPLACE:
+            setAlphaSceneBlending(SBF_ONE, SBF_ZERO);
+            break;
+            // TODO: more
+            }
+
+    }
+    //-----------------------------------------------------------------------
+    void Pass::setAlphaSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)
+    {
+                mAlphaSourceBlendFactor = sourceFactor;
+            mAlphaDestBlendFactor = destFactor;
+    }
+#endif
+
     //-----------------------------------------------------------------------
     SceneBlendFactor Pass::getSourceBlendFactor(void) const

OGRE/trunk/ogre_changes/Ogre1.2/OgreMain/src/OgreSceneManager.cpp

@@ -809 +809 @@
 
                 // The rest of the settings are the same no matter whether we use programs or not
-
-                // Set scene blending
+// Set scene blending
+#ifdef GAMETOOLS_ILLUMINATION_MODULE
+                mDestRenderSystem->_setSceneBlending(
+                        pass->getSourceBlendFactor(), 
+                        pass->getDestBlendFactor(),
+                        pass->getSceneBlendOperation(),
+                        pass->getSeparateAlphaBlend(),
+                        pass->getAlphaSceneBlendingSrcFactor(),
+                        pass->getAlphaSceneBlendingDestFactor(),
+                        pass->getSceneBlendOperationAlpha());
+#else
                 mDestRenderSystem->_setSceneBlending(
                         pass->getSourceBlendFactor(), pass->getDestBlendFactor());
+#endif
 
                 // Set point parameters