Python

src/Renderer/Drawers/SceneDrawer.cpp

@@ -84,17 +84,17 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 {
 	uint textureUnit = 0;
 
-	const Material& mtl = mtlr.getMaterial();
-	mtl.getShaderProg().bind();
+	//const Material& mtl = mtlr.getMaterial();
+	mtlr.getMaterial().getShaderProg().bind();
 
 	//
 	// FFP stuff
 	//
-	if(mtl.isBlendingEnabled())
+	if(mtlr.isBlendingEnabled())
 	{
 		glEnable(GL_BLEND);
 		//glDisable(GL_BLEND);
-		glBlendFunc(mtl.getBlendingSfactor(), mtl.getBlendingDfactor());
+		glBlendFunc(mtlr.getBlendingSfactor(), mtlr.getBlendingDfactor());
 	}
 	else
 	{
@@ -102,7 +102,7 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 	}
 
 
-	if(mtl.isDepthTestingEnabled())
+	if(mtlr.isDepthTestingEnabled())
 	{
 		glEnable(GL_DEPTH_TEST);
 	}
@@ -111,7 +111,7 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 		glDisable(GL_DEPTH_TEST);
 	}
 
-	if(mtl.isWireframeEnabled())
+	if(mtlr.isWireframeEnabled())
 	{
 		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 	}
@@ -132,104 +132,104 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 	Mat4 modelViewProjectionMat;
 
 	// should I calculate the modelViewMat ?
-	if(mtl.getStdUniVar(Material::SUV_MODELVIEW_MAT) ||
-	   mtl.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT) ||
-	   mtl.getStdUniVar(Material::SUV_NORMAL_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_MODELVIEW_MAT) ||
+	   mtlr.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT) ||
+	   mtlr.getStdUniVar(Material::SUV_NORMAL_MAT))
 	{
 		modelViewMat = Mat4::combineTransformations(viewMat, modelMat);
 	}
 
 	// set matrices
-	if(mtl.getStdUniVar(Material::SUV_MODEL_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_MODEL_MAT))
 	{
-		mtl.getStdUniVar(Material::SUV_MODEL_MAT)->set(&modelMat);
+		mtlr.getStdUniVar(Material::SUV_MODEL_MAT)->set(&modelMat);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_VIEW_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_VIEW_MAT))
 	{
-		mtl.getStdUniVar(Material::SUV_VIEW_MAT)->set(&viewMat);
+		mtlr.getStdUniVar(Material::SUV_VIEW_MAT)->set(&viewMat);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_PROJECTION_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_PROJECTION_MAT))
 	{
-		mtl.getStdUniVar(Material::SUV_PROJECTION_MAT)->set(&projectionMat);
+		mtlr.getStdUniVar(Material::SUV_PROJECTION_MAT)->set(&projectionMat);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_MODELVIEW_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_MODELVIEW_MAT))
 	{
-		mtl.getStdUniVar(Material::SUV_MODELVIEW_MAT)->set(&modelViewMat);
+		mtlr.getStdUniVar(Material::SUV_MODELVIEW_MAT)->set(&modelViewMat);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT))
 	{
-		mtl.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT)->set(&r.getViewProjectionMat());
+		mtlr.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT)->set(&r.getViewProjectionMat());
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_NORMAL_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_NORMAL_MAT))
 	{
 		normalMat = modelViewMat.getRotationPart();
-		mtl.getStdUniVar(Material::SUV_NORMAL_MAT)->set(&normalMat);
+		mtlr.getStdUniVar(Material::SUV_NORMAL_MAT)->set(&normalMat);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT))
+	if(mtlr.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT))
 	{
 		modelViewProjectionMat = projectionMat * modelViewMat;
-		mtl.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT)->set(&modelViewProjectionMat);
+		mtlr.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT)->set(&modelViewProjectionMat);
 	}
 
 
 	//
 	// FAis
 	//
