Fixed lights, lights are now sent to the draw buffer via their Render method and do not require to be added to the Scene as addLight, which has now been removed. Fixed shadowmap rendering. Added castsShadows flag to entities. Fixed entity editor gizmos not rendering. Fixed SceneCurves not rendering.

bindings/javascript/Polycode/Entity.js

@@ -25,7 +25,8 @@ function Entity() {
 		'snapToPixels': { enumerable: true, configurable: true, get: Entity.prototype.__get_snapToPixels, set: Entity.prototype.__set_snapToPixels},
 		'mouseOver': { enumerable: true, configurable: true, get: Entity.prototype.__get_mouseOver, set: Entity.prototype.__set_mouseOver},
 		'rendererVis': { enumerable: true, configurable: true, get: Entity.prototype.__get_rendererVis, set: Entity.prototype.__set_rendererVis},
-		'layerID': { enumerable: true, configurable: true, get: Entity.prototype.__get_layerID, set: Entity.prototype.__set_layerID}
+		'layerID': { enumerable: true, configurable: true, get: Entity.prototype.__get_layerID, set: Entity.prototype.__set_layerID},
+		'castShadows': { enumerable: true, configurable: true, get: Entity.prototype.__get_castShadows, set: Entity.prototype.__set_castShadows}
 	})
 }
 
@@ -208,6 +209,14 @@ Entity.prototype.__set_layerID = function(val) {
 	Polycode.Entity__set_layerID(this.__ptr, val.__ptr)
 }
 
+Entity.prototype.__get_castShadows = function() {
+	return Polycode.Entity__get_castShadows(this.__ptr)
+}
+
+Entity.prototype.__set_castShadows = function(val) {
+	Polycode.Entity__set_castShadows(this.__ptr, val)
+}
+
 
 Entity.prototype.initEntity = function() {
 	Polycode.Entity_initEntity(this.__ptr)

bindings/javascript/Polycode/GPUDrawBuffer.js

@@ -10,7 +10,8 @@ function GPUDrawBuffer() {
 		'clearDepthBuffer': { enumerable: true, configurable: true, get: GPUDrawBuffer.prototype.__get_clearDepthBuffer, set: GPUDrawBuffer.prototype.__set_clearDepthBuffer},
 		'clearColorBuffer': { enumerable: true, configurable: true, get: GPUDrawBuffer.prototype.__get_clearColorBuffer, set: GPUDrawBuffer.prototype.__set_clearColorBuffer},
 		'backingResolutionScale': { enumerable: true, configurable: true, get: GPUDrawBuffer.prototype.__get_backingResolutionScale, set: GPUDrawBuffer.prototype.__set_backingResolutionScale},
-		'viewport': { enumerable: true, configurable: true, get: GPUDrawBuffer.prototype.__get_viewport, set: GPUDrawBuffer.prototype.__set_viewport}
+		'viewport': { enumerable: true, configurable: true, get: GPUDrawBuffer.prototype.__get_viewport, set: GPUDrawBuffer.prototype.__set_viewport},
+		'shadowMapPass': { enumerable: true, configurable: true, get: GPUDrawBuffer.prototype.__get_shadowMapPass, set: GPUDrawBuffer.prototype.__set_shadowMapPass}
 	})
 }
 
@@ -91,6 +92,14 @@ GPUDrawBuffer.prototype.__set_viewport = function(val) {
 	Polycode.GPUDrawBuffer__set_viewport(this.__ptr, val.__ptr)
 }
 
