#5532: Rename ShaderLayer.h to ishaderlayer.h

include/iglrender.h

@@ -3,8 +3,7 @@
 #include "igl.h"
 #include "imodule.h"
 #include "ishaders.h"
-
-#include "ShaderLayer.h"
+#include "ishaderlayer.h"
 
 #include "math/Vector4.h"
 
@@ -173,11 +172,11 @@ class OpenGLState
      * which hold the actual values of many parameters, some of them
      * time-dependent or depending on entity parameters.
      */
-    ShaderLayerPtr stage0;
-    ShaderLayerPtr stage1;
-    ShaderLayerPtr stage2;
-    ShaderLayerPtr stage3;
-    ShaderLayerPtr stage4;
+    ShaderLayer::Ptr stage0;
+    ShaderLayer::Ptr stage1;
+    ShaderLayer::Ptr stage2;
+    ShaderLayer::Ptr stage3;
+    ShaderLayer::Ptr stage4;
 
     /**
      * \brief

include/irender.h

@@ -6,7 +6,7 @@
 #include "math/Vector3.h"
 #include "math/AABB.h"
 
-#include "ShaderLayer.h"
+#include "ishaderlayer.h"
 #include <sigc++/signal.h>
 
 /**

include/ShaderLayer.h → include/ishaderlayer.h

@@ -54,6 +54,7 @@ class BlendFunc
 class ShaderLayer
 {
 public:
+    using Ptr = std::shared_ptr<ShaderLayer>;
 
     /// Enumeration of layer types.
     enum Type
@@ -371,15 +372,9 @@ class ShaderLayer
     virtual int getParseFlags() const = 0;
 };
 
-/**
- * \brief
- * Shader pointer for ShaderLayer,
- */
-typedef std::shared_ptr<ShaderLayer> ShaderLayerPtr;
-
 /**
  * \brief
  * Vector of ShaderLayer pointers.
  */
-typedef std::vector<ShaderLayerPtr> ShaderLayerVector;
+typedef std::vector<ShaderLayer::Ptr> ShaderLayerVector;
 

include/ishaders.h

@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "Texture.h"
-#include "ShaderLayer.h"
+#include "ishaderlayer.h"
 #include "ishaderexpression.h"
 
 class Image;

include/precompiled_interfaces.h

@@ -95,7 +95,7 @@
 #include "mapfile.h"
 #include "modelskin.h"
 #include "ModResource.h"
-#include "ShaderLayer.h"
+#include "ishaderlayer.h"
 #include "StringSerialisable.h"
 #include "Texture.h"
 #include "VolumeIntersectionValue.h"

libs/materials/ParseLib.h

@@ -2,7 +2,7 @@
 
 #include <map>
 #include "ishaders.h"
-#include "ShaderLayer.h"
+#include "ishaderlayer.h"
 
 namespace shaders
 {

radiant/ui/materials/MaterialEditor.cpp

@@ -355,8 +355,8 @@ void MaterialEditor::setupMaterialStageView()
 
 void MaterialEditor::setupStageFlag(const std::string& controlName, int flags)
 {
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>(controlName),
-        [=](const ShaderLayerPtr& layer)
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>(controlName),
+        [=](const ShaderLayer::Ptr& layer)
     {
         return (layer->getStageFlags() & flags) == flags;
     }));