-	if(mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_MS_NORMAL_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI)->set(r.getMs().getNormalFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_MS_NORMAL_FAI)->set(r.getMs().getNormalFai(), textureUnit++);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI)->set(r.getMs().getDiffuseFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI)->set(r.getMs().getDiffuseFai(), textureUnit++);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_MS_SPECULAR_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI)->set(r.getMs().getSpecularFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_MS_SPECULAR_FAI)->set(r.getMs().getSpecularFai(), textureUnit++);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_MS_DEPTH_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI)->set(r.getMs().getDepthFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_MS_DEPTH_FAI)->set(r.getMs().getDepthFai(), textureUnit++);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_IS_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_IS_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_IS_FAI)->set(r.getIs().getFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_IS_FAI)->set(r.getIs().getFai(), textureUnit++);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI)->set(r.getPps().getPrePassFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI)->set(r.getPps().getPrePassFai(), textureUnit++);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI))
+	if(mtlr.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI)->set(r.getPps().getPostPassFai(), textureUnit++);
+		mtlr.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI)->set(r.getPps().getPostPassFai(), textureUnit++);
 	}
 
 
 	//
 	// Other
 	//
-	if(mtl.getStdUniVar(Material::SUV_RENDERER_SIZE))
+	if(mtlr.getStdUniVar(Material::SUV_RENDERER_SIZE))
 	{
 		Vec2 v(r.getWidth(), r.getHeight());
-		mtl.getStdUniVar(Material::SUV_RENDERER_SIZE)->set(&v);
+		mtlr.getStdUniVar(Material::SUV_RENDERER_SIZE)->set(&v);
 	}
 
-	if(mtl.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR))
+	if(mtlr.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR))
 	{
 		Vec3 col(SceneSingleton::getInstance().getAmbientCol());
-		mtl.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR)->set(&col);
+		mtlr.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR)->set(&col);
 	}
 
 

src/Resources/LightRsrc.cpp

@@ -74,7 +74,7 @@ void LightRsrc::load(const char* filename)
 			radius = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() :
 			                                                     float(token->getValue().getInt());
 		}
-		// castsShadow
+		// castsShadowFlag
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "castsShadow"))
 		{
 			token = &scanner.getNextToken();

src/Resources/Material/Material.cpp

@@ -114,12 +114,12 @@ static bool searchBlendEnum(const char* str, int& gl_enum)
 //======================================================================================================================
 Material::Material()
 {
-	blendingStage = false;
+	renderInBlendingStageFlag = false;
 	blendingSfactor = GL_ONE;
 	blendingDfactor = GL_ZERO;
 	depthTesting = true;
 	wireframe = false;
-	castsShadow = true;
+	castsShadowFlag = true;
 }
 
 
@@ -179,12 +179,12 @@ void Material::load(const char* filename)
 		}
 
 		//
-		// blendingStage
+		// renderInBlendingStageFlag
 		//
 		boost::optional<bool> blendingStage_ = PropertyTree::getBoolOptional(pt, "blendingStage");
 		if(blendingStage_)
 		{
-			blendingStage = blendingStage_.get();
+			renderInBlendingStageFlag = blendingStage_.get();
 		}
 
 		//
