Removed the PassType enum in favor of hashed pass names, to prepare for freeform/redefinable render pipeline.

Docs/ScriptAPI.dox

@@ -1508,6 +1508,7 @@ Properties:<br>
 - VariantMap vars (readonly)
 - bool active
 - float timeScale
+- float elapsedTime
 - float smoothingConstant
 - float snapThreshold
 - bool asyncLoading (readonly)
@@ -1812,9 +1813,9 @@ Methods:<br>
 - void SendEvent(const String&, VariantMap& arg1 = VariantMap ( ))
 - bool Load(File@)
 - bool Save(File@)
-- Pass@ CreatePass(PassType)
-- void RemovePass(PassType)
-- bool HasPass(PassType) const
+- Pass@ CreatePass(StringHash)
+- void RemovePass(StringHash)
+- bool HasPass(StringHash) const
 
 Properties:<br>
 - ShortStringHash type (readonly)

Engine/Engine/GraphicsAPI.cpp

@@ -338,16 +338,6 @@ static void RegisterMaterial(asIScriptEngine* engine)
     engine->RegisterEnumValue("TextureUnit", "TU_ENVIRONMENT", TU_ENVIRONMENT);
     engine->RegisterEnumValue("TextureUnit", "MAX_MATERIAL_TEXTURE_UNITS", MAX_MATERIAL_TEXTURE_UNITS);
     
-    engine->RegisterEnum("PassType");
-    engine->RegisterEnumValue("PassType", "PASS_BASE", PASS_BASE);
-    engine->RegisterEnumValue("PassType", "PASS_LIGHT", PASS_LIGHT);
-    engine->RegisterEnumValue("PassType", "PASS_PREALPHA", PASS_PREALPHA);
-    engine->RegisterEnumValue("PassType", "PASS_POSTALPHA", PASS_POSTALPHA);
-    engine->RegisterEnumValue("PassType", "PASS_PREPASS", PASS_PREPASS);
-    engine->RegisterEnumValue("PassType", "PASS_MATERIAL", PASS_MATERIAL);
-    engine->RegisterEnumValue("PassType", "PASS_DEFERRED", PASS_DEFERRED);
-    engine->RegisterEnumValue("PassType", "PASS_SHADOW", PASS_SHADOW);
-    
     engine->RegisterEnum("BlendMode");
     engine->RegisterEnumValue("BlendMode", "BLEND_REPLACE", BLEND_REPLACE);
     engine->RegisterEnumValue("BlendMode", "BLEND_ADD", BLEND_ADD);
@@ -386,12 +376,12 @@ static void RegisterMaterial(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Pass", "const String& get_pixelShader() const", asMETHOD(Pass, GetPixelShader), asCALL_THISCALL);
     
     RegisterResource<Technique>(engine, "Technique");
-    engine->RegisterObjectMethod("Technique", "Pass@+ CreatePass(PassType)", asMETHOD(Technique, CreatePass), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Technique", "void RemovePass(PassType)", asMETHOD(Technique, RemovePass), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Technique", "bool HasPass(PassType) const", asMETHOD(Technique, HasPass), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Technique", "Pass@+ CreatePass(StringHash)", asMETHOD(Technique, CreatePass), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Technique", "void RemovePass(StringHash)", asMETHOD(Technique, RemovePass), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Technique", "bool HasPass(StringHash) const", asMETHOD(Technique, HasPass), asCALL_THISCALL);
     engine->RegisterObjectMethod("Technique", "void set_sm3(bool)", asMETHOD(Technique, SetIsSM3), asCALL_THISCALL);
     engine->RegisterObjectMethod("Technique", "bool get_sm3() const", asMETHOD(Technique, IsSM3), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Technique", "Pass@+ get_passes(PassType)", asMETHOD(Technique, GetPass), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Technique", "Pass@+ get_passes(StringHash)", asMETHOD(Technique, GetPass), asCALL_THISCALL);
     
     RegisterResource<Material>(engine, "Material");
     engine->RegisterObjectMethod("Material", "void SetUVTransform(const Vector2&in, float, const Vector2&in)", asMETHODPR(Material, SetUVTransform, (const Vector2&, float, const Vector2&), void), asCALL_THISCALL);

Engine/Graphics/GraphicsDefs.cpp

@@ -69,6 +69,16 @@ StringHash PSP_SHADOWMAPINVSIZE("ShadowMapInvSize");
 StringHash PSP_SHADOWSPLITS("ShadowSplits");
 StringHash PSP_LIGHTMATRICES("LightMatricesPS");
 
+StringHash PASS_BASE("base");
+StringHash PASS_LITBASE("litbase");
+StringHash PASS_LIGHT("light");
+StringHash PASS_SHADOW("shadow");
+StringHash PASS_DEFERRED("deferred");
+StringHash PASS_PREPASS("prepass");
+StringHash PASS_MATERIAL("material");
+StringHash PASS_PREALPHA("prealpha");
+StringHash PASS_POSTALPHA("postalpha");
+
 Vector3 DOT_SCALE(1 / 3.0f, 1 / 3.0f, 1 / 3.0f);
 
 }

Engine/Graphics/GraphicsDefs.h

@@ -177,21 +177,6 @@ enum TextureUsage
     TEXTURE_DEPTHSTENCIL
 };
 