@@ -368,10 +368,10 @@ void MaterialEditor::prepareMaterialForSave()
 }
 
 void MaterialEditor::createExpressionBinding(const std::string& textCtrlName,
-    const std::function<shaders::IShaderExpressionPtr(const ShaderLayerPtr&)>& loadFunc,
-    const std::function<void(const ShaderLayerPtr&, const std::string&)>& saveFunc)
+    const std::function<shaders::IShaderExpressionPtr(const ShaderLayer::Ptr&)>& loadFunc,
+    const std::function<void(const ShaderLayer::Ptr&, const std::string&)>& saveFunc)
 {
-    _stageBindings.emplace(std::make_shared<ExpressionBinding<ShaderLayerPtr>>(
+    _stageBindings.emplace(std::make_shared<ExpressionBinding<ShaderLayer::Ptr>>(
         getControl<wxTextCtrl>(textCtrlName),
         loadFunc,
         std::bind(&MaterialEditor::prepareMaterialForSave, this),
@@ -388,8 +388,8 @@ void MaterialEditor::setupMaterialStageProperties()
     setupStageFlag("MaterialStageFlagMaskDepth", ShaderLayer::FLAG_MASK_DEPTH);
     setupStageFlag("MaterialStageIgnoreAlphaTest", ShaderLayer::FLAG_IGNORE_ALPHATEST);
 
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>("MaterialStageHasAlphaTest"),
-        [](const ShaderLayerPtr& layer)
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>("MaterialStageHasAlphaTest"),
+        [](const ShaderLayer::Ptr& layer)
     {
         return layer->hasAlphaTest();
     }));
@@ -423,17 +423,17 @@ void MaterialEditor::setupMaterialStageProperties()
     }
 
     // Texture
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>("MaterialStageClamp"),
-        [](const ShaderLayerPtr& layer) { return layer->getClampType() == CLAMP_NOREPEAT; }));
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>("MaterialStageNoclamp"),
-        [](const ShaderLayerPtr& layer)
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>("MaterialStageClamp"),
+        [](const ShaderLayer::Ptr& layer) { return layer->getClampType() == CLAMP_NOREPEAT; }));
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>("MaterialStageNoclamp"),
+        [](const ShaderLayer::Ptr& layer)
     { 
         return layer->getClampType() == CLAMP_REPEAT && (layer->getParseFlags() & ShaderLayer::PF_HasNoclampKeyword) != 0; 
     }));
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>("MaterialStageZeroClamp"),
-        [](const ShaderLayerPtr& layer) { return layer->getClampType() == CLAMP_ZEROCLAMP; }));
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>("MaterialStageAlphaZeroClamp"),
-        [](const ShaderLayerPtr& layer) { return layer->getClampType() == CLAMP_ALPHAZEROCLAMP; }));
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>("MaterialStageZeroClamp"),
+        [](const ShaderLayer::Ptr& layer) { return layer->getClampType() == CLAMP_ZEROCLAMP; }));
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>("MaterialStageAlphaZeroClamp"),
+        [](const ShaderLayer::Ptr& layer) { return layer->getClampType() == CLAMP_ALPHAZEROCLAMP; }));
 
     setupStageFlag("MaterialStageFilterNearest", ShaderLayer::FLAG_FILTER_NEAREST);
     setupStageFlag("MaterialStageFilterLinear", ShaderLayer::FLAG_FILTER_LINEAR);
@@ -451,42 +451,42 @@ void MaterialEditor::setupMaterialStageProperties()
     }
 
     createExpressionBinding("MaterialStageTranslateX",
-        [](const ShaderLayerPtr& layer) { return layer->getTranslationExpression(0); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getTranslationExpression(0); });
     createExpressionBinding("MaterialStageTranslateY",
-        [](const ShaderLayerPtr& layer) { return layer->getTranslationExpression(1); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getTranslationExpression(1); });
 
     createExpressionBinding("MaterialStageScaleX",
-        [](const ShaderLayerPtr& layer) { return layer->getScaleExpression(0); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getScaleExpression(0); });
     createExpressionBinding("MaterialStageScaleY",
-        [](const ShaderLayerPtr& layer) { return layer->getScaleExpression(1); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getScaleExpression(1); });
 
     createExpressionBinding("MaterialStageCenterScaleX",
-        [](const ShaderLayerPtr& layer) { return layer->getCenterScaleExpression(0); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getCenterScaleExpression(0); });
     createExpressionBinding("MaterialStageCenterScaleY",
-        [](const ShaderLayerPtr& layer) { return layer->getCenterScaleExpression(1); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getCenterScaleExpression(1); });
 
     createExpressionBinding("MaterialStageShearX",
-        [](const ShaderLayerPtr& layer) { return layer->getShearExpression(0); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getShearExpression(0); });
     createExpressionBinding("MaterialStageShearY",
-        [](const ShaderLayerPtr& layer) { return layer->getShearExpression(1); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getShearExpression(1); });
 
     createExpressionBinding("MaterialStageRotate",
-        [](const ShaderLayerPtr& layer) { return layer->getRotationExpression(); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getRotationExpression(); });
 
     createExpressionBinding("MaterialStageCondition",
-        [](const ShaderLayerPtr& layer) { return layer->getConditionExpression(); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getConditionExpression(); });
 