@@ -267,7 +267,7 @@ void Material::load(const char* filename)
 
 						if(texture)
 						{
-							userDefinedVars.push_back(new MtlUserDefinedVar(uni, texture.get().c_str()));
+							userDefinedVars.push_back(new MtlUserDefinedVar(uni, texture.get()));
 						}
 						else if(fai)
 						{

src/Resources/Material/Material.h

@@ -10,6 +10,19 @@
 #include "MtlUserDefinedVar.h"
 
 
+/// Contains a few properties that other classes may use
+struct MaterialProps
+{
+	bool castsShadowFlag; ///< Used in depth passes of shadowmapping and not in other depth passes like EarlyZ
+	/// The entities with blending are being rendered in blending stage and those without in material stage
+	bool renderInBlendingStageFlag;
+	int blendingSfactor; ///< Default GL_ONE
+	int blendingDfactor; ///< Default GL_ZERO
+	bool depthTesting;
+	bool wireframe;
+};
+
+
 /// Mesh material Resource
 ///
 /// Every material keeps info of how to render a MeshNode. Among this info it keeps the locations of attribute and
@@ -34,7 +47,7 @@
 /// 		<customDpSProg>...</customDpSProg>
 /// 	</shaderProg>
 ///
-/// 	[<blendingStage>true|false</blendingStage>]
+/// 	[<renderInBlendingStageFlag>true|false</renderInBlendingStageFlag>]
 ///
 /// 	[<blendFuncs> *
 /// 		<sFactor>GL_SOMETHING</sFactor>
@@ -45,7 +58,7 @@
 ///
 /// 	[<wireframe>true|false</wireframe>]
 ///
-/// 	[<castsShadow>true|false</castsShadow>]
+/// 	[<castsShadowFlag>true|false</castsShadowFlag>]
 ///
 /// 	[<userDefinedVars>
 /// 		<userDefinedVar>
@@ -64,10 +77,10 @@
 /// 	</userDefinedVars>]
 /// </material>
 ///
-/// *: Has nothing to do with the blendingStage. blendFuncs can be in material stage as well
+/// *: Has nothing to do with the renderInBlendingStageFlag. blendFuncs can be in material stage as well
 /// **: Depends on the type of the var
 /// @endcode
-class Material
+class Material: private MaterialProps
 {
 	//==================================================================================================================
 	// Public                                                                                                          =
@@ -124,13 +137,13 @@ class Material
 		/// @{
 		const SProgAttribVar* getStdAttribVar(StdAttribVars id) const {return stdAttribVars[id];}
 		const SProgUniVar* getStdUniVar(StdUniVars id) const {return stdUniVars[id];}
-		const ShaderProg& getShaderProg() const {return *shaderProg.get();}
-		GETTER_R(bool, castsShadow, isShadowCaster)
-		GETTER_R(bool, blendingStage, renderInBlendingStage)
-		GETTER_R(int, blendingSfactor, getBlendingSfactor)
-		GETTER_R(int, blendingDfactor, getBlendingDfactor)
-		GETTER_R(bool, depthTesting, isDepthTestingEnabled)
-		GETTER_R(bool, wireframe, isWireframeEnabled)
+		const ShaderProg& getShaderProg() const {return *shaderProg;}
+		GETTER_R_BY_VAL(bool, castsShadowFlag, castsShadow)
+		GETTER_R_BY_VAL(bool, renderInBlendingStageFlag, renderInBlendingStage)
+		GETTER_R_BY_VAL(int, blendingSfactor, getBlendingSfactor)
+		GETTER_R_BY_VAL(int, blendingDfactor, getBlendingDfactor)
+		GETTER_R_BY_VAL(bool, depthTesting, isDepthTestingEnabled)
+		GETTER_R_BY_VAL(bool, wireframe, isWireframeEnabled)
 		GETTER_R(boost::ptr_vector<MtlUserDefinedVar>, userDefinedVars, getUserDefinedVars)
 		/// @}
 
@@ -157,13 +170,6 @@ class Material
 			GLenum dataType; ///< aka GL data type
 		};
 
-		bool castsShadow; ///< Used in depth passes of shadowmapping and not in other depth passes like EarlyZ
-		/// The entities with blending are being rendered in blending stage and those without in material stage
-		bool blendingStage;
-		int blendingSfactor; ///< Default GL_ONE
-		int blendingDfactor; ///< Default GL_ZERO
-		bool depthTesting;
-		bool wireframe;
 		boost::ptr_vector<MtlUserDefinedVar> userDefinedVars;
 
 		static PreprocDefines msGenericDefines[]; ///< Material stage defines accepted in MsGeneric.glsl

src/Resources/Material/MtlUserDefinedVar.cpp

@@ -6,7 +6,8 @@
 // Constructors                                                                                                        =
 //======================================================================================================================
 
-MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, Fai fai_):
+template<>
+MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Fai& fai_):
 	sProgVar(sProgVar)
 {
 	ASSERT(sProgVar.getGlDataType() == GL_SAMPLER_2D);
@@ -14,7 +15,8 @@ MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, Fai fai_):
 }
 
 
-MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, float f):
+template<>
+MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const float& f):
 	sProgVar(sProgVar)
 {
 	ASSERT(sProgVar.getGlDataType() == GL_FLOAT);
@@ -22,6 +24,7 @@ MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, float f):
 }
 
 
+template<>
 MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec2& v):
 	sProgVar(sProgVar)
 {
@@ -30,6 +33,7 @@ MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec2& v)
 }
 
 
