Light stencil geometry is no longer generated for each light, even though it is same for all lights

BansheeEngine/Include/BsLight.h

@@ -10,10 +10,7 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Light type that determines how is light information parsed
-	 *			by the renderer and other systems.
-	 */
+	/** Light type that determines how is light information parsed by the renderer and other systems. */
 	enum class LightType
 	{
 		Directional, 
@@ -21,9 +18,7 @@ namespace BansheeEngine
 		Spot
 	};
 
-	/**
-	 * @brief	Signals which portion of a LightInternal is dirty.
-	 */
+	/**	Signals which portion of a LightInternal is dirty. */
 	enum class LightDirtyFlag
 	{
 		Transform = 0x01,
@@ -31,8 +26,7 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Illuminates a portion of the scene covered by a light. Base class for both sim and core 
-	 *			thread Light implementations.
+	 * Illuminates a portion of the scene covered by a light. Base class for both sim and core thread Light implementations.
 	 */
 	class BS_EXPORT LightBase
 	{
@@ -43,135 +37,101 @@ namespace BansheeEngine
 
 		virtual ~LightBase() { }
 
-		/**
-		 * @brief	Returns the position of the light, in world space.
-		 */
+		/**	Returns the position of the light, in world space. */
 		Vector3 getPosition() const { return mPosition; }
 
-		/**
-		 * @brief	Sets the position of the light, in world space.
-		 */
+		/**	Sets the position of the light, in world space. */
 		void setPosition(const Vector3& position) { mPosition = position; _markCoreDirty(); updateBounds(); }
 
-		/**
-		 * @brief	Returns the rotation of the light, in world space.
-		 */
+		/**	Returns the rotation of the light, in world space. */
 		Quaternion getRotation() const { return mRotation; }
 
-		/**
-		 * @brief	Sets the rotation of the light, in world space.
-		 */
+		/**	Sets the rotation of the light, in world space. */
 		void setRotation(const Quaternion& rotation) { mRotation = rotation; _markCoreDirty(); updateBounds(); }
 
-		/**
-		 * @brief	Returns the type of the light.
-		 */
+		/**	Returns the type of the light. */
 		LightType getType() const { return mType; }
 
-		/**
-		 * @brief	Changes the type of the light.
-		 */
+		/**	Changes the type of the light. */
 		void setType(LightType type) { mType = type; _markCoreDirty(); updateBounds(); }
 
-		/**
-		 * @brief	Checks does this light cast shadows when rendered.
-		 */
+		/**	Checks does this light cast shadows when rendered. */
 		bool getCastsShadow() const { return mCastsShadows; }
 
-		/**
-		 * @brief	Sets whether this light will cast shadows when rendered.
-		 */
+		/**	Sets whether this light will cast shadows when rendered. */
 		void setCastsShadow(bool castsShadow) { mCastsShadows = castsShadow; _markCoreDirty(); }
 
-		/**
-		 * @brief	Returns the color emitted from the light.
-		 */
+		/**	Returns the color emitted from the light. */
 		Color getColor() const { return mColor; }
 
-		/**
-		 * @brief	Sets the color emitted from the light.
-		 */
+		/**	Sets the color emitted from the light. */
 		void setColor(const Color& color) { mColor = color; _markCoreDirty(); }
 
-		/**
-		 * @brief	Returns the maximum range of the light. Light will not affect any geometry past that point.
-		 */
+		/**	Returns the maximum range of the light. Light will not affect any geometry past that point. */
 		float getRange() const { return mRange; }
 
 		/**
-		 * @brief	Returns the maximum range of the light. Light will not affect any geometry past that point.
+		 * Returns the maximum range of the light. Light will not affect any geometry past that point.
 		 *
 		 * @note	Normally you want to set this at a point where light intensity is too low due to attenuation.
 		 */
 		void setRange(float range) { mRange = range; _markCoreDirty(); updateBounds(); }
 
 		/**
-		 * @brief	Gets the power of the light source. This is luminous flux for point & spot lights, 
-		 *			and radiance for directional lights.
+		 * Gets the power of the light source. This is luminous flux for point & spot lights, and radiance for directional 
+		 * lights.
 		 */
 		float getIntensity() const { return mIntensity; }
 
 		/**
-		 * @brief	Sets the power of the light source. This will be luminous flux for point & spot lights, 
-		 *			and radiance for directional lights.
+		 * Sets the power of the light source. This will be luminous flux for point & spot lights, and radiance for 
+		 * directional lights.
 		 */
 		void setIntensity(float intensity) { mIntensity = intensity; _markCoreDirty(); }
 
-		/**
-		 * @brief	Gets the total angle covered by a spot light.
-		 */
+		/**	Gets the total angle covered by a spot light. */
 		Degree getSpotAngle() const { return mSpotAngle; }
 
-		/**
-		 * @brief	Sets the total angle covered by a spot light.
-		 */
+		/**	Sets the total angle covered by a spot light. */
 		void setSpotAngle(const Degree& spotAngle) { mSpotAngle = spotAngle; _markCoreDirty(); updateBounds(); }
 
 		/**
-		 * @brief	Gets the falloff angle covered by a spot light. Falloff angle determines at what point does light intensity
-		 *			starts linearly falling off as the angle approaches the total spot angle.
+		 * Gets the falloff angle covered by a spot light. Falloff angle determines at what point does light intensity 
+		 * starts quadratically falling off as the angle approaches the total spot angle.
 		 */
 		Degree getSpotFalloffAngle() const { return mSpotFalloffAngle; }
 
 		/**
-		 * @brief	Sets the falloff angle covered by a spot light. Falloff angle determines at what point does light intensity
-		 *			starts linearly falling off as the angle approaches the total spot angle.
+		 * Sets the falloff angle covered by a spot light. Falloff angle determines at what point does light intensity 
+		 * starts quadratically falling off as the angle approaches the total spot angle.
 		 */
-		void setSpotFalloffAngle(const Degree& spotFallofAngle) { mSpotFalloffAngle = spotFallofAngle; _markCoreDirty(); updateBounds(); }
+		void setSpotFalloffAngle(const Degree& spotFallofAngle) 
+		{ mSpotFalloffAngle = spotFallofAngle; _markCoreDirty(); updateBounds(); }
 
-		/**
-		 * @brief	Returns world space bounds that completely encompass the light's area of influence.
-		 */
+		/**	Returns world space bounds that completely encompass the light's area of influence. */
 		Sphere getBounds() const { return mBounds; }
 
 		/**
-		 * @brief	Returns the radiance of the light source. This is the value that should be used in lighting equations.
+		 * Returns the radiance of the light source. This is the value that should be used in lighting equations.
 		 *
-		 * @note	Ignores the light direction, therefore caller must ensure to properly handle non-uniform emitters like spot lights
+		 * @note	
+		 * Ignores the light direction, therefore caller must ensure to properly handle non-uniform emitters like spot 
+		 * lights.
 		 */
 		float getRadiance() const;
 
-		/**
-		 * @brief	Checks whether the light should be rendered or not.
-		 */
+		/**	Checks whether the light should be rendered or not. */
 		bool getIsActive() const { return mIsActive; }
 
-		/**
-		 * @brief	Sets whether the light should be rendered or not.
-		 */
+		/**	Sets whether the light should be rendered or not. */
 		void setIsActive(bool active) { mIsActive = active; _markCoreDirty(); }
 
-		/**
-		 * @copydoc	CoreObject::markCoreDirty
-		 */
+		/** @copydoc CoreObject::markCoreDirty */
 		virtual void _markCoreDirty(LightDirtyFlag flag = LightDirtyFlag::Everything) { }
 
 	protected:
-		/**
-		 * @brief	Updates the internal bounds for the light. Call this whenever a property affecting
-		 *			the bounds changes.
-		 */
-		virtual void updateBounds();
+		/** Updates the internal bounds for the light. Call this whenever a property affecting the bounds changes. */
+		void updateBounds();
 
 		Vector3 mPosition; /**< World space position. */
 		Quaternion mRotation; /**< World space rotation. */
@@ -188,7 +148,7 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Core thread usable version of a light.
+	 * Core thread usable version of a light.
 	 *
 	 * @see		LightBase
 	 */
@@ -197,20 +157,14 @@ namespace BansheeEngine
 	public:
 		~LightCore();
 
-		/**
-		 * @brief	Sets an ID that can be used for uniquely identifying this object by the renderer.
-		 */
+		/**	Sets an ID that can be used for uniquely identifying this object by the renderer. */
 		void setRendererId(UINT32 id) { mRendererId = id; }
 
-		/**
-		 * @brief	Retrieves an ID that can be used for uniquely identifying this object by the renderer.
-		 */
+		/**	Retrieves an ID that can be used for uniquely identifying this object by the renderer. */
 		UINT32 getRendererId() const { return mRendererId; }
 
-		/**
-		 * @brief	Returns a mesh that represents the light's bounds.
-		 */
-		SPtr<MeshCore> getMesh() const { return mMesh; }
+		/**	Returns a mesh that represents the light's bounds. */
+		SPtr<MeshCore> getMesh() const;
 
 		static const UINT32 LIGHT_CONE_NUM_SIDES;
 		static const UINT32 LIGHT_CONE_NUM_SLICES;
@@ -220,77 +174,52 @@ namespace BansheeEngine
 		LightCore(LightType type, Color color, float intensity, 
 			float range, bool castsShadows, Degree spotAngle, Degree spotFalloffAngle);
 
-		/**
-		 * @copydoc	CoreObjectCore::initialize
-		 */
+		/** @copydoc CoreObjectCore::initialize */
 		void initialize() override;
 
-		/**
-		 * @copydoc	CoreObject::syncToCore
-		 */
+		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;
 
-		/**
-		 * @copydoc	CoreObject::updateBounds
-		 */
-		void updateBounds() override;
-
-		/**
-		 * @brief	Generates a mesh that represents the light's bounds. Uses current light properties
-		 * 			for determining the mesh type and size.
-		 */
-		void generateMesh();
-
 		UINT32 mRendererId;
 		SPtr<MeshCore> mMesh;
 	};
 
 	/**
-	 * @brief	Sim thread usable version of a light.
+	 * Sim thread usable version of a light.
 	 *
 	 * @see		LightBase
 	 */
 	class BS_EXPORT Light : public IReflectable, public CoreObject, public LightBase
 	{
 	public:
-		/**
-		 * @brief	Retrieves an implementation of a light usable only from the core thread.
-		 */
+		/**	Retrieves an implementation of a light usable only from the core thread. */
 		SPtr<LightCore> getCore() const;
 
-		/**
-	     * @brief	Returns the hash value that can be used to identify if the internal data needs an update.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Returns the hash value that can be used to identify if the internal data needs an update. */
 		UINT32 _getLastModifiedHash() const { return mLastUpdateHash; }
 
-		/**
-	     * @brief	Sets the hash value that can be used to identify if the internal data needs an update.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Sets the hash value that can be used to identify if the internal data needs an update. */
 		void _setLastModifiedHash(UINT32 hash) { mLastUpdateHash = hash; }
 
 		/**
-		 * @brief	Updates internal transform values from the specified scene object, in case that scene
-		 *			object's transform changed since the last call.
+		 * Updates internal transform values from the specified scene object, in case that scene object's transform changed
+		 * since the last call.
 		 *
 		 * @note	Assumes the same scene object will be provided every time.
 		 */
 		void _updateTransform(const HSceneObject& parent);
 
 		/**
-		 * @brief	Creates a new light with provided settings.
+		 * Creates a new light with provided settings.
 		 *
-		 * @param	type				Type of light that determines how are the rest of the parameters interpreted.
-		 * @param	color				Color of the light.
-		 * @param	intensity			Power of the light source. This will be luminous flux for point & spot lights, 
-		 *								and radiance for directional lights.
-		 * @param	range				Cut off range for the light when rendering.
-		 * @param	castsShadows		Determines whether the light casts shadows.
-		 * @param	spotAngle			Total angle covered by a spot light.
-		 * @param	spotFalloffAngle	Spot light angle at which falloff starts. Must be smaller than total angle.
+		 * @param[in]	type				Type of light that determines how are the rest of the parameters interpreted.
+		 * @param[in]	color				Color of the light.
+		 * @param[in]	intensity			Power of the light source. This will be luminous flux for point & spot lights, 
+		 *									and radiance for directional lights.
+		 * @param[in]	range				Cut off range for the light when rendering.
+		 * @param[in]	castsShadows		Determines whether the light casts shadows.
+		 * @param[in]	spotAngle			Total angle covered by a spot light.
+		 * @param[in]	spotFalloffAngle	Spot light angle at which falloff starts. Must be smaller than total angle.
 		 */
 		static SPtr<Light> create(LightType type = LightType::Point, Color color = Color::White,
 			float intensity = 100.0f, float range = 10.0f, bool castsShadows = false,
@@ -300,24 +229,16 @@ namespace BansheeEngine
 		Light(LightType type, Color color, float intensity, float range, 
 			bool castsShadows, Degree spotAngle, Degree spotFalloffAngle);
 
-		/**
-		 * @copydoc	CoreObject::createCore
-		 */
+		/** @copydoc CoreObject::createCore */
 		SPtr<CoreObjectCore> createCore() const override;
 
-		/**
-		 * @copydoc	CoreObject::markCoreDirty
-		 */
+		/** @copydoc CoreObject::markCoreDirty */
 		void _markCoreDirty(LightDirtyFlag flag = LightDirtyFlag::Everything) override;
 
-		/**
-		 * @copydoc	CoreObject::syncToCore
-		 */
+		/** @copydoc CoreObject::syncToCore */
 		CoreSyncData syncToCore(FrameAlloc* allocator) override;
 
-		/**
-		 * @brief	Creates a light with without initializing it. Used for serialization.
-		 */
+		/**	Creates a light with without initializing it. Used for serialization. */
 		static SPtr<Light> createEmpty();
 
 		UINT32 mLastUpdateHash;

BansheeEngine/Source/BsLight.cpp

@@ -10,6 +10,110 @@
 
 namespace BansheeEngine
 {
+	/** Contains stencil meshes used for rendering light geometry */
+	class LightStencilGeometry
+	{
+	public:
+		/** Returns a stencil mesh used for a point light (a unit sphere). */
+		static SPtr<MeshCore> getPointLightStencil()
+		{
+			if (sPointLightMesh == nullptr)
+			{
+				SPtr<VertexDataDesc> vertexDesc = bs_shared_ptr_new<VertexDataDesc>();
+				vertexDesc->addVertElem(VET_FLOAT3, VES_POSITION);
+
+				UINT32 numVertices = 0;
+				UINT32 numIndices = 0;
+
+				ShapeMeshes3D::getNumElementsSphere(1, numVertices, numIndices);
+				MeshDataPtr meshData = bs_shared_ptr_new<MeshData>(numVertices, numIndices, vertexDesc);
+
+				UINT32* indexData = meshData->getIndices32();
+				UINT8* positionData = meshData->getElementData(VES_POSITION);
+
+				Sphere localSphere(Vector3::ZERO, 1.0f);
+				ShapeMeshes3D::solidSphere(localSphere, positionData, nullptr, 0,
+					vertexDesc->getVertexStride(), indexData, 0, 1);
+
+				sPointLightMesh = MeshCore::create(meshData);
+			}
+
+			return sPointLightMesh;
+		}
+
+		/** Returns a stencil mesh used for spot light. Actual vertex positions need to be computed in shader. */
+		static SPtr<MeshCore> getSpotLightStencil()
+		{
+			if (sSpotLightMesh == nullptr)
+			{
+				UINT32 numSides = LightCore::LIGHT_CONE_NUM_SIDES;
+				UINT32 numSlices = LightCore::LIGHT_CONE_NUM_SLICES;
+
+				SPtr<VertexDataDesc> vertexDesc = bs_shared_ptr_new<VertexDataDesc>();
+				vertexDesc->addVertElem(VET_FLOAT3, VES_POSITION);
+
+				UINT32 numVertices = numSides * numSlices * 2;
+				UINT32 numIndices = ((numSides * 2) * (numSlices - 1) * 2) * 3;
+
+				MeshDataPtr meshData = bs_shared_ptr_new<MeshData>(numVertices, numIndices, vertexDesc);
+
+				UINT32* indexData = meshData->getIndices32();
+				UINT8* positionData = meshData->getElementData(VES_POSITION);
+				UINT32 stride = vertexDesc->getVertexStride();
+
+				// Dummy vertex positions, actual ones generated in shader
+				for (UINT32 i = 0; i < numVertices; i++)
+				{
+					memcpy(positionData, &Vector3::ZERO, sizeof(Vector3));
+					positionData += stride;
+				}
+
+				// Cone indices
+				UINT32 curIdx = 0;
+				for (UINT32 sliceIdx = 0; sliceIdx < (numSlices - 1); sliceIdx++)
+				{
+					for (UINT32 sideIdx = 0; sideIdx < numSides; sideIdx++)
+					{
+						indexData[curIdx++] = sliceIdx * numSides + sideIdx;
+						indexData[curIdx++] = sliceIdx * numSides + (sideIdx + 1) % numSides;
+						indexData[curIdx++] = (sliceIdx + 1) * numSides + sideIdx;
+
+						indexData[curIdx++] = sliceIdx * numSides + (sideIdx + 1) % numSides;
+						indexData[curIdx++] = (sliceIdx + 1) * numSides + (sideIdx + 1) % numSides;
+						indexData[curIdx++] = (sliceIdx + 1) * numSides + sideIdx;
+					}
+				}
+
+				// Sphere cap indices
+				UINT32 coneOffset = numSides * numSlices;
+				for (UINT32 sliceIdx = 0; sliceIdx < (numSlices - 1); sliceIdx++)
+				{
+					for (UINT32 sideIdx = 0; sideIdx < numSides; sideIdx++)
+					{
+						indexData[curIdx++] = coneOffset + sliceIdx * numSides + sideIdx;
+						indexData[curIdx++] = coneOffset + sliceIdx * numSides + (sideIdx + 1) % numSides;
+						indexData[curIdx++] = coneOffset + (sliceIdx + 1) * numSides + sideIdx;
+
+						indexData[curIdx++] = coneOffset + sliceIdx * numSides + (sideIdx + 1) % numSides;
+						indexData[curIdx++] = coneOffset + (sliceIdx + 1) * numSides + (sideIdx + 1) % numSides;
+						indexData[curIdx++] = coneOffset + (sliceIdx + 1) * numSides + sideIdx;
+					}
+				}
+
+				sSpotLightMesh = MeshCore::create(meshData);
+			}
+
+			return sSpotLightMesh;
+		}
+
+	private:
+		static SPtr<MeshCore> sPointLightMesh;
+		static SPtr<MeshCore> sSpotLightMesh;
+	};
+
+	SPtr<MeshCore> LightStencilGeometry::sPointLightMesh;
+	SPtr<MeshCore> LightStencilGeometry::sSpotLightMesh;
+
 	LightBase::LightBase()
 		:mType(LightType::Point), mCastsShadows(false), mRange(10.0f),
 		mIntensity(5.0f), mSpotAngle(45), mSpotFalloffAngle(35.0f), mColor(Color::White), mIsActive(true)
@@ -152,98 +256,19 @@ namespace BansheeEngine
 		}
 	}
 
-	void LightCore::updateBounds()
-	{
-		LightBase::updateBounds();
-
-		generateMesh();
-	}
-
-	void LightCore::generateMesh()
+	SPtr<MeshCore> LightCore::getMesh() const
 	{
 		switch (mType)
 		{
 		case LightType::Directional:
-			mMesh = nullptr;
-			return;
+			return nullptr;
 		case LightType::Point:
-		{
-			SPtr<VertexDataDesc> vertexDesc = bs_shared_ptr_new<VertexDataDesc>();
-			vertexDesc->addVertElem(VET_FLOAT3, VES_POSITION);
-
-			UINT32 numVertices = 0;
-			UINT32 numIndices = 0;
-
-			ShapeMeshes3D::getNumElementsSphere(1, numVertices, numIndices);
-			MeshDataPtr meshData = bs_shared_ptr_new<MeshData>(numVertices, numIndices, vertexDesc);
-
-			UINT32* indexData = meshData->getIndices32();
-			UINT8* positionData = meshData->getElementData(VES_POSITION);
-
-			Sphere localSphere(Vector3::ZERO, 1.0f);
-			ShapeMeshes3D::solidSphere(localSphere, positionData, nullptr, 0,
-				vertexDesc->getVertexStride(), indexData, 0, 1);
-
-			mMesh = MeshCore::create(meshData);
-		}
-			return;
+			return LightStencilGeometry::getPointLightStencil();
 		case LightType::Spot:
-		{
-			SPtr<VertexDataDesc> vertexDesc = bs_shared_ptr_new<VertexDataDesc>();
-			vertexDesc->addVertElem(VET_FLOAT3, VES_POSITION);
-
-			UINT32 numVertices = LIGHT_CONE_NUM_SIDES * LIGHT_CONE_NUM_SLICES * 2;
-			UINT32 numIndices = ((LIGHT_CONE_NUM_SIDES * 2) * (LIGHT_CONE_NUM_SLICES - 1) * 2) * 3;
-
-			MeshDataPtr meshData = bs_shared_ptr_new<MeshData>(numVertices, numIndices, vertexDesc);
-
-			UINT32* indexData = meshData->getIndices32();
-			UINT8* positionData = meshData->getElementData(VES_POSITION);
-			UINT32 stride = vertexDesc->getVertexStride();
-
-			// Dummy vertex positions, actual ones generated in shader
-			for (UINT32 i = 0; i < numVertices; i++)
-			{
-				memcpy(positionData, &Vector3::ZERO, sizeof(Vector3));
-				positionData += stride;
-			}
-
-			// Cone indices
-			UINT32 curIdx = 0;
-			for (UINT32 sliceIdx = 0; sliceIdx < (LIGHT_CONE_NUM_SLICES - 1); sliceIdx++)
-			{
-				for (UINT32 sideIdx = 0; sideIdx < LIGHT_CONE_NUM_SIDES; sideIdx++)
-				{
-					indexData[curIdx++] = sliceIdx * LIGHT_CONE_NUM_SIDES + sideIdx;
-					indexData[curIdx++] = sliceIdx * LIGHT_CONE_NUM_SIDES + (sideIdx + 1) % LIGHT_CONE_NUM_SIDES;
-					indexData[curIdx++] = (sliceIdx + 1) * LIGHT_CONE_NUM_SIDES + sideIdx;
-
-					indexData[curIdx++] = sliceIdx * LIGHT_CONE_NUM_SIDES + (sideIdx + 1) % LIGHT_CONE_NUM_SIDES;
-					indexData[curIdx++] = (sliceIdx + 1) * LIGHT_CONE_NUM_SIDES + (sideIdx + 1) % LIGHT_CONE_NUM_SIDES;
-					indexData[curIdx++] = (sliceIdx + 1) * LIGHT_CONE_NUM_SIDES + sideIdx;
-				}
-			}
-
-			// Sphere cap indices
-			UINT32 coneOffset = LIGHT_CONE_NUM_SIDES * LIGHT_CONE_NUM_SLICES;
-			for (UINT32 sliceIdx = 0; sliceIdx < (LIGHT_CONE_NUM_SLICES - 1); sliceIdx++)
-			{
-				for (UINT32 sideIdx = 0; sideIdx < LIGHT_CONE_NUM_SIDES; sideIdx++)
-				{
-					indexData[curIdx++] = coneOffset + sliceIdx * LIGHT_CONE_NUM_SIDES + sideIdx;
-					indexData[curIdx++] = coneOffset + sliceIdx * LIGHT_CONE_NUM_SIDES + (sideIdx + 1) % LIGHT_CONE_NUM_SIDES;
-					indexData[curIdx++] = coneOffset + (sliceIdx + 1) * LIGHT_CONE_NUM_SIDES + sideIdx;
-
-					indexData[curIdx++] = coneOffset + sliceIdx * LIGHT_CONE_NUM_SIDES + (sideIdx + 1) % LIGHT_CONE_NUM_SIDES;
-					indexData[curIdx++] = coneOffset + (sliceIdx + 1) * LIGHT_CONE_NUM_SIDES + (sideIdx + 1) % LIGHT_CONE_NUM_SIDES;
-					indexData[curIdx++] = coneOffset + (sliceIdx + 1) * LIGHT_CONE_NUM_SIDES + sideIdx;
-				}
-			}
-
-			mMesh = MeshCore::create(meshData);
-		}
-			return;
+			return LightStencilGeometry::getSpotLightStencil();
 		}
+
+		return nullptr;
 	}
 
 	Light::Light()