-    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayerPtr>>(getControl<wxCheckBox>("MaterialStageColored"),
-        [](const ShaderLayerPtr& layer) { return (layer->getParseFlags() & ShaderLayer::PF_HasColoredKeyword) != 0; }));
+    _stageBindings.emplace(std::make_shared<CheckBoxBinding<ShaderLayer::Ptr>>(getControl<wxCheckBox>("MaterialStageColored"),
+        [](const ShaderLayer::Ptr& layer) { return (layer->getParseFlags() & ShaderLayer::PF_HasColoredKeyword) != 0; }));
 
     createExpressionBinding("MaterialStageRed",
-        [](const ShaderLayerPtr& layer) { return layer->getColourExpression(ShaderLayer::COMP_RED); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getColourExpression(ShaderLayer::COMP_RED); });
     createExpressionBinding("MaterialStageGreen",
-        [](const ShaderLayerPtr& layer) { return layer->getColourExpression(ShaderLayer::COMP_GREEN); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getColourExpression(ShaderLayer::COMP_GREEN); });
     createExpressionBinding("MaterialStageBlue",
-        [](const ShaderLayerPtr& layer) { return layer->getColourExpression(ShaderLayer::COMP_BLUE); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getColourExpression(ShaderLayer::COMP_BLUE); });
     createExpressionBinding("MaterialStageAlpha",
-        [](const ShaderLayerPtr& layer) { return layer->getColourExpression(ShaderLayer::COMP_ALPHA); });
+        [](const ShaderLayer::Ptr& layer) { return layer->getColourExpression(ShaderLayer::COMP_ALPHA); });
 
     auto parameterPanel = getControl<wxPanel>("MaterialStageProgramParameters");
     _stageProgramParameters = wxutil::TreeModel::Ptr(new wxutil::TreeModel(_stageProgramColumns, true));
@@ -801,11 +801,11 @@ void MaterialEditor::selectStageByIndex(std::size_t index)
     updateStageControls();
 }
 
-ShaderLayerPtr MaterialEditor::getSelectedStage()
+ShaderLayer::Ptr MaterialEditor::getSelectedStage()
 {
     auto selectedStageItem = _stageView->GetSelection();
 
-    if (!selectedStageItem.IsOk() || !_material) return ShaderLayerPtr();
+    if (!selectedStageItem.IsOk() || !_material) return ShaderLayer::Ptr();
 
     const auto& layers = _material->getAllLayers();
     wxutil::TreeModel::Row stageRow(selectedStageItem, *_stageList);
@@ -816,7 +816,7 @@ ShaderLayerPtr MaterialEditor::getSelectedStage()
         return layers[stageIndex];
     }
 
-    return ShaderLayerPtr();
+    return ShaderLayer::Ptr();
 }
 
 void MaterialEditor::updateStageBlendControls()

radiant/ui/materials/MaterialEditor.h

@@ -35,7 +35,7 @@ class MaterialEditor :
     MaterialPtr _material;
 
     std::set<std::shared_ptr<Binding<MaterialPtr>>> _materialBindings;
-    std::set<std::shared_ptr<Binding<ShaderLayerPtr>>> _stageBindings;
+    std::set<std::shared_ptr<Binding<ShaderLayer::Ptr>>> _stageBindings;
     std::map<Material::DeformType, wxPanel*> _deformPanels;
 
     struct StageProgramParmsColumns :
@@ -78,16 +78,16 @@ class MaterialEditor :
     void setupStageFlag(const std::string& controlName, int flags);
 
     void createExpressionBinding(const std::string& textCtrlName,
-        const std::function<shaders::IShaderExpressionPtr(const ShaderLayerPtr&)>& loadFunc,
-        const std::function<void(const ShaderLayerPtr&, const std::string&)>& saveFunc = std::function<void(const ShaderLayerPtr&, const std::string&)>());
+        const std::function<shaders::IShaderExpressionPtr(const ShaderLayer::Ptr&)>& loadFunc,
+        const std::function<void(const ShaderLayer::Ptr&, const std::string&)>& saveFunc = std::function<void(const ShaderLayer::Ptr&, const std::string&)>());
 
     void updateControlsFromMaterial();
     void updateDeformControlsFromMaterial();
     void updateStageListFromMaterial();
     void updateMaterialPropertiesFromMaterial();
 
     void selectStageByIndex(std::size_t index);
-    ShaderLayerPtr getSelectedStage();
+    ShaderLayer::Ptr getSelectedStage();
 
     void prepareMaterialForSave();
 

radiantcore/rendersystem/backend/OpenGLShader.cpp