-/// Rendering passes.
-enum PassType
-{
-    PASS_BASE = 0,
-    PASS_LITBASE,
-    PASS_LIGHT,
-    PASS_PREALPHA,
-    PASS_POSTALPHA,
-    PASS_PREPASS,
-    PASS_MATERIAL,
-    PASS_DEFERRED,
-    PASS_SHADOW,
-    MAX_PASSES
-};
-
 /// Cube map faces.
 enum CubeMapFace
 {
@@ -251,7 +236,18 @@ extern StringHash PSP_SHADOWMAPINVSIZE;
 extern StringHash PSP_SHADOWSPLITS;
 extern StringHash PSP_LIGHTMATRICES;
 
-// Scale calculation from bounding box diagonal
+// Inbuild pass types
+extern StringHash PASS_BASE;
+extern StringHash PASS_LITBASE;
+extern StringHash PASS_LIGHT;
+extern StringHash PASS_SHADOW;
+extern StringHash PASS_DEFERRED;
+extern StringHash PASS_PREPASS;
+extern StringHash PASS_MATERIAL;
+extern StringHash PASS_PREALPHA;
+extern StringHash PASS_POSTALPHA;
+
+// Scale calculation from bounding box diagonal.
 extern Vector3 DOT_SCALE;
 
 /// Texture units.

Engine/Graphics/Material.cpp

@@ -408,10 +408,10 @@ Technique* Material::GetTechnique(unsigned index) const
     return index < techniques_.Size() ? techniques_[index].technique_ : (Technique*)0;
 }
 
-Pass* Material::GetPass(unsigned index, PassType pass) const
+Pass* Material::GetPass(unsigned index, StringHash passType) const
 {
     Technique* tech = index < techniques_.Size() ? techniques_[index].technique_ : (Technique*)0;
-    return tech ? tech->GetPass(pass) : 0;
+    return tech ? tech->GetPass(passType) : 0;
 }
 
 Texture* Material::GetTexture(TextureUnit unit) const