+template<>
 MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec3& v):
 	sProgVar(sProgVar)
 {
@@ -38,6 +42,7 @@ MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec3& v)
 }
 
 
+template<>
 MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec4& v):
 	sProgVar(sProgVar)
 {
@@ -46,10 +51,11 @@ MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec4& v)
 }
 
 
-MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const char* texFilename):
+template<>
+MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const std::string& texFilename):
 	sProgVar(sProgVar)
 {
 	ASSERT(sProgVar.getGlDataType() == GL_SAMPLER_2D);
 	data = RsrcPtr<Texture>();
-	boost::get<RsrcPtr<Texture> >(data).loadRsrc(texFilename);
+	boost::get<RsrcPtr<Texture> >(data).loadRsrc(texFilename.c_str());
 }

src/Resources/Material/MtlUserDefinedVar.h

@@ -27,15 +27,10 @@ class MtlUserDefinedVar
 		/// The data union
 		typedef boost::variant<float, Vec2, Vec3, Vec4, RsrcPtr<Texture>, Fai> DataVariant;
 
-		/// @name Contructors
-		/// @{
-		MtlUserDefinedVar(const SProgUniVar& sProgVar, const char* texFilename);
-		MtlUserDefinedVar(const SProgUniVar& sProgVar, Fai fai);
-		MtlUserDefinedVar(const SProgUniVar& sProgVar, float f);
-		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec2& v);
-		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec3& v);
-		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec4& v);
-		/// @}
+		/// Contructor
+		/// @tparam Type Can be std::string, Fai, float, Vec2, Vec3, Vec4
+		template<typename Type>
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Type& val);
 
 		/// @name Accessors
 		/// @{

src/Scene/MaterialRuntime/MaterialRuntime.cpp

