Load shaders per pass when first needed, not to every pass at once.

Engine/Graphics/Renderer.cpp

@@ -1038,14 +1038,15 @@ ShaderVariation* Renderer::GetShader(ShaderType type, const String& name, bool c
 void Renderer::SetBatchShaders(Batch& batch, Technique* tech, bool allowShadows)
 {
     // Check if shaders are unloaded or need reloading
-    Vector<SharedPtr<ShaderVariation> >& vertexShaders = batch.pass_->GetVertexShaders();
-    Vector<SharedPtr<ShaderVariation> >& pixelShaders = batch.pass_->GetPixelShaders();
-    if (!vertexShaders.Size() || !pixelShaders.Size() || tech->GetShadersLoadedFrameNumber() !=
+    Pass* pass = batch.pass_;
+    Vector<SharedPtr<ShaderVariation> >& vertexShaders = pass->GetVertexShaders();
+    Vector<SharedPtr<ShaderVariation> >& pixelShaders = pass->GetPixelShaders();
+    if (!vertexShaders.Size() || !pixelShaders.Size() || pass->GetShadersLoadedFrameNumber() !=
         shadersChangedFrameNumber_)
     {
         // First release all previous shaders, then load
-        tech->ReleaseShaders();
-        LoadMaterialShaders(tech);
+        pass->ReleaseShaders();
+        LoadPassShaders(tech, pass->GetType());
     }
     
     // Make sure shaders are loaded now
@@ -1062,7 +1063,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
-        if (batch.pass_->GetLightingMode() == LIGHTING_PERPIXEL)
+        if (pass->GetLightingMode() == LIGHTING_PERPIXEL)
         {
             LightBatchQueue* lightQueue = batch.lightQueue_;
             if (!lightQueue)
@@ -1132,7 +1133,7 @@ void Renderer::SetBatchShaders(Batch& batch, Technique* tech, bool allowShadows)
         else
         {
             // Check if pass has vertex lighting support
-            if (batch.pass_->GetLightingMode() == LIGHTING_PERVERTEX)
+            if (pass->GetLightingMode() == LIGHTING_PERVERTEX)
             {
                 unsigned numVertexLights = 0;
                 if (batch.lightQueue_)
@@ -1482,19 +1483,14 @@ void Renderer::LoadShaders()
     shadersDirty_ = false;
 }
 
-void Renderer::LoadMaterialShaders(Technique* tech)
-{
-    const HashMap<StringHash, SharedPtr<Pass> >& passes = tech->GetPasses();
-    for (HashMap<StringHash, SharedPtr<Pass> >::ConstIterator i = passes.Begin(); i != passes.End(); ++i)
-        LoadPassShaders(tech, i->first_);
-}
-
 void Renderer::LoadPassShaders(Technique* tech, StringHash type)
 {
     Pass* pass = tech->GetPass(type);
     if (!pass)
         return;
     
+    PROFILE(LoadPassShaders);
+    
     unsigned shadows = (graphics_->GetHardwareShadowSupport() ? 1 : 0) | (shadowQuality_ & SHADOWQUALITY_HIGH_16BIT);
     
     String vertexShaderName = pass->GetVertexShader();
@@ -1558,7 +1554,7 @@ void Renderer::LoadPassShaders(Technique* tech, StringHash type)
         pixelShaders[0] = GetPixelShader(pixelShaderName);
     }
     
-    tech->MarkShadersLoaded(shadersChangedFrameNumber_);
+    pass->MarkShadersLoaded(shadersChangedFrameNumber_);
 }
 
 void Renderer::ReleaseMaterialShaders()

Engine/Graphics/Renderer.h

@@ -339,8 +339,6 @@ private:
     void ResetViews();
     /// Reload shaders.
     void LoadShaders();
-    /// Reload shaders for a material technique.
-    void LoadMaterialShaders(Technique* tech);
     /// Reload shaders for a material pass.
     void LoadPassShaders(Technique* tech, StringHash passType);
     /// Release shaders used in materials.

Engine/Graphics/Technique.cpp

@@ -72,6 +72,7 @@ Pass::Pass(StringHash type) :
     blendMode_(BLEND_REPLACE),
     depthTestMode_(CMP_LESSEQUAL),
     lightingMode_(LIGHTING_UNLIT),
+    shadersLoadedFrameNumber_(0),
     depthWrite_(true),
     alphaMask_(false)
 {
@@ -129,12 +130,16 @@ void Pass::ReleaseShaders()
     pixelShaders_.Clear();
 }
 
+void Pass::MarkShadersLoaded(unsigned frameNumber)
+{
+    shadersLoadedFrameNumber_ = frameNumber;
+}
+
 OBJECTTYPESTATIC(Technique);
 
 Technique::Technique(Context* context) :
     Resource(context),
-    isSM3_(false),
-    shadersLoadedFrameNumber_(0)
+    isSM3_(false)
 {
 }
 
@@ -254,9 +259,4 @@ Pass* Technique::GetPass(StringHash type) const
     return i != passes_.End() ? i->second_ : (Pass*)0;
 }
 
-void Technique::MarkShadersLoaded(unsigned frameNumber)
-{
-    shadersLoadedFrameNumber_ = frameNumber;
-}
-
 }

Engine/Graphics/Technique.h

@@ -63,6 +63,8 @@ public:
     void SetPixelShader(const String& name);
     /// Reset shader pointers.
     void ReleaseShaders();
+    /// Mark shaders loaded this frame.
+    void MarkShadersLoaded(unsigned frameNumber);
     
     /// Return pass type.
     const StringHash& GetType() const { return type_; }
@@ -72,6 +74,8 @@ public:
     CompareMode GetDepthTestMode() const { return depthTestMode_; }
     /// Return pass lighting mode.
     PassLightingMode GetLightingMode() const { return lightingMode_; }
+    /// Return last shaders loaded frame number.
+    unsigned GetShadersLoadedFrameNumber() const { return shadersLoadedFrameNumber_; }
     /// Return depth write mode.
     bool GetDepthWrite() const { return depthWrite_; }
     /// Return alpha masking hint.
@@ -94,6 +98,8 @@ private:
     CompareMode depthTestMode_;
     /// Lighting mode.
     PassLightingMode lightingMode_;
+    /// Last shaders loaded frame number.
+    unsigned shadersLoadedFrameNumber_;
     /// Depth write mode.
     bool depthWrite_;
     /// Alpha masking hint.
@@ -134,8 +140,6 @@ public:
     void RemovePass(StringHash type);
     /// Reset shader pointers in all passes.
     void ReleaseShaders();
-    /// Mark shaders loaded this frame
-    void MarkShadersLoaded(unsigned frameNumber);
     
     /// Return all passes.
     const HashMap<StringHash, SharedPtr<Pass> >& GetPasses() const { return passes_; }
@@ -145,14 +149,10 @@ public:
     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_; }
     
 private:
     /// Require %Shader %Model 3 flag.
     bool isSM3_;
-    /// Last shaders loaded frame number.
-    unsigned shadersLoadedFrameNumber_;
     /// Passes.
     HashMap<StringHash, SharedPtr<Pass> > passes_;
 };