@@ -18,9 +18,9 @@ namespace render
 struct OpenGLShader::DBSTriplet
 {
     // DBS layers
-    ShaderLayerPtr diffuse;
-    ShaderLayerPtr bump;
-    ShaderLayerPtr specular;
+    ShaderLayer::Ptr diffuse;
+    ShaderLayer::Ptr bump;
+    ShaderLayer::Ptr specular;
 
     // Need-depth-fill flag
     bool needDepthFill;
@@ -446,7 +446,7 @@ void OpenGLShader::determineBlendModeForEditorPass(OpenGLState& pass)
          i != allLayers.end();
          ++i)
     {
-        const ShaderLayerPtr& layer = *i;
+        const ShaderLayer::Ptr& layer = *i;
 
         if (layer->getType() == ShaderLayer::DIFFUSE)
         {
@@ -522,7 +522,7 @@ void OpenGLShader::constructEditorPreviewPassFromMaterial()
 }
 
 // Append a blend (non-interaction) layer
-void OpenGLShader::appendBlendLayer(const ShaderLayerPtr& layer)
+void OpenGLShader::appendBlendLayer(const ShaderLayer::Ptr& layer)
 {
     TexturePtr layerTex = layer->getTexture();
 

radiantcore/rendersystem/backend/OpenGLShader.h

@@ -48,7 +48,7 @@ class OpenGLShader :
     void constructNormalShader(const std::string& name);
 
     // Shader pass construction helpers
-    void appendBlendLayer(const ShaderLayerPtr& layer);
+    void appendBlendLayer(const ShaderLayer::Ptr& layer);
 
     struct DBSTriplet;
     void appendInteractionLayer(const DBSTriplet& triplet);

radiantcore/rendersystem/backend/OpenGLShaderPass.cpp

@@ -65,7 +65,7 @@ inline void setState(unsigned int state,
     }
 }
 
-inline void evaluateStage(const ShaderLayerPtr& stage, std::size_t time, const IRenderEntity* entity)
+inline void evaluateStage(const ShaderLayer::Ptr& stage, std::size_t time, const IRenderEntity* entity)
 {
     if (stage)
     {
@@ -147,7 +147,7 @@ void OpenGLShaderPass::disableRenderBlend()
     debug::assertNoGlErrors();
 }
 
-void OpenGLShaderPass::setupTextureMatrix(GLenum textureUnit, const ShaderLayerPtr& stage)
+void OpenGLShaderPass::setupTextureMatrix(GLenum textureUnit, const ShaderLayer::Ptr& stage)
 {
     // Set the texture matrix for the given unit
     glActiveTexture(textureUnit);

radiantcore/rendersystem/backend/OpenGLShaderPass.h

@@ -82,7 +82,7 @@ class OpenGLShaderPass
 	// Returns true if the stage associated to this pass is active and should be rendered
 	bool stateIsActive();
 
-	void setupTextureMatrix(GLenum textureUnit, const ShaderLayerPtr& stage);
+	void setupTextureMatrix(GLenum textureUnit, const ShaderLayer::Ptr& stage);
 
 	// Render all of the given TransformedRenderables
 	void renderAllContained(const Renderables& renderables,

radiantcore/shaders/Doom3ShaderLayer.h

@@ -115,6 +115,8 @@ class Doom3ShaderLayer :
     int _parseFlags;
 
 public:
+    using Ptr = std::shared_ptr<Doom3ShaderLayer>;
+
     Doom3ShaderLayer(ShaderTemplate& material, 
                      ShaderLayer::Type type = ShaderLayer::BLEND,
                      const NamedBindablePtr& btex = NamedBindablePtr());
@@ -539,11 +541,5 @@ class Doom3ShaderLayer :
     void setParseFlag(ParseFlags flag);
 };
 
-/**
- * \brief
- * Pointer typedef for Doom3ShaderLayer.
- */
-typedef std::shared_ptr<Doom3ShaderLayer> Doom3ShaderLayerPtr;
-
 }
 

radiantcore/shaders/ShaderTemplate.cpp

@@ -1374,7 +1374,7 @@ void ShaderTemplate::parseDefinition()
 	}
 }
 
-void ShaderTemplate::addLayer(const Doom3ShaderLayerPtr& layer)
+void ShaderTemplate::addLayer(const Doom3ShaderLayer::Ptr& layer)
 {
 	// Add the layer
 	_layers.emplace_back(layer);

radiantcore/shaders/ShaderTemplate.h

@@ -29,12 +29,12 @@ class ShaderTemplate final
 	std::string _name;
 
 	// Temporary current layer (used by the parsing functions)
-	Doom3ShaderLayerPtr _currentLayer;
+	Doom3ShaderLayer::Ptr _currentLayer;
 
 public:
 
   	// Vector of LayerTemplates representing each stage in the material
-    std::vector<Doom3ShaderLayerPtr> _layers;
+    std::vector<Doom3ShaderLayer::Ptr> _layers;
 
     // Editorimage texture
 	NamedBindablePtr _editorTex;
@@ -251,7 +251,7 @@ class ShaderTemplate final
 		return _coverage;
 	}
 
-	const std::vector<Doom3ShaderLayerPtr>& getLayers()
+	const std::vector<Doom3ShaderLayer::Ptr>& getLayers()
 	{
 		if (!_parsed) parseDefinition();
 		return _layers;
@@ -347,7 +347,7 @@ class ShaderTemplate final
 private:
 
 	// Add the given layer and assigns editor preview layer if applicable
-	void addLayer(const Doom3ShaderLayerPtr& layer);
+	void addLayer(const Doom3ShaderLayer::Ptr& layer);
 
 	/**
 	 * Parse a Doom 3 material decl. This is the master parse function, it