@@ -10,6 +10,13 @@
 MaterialRuntime::MaterialRuntime(const Material& mtl_):
 	mtl(mtl_)
 {
+	castsShadowFlag = mtl.castsShadow();
+	renderInBlendingStageFlag = mtl.renderInBlendingStage();
+	blendingSfactor = mtl.getBlendingSfactor();
+	blendingDfactor = mtl.getBlendingDfactor();
+	depthTesting = mtl.isDepthTestingEnabled();
+	wireframe = mtl.isWireframeEnabled();
+
 	BOOST_FOREACH(const MtlUserDefinedVar& udv, mtl.getUserDefinedVars())
 	{
 		MtlUserDefinedVarRuntime* udvr = new MtlUserDefinedVarRuntime(udv);

src/Scene/MaterialRuntime/MaterialRuntime.h

@@ -5,13 +5,12 @@
 #include "MtlUserDefinedVarRuntime.h"
 #include "Properties.h"
 #include "CharPtrHashMap.h"
+#include "Material.h"
 
 
-class Material;
-
 
 /// One layer above material resource
-class MaterialRuntime
+class MaterialRuntime: private MaterialProps
 {
 	public:
 		MaterialRuntime(const Material& mtl);
@@ -32,11 +31,31 @@ class MaterialRuntime
 
 		const Material& getMaterial() const {return mtl;}
 
-		/// @todo
+		/// Find var and set its value
+		template<typename Type>
+		void setUserDefVarValue(const char* name, const Type& value);
+
+		/// Find var and set its value
+		template<typename Type>
+		const Type& getUserDefVarValue(const char* name) const;
+
 		template<typename Type>
-		void setUserDefVar(const char* name, const Type& value);
+		Type& getUserDefVarValue(const char* name);
+
+		GETTER_SETTER_BY_VAL(bool, castsShadowFlag, castsShadow, setCastsShadow)
+		GETTER_SETTER_BY_VAL(bool, renderInBlendingStageFlag, renderInBlendingStage, setRenderInBlendingStage)
+		GETTER_SETTER_BY_VAL(int, blendingSfactor, getBlendingSfactor, setBlendingSfactor)
+		GETTER_SETTER_BY_VAL(int, blendingDfactor, getBlendingDfactor, setBlendingDfactor)
+		GETTER_SETTER_BY_VAL(bool, depthTesting, isDepthTestingEnabled, setDepthTestingEnabled)
+		GETTER_SETTER_BY_VAL(bool, wireframe, isWireframeEnabled, setWireframeEnabled)
+
+		const SProgAttribVar* getStdAttribVar(Material::StdAttribVars id) const {return mtl.getStdAttribVar(id);}
+		const SProgUniVar* getStdUniVar(Material::StdUniVars id) const {return mtl.getStdUniVar(id);}
+		const ShaderProg& getShaderProg() const {return mtl.getShaderProg();}
 		/// @}
 
+		bool isBlendingEnabled() const {return blendingSfactor != GL_ONE || blendingDfactor != GL_ZERO;}
+
 	private:
 		const Material& mtl; ///< The resource
 		boost::ptr_vector<MtlUserDefinedVarRuntime> userDefVars;
@@ -45,9 +64,23 @@ class MaterialRuntime
 
 
 template<typename Type>
-void MaterialRuntime::setUserDefVar(const char* name, const Type& value)
+const Type& MaterialRuntime::getUserDefVarValue(const char* name) const
+{
+	return getUserDefinedVarByName(name).get<Type>();
+}
+
+
+template<typename Type>
+Type& MaterialRuntime::getUserDefVarValue(const char* name)
+{
+	return getUserDefinedVarByName(name).get<Type>();
+}
+
+
+template<typename Type>
+void MaterialRuntime::setUserDefVarValue(const char* name, const Type& value)
 {
-	getUserDefinedVarByName(name).get<Type>() = value;
+	getUserDefinedVarByName(name).set<Type>(value);
 }
 
 

src/Scene/MaterialRuntime/MtlUserDefinedVarRuntime.h

@@ -33,6 +33,9 @@ class MtlUserDefinedVarRuntime
 		/// @exception boost::exception when you try to get the incorrect data type
 		template<typename Type>
 		Type& get() {return boost::get<Type>(data);}
+
+		template<typename Type>
+		void set(const Type& v) {boost::get<Type>(data) = v;}
 		/// @}
 
 	private:

src/Scene/VisibilityTester.cpp

@@ -130,7 +130,7 @@ void VisibilityTester::getRenderableNodes(bool skipShadowless, Camera& cam)
 		BOOST_FOREACH(ModelPatchNode* modelPatchNode, node->getModelPatchNodes())
 		{
 			// Skip shadowless
-			if(skipShadowless && !modelPatchNode->getCpMtl().isShadowCaster())
+			if(skipShadowless && !modelPatchNode->getCpMtl().castsShadow())
 			{
 				continue;
 			}
@@ -168,7 +168,7 @@ void VisibilityTester::getRenderableNodes(bool skipShadowless, Camera& cam)
 		/*BOOST_FOREACH(SkinPatchNode* patchNode, node->getPatcheNodes())
 		{
 			// Skip shadowless
-			if(skipShadowless && !patchNode->getCpMtl().isShadowCaster())
+			if(skipShadowless && !patchNode->getCpMtl().castsShadow())
 			{
 				continue;
 			}

src/Scripting/Scene/MaterialRuntime/MaterialRuntime.bpi.cpp

@@ -5,6 +5,12 @@
 WRAP(MaterialRuntime)
 {
 	class_<MaterialRuntime, noncopyable>("MaterialRuntime", no_init)
-		.def("setUserDefVar", (void (MaterialRuntime::*)(const char*, const Vec3&))(&MaterialRuntime::setUserDefVar))
+		.def("setUserDefVar", (void (MaterialRuntime::*)(const char*, const float&))(&MaterialRuntime::setUserDefVarValue))
+		.def("setUserDefVar", (void (MaterialRuntime::*)(const char*, const Vec2&))(&MaterialRuntime::setUserDefVarValue))
+		.def("setUserDefVar", (void (MaterialRuntime::*)(const char*, const Vec3&))(&MaterialRuntime::setUserDefVarValue))
+		.def("setUserDefVar", (void (MaterialRuntime::*)(const char*, const MtlUserDefinedVar::Fai&))(&MaterialRuntime::setUserDefVarValue))
+
+		.def("isWireframeEnabled", (bool (MaterialRuntime::*)() const)(&MaterialRuntime::isWireframeEnabled))
+		.def("setWireframeEnabled", &MaterialRuntime::setWireframeEnabled)
 	;
 }