+GPUDrawBuffer.prototype.__get_shadowMapPass = function() {
+	return Polycode.GPUDrawBuffer__get_shadowMapPass(this.__ptr)
+}
+
+GPUDrawBuffer.prototype.__set_shadowMapPass = function(val) {
+	Polycode.GPUDrawBuffer__set_shadowMapPass(this.__ptr, val)
+}
+
 Duktape.fin(GPUDrawBuffer.prototype, function (x) {
 	if (x === GPUDrawBuffer.prototype) {
 		return;

bindings/javascript/Polycode/LocalShaderParam.js

@@ -127,7 +127,3 @@ LocalShaderParam.prototype.getCubemap = function() {
 	retVal.__ptr = Polycode.LocalShaderParam_getCubemap(this.__ptr)
 	return retVal
 }
-
-LocalShaderParam.prototype.setParamValueFromString = function(type,pvalue) {
-	Polycode.LocalShaderParam_setParamValueFromString(this.__ptr, type, pvalue)
-}

bindings/javascript/Polycode/Scene.js

@@ -156,10 +156,6 @@ Scene.prototype.setOverrideMaterial = function(material) {
 	Polycode.Scene_setOverrideMaterial(this.__ptr, material)
 }
 
-Scene.prototype.getNumLights = function() {
-	return Polycode.Scene_getNumLights(this.__ptr)
-}
-
 Scene.prototype.doVisibilityChecking = function(val) {
 	Polycode.Scene_doVisibilityChecking(this.__ptr, val)
 }

bindings/javascript/Polycode/SceneCurve.js

@@ -41,7 +41,3 @@ SceneCurve.prototype.getWorldPointAt = function(t) {
 	retVal.__ptr = Polycode.SceneCurve_getWorldPointAt(this.__ptr, t)
 	return retVal
 }
-
-SceneCurve.prototype.Update = function() {
-	Polycode.SceneCurve_Update(this.__ptr)
-}

bindings/javascript/Polycode/ShaderBinding.js

@@ -18,12 +18,6 @@ ShaderBinding.prototype.addParam = function(type,name) {
 	return retVal
 }
 
-ShaderBinding.prototype.addParamFromData = function(name,data) {
-	var retVal = new LocalShaderParam("__skip_ptr__")
-	retVal.__ptr = Polycode.ShaderBinding_addParamFromData(this.__ptr, name, data)
-	return retVal
-}
-
 ShaderBinding.prototype.getNumLocalParams = function() {
 	return Polycode.ShaderBinding_getNumLocalParams(this.__ptr)
 }

bindings/lua/Polycode/Entity.lua

@@ -62,6 +62,8 @@ function Entity:__getvar(name)
 		local __c = _G["char"]("__skip_ptr__")
 		__c.__ptr = retVal
 		return __c
+	elseif name == "castShadows" then
+		return Polycode.Entity_get_castShadows(self.__ptr)
 	end
 	if EventDispatcher["__getvar"] ~= nil then
 		return EventDispatcher.__getvar(self, name)
@@ -132,6 +134,9 @@ function Entity:__setvar(name,value)
 	elseif name == "layerID" then
 		Polycode.Entity_set_layerID(self.__ptr, value.__ptr)
 		return true
+	elseif name == "castShadows" then
+		Polycode.Entity_set_castShadows(self.__ptr, value)
+		return true
 	end
 	if EventDispatcher["__setvar"] ~= nil then
 		return EventDispatcher.__setvar(self, name, value)

bindings/lua/Polycode/GPUDrawBuffer.lua

@@ -42,6 +42,8 @@ function GPUDrawBuffer:__getvar(name)
 		local __c = _G["Rectangle"]("__skip_ptr__")
 		__c.__ptr = retVal
 		return __c
+	elseif name == "shadowMapPass" then
+		return Polycode.GPUDrawBuffer_get_shadowMapPass(self.__ptr)
 	end
 end
 
@@ -70,6 +72,9 @@ function GPUDrawBuffer:__setvar(name,value)
 	elseif name == "viewport" then
 		Polycode.GPUDrawBuffer_set_viewport(self.__ptr, value.__ptr)
 		return true
+	elseif name == "shadowMapPass" then
+		Polycode.GPUDrawBuffer_set_shadowMapPass(self.__ptr, value)
+		return true
 	end
 	return false
 end

bindings/lua/Polycode/LocalShaderParam.lua

@@ -136,10 +136,6 @@ function LocalShaderParam:getCubemap()
 	return __c
 end
 
-function LocalShaderParam:setParamValueFromString(type, pvalue)
-	local retVal = Polycode.LocalShaderParam_setParamValueFromString(self.__ptr, type, pvalue)
-end
-
 function LocalShaderParam:__delete()
 	if self then Polycode.delete_LocalShaderParam(self.__ptr) end
 end

bindings/lua/Polycode/Scene.lua

@@ -149,11 +149,6 @@ function Scene:setOverrideMaterial(material)
 	local retVal = Polycode.Scene_setOverrideMaterial(self.__ptr, material.__ptr)
 end
 
-function Scene:getNumLights()
-	local retVal =  Polycode.Scene_getNumLights(self.__ptr)
-	return retVal
-end
-
 function Scene:doVisibilityChecking(val)
 	local retVal = Polycode.Scene_doVisibilityChecking(self.__ptr, val)
 end

bindings/lua/Polycode/SceneCurve.lua

@@ -56,10 +56,6 @@ function SceneCurve:getWorldPointAt(t)
 	return __c
 end
 
-function SceneCurve:Update()
-	local retVal =  Polycode.SceneCurve_Update(self.__ptr)
-end
-
 function SceneCurve:__delete()
 	if self then Polycode.delete_SceneCurve(self.__ptr) end
 end

bindings/lua/Polycode/ShaderBinding.lua

@@ -23,14 +23,6 @@ function ShaderBinding:addParam(type, name)
 	return __c
 end
 
-function ShaderBinding:addParamFromData(name, data)
-	local retVal = Polycode.ShaderBinding_addParamFromData(self.__ptr, name, data)
-	if retVal == nil then return nil end
-	local __c = _G["shared_ptr<LocalShaderParam>"]("__skip_ptr__")
-	__c.__ptr = retVal
-	return __c
-end
-
 function ShaderBinding:getNumLocalParams()
 	local retVal =  Polycode.ShaderBinding_getNumLocalParams(self.__ptr)
 	return retVal

include/polycode/bindings/javascript/PolycodeJSWrappers.h

@@ -2908,6 +2908,18 @@ namespace Polycode {
 		return 0;
 	}
 
+	duk_ret_t Polycode_Entity__get_castShadows(duk_context *context) {
+		std::shared_ptr<Entity> *inst = (std::shared_ptr<Entity>*)duk_to_pointer(context, 0);
+		duk_push_boolean(context, (*inst)->castShadows);
+		return 1;
+	}
+
+	duk_ret_t Polycode_Entity__set_castShadows(duk_context *context) {
+		Entity *inst = (Entity*)duk_to_pointer(context, 0);
+		inst->castShadows = duk_to_boolean(context, 1);
+		return 0;
+	}
+
 	duk_ret_t Polycode_Entity__delete(duk_context *context) {
 		std::shared_ptr<Entity> *inst = (std::shared_ptr<Entity>*)duk_to_pointer(context, 0);
 		delete inst;
@@ -4252,6 +4264,18 @@ namespace Polycode {
 		return 0;
 	}
 
+	duk_ret_t Polycode_GPUDrawBuffer__get_shadowMapPass(duk_context *context) {
+		std::shared_ptr<GPUDrawBuffer> *inst = (std::shared_ptr<GPUDrawBuffer>*)duk_to_pointer(context, 0);
+		duk_push_boolean(context, (*inst)->shadowMapPass);
+		return 1;
+	}
+
+	duk_ret_t Polycode_GPUDrawBuffer__set_shadowMapPass(duk_context *context) {
+		GPUDrawBuffer *inst = (GPUDrawBuffer*)duk_to_pointer(context, 0);
+		inst->shadowMapPass = duk_to_boolean(context, 1);
+		return 0;
+	}
+
 	duk_ret_t Polycode_GPUDrawBuffer__delete(duk_context *context) {
 		std::shared_ptr<GPUDrawBuffer> *inst = (std::shared_ptr<GPUDrawBuffer>*)duk_to_pointer(context, 0);
 		delete inst;
@@ -8123,12 +8147,6 @@ namespace Polycode {
 		return 0;
 	}
 
-	duk_ret_t Polycode_Scene_getNumLights(duk_context *context) {
-		std::shared_ptr<Scene> *inst = (std::shared_ptr<Scene>*)duk_to_pointer(context, 0);
-		duk_push_int(context, (*inst)->getNumLights());
-		return 1;
-	}
-
 	duk_ret_t Polycode_Scene_doVisibilityChecking(duk_context *context) {
 		std::shared_ptr<Scene> *inst = (std::shared_ptr<Scene>*)duk_to_pointer(context, 0);
 		bool val = duk_to_boolean(context, 1);
@@ -8609,12 +8627,6 @@ namespace Polycode {
 		return 1;
 	}
 
-	duk_ret_t Polycode_SceneCurve_Update(duk_context *context) {
-		std::shared_ptr<SceneCurve> *inst = (std::shared_ptr<SceneCurve>*)duk_to_pointer(context, 0);
-		(*inst)->Update();
-		return 0;
-	}
-
 	duk_ret_t Polycode_SceneLine(duk_context *context) {
 		Vector3 startp = *(Vector3*)duk_to_pointer(context, 0);
 		Vector3 endp = *(Vector3*)duk_to_pointer(context, 1);
@@ -10000,14 +10012,6 @@ namespace Polycode {
 		return 1;
 	}
 
-	duk_ret_t Polycode_LocalShaderParam_setParamValueFromString(duk_context *context) {
-		std::shared_ptr<LocalShaderParam> *inst = (std::shared_ptr<LocalShaderParam>*)duk_to_pointer(context, 0);
-		int type = duk_to_int(context, 1);
-		String pvalue = duk_to_string(context, 2);
-		(*inst)->setParamValueFromString(type,pvalue);
-		return 0;
-	}
-
 	duk_ret_t Polycode_ShaderProgram(duk_context *context) {
 		String fileName = duk_to_string(context, 0);
 		std::shared_ptr<ShaderProgram> *inst = new std::shared_ptr<ShaderProgram>;
@@ -10100,16 +10104,6 @@ namespace Polycode {
 		return 1;
 	}
 
-	duk_ret_t Polycode_ShaderBinding_addParamFromData(duk_context *context) {
-		std::shared_ptr<ShaderBinding> *inst = (std::shared_ptr<ShaderBinding>*)duk_to_pointer(context, 0);
-		String name = duk_to_string(context, 1);
-		String data = duk_to_string(context, 2);
-		std::shared_ptr<shared_ptr<LocalShaderParam>> *retInst = new std::shared_ptr<shared_ptr<LocalShaderParam>>;
-		*(*retInst) = (*inst)->addParamFromData(name,data);
-		duk_push_pointer(context, (void*)retInst);
-		return 1;
-	}
-
 	duk_ret_t Polycode_ShaderBinding_getNumLocalParams(duk_context *context) {
 		std::shared_ptr<ShaderBinding> *inst = (std::shared_ptr<ShaderBinding>*)duk_to_pointer(context, 0);
 		duk_push_int(context, (*inst)->getNumLocalParams());

include/polycode/bindings/lua/PolycodeLuaWrappers.h

@@ -3343,6 +3343,13 @@ static int Polycode_Entity_get_layerID(lua_State *L) {
 	return 1;
 }
 
+static int Polycode_Entity_get_castShadows(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TUSERDATA);
+	Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+	lua_pushboolean(L, inst->castShadows);
+	return 1;
+}
+
 static int Polycode_Entity_set_ownsChildren(lua_State *L) {
 	luaL_checktype(L, 1, LUA_TUSERDATA);
 	Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
@@ -3515,6 +3522,14 @@ static int Polycode_Entity_set_layerID(lua_State *L) {
 	return 0;
 }
 
+static int Polycode_Entity_set_castShadows(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TUSERDATA);
+	Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+	bool param = lua_toboolean(L, 2) != 0;
+	inst->castShadows = param;
+	return 0;
+}
+
 	static int Polycode_Entity(lua_State *L) {
 		Entity *inst = new Entity();
 		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
@@ -5061,6 +5076,13 @@ static int Polycode_GPUDrawBuffer_get_viewport(lua_State *L) {
 	return 1;
 }
 
+static int Polycode_GPUDrawBuffer_get_shadowMapPass(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TUSERDATA);
+	GPUDrawBuffer *inst = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 1));
+	lua_pushboolean(L, inst->shadowMapPass);
+	return 1;
+}
+
 static int Polycode_GPUDrawBuffer_set_projectionMatrix(lua_State *L) {
 	luaL_checktype(L, 1, LUA_TUSERDATA);
 	GPUDrawBuffer *inst = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 1));
@@ -5131,6 +5153,14 @@ static int Polycode_GPUDrawBuffer_set_viewport(lua_State *L) {
 	return 0;
 }
 
+static int Polycode_GPUDrawBuffer_set_shadowMapPass(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TUSERDATA);
+	GPUDrawBuffer *inst = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 1));
+	bool param = lua_toboolean(L, 2) != 0;
+	inst->shadowMapPass = param;
+	return 0;
+}
+
 	static int Polycode_GPUDrawBuffer(lua_State *L) {
 		GPUDrawBuffer *inst = new GPUDrawBuffer();
 		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
@@ -9898,12 +9928,6 @@ static int Polycode_Scene_set_constrainPickingToViewport(lua_State *L) {
 		inst->setOverrideMaterial(material);
 		return 0;
 	}
-	static int Polycode_Scene_getNumLights(lua_State *L) {
-		luaL_checktype(L, 1, LUA_TUSERDATA);
-		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
-		lua_pushinteger(L, inst->getNumLights());
-		return 1;
-	}
 	static int Polycode_Scene_doVisibilityChecking(lua_State *L) {
 		luaL_checktype(L, 1, LUA_TUSERDATA);
 		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
@@ -10504,12 +10528,6 @@ static int Polycode_SceneCurve_set_curveResolution(lua_State *L) {
 		*userdataPtr = (PolyBase*)retInst;
 		return 1;
 	}
-	static int Polycode_SceneCurve_Update(lua_State *L) {
-		luaL_checktype(L, 1, LUA_TUSERDATA);
-		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
-		inst->Update();
-		return 0;
-	}
 	static int Polycode_delete_SceneCurve(lua_State *L) {
 		luaL_checktype(L, 1, LUA_TUSERDATA);
 		PolyBase **inst = (PolyBase**)lua_touserdata(L, 1);
@@ -12211,16 +12229,6 @@ static int Polycode_LocalShaderParam_set_arraySize(lua_State *L) {
 		*userdataPtr = (PolyBase*)retInst;
 		return 1;
 	}
-	static int Polycode_LocalShaderParam_setParamValueFromString(lua_State *L) {
-		luaL_checktype(L, 1, LUA_TUSERDATA);
-		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
-		luaL_checktype(L, 2, LUA_TNUMBER);
-		int type = lua_tointeger(L, 2);
-		luaL_checktype(L, 3, LUA_TSTRING);
-		String pvalue = String(lua_tostring(L, 3));
-		inst->setParamValueFromString(type, pvalue);
-		return 0;
-	}
 	static int Polycode_delete_LocalShaderParam(lua_State *L) {
 		luaL_checktype(L, 1, LUA_TUSERDATA);
 		PolyBase **inst = (PolyBase**)lua_touserdata(L, 1);
@@ -12337,21 +12345,6 @@ static int Polycode_AttributeBinding_set_enabled(lua_State *L) {
 		*userdataPtr = (PolyBase*)retInst;
 		return 1;
 	}
-	static int Polycode_ShaderBinding_addParamFromData(lua_State *L) {
-		luaL_checktype(L, 1, LUA_TUSERDATA);
-		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
-		luaL_checktype(L, 2, LUA_TSTRING);
-		String name = String(lua_tostring(L, 2));
-		luaL_checktype(L, 3, LUA_TSTRING);
-		String data = String(lua_tostring(L, 3));
-		shared_ptr<LocalShaderParam> *retInst = new shared_ptr<LocalShaderParam>();
-		*retInst = inst->addParamFromData(name, data);
-		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
-		luaL_getmetatable(L, "Polycode.shared_ptr<LocalShaderParam>");
-		lua_setmetatable(L, -2);
-		*userdataPtr = (PolyBase*)retInst;
-		return 1;
-	}
 	static int Polycode_ShaderBinding_getNumLocalParams(lua_State *L) {
 		luaL_checktype(L, 1, LUA_TUSERDATA);
 		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));

include/polycode/core/PolyEntity.h

@@ -888,6 +888,8 @@ namespace Polycode {
 			void detachScript(Script *script);
 			unsigned int getNumScripts();
 			ScriptInstance *getScriptAtIndex(unsigned int index);
+        
+            bool castShadows;
 		
 		protected:
 

include/polycode/core/PolyGPUDrawBuffer.h

@@ -98,5 +98,7 @@ namespace Polycode {
 		Polycode::Rectangle viewport;
 		std::vector<GPUDrawCall> drawCalls;
 		RenderFrame *renderFrame;
+        bool shadowMapPass;
+        void *userData;
 	};
 }

include/polycode/core/PolyScene.h

@@ -37,7 +37,6 @@ namespace Polycode {
 		
 	class Camera;
 	class Entity;
-	class SceneLight;
 	class Mesh;
 	class RenderFrame;
 	
@@ -123,7 +122,7 @@ namespace Polycode {
 		bool isEnabled();		
 		void setEnabled(bool enabled);
 		
-		void Render(RenderFrame *frame, Camera *targetCamera = NULL, std::shared_ptr<RenderBuffer> targetFramebuffer = nullptr, std::shared_ptr<Material> overrideMaterial = nullptr, bool sendLights = false);
+		void Render(RenderFrame *frame, Camera *targetCamera = NULL, std::shared_ptr<RenderBuffer> targetFramebuffer = nullptr, std::shared_ptr<Material> overrideMaterial = nullptr, bool shadowMapPass = false);
 		
 		
 		void setOverrideMaterial(std::shared_ptr<Material> material);
@@ -132,21 +131,6 @@ namespace Polycode {
 		
 		Ray projectRayFromCameraAndViewportCoordinate(Camera *camera, Vector2 coordinate);
 		
-		/**
-		* Adds a light to the scene.
-		* @param light Light to add to the scene.
-		*/
-		void addLight(SceneLight *light);
-		
-		/**
-		* Removes a light from the scene.
-		* @param light Light to remove from the scene.
-		*/		
-		void removeLight(SceneLight *light);		
-				
-		int getNumLights();
-		SceneLight *getLight(int index);
-		
 		/**
 		* Scene clear color
 		*/ 
@@ -204,11 +188,8 @@ namespace Polycode {
 		void setEntityVisibility(Entity *entity, Camera *camera);
 		void setEntityVisibilityBool(Entity *entity, bool val);
 		
-		bool hasLightmaps;
 		bool _doVisibilityChecking;
 
-		std::vector <SceneLight*> lights;
-		
 		Camera *defaultCamera;
 		Camera *activeCamera;
 		

include/polycode/core/PolySceneLight.h

@@ -82,6 +82,8 @@ namespace Polycode {
 			int getType() const;
 			
 			void renderDepthMap(RenderFrame *frame, Scene *scene);
+        
+            void Render(GPUDrawBuffer *buffer);
 			
 			static const int POINT_LIGHT = 0;
 			static const int SPOT_LIGHT = 1;

include/polycode/core/PolySceneLine.h

@@ -61,7 +61,7 @@ namespace Polycode {
 
 		
 			virtual ~SceneCurve();
-			void Update();
+			void Render(GPUDrawBuffer *buffer);
 		
 		
 			virtual Entity *Clone(bool deepClone, bool ignoreEditorOnly) const;

include/polycode/core/PolyShader.h

@@ -41,7 +41,8 @@ namespace Polycode {
 	class LocalShaderParam;
 	class RenderBuffer;
     class Core;
-	
+    class ResourcePool;
+    
 	class _PolyExport ProgramParam {
 		public:
 	
@@ -181,7 +182,7 @@ namespace Polycode {
 			void setCubemap(std::shared_ptr<Cubemap> cubemap);
 			std::shared_ptr<Cubemap> getCubemap();
 		
-			void setParamValueFromString(int type, String pvalue);
+			void setParamValueFromString(ResourcePool *pool, int type, String pvalue);
         
             std::mutex POLYIGNORE accessMutex;
 	};
@@ -217,7 +218,7 @@ namespace Polycode {
 			std::shared_ptr<LocalShaderParam> addParam(int type, const String& name);
 			std::shared_ptr<LocalShaderParam> addParamPointer(int type, const String& name, void *ptr);
 		
-			std::shared_ptr<LocalShaderParam> addParamFromData(const String &name, const String &data);
+			std::shared_ptr<LocalShaderParam> addParamFromData(ResourcePool *pool, const String &name, const String &data);
 		
 			unsigned int getNumLocalParams();
 			std::shared_ptr<LocalShaderParam> getLocalParam(unsigned int index);

include/polycode/ide/PolycodeEntityEditor.h

@@ -145,7 +145,7 @@ class CurveDisplay : public DummyTargetEntity {
 
 class LightDisplay : public Entity {
 public:
-	LightDisplay(SceneLight *light);
+    LightDisplay(std::shared_ptr<Material> material, SceneLight *light);
 	~LightDisplay();
 	void Update(Number elapsed);
 	
@@ -159,7 +159,7 @@ private:
 
 class CameraDisplay : public Entity {
 	public:
-		CameraDisplay(Camera *camera);
+		CameraDisplay(std::shared_ptr<Material> material, Camera *camera);
 		~CameraDisplay();
 		void Update(Number elapsed);
 	

include/polycode/ide/PolycodeMaterialEditor.h

@@ -317,7 +317,7 @@ class PolycodeMaterialEditor : public PolycodeEditor {
 	void saveFile();
 	void saveMaterials(ObjectEntry *materialsEntry, std::vector<std::shared_ptr<Material> > materials);
 	
-	static String createStringValue(unsigned int type, void *value);
+	static String createStringValue(std::shared_ptr<LocalShaderParam> param);
 	
 	protected:
 	

src/bindings/javascript/PolycodeJS.cpp

@@ -417,6 +417,8 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"Entity__set_rendererVis", Polycode_Entity__set_rendererVis, 2},
 			{"Entity__get_layerID", Polycode_Entity__get_layerID, 1},
 			{"Entity__set_layerID", Polycode_Entity__set_layerID, 2},
+			{"Entity__get_castShadows", Polycode_Entity__get_castShadows, 1},
+			{"Entity__set_castShadows", Polycode_Entity__set_castShadows, 2},
 			{"Entity__delete", Polycode_Entity__delete, 1},
 			{"Entity_initEntity", Polycode_Entity_initEntity, 1},
 			{"Entity_Update", Polycode_Entity_Update, 2},
@@ -610,6 +612,8 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"GPUDrawBuffer__set_backingResolutionScale", Polycode_GPUDrawBuffer__set_backingResolutionScale, 2},
 			{"GPUDrawBuffer__get_viewport", Polycode_GPUDrawBuffer__get_viewport, 1},
 			{"GPUDrawBuffer__set_viewport", Polycode_GPUDrawBuffer__set_viewport, 2},
+			{"GPUDrawBuffer__get_shadowMapPass", Polycode_GPUDrawBuffer__get_shadowMapPass, 1},
+			{"GPUDrawBuffer__set_shadowMapPass", Polycode_GPUDrawBuffer__set_shadowMapPass, 2},
 			{"GPUDrawBuffer__delete", Polycode_GPUDrawBuffer__delete, 1},
 			{"Image", Polycode_Image, 0},
 			{"Image__delete", Polycode_Image__delete, 1},
@@ -1155,7 +1159,6 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"Scene_isEnabled", Polycode_Scene_isEnabled, 1},
 			{"Scene_setEnabled", Polycode_Scene_setEnabled, 2},
 			{"Scene_setOverrideMaterial", Polycode_Scene_setOverrideMaterial, 2},
-			{"Scene_getNumLights", Polycode_Scene_getNumLights, 1},
 			{"Scene_doVisibilityChecking", Polycode_Scene_doVisibilityChecking, 2},
 			{"Scene_doesVisibilityChecking", Polycode_Scene_doesVisibilityChecking, 1},
 			{"SceneEntityInstanceResourceEntry", Polycode_SceneEntityInstanceResourceEntry, 0},
@@ -1226,7 +1229,6 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"SceneCurve__set_curveResolution", Polycode_SceneCurve__set_curveResolution, 2},
 			{"SceneCurve__delete", Polycode_SceneCurve__delete, 1},
 			{"SceneCurve_getWorldPointAt", Polycode_SceneCurve_getWorldPointAt, 2},
-			{"SceneCurve_Update", Polycode_SceneCurve_Update, 1},
 			{"SceneLine", Polycode_SceneLine, 2},
 			{"SceneLine__delete", Polycode_SceneLine__delete, 1},
 			{"SceneLine_setStart", Polycode_SceneLine_setStart, 2},
@@ -1433,7 +1435,6 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"LocalShaderParam_getTexture", Polycode_LocalShaderParam_getTexture, 1},
 			{"LocalShaderParam_setCubemap", Polycode_LocalShaderParam_setCubemap, 2},
 			{"LocalShaderParam_getCubemap", Polycode_LocalShaderParam_getCubemap, 1},
-			{"LocalShaderParam_setParamValueFromString", Polycode_LocalShaderParam_setParamValueFromString, 3},
 			{"ShaderProgram", Polycode_ShaderProgram, 1},
 			{"ShaderProgram__get_type", Polycode_ShaderProgram__get_type, 1},
 			{"ShaderProgram__set_type", Polycode_ShaderProgram__set_type, 2},
@@ -1448,7 +1449,6 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"ShaderBinding", Polycode_ShaderBinding, 0},
 			{"ShaderBinding__delete", Polycode_ShaderBinding__delete, 1},
 			{"ShaderBinding_addParam", Polycode_ShaderBinding_addParam, 3},
-			{"ShaderBinding_addParamFromData", Polycode_ShaderBinding_addParamFromData, 3},
 			{"ShaderBinding_getNumLocalParams", Polycode_ShaderBinding_getNumLocalParams, 1},
 			{"ShaderBinding_getLocalParam", Polycode_ShaderBinding_getLocalParam, 2},
 			{"ShaderBinding_getLocalParamByName", Polycode_ShaderBinding_getLocalParamByName, 2},

src/bindings/lua/PolycodeLua.cpp

@@ -390,6 +390,7 @@ int luaopen_Polycode(lua_State *L) {
 		{"Entity_get_mouseOver", Polycode_Entity_get_mouseOver},
 		{"Entity_get_rendererVis", Polycode_Entity_get_rendererVis},
 		{"Entity_get_layerID", Polycode_Entity_get_layerID},
+		{"Entity_get_castShadows", Polycode_Entity_get_castShadows},
 		{"Entity_set_ownsChildren", Polycode_Entity_set_ownsChildren},
 		{"Entity_set_billboardMode", Polycode_Entity_set_billboardMode},
 		{"Entity_set_color", Polycode_Entity_set_color},
@@ -411,6 +412,7 @@ int luaopen_Polycode(lua_State *L) {
 		{"Entity_set_mouseOver", Polycode_Entity_set_mouseOver},
 		{"Entity_set_rendererVis", Polycode_Entity_set_rendererVis},
 		{"Entity_set_layerID", Polycode_Entity_set_layerID},
+		{"Entity_set_castShadows", Polycode_Entity_set_castShadows},
 		{"Entity", Polycode_Entity},
 		{"Entity_initEntity", Polycode_Entity_initEntity},
 		{"Entity_Update", Polycode_Entity_Update},
@@ -593,6 +595,7 @@ int luaopen_Polycode(lua_State *L) {
 		{"GPUDrawBuffer_get_clearColorBuffer", Polycode_GPUDrawBuffer_get_clearColorBuffer},
 		{"GPUDrawBuffer_get_backingResolutionScale", Polycode_GPUDrawBuffer_get_backingResolutionScale},
 		{"GPUDrawBuffer_get_viewport", Polycode_GPUDrawBuffer_get_viewport},
+		{"GPUDrawBuffer_get_shadowMapPass", Polycode_GPUDrawBuffer_get_shadowMapPass},
 		{"GPUDrawBuffer_set_projectionMatrix", Polycode_GPUDrawBuffer_set_projectionMatrix},
 		{"GPUDrawBuffer_set_viewMatrix", Polycode_GPUDrawBuffer_set_viewMatrix},
 		{"GPUDrawBuffer_set_cameraMatrix", Polycode_GPUDrawBuffer_set_cameraMatrix},
@@ -601,6 +604,7 @@ int luaopen_Polycode(lua_State *L) {
 		{"GPUDrawBuffer_set_clearColorBuffer", Polycode_GPUDrawBuffer_set_clearColorBuffer},
 		{"GPUDrawBuffer_set_backingResolutionScale", Polycode_GPUDrawBuffer_set_backingResolutionScale},
 		{"GPUDrawBuffer_set_viewport", Polycode_GPUDrawBuffer_set_viewport},
+		{"GPUDrawBuffer_set_shadowMapPass", Polycode_GPUDrawBuffer_set_shadowMapPass},
 		{"GPUDrawBuffer", Polycode_GPUDrawBuffer},
 		{"delete_GPUDrawBuffer", Polycode_delete_GPUDrawBuffer},
 		{"Image_createEmpty", Polycode_Image_createEmpty},
@@ -1137,7 +1141,6 @@ int luaopen_Polycode(lua_State *L) {
 		{"Scene_isEnabled", Polycode_Scene_isEnabled},
 		{"Scene_setEnabled", Polycode_Scene_setEnabled},
 		{"Scene_setOverrideMaterial", Polycode_Scene_setOverrideMaterial},
-		{"Scene_getNumLights", Polycode_Scene_getNumLights},
 		{"Scene_doVisibilityChecking", Polycode_Scene_doVisibilityChecking},
 		{"Scene_doesVisibilityChecking", Polycode_Scene_doesVisibilityChecking},
 		{"delete_Scene", Polycode_delete_Scene},
@@ -1207,7 +1210,6 @@ int luaopen_Polycode(lua_State *L) {
 		{"SceneCurve_set_curveResolution", Polycode_SceneCurve_set_curveResolution},
 		{"SceneCurve", Polycode_SceneCurve},
 		{"SceneCurve_getWorldPointAt", Polycode_SceneCurve_getWorldPointAt},
-		{"SceneCurve_Update", Polycode_SceneCurve_Update},
 		{"delete_SceneCurve", Polycode_delete_SceneCurve},
 		{"SceneLine", Polycode_SceneLine},
 		{"SceneLine_setStart", Polycode_SceneLine_setStart},
@@ -1411,7 +1413,6 @@ int luaopen_Polycode(lua_State *L) {
 		{"LocalShaderParam_getTexture", Polycode_LocalShaderParam_getTexture},
 		{"LocalShaderParam_setCubemap", Polycode_LocalShaderParam_setCubemap},
 		{"LocalShaderParam_getCubemap", Polycode_LocalShaderParam_getCubemap},
-		{"LocalShaderParam_setParamValueFromString", Polycode_LocalShaderParam_setParamValueFromString},
 		{"delete_LocalShaderParam", Polycode_delete_LocalShaderParam},
 		{"ShaderProgram_get_type", Polycode_ShaderProgram_get_type},
 		{"ShaderProgram_set_type", Polycode_ShaderProgram_set_type},
@@ -1426,7 +1427,6 @@ int luaopen_Polycode(lua_State *L) {
 		{"delete_AttributeBinding", Polycode_delete_AttributeBinding},
 		{"ShaderBinding", Polycode_ShaderBinding},
 		{"ShaderBinding_addParam", Polycode_ShaderBinding_addParam},
-		{"ShaderBinding_addParamFromData", Polycode_ShaderBinding_addParamFromData},
 		{"ShaderBinding_getNumLocalParams", Polycode_ShaderBinding_getNumLocalParams},
 		{"ShaderBinding_getLocalParam", Polycode_ShaderBinding_getLocalParam},
 		{"ShaderBinding_getLocalParamByName", Polycode_ShaderBinding_getLocalParamByName},

src/core/PolyCamera.cpp

@@ -406,7 +406,7 @@ void Camera::drawFilter(RenderFrame *frame, std::shared_ptr<RenderBuffer> target
         rebuildMaterialBindings();
     }
     
-	targetScene->Render(frame, this, originalFramebuffer, NULL, true);
+	targetScene->Render(frame, this, originalFramebuffer, NULL);
 	
 	for(int i=0; i < shaderPasses.size(); i++) {
 		

src/core/PolyEntity.cpp

@@ -78,6 +78,7 @@ void Entity::initEntity() {
 	rendererVis = true;
 	layerID = 0;
 	containerScene = NULL;
+    castShadows = true;
 }
 
 Entity *Entity::getEntityById(String id, bool recursive) const {
@@ -123,7 +124,7 @@ void Entity::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) co
 	clone->snapToPixels = snapToPixels;
 	clone->setAnchorPoint(anchorPoint);
 	clone->layerID = layerID;
-	
+	clone->castShadows = castShadows;
 	clone->drawCall.options = drawCall.options;
 	
 	clone->id = id;
@@ -541,7 +542,14 @@ void Entity::transformAndRender(GPUDrawBuffer *buffer, Polycode::Rectangle *pare
 	
 	
 	if(visible && rendererVis) {
-		Render(buffer);
+        if(buffer->shadowMapPass) {
+            if(castShadows) {
+                Render(buffer);
+            }
+        } else {
+            Render(buffer);
+        }
+        
 	}
 	
 	if(visible || (!visible && !visibilityAffectsChildren)) {

src/core/PolyRenderer.cpp

@@ -190,7 +190,7 @@ void RenderThread::processDrawBufferLights(GPUDrawBuffer *buffer) {
 			
 			if(buffer->lights[i].shadowsEnabled) {
 				lightShadows[lightShadowIndex].shadowMatrix->setMatrix4(buffer->lights[i].lightViewMatrix);
-				lightShadows[lightShadowIndex].shadowBuffer->data = (void*) &*buffer->lights[i].shadowMapTexture;
+				lightShadows[lightShadowIndex].shadowBuffer->setTexture(buffer->lights[i].shadowMapTexture);
 				
 				lights[i].shadowEnabled->setNumber(1.0);
 				
@@ -199,6 +199,7 @@ void RenderThread::processDrawBufferLights(GPUDrawBuffer *buffer) {
 				}
 			} else {
 				lights[i].shadowEnabled->setNumber(0.0);
+                lightShadows[lightShadowIndex].shadowBuffer->setTexture(NULL);
 			}
 		} else {
 			lights[i].diffuse->setColor(Color(0.0, 0.0, 0.0, 0.0));

src/core/PolyResourceManager.cpp

@@ -359,7 +359,7 @@ std::shared_ptr<Material> ResourcePool::materialFromXMLNode(TiXmlNode *node) {
 
 								String pvalue = pChild2Element->Attribute("value");
 								int type = shaderPass.shader->getExpectedParamType(pname);
-								std::shared_ptr<LocalShaderParam> param = shaderPass.shaderBinding->addParamFromData(pname, pvalue);
+								std::shared_ptr<LocalShaderParam> param = shaderPass.shaderBinding->addParamFromData(this, pname, pvalue);
 							}
 						}
 					}

src/core/PolyScene.cpp

@@ -28,7 +28,6 @@
 #include "polycode/core/PolyRenderer.h"
 #include "polycode/core/PolyResource.h"
 #include "polycode/core/PolyResourceManager.h"
-#include "polycode/core/PolySceneLight.h"
 #include "polycode/core/PolyInputEvent.h"
 #include "polycode/core/PolySceneMesh.h"
 #include "polycode/core/PolyTexture.h"
@@ -52,7 +51,6 @@ void Scene::initScene(int sceneType) {
 	activeCamera = defaultCamera;
 	overrideMaterial = NULL;
 	enabled = true;
-	hasLightmaps = false;
 	clearColor.setColor(0.13f,0.13f,0.13f,1.0f); 
 	ambientColor.setColor(0.0,0.0,0.0,1.0); 
 	useClearColor = false;
@@ -189,20 +187,19 @@ void Scene::setEntityVisibility(Entity *entity, Camera *camera) {
 	}
 }
 
-void Scene::Render(RenderFrame *frame, Camera *targetCamera, std::shared_ptr<RenderBuffer> targetFramebuffer, std::shared_ptr<Material> overrideMaterial, bool sendLights) {
+void Scene::Render(RenderFrame *frame, Camera *targetCamera, std::shared_ptr<RenderBuffer> targetFramebuffer, std::shared_ptr<Material> overrideMaterial, bool shadowMapPass) {
 	if(!targetCamera && !activeCamera)
 		return;
 	
-	if(!targetCamera)
+    if(!targetCamera) {
 		targetCamera = activeCamera;
-	
-	
+    }
+    
 	if(targetFramebuffer) {
 		targetCamera->setViewport(Polycode::Rectangle(0.0, 0.0, targetFramebuffer->getWidth(), targetFramebuffer->getHeight()));
 	} else {
 		targetCamera->setViewport(frame->viewport);
 	}
-
 	
 	GPUDrawBuffer *drawBuffer = new GPUDrawBuffer();
 	drawBuffer->renderFrame = frame;
@@ -211,54 +208,20 @@ void Scene::Render(RenderFrame *frame, Camera *targetCamera, std::shared_ptr<Ren
 	drawBuffer->clearDepthBuffer = useClearDepth;
 	drawBuffer->targetFramebuffer = targetFramebuffer;
 	drawBuffer->viewport = targetCamera->getViewport();
-	drawBuffer->backingResolutionScale = Vector2(1.0, 1.0);
-	
+	drawBuffer->backingResolutionScale = Vector2(1.0, 1.0);	
+    drawBuffer->userData = (void*) this;
+    drawBuffer->shadowMapPass = shadowMapPass;
+    
 	if(overrideMaterial) {
 		drawBuffer->globalMaterial = overrideMaterial;
 	} else {
 		drawBuffer->globalMaterial = this->overrideMaterial;
 	}
-	
-	Matrix4 textureMatrix;
-	
+		
 	drawBuffer->projectionMatrix = targetCamera->createProjectionMatrix();
 	drawBuffer->viewMatrix = targetCamera->getConcatenatedMatrix().Inverse();
 	drawBuffer->cameraMatrix = targetCamera->getConcatenatedMatrix();
-	
-	if(sendLights) {
-		for(int i=0; i < lights.size(); i++) {
-			SceneLight *light = lights[i];
-			if(!light->enabled)
-				continue;
-				
-			Vector3 direction;
-			Vector3 position;
-			
-			direction.x = 0;
-			direction.y = 0.0;
-			direction.z = -1.0;
-			direction.Normalize();
-			
-			direction = light->getConcatenatedMatrix().rotateVector(direction);
-			direction = drawBuffer->viewMatrix.rotateVector(direction);
-			
-			if(light->areShadowsEnabled()) {
-				if(light->getType() == SceneLight::SPOT_LIGHT) {
-					light->renderDepthMap(frame, this);
-				}
-			}
-			
-			position = light->getPosition();
-			if(light->getParentEntity() != NULL) {
-				position = light->getParentEntity()->getConcatenatedMatrix() * position;
-			}
-			position = drawBuffer->viewMatrix * position;
-			
-			drawBuffer->lights.push_back(light->getLightInfo());
-			drawBuffer->lights[drawBuffer->lights.size()-1].position = position;
-			drawBuffer->lights[drawBuffer->lights.size()-1].direction = direction;
-		}
-	}
+
 	/*
 	if(_doVisibilityChecking) {
 		targetCamera->buildFrustumPlanes();
@@ -370,25 +333,3 @@ void Scene::handleEvent(Event *event) {
 	}
 }
 
-void Scene::addLight(SceneLight *light) {
-	lights.push_back(light);
-}
-
-void Scene::removeLight(SceneLight *light) {
-	removeEntity(light);
-	for(int i=0; i < lights.size(); i++) {
-		if(lights[i] == light) {
-			lights.erase(lights.begin()+i);
-			return;
-		}		
-	}
-}
-
-int Scene::getNumLights() {
-	return lights.size();
-}
-
-SceneLight *Scene::getLight(int index) {
-	return lights[index];
-}
-

src/core/PolySceneEntityInstance.cpp

@@ -231,7 +231,7 @@ void SceneEntityInstance::applySceneMesh(ObjectEntry *entry, SceneMesh *sceneMes
 											int type = materialShader->getExpectedParamType(nameEntry->stringVal);
 											
 											// RENDERER_TODO
-											std::shared_ptr<LocalShaderParam> param = sceneMesh->getShaderPass(0).shaderBinding->addParamFromData(nameEntry->stringVal, valueEntry->stringVal);
+											std::shared_ptr<LocalShaderParam> param = sceneMesh->getShaderPass(0).shaderBinding->addParamFromData(core->getResourceManager()->getGlobalPool(), nameEntry->stringVal, valueEntry->stringVal);
 										}
 									}
 								}
@@ -305,7 +305,7 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
 				curve->curveResolution = (*curveEntry)["resolution"]->intVal;				 
 				parseObjectIntoCurve((*curveEntry)["curve"], curve->getCurve());
 			}
-			 
+			 applySceneMesh((*entry)["SceneMesh"], curve);
 			 entity = curve;
 			 
 		 } else if(entityType->stringVal == "SceneSprite") {
@@ -400,7 +400,7 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
 			ObjectEntry *lightEntry = (*entry)["SceneLight"];
 			if(lightEntry) {
 				int lightType = (*lightEntry)["type"]->intVal;
-				SceneLight *newLight  = new SceneLight(lightType, 0);
+				SceneLight *newLight  = new SceneLight(lightType, 0, 1, 1, 1, core->getResourceManager()->getGlobalPool()->getMaterial("Unlit"));
 				
 				newLight->setIntensity((*lightEntry)["intensity"]->NumberVal);
 				

src/core/PolySceneLight.cpp

@@ -128,7 +128,7 @@ unsigned int SceneLight::getShadowMapResolution() const {
 void SceneLight::renderDepthMap(RenderFrame *frame, Scene *scene) {
 	spotCamera->setFOV(shadowMapFOV);
 	spotCamera->setViewport(Polycode::Rectangle(0, 0, shadowMapRes, shadowMapRes));
-	scene->Render(frame, spotCamera, shadowMapRenderBuffer, depthMapMaterial, false);
+	scene->Render(frame, spotCamera, shadowMapRenderBuffer, depthMapMaterial, true);
 	
 	Matrix4 matTexAdj(0.5f, 0.0f,	0.0f,	0.0f,
 					  0.0f, 0.5f,	0.0f,	0.0f,
@@ -139,6 +139,36 @@ void SceneLight::renderDepthMap(RenderFrame *frame, Scene *scene) {
 	lightInfo.shadowMapTexture = shadowMapRenderBuffer->depthTexture;
 }
 
+void SceneLight::Render(GPUDrawBuffer *buffer) {
+    
+    if(!enabled || buffer->shadowMapPass) {
+        return;
+    }
+    
+    Vector3 direction;
+    Vector3 position;
+            
+    direction.x = 0.0;
+    direction.y = 0.0;
+    direction.z = -1.0;
+            
+    direction = getConcatenatedMatrix().rotateVector(direction);
+    direction = buffer->viewMatrix.rotateVector(direction);
+            
+    if(areShadowsEnabled()) {
+        if(getType() == SceneLight::SPOT_LIGHT) {
+            renderDepthMap(buffer->renderFrame, (Scene*)buffer->userData);
+        }
+    }
+            
+    position = getConcatenatedMatrix().getPosition();
+    position = buffer->viewMatrix * position;
+            
+    buffer->lights.push_back(lightInfo);
+    buffer->lights[buffer->lights.size()-1].position = position;
+    buffer->lights[buffer->lights.size()-1].direction = direction;
+}
+
 LightInfo SceneLight::getLightInfo() const {
 	return lightInfo;
 }

src/core/PolySceneLine.cpp

@@ -79,7 +79,7 @@ BezierCurve *SceneCurve::getCurve() {
 	return curve;
 }
 
-void SceneCurve::Update() {
+void SceneCurve::Render(GPUDrawBuffer *buffer) {
 	mesh->clearMesh();
 	Vector3 bBox;
 	
@@ -100,8 +100,8 @@ void SceneCurve::Update() {
 	}
 	
 	mesh->addSubmesh(geometry);
-	
 	setLocalBoundingBox(bBox * 2.0);
+    SceneMesh::Render(buffer);
 }
 
 SceneLine::SceneLine(const Vector3 &startp, const Vector3 &endp) : SceneMesh() {

src/core/PolySceneRenderTexture.cpp

@@ -44,7 +44,7 @@ void SceneRenderTexture::Render(RenderFrame *frame, Scene *targetScene, Camera*
 	if(targetCamera->hasFilterShader()) {
 		targetCamera->drawFilter(frame, targetFramebuffer, targetScene);
 	} else {
-		targetScene->Render(frame, targetCamera, targetFramebuffer, NULL, true);
+		targetScene->Render(frame, targetCamera, targetFramebuffer, NULL);
 	}
 }
 

src/core/PolyShader.cpp

@@ -180,7 +180,7 @@ std::shared_ptr<LocalShaderParam> ShaderBinding::addParam(int type, const String
 	return newParam;
 }
 
-std::shared_ptr<LocalShaderParam> ShaderBinding::addParamFromData(const String &name, const Polycode::String &data) {
+std::shared_ptr<LocalShaderParam> ShaderBinding::addParamFromData(ResourcePool *pool, const String &name, const Polycode::String &data) {
 	std::shared_ptr<LocalShaderParam> param = std::make_shared<LocalShaderParam>();
 	std::istringstream stream(data.contents);
 	
@@ -216,7 +216,7 @@ std::shared_ptr<LocalShaderParam> ShaderBinding::addParamFromData(const String &
 		newParam->ownsPointer = false;
 	}
 	
-	newParam->setParamValueFromString(type, data);
+	newParam->setParamValueFromString(pool, type, data);
 	
 	accessMutex.lock();
 	localParams.push_back(newParam);
@@ -632,7 +632,7 @@ AttributeBinding *ShaderBinding::addAttributeBinding(const String &name, VertexD
 	return binding;
 }
 
-void LocalShaderParam::setParamValueFromString(int type, String pvalue) {
+void LocalShaderParam::setParamValueFromString(ResourcePool *pool, int type, String pvalue) {
 		switch(type) {
 			case ProgramParam::PARAM_NUMBER:
 			{
@@ -670,12 +670,8 @@ void LocalShaderParam::setParamValueFromString(int type, String pvalue) {
 			}
 			break;
 			case ProgramParam::PARAM_TEXTURE:
-                //NO_CORE_SERVICES_TODO
-                /*
-				ResourcePool *globalPool = core->getResourceManager()->getGlobalPool();
-				std::shared_ptr<Texture> texture = std::static_pointer_cast<Texture>(globalPool->loadResource(pvalue));
+				std::shared_ptr<Texture> texture = std::static_pointer_cast<Texture>(pool->loadResource(pvalue));
 				setTexture(texture);
-                 */
 			break;
 		}
 }

src/ide/EditorGrid.cpp

@@ -105,6 +105,7 @@ EditorGrid::EditorGrid(Core *core) : UIElement(core) {
 	grid->setMaterial(core->getResourceManager()->getGlobalPool()->getMaterial("UnlitUntextured"));
 	grid->setForceMaterial(true);
 	grid->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
+    grid->castShadows = false;
 	
 	grid->setColor(0.3, 0.3, 0.3, 1.0);
 	grid->setLineWidth(core->getRenderer()->getBackingResolutionScaleX());
@@ -115,17 +116,20 @@ EditorGrid::EditorGrid(Core *core) : UIElement(core) {
 	yLine->color.setColorHexFromString(GRID_Y_COLOR);
 	yLine->visible = false;
 	yLine->setForceMaterial(true);
+    yLine->castShadows = false;
 	
 	xLine = new SceneLine(Vector3(), Vector3());
 	addChild(xLine);
 	xLine->color.setColorHexFromString(GRID_X_COLOR);
 	xLine->setForceMaterial(true);
-	
+	xLine->castShadows = false;
+    
 	zLine = new SceneLine(Vector3(), Vector3());
 	addChild(zLine);
 	zLine->color.setColorHexFromString(GRID_Z_COLOR);
 	zLine->setForceMaterial(true);
-	
+	zLine->castShadows = false;
+    
 	xLine->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
 	yLine->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
 	zLine->setBlendingMode(Renderer::BLEND_MODE_NORMAL);

src/ide/PolycodeEntityEditor.cpp

@@ -99,6 +99,8 @@ CurveDisplay::CurveDisplay(CoreInput *input, ResourcePool *resourcePool, Scene *
 	controlPointLines->setColor(1.0, 1.0, 0.4, 1.0);
 	addChild(controlPointLines);
 	controlPointLines->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
+    controlPointLines->castShadows = false;
+    controlPointLines->setMaterial(resourcePool->getMaterial("UnlitUntextured"));
 	controlPointLines->setForceMaterial(true);
    
 	mainPoints = new SceneMesh();
@@ -106,10 +108,12 @@ CurveDisplay::CurveDisplay(CoreInput *input, ResourcePool *resourcePool, Scene *
 	addChild(mainPoints);
 	mainPoints->pointSmooth = true;
 	mainPoints->setForceMaterial(true);
+    mainPoints->castShadows = false;
 	mainPoints->setMaterial(resourcePool->getMaterial("UnlitPointUntextured"));
 	mainPoints->getShaderPass(0).shaderBinding->addParam(ProgramParam::PARAM_NUMBER, "pointSize")->setNumber(10.0);
 	
 	controlPoints = new SceneMesh();
+    controlPoints->castShadows = false;
 	controlPoints->setColor(1.0, 0.7, 0.0, 1.0);
 	addChild(controlPoints);
 	controlPoints->pointSmooth = true;
@@ -291,24 +295,29 @@ void CurveDisplay::Update(Number elapsed) {
 	
 }
 
-LightDisplay::LightDisplay(SceneLight *light) : Entity() {
+LightDisplay::LightDisplay(std::shared_ptr<Material> material, SceneLight *light) : Entity() {
 	editorOnly = true;
 	this->light = light;
 	spotSpot = new ScenePrimitive(ScenePrimitive::TYPE_LINE_CIRCLE, 1.0, 1.0, 32);
+    spotSpot->setMaterial(material);
 	addChild(spotSpot);
 	spotSpot->setColor(1.0, 0.8, 0.0, 1.0);
 	spotSpot->enabled = false;
 	spotSpot->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
 	spotSpot->setForceMaterial(true);
+    spotSpot->castShadows = false;
 	
 	fovSceneMesh = new SceneMesh();
+    fovSceneMesh->setMaterial(material);
 	fovSceneMesh->setColor(1.0, 0.8, 0.0, 1.0);
 	fovMesh = fovSceneMesh->getMesh();
 	addChild(fovSceneMesh);
 	fovSceneMesh->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
 	fovSceneMesh->setForceMaterial(true);
-	
+	fovSceneMesh->castShadows = false;
+    
 	MeshGeometry fovMeshGeometry;
+    fovMeshGeometry.indexedMesh = true;
 	fovMeshGeometry.setMeshType(MeshGeometry::LINE_MESH);
 	
 	fovMeshGeometry.addVertex(0.0, 0.0, 0.0);
@@ -361,11 +370,13 @@ void LightDisplay::Update(Number elapsed) {
 }
 
 
-CameraDisplay::CameraDisplay(Camera *camera) : Entity() {
+CameraDisplay::CameraDisplay(std::shared_ptr<Material> material, Camera *camera) : Entity() {
 	
 	editorOnly = true;
 	
 	fovSceneMesh = new SceneMesh();
+    fovSceneMesh->castShadows = false;
+    fovSceneMesh->setMaterial(material);
 	fovSceneMesh->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
 	fovSceneMesh->setColor(1.0, 0.0, 1.0, 1.0);
 	fovMesh = fovSceneMesh->getMesh();
@@ -563,6 +574,7 @@ void CameraPreviewWindow::setCamera(Scene *scene, Camera *camera) {
 	
 	if(camera) {
 		enabled = true;
+        visible = true;
 		if(renderTexture) {
 			delete renderTexture;
 		}
@@ -572,6 +584,7 @@ void CameraPreviewWindow::setCamera(Scene *scene, Camera *camera) {
 	} else {
 		if(!pinned) {
 			enabled = false;
+            visible = false;
 		}
 	}
 }
@@ -605,13 +618,13 @@ EntityEditorMainView::EntityEditorMainView(Core *core, ResourcePool *pool, Polyc
 	customLight1 = new SceneLight(SceneLight::POINT_LIGHT, 999999, customFalloff, customFalloff, customFalloff);
 	customLight1->editorOnly = true;
 	customLight1->setPosition(-9999, 9999, 9999);
-	mainScene->addLight(customLight1);
+	mainScene->addChild(customLight1);
 	customLight1->enabled = false;
 
 	customLight2 = new SceneLight(SceneLight::POINT_LIGHT, 999999, customFalloff, customFalloff, customFalloff);
 	customLight2->editorOnly = true;
 	customLight2->setPosition(8999, -8999, -8999);
-	mainScene->addLight(customLight2);
+	mainScene->addChild(customLight2);
 	customLight2->enabled = false;
 	
 	renderTextureShape = new UIRect(core, pool, 256, 256);
@@ -815,10 +828,6 @@ void EntityEditorMainView::doAction(String actionName, PolycodeEditorActionData
 				sceneData->entries[i].parentEntity->addChild(sceneData->entries[i].entity);
 				
 				SceneLight *sceneLight = dynamic_cast<SceneLight*>(sceneData->entries[i].entity);
-				if(sceneLight) {
-					mainScene->addLight(sceneLight);
-				}
-				
 				setEditorPropsRecursive(sceneData->entries[i].entity);
 				selectEntity(sceneData->entries[i].entity, true, false);
 			}
@@ -840,10 +849,6 @@ void EntityEditorMainView::doAction(String actionName, PolycodeEditorActionData
 			sceneData->entries[0].parentEntity->addChild(sceneData->entries[0].entity);
 			
 			SceneLight *sceneLight = dynamic_cast<SceneLight*>(sceneData->entries[0].entity);
-			if(sceneLight) {
-				mainScene->addLight(sceneLight);
-			}
-			
 			
 			setEditorPropsRecursive(sceneData->entries[0].entity);
 			selectEntity(sceneData->entries[0].entity, true, false);
@@ -1121,15 +1126,9 @@ void EntityEditorMainView::setEditorProps(Entity *entity) {
 	SceneLight *sceneLight = dynamic_cast<SceneLight*>(entity);
 	if(sceneLight) {
 		createIcon(entity, "light_icon.png");
-		LightDisplay *lightVis = new LightDisplay(sceneLight);
-		
-		// TODO: fix this
-		/*
-		if(!sceneLight->getParentScene()) {
-			sceneLight->setParentScene(mainScene);
-			mainScene->addLight(sceneLight);
-		}
-		 */
+		LightDisplay *lightVis = new LightDisplay(core->getResourceManager()->getGlobalPool()->getMaterial("UnlitUntextured"), sceneLight);
+        
+
 	}
 	
 	SceneCurve *sceneCurve = dynamic_cast<SceneCurve*>(entity);
@@ -1153,7 +1152,7 @@ void EntityEditorMainView::setEditorProps(Entity *entity) {
 
 	Camera *camera = dynamic_cast<Camera*>(entity);
 	if(camera) {
-		CameraDisplay *camVis = new CameraDisplay(camera);
+		CameraDisplay *camVis = new CameraDisplay(core->getResourceManager()->getGlobalPool()->getMaterial("UnlitUntextured"), camera);
 		createIcon(entity, "camera_icon.png");
 	}
 	
@@ -1268,7 +1267,6 @@ void EntityEditorMainView::addEntityFromMenu(String command) {
 	if(command == "add_light") {
 		SceneLight *newLight = new SceneLight(SceneLight::POINT_LIGHT, 1.0);
 		sceneObjectRoot->addChild(newLight);
-		mainScene->addLight(newLight);
 		newLight->enabled = !lightsDisabled;		
 		setEditorProps(newLight);
 		newLight->setLocalBoundingBox(Vector3());
@@ -1375,9 +1373,6 @@ void EntityEditorMainView::deleteSelected(bool doAction) {
 	for(int i=0; i < selectedEntities.size(); i++) {
 		selectedEntities[i]->getParentEntity()->removeChild(selectedEntities[i]);
 		SceneLight *sceneLight = dynamic_cast<SceneLight*>(selectedEntities[i]);
-		if(sceneLight) {
-			mainScene->removeLight(sceneLight);
-		}
 	}
 	
 	for(int i=0; i < selectedEntities.size(); i++) {
@@ -1766,11 +1761,8 @@ void EntityEditorMainView::selectNone(bool doAction) {
 void EntityEditorMainView::disableLighting(bool disable) {
 	
 	lightsDisabled = disable;
-	
-	for(int i=0; i < mainScene->getNumLights(); i++) {
-		SceneLight *light = mainScene->getLight(i);
-		light->enabled = !disable;
-	}
+    
+    
 	
 	if(disable) {
 		customLight1->enabled = true;
@@ -2495,7 +2487,7 @@ void PolycodeEntityEditor::saveShaderOptionsToEntry(ObjectEntry *entry, Material
 					if(binding->getLocalParamByName(shader->expectedParams[j].name)) {
 						ObjectEntry *paramEntry = paramsEntry->addChild("param");
 						paramEntry->addChild("name", shader->expectedParams[j].name);
-						paramEntry->addChild("value", PolycodeMaterialEditor::createStringValue(shader->expectedParams[j].type, binding->getLocalParamByName(shader->expectedParams[j].name)->data));
+						paramEntry->addChild("value", PolycodeMaterialEditor::createStringValue(binding->getLocalParamByName(shader->expectedParams[j].name)));
 					}
 				}
 			}

src/ide/PolycodeMaterialEditor.cpp

@@ -563,11 +563,11 @@ PostPreviewBox::PostPreviewBox(Core *core, ResourcePool *pool) : UIElement(core)
 
 	mainLight = new SceneLight(SceneLight::POINT_LIGHT, 90.0);
 	mainLight->setPosition(-6,6,6);
-	previewScene->addLight(mainLight);
+	previewScene->addChild(mainLight);
 
 	secondLight = new SceneLight(SceneLight::POINT_LIGHT, 90.0);
 	secondLight->setPosition(6,-6,6);
-	previewScene->addLight(secondLight);
+	previewScene->addChild(secondLight);
 
 	previewPrimitive = new ScenePrimitive(ScenePrimitive::TYPE_PLANE, 10.0, 10.0);
 	previewScene->addChild(previewPrimitive);
@@ -743,11 +743,11 @@ MaterialPreviewBox::MaterialPreviewBox(Core *core, ResourcePool *pool) : UIEleme
 	
 	mainLight = new SceneLight(SceneLight::POINT_LIGHT, 290.0);
 	mainLight->setPosition(-10,10,10);
-	previewScene->addLight(mainLight);
+	previewScene->addChild(mainLight);
 
 	secondLight = new SceneLight(SceneLight::POINT_LIGHT,  250.0);
 	secondLight->setPosition(10,-10,10);
-	previewScene->addLight(secondLight);
+	previewScene->addChild(secondLight);
 
 	
 	previewScene->getDefaultCamera()->setPosition(0,7,9);
@@ -1248,35 +1248,36 @@ bool PolycodeMaterialEditor::openFile(OSFileEntry filePath) {
 	return true;
 }
 
-String PolycodeMaterialEditor::createStringValue(unsigned int type, void *value) {
+String PolycodeMaterialEditor::createStringValue(std::shared_ptr<LocalShaderParam> param) {
 	String retString;
 	
-	switch(type) {
+	switch(param->type) {
 		case ProgramParam::PARAM_NUMBER:
-			retString = String::NumberToString(*((Number*)value));
+			retString = String::NumberToString(*((Number*)param->data));
 		break;
 		case ProgramParam::PARAM_COLOR:
 		{
-			Color color = *((Color*)value);
+			Color color = *((Color*)param->data);
 			retString = String::NumberToString(color.r) + " " + String::NumberToString(color.g) + " " + String::NumberToString(color.b) + " " + String::NumberToString(color.a);
 		}
 		break;
 		case ProgramParam::PARAM_VECTOR2:
 		{
-			Vector2 vec = *((Vector2*)value);
+			Vector2 vec = *((Vector2*)param->data);
 			retString = String::NumberToString(vec.x) + " " + String::NumberToString(vec.y);
 		}
 		break;
 		case ProgramParam::PARAM_VECTOR3:
 		{
-			Vector3 vec = *((Vector3*)value);
+			Vector3 vec = *((Vector3*)param->data);
 			retString = String::NumberToString(vec.x) + " " + String::NumberToString(vec.y) + " " + String::NumberToString(vec.z);
 		}
 		break;
 		case ProgramParam::PARAM_TEXTURE:
 		{
-			Texture *tex = (Texture*) value;
-			retString = tex->getResourcePath();
+            if(param->getTexture()) {
+                retString = param->getTexture()->getResourcePath();
+            }
 		}
 		break;
 	}
@@ -1371,7 +1372,7 @@ void PolycodeMaterialEditor::saveMaterials(ObjectEntry *materialsEntry, std::vec
 						if(shaderBinding->getLocalParamByName(shader->expectedParams[j].name)) {
 							ObjectEntry *paramEntry = paramsEntry->addChild("param");
 							paramEntry->addChild("name", shader->expectedParams[j].name);
-							paramEntry->addChild("value", PolycodeMaterialEditor::createStringValue(shader->expectedParams[j].type, shaderBinding->getLocalParamByName(shader->expectedParams[j].name)->data));
+							paramEntry->addChild("value", PolycodeMaterialEditor::createStringValue(shaderBinding->getLocalParamByName(shader->expectedParams[j].name)));
 						}
 					}
 				}

src/ide/PolycodeMeshEditor.cpp

@@ -38,10 +38,10 @@ PolycodeMeshEditor::PolycodeMeshEditor(Core *core, ResourcePool *pool) : Polycod
 				
 	Number customFalloff = 0.006;
 	mainLight = new SceneLight(SceneLight::POINT_LIGHT, 999999, customFalloff, customFalloff, customFalloff);
-	previewScene->addLight(mainLight);
+	previewScene->addChild(mainLight);
 
 	secondLight = new SceneLight(SceneLight::POINT_LIGHT, 999999, customFalloff, customFalloff, customFalloff);
-	previewScene->addLight(secondLight);
+	previewScene->addChild(secondLight);
 	
 	mainLight->setPosition(9999, 9999, 9999);
 	secondLight->setPosition(-9999, -9999, -9999);

src/ide/PolycodeProps.cpp

@@ -1258,11 +1258,11 @@ const String &caption) : PropProp(core, pool, caption, "Material"){
 	
 	mainLight = new SceneLight(SceneLight::POINT_LIGHT, 290.0);
 	mainLight->setPosition(-10,10,10);
-	previewScene->addLight(mainLight);
+	previewScene->addChild(mainLight);
 	
 	secondLight = new SceneLight(SceneLight::POINT_LIGHT, 250.0);
 	secondLight->setPosition(10,-10,10);
-	previewScene->addLight(secondLight);
+	previewScene->addChild(secondLight);
 	
 	
 	previewScene->getDefaultCamera()->setPosition(0,5,8);