@@ -432,7 +432,7 @@ const String& Material::GetTextureUnitName(TextureUnit unit)
 
 void Material::CheckOcclusion()
 {
-    // Determine occlusion by checking the first pass of each technique
+    // Determine occlusion by checking the base pass of each technique
     occlusion_ = false;
     for (unsigned i = 0; i < techniques_.Size(); ++i)
     {

Engine/Graphics/Material.h

@@ -118,7 +118,7 @@ public:
     /// Return technique by index.
     Technique* GetTechnique(unsigned index) const;
     /// Return pass by technique index and pass type.
-    Pass* GetPass(unsigned index, PassType pass) const;
+    Pass* GetPass(unsigned index, StringHash passType) const;
     /// Return texture by unit.
     Texture* GetTexture(TextureUnit unit) const;
    /// Return all textures.

Engine/Graphics/Renderer.cpp

@@ -1050,7 +1050,7 @@ void Renderer::SetBatchShaders(Batch& batch, Technique* tech, bool allowShadows)
             geomType = GEOM_STATIC;
         
         //  Check whether is a pixel lit forward pass. If not, there is only one pixel shader
-        PassType type = batch.pass_->GetType();
+        const StringHash& type = batch.pass_->GetType();
         if (type == PASS_LIGHT || type == PASS_LITBASE)
         {
             LightBatchQueue* lightQueue = batch.lightQueue_;
@@ -1518,7 +1518,7 @@ void Renderer::LoadMaterialShaders(Technique* tech)
     LoadPassShaders(tech, PASS_SHADOW);
 }
 
-void Renderer::LoadPassShaders(Technique* tech, PassType type)
+void Renderer::LoadPassShaders(Technique* tech, StringHash type)
 {
     Pass* pass = tech->GetPass(type);
     if (!pass)

Engine/Graphics/Renderer.h

@@ -338,7 +338,7 @@ private:
     /// Reload shaders for a material technique.
     void LoadMaterialShaders(Technique* tech);
     /// Reload shaders for a material pass.
-    void LoadPassShaders(Technique* tech, PassType type);
+    void LoadPassShaders(Technique* tech, StringHash passType);
     /// Release shaders used in materials.
     void ReleaseMaterialShaders();
     /// Reload textures.

Engine/Graphics/Technique.cpp

@@ -36,20 +36,6 @@
 namespace Urho3D
 {
 
-static const String passNames[] =
-{
-    "base",
-    "litbase",
-    "light",
-    "prealpha",
-    "postalpha",
-    "prepass",
-    "material",
-    "deferred",
-    "shadow",
-    ""
-};
-
 static const String blendModeNames[] =
 {
     "replace",
@@ -74,7 +60,7 @@ static const String compareModeNames[] =
     ""
 };
 
-Pass::Pass(PassType type) :
+Pass::Pass(StringHash type) :
     type_(type),
     blendMode_(BLEND_REPLACE),
     depthTestMode_(CMP_LESSEQUAL),
@@ -158,20 +144,10 @@ bool Technique::Load(Deserializer& source)
     XMLElement passElem = rootElem.GetChild("pass");
     while (passElem)
     {
-        PassType type = MAX_PASSES;
         if (passElem.HasAttribute("name"))
         {
-            String name = passElem.GetAttributeLower("name");
-            type = (PassType)GetStringListIndex(name, passNames, MAX_PASSES);
-            if (type == MAX_PASSES)
-                LOGERROR("Unknown pass " + name);
-        }
-        else
-            LOGERROR("Missing pass name");
-        
-        if (type != MAX_PASSES)
-        {
-            Pass* newPass = CreatePass(type);
+            StringHash nameHash(passElem.GetAttribute("name"));
+            Pass* newPass = CreatePass(nameHash);
             
             if (passElem.HasAttribute("vs"))
                 newPass->SetVertexShader(passElem.GetAttribute("vs"));
@@ -200,17 +176,18 @@ bool Technique::Load(Deserializer& source)
             if (passElem.HasAttribute("alphamask"))
                 newPass->SetAlphaMask(passElem.GetBool("alphamask"));
         }
+        else
+            LOGERROR("Missing pass name");
         
         passElem = passElem.GetNext("pass");
     }
     
+    // Rehash the pass map to ensure minimum load factor and fast queries
+    passes_.Rehash(NextPowerOfTwo(passes_.Size()));
+    
     // Calculate memory use
     unsigned memoryUse = sizeof(Technique);
-    for (unsigned i = 0; i < MAX_PASSES; ++i)
-    {
-        if (passes_[i])
-            memoryUse += sizeof(Pass);
-    }
+    memoryUse += sizeof(HashMap<StringHash, SharedPtr<Pass> >) + passes_.Size() * sizeof(Pass);
     
     SetMemoryUse(memoryUse);
     return true;
@@ -223,34 +200,39 @@ void Technique::SetIsSM3(bool enable)
 
 void Technique::ReleaseShaders()
 {
-    for (unsigned i = 0; i < MAX_PASSES; ++i)
-    {
-        if (passes_[i])
-            passes_[i]->ReleaseShaders();
-    }
+    for (HashMap<StringHash, SharedPtr<Pass> >::Iterator i = passes_.Begin(); i != passes_.End(); ++i)
+        i->second_->ReleaseShaders();
 }
 
-Pass* Technique::CreatePass(PassType pass)
+Pass* Technique::CreatePass(StringHash type)
 {
-    if (!passes_[pass])
-        passes_[pass] = new Pass(pass);
+    Pass* oldPass = GetPass(type);
+    if (oldPass)
+        return oldPass;
+    
+    SharedPtr<Pass> newPass(new Pass(type));
+    passes_[type] = newPass;
     
-    return passes_[pass];
+    // Rehash the pass map to ensure minimum load factor and fast queries
+    passes_.Rehash(NextPowerOfTwo(passes_.Size()));
+    
+    return newPass;
 }
 
-void Technique::RemovePass(PassType pass)
+void Technique::RemovePass(StringHash type)
 {
-    passes_[pass].Reset();
+    passes_.Erase(type);
 }
 
-void Technique::MarkShadersLoaded(unsigned frameNumber)
+Pass* Technique::GetPass(StringHash type) const
 {
-    shadersLoadedFrameNumber_ = frameNumber;
+    HashMap<StringHash, SharedPtr<Pass> >::ConstIterator i = passes_.Find(type);
+    return i != passes_.End() ? i->second_ : (Pass*)0;
 }
 
-const String& Technique::GetPassName(PassType pass)
+void Technique::MarkShadersLoaded(unsigned frameNumber)
 {
-    return passNames[pass];
+    shadersLoadedFrameNumber_ = frameNumber;
 }
 
 }

Engine/Graphics/Technique.h

@@ -36,7 +36,7 @@ class Pass : public RefCounted
 {
 public:
     /// Construct.
-    Pass(PassType type);
+    Pass(StringHash type);
     /// Destruct.
     ~Pass();
     
@@ -56,7 +56,7 @@ public:
     void ReleaseShaders();
     
     /// Return pass type.
-    PassType GetType() const { return type_; }
+    const StringHash& GetType() const { return type_; }
     /// Return blend mode.
     BlendMode GetBlendMode() const { return blendMode_; }
     /// Return depth compare mode.
@@ -76,7 +76,7 @@ public:
     
 private:
     /// Pass type.
-    PassType type_;
+    StringHash type_;
     /// Blend mode.
     BlendMode blendMode_;
     /// Depth compare mode.
@@ -116,33 +116,30 @@ public:
     /// Set whether requires %Shader %Model 3.
     void SetIsSM3(bool enable);
     /// Create a new pass.
-    Pass* CreatePass(PassType pass);
+    Pass* CreatePass(StringHash type);
     /// Remove a pass.
-    void RemovePass(PassType pass);
+    void RemovePass(StringHash type);
     /// Reset shader pointers in all passes.
     void ReleaseShaders();
     /// Mark shaders loaded this frame
     void MarkShadersLoaded(unsigned frameNumber);
     
     /// Return whether has a pass.
-    bool HasPass(PassType pass) const { return passes_[pass] != 0; }
-    /// Return a pass.
-    Pass* GetPass(PassType pass) const { return passes_[pass]; }
+    bool HasPass(StringHash type) const { return passes_.Contains(type); }
+    /// Return a pass, or null if not found.
+    Pass* GetPass(StringHash type) const;
     /// Return whether requires %Shader %Model 3.
     bool IsSM3() const { return isSM3_; }
     /// Return last shaders loaded frame number.
     unsigned GetShadersLoadedFrameNumber() const { return shadersLoadedFrameNumber_; }
     
-    /// Return name for pass.
-    static const String& GetPassName(PassType pass);
-    
 private:
     /// Require %Shader %Model 3 flag.
     bool isSM3_;
     /// Last shaders loaded frame number.
     unsigned shadersLoadedFrameNumber_;
     /// Passes.
-    SharedPtr<Pass> passes_[MAX_PASSES];
+    HashMap<StringHash, SharedPtr<Pass> > passes_;
 };
 
 }