/* (c) 1999-2000 Tino Schwarze, see COPYING for details */
/**@pkg cObject.cVisibleObject.cInteractiveObject.cLight*/
/**
 * a class for managing an OpenGL light
 *
 * #include "cLight.hh"
 *
 * -lMesaGL or -lGL
 *
 * This is the base class for lights and represents a point light.
 * GL_x_ATTENUATION is not (yet) supported. (It's not terribly useful
 * anyway.)
 *
 * @see cInteractiveObject
 * @pkgdoc cObject.cVisibleObject.cInteractiveObject.cLight
 */

#ifndef cLight_hh
#define cLight_hh

// include class cVisibleObject to derive from
#include "cInteractiveObject.hh"

// include class cColor representing an RGB(A) color for use
// with OpenGL
#include "cADSEColor.hh"

// include common project macros, definitions and headers
#include "common.hh"

// I don't want to include glu.h here; we just need a type.
typedef struct GLUquadricObj GLUquadricObj;

/**
 * A class for managing OpenGL lights.
 	*
	* Lights are very special since there might be only a limited amount
	* of them active at once. We need to check that before turning a
	* light on (that's what the static variables are for).
	*
	* It's a special object since it does not draw itself, but only
	* is glEnabled() during SetUpForDrawing and glDisabled() during
	* CleanUpAfterDrawing() (of course, the light needs to be turned on).
	*
	* It might (and actually is) derived from this class, e.g. for
	* providing a directional and a spot light.
	*
	* Note that cLights are treatened like all other cObjects as far as they
	* might have siblings and take part in the normal scene hierarchy.
	*
	* The inherited mRotation quaternion is not used.
	*/
class cLight 
:	public cInteractiveObject
{
public:

	/**
	 * an extra type for the light status
	 	*/
	typedef enum eLightState {
		LIGHT_OFF,
		LIGHT_ON
	} teLightState;

	/**
	 * default constructor
	 	*/
	cLight (
		cEventDispatcher *disp,
		const char *name = NULL);

#if DEBUG
	/**
	 * copy constructor (inherited)
	 	*/
	cLight (const cLight &);
#endif

	/**
	 * constructor with initialization of position and name
	 	* @param pos initial position of light source
		* @param state initial state of light source (default: on)
		* @param name name of light source (optional)
	 	*/
	cLight (
		cEventDispatcher *disp,
		const cVertex &pos, 
		const char *name = NULL);

	/**
	 * constructor with initialization of position, state and name
	 	* @param pos initial position of light source
		* @param state initial state of light source (default: on)
		* @param name name of light source (optional)
	 	*/
	cLight (
		cEventDispatcher *disp,
		const cVertex &pos, 
		const teLightState state = LIGHT_ON, 
		const char *name = NULL);

	/**
	 * constructor with initialization of position, color, state 
	 * and name
	 	* @param pos initial position of light source
		* @param col color of the light source (cADSEColor object)
		*        (emissive color component is not used)
		* @param state initial state of light source (default: on)
		* @param name name of light source (optional)
	 	*/
	cLight (
		cEventDispatcher *disp,
		const cVertex &pos, 
		const cADSEColor &col,
		const teLightState state = LIGHT_ON, 
		const char *name = NULL);

	/**
	 * destructor
	 	*/
	virtual ~cLight ();

// OPERATIONS
	// note: translating the light is obtained via functions inherited from
	// cVisibleObject (@see cVisibleObject::MoveBy, cVisibleObject::MoveTo)

// ACCESS
	/**
	 * enable the light
		* @param state teLightState - LIGHT_ON or LIGHT_OFF
	 	*/
	void SetState (teLightState state);

	/**
	 * query light status
	 	* @return bool stating whether the light is on or off
	 	*/
	bool IsOn () const;

	/**
	 * set ambient color
	 	* @param c new ambient color of light
	 	*/
	virtual void SetAmbientColor (const cColor &c);

	/**
	 * set diffuse color
	 	* @param c new diffuse color of light
	 	*/
	virtual void SetDiffuseColor (const cColor &c);

	/**
	 * set specular color
	 	* @param c new specular color of light
	 	*/
	virtual void SetSpecularColor (const cColor &c);


	/**
	 * event receiver - we listen for switchon/switchoff events
		*
		* @return 0 - event accepted, -1 - event not
		* accepted
		*/
	virtual int ReceiveEvent (const cEvent &event);

	/**
	 * overload cVisibleObject::MoveTo since we want to ignore
	 * mRotation while moving (it's used to determine direction only)
	 	*/
	virtual void MoveTo (const cVertex &v);

	/**
	 * overload cVisibleObject::MoveBy since we want to ignore
	 * mRotation while moving (it's used to determine direction only)
	 	*/
	virtual void MoveBy (const cVertex &v);

protected:
	/**
	 * set up for drawing (overloaded from cVisibleObject)
	 	*
		* Lights should follow the following behaviour:
		* 1. If you change a standard parameter for a light,
		*    undo it in Deactivate()
		* 2. Position and {Ambient,Diffuse,Specular}Color do not
		*    count for 1.
	 	*/
	virtual void Activate ();

	/**
	 * this one performs the actual set up of the light
		*
		* (called by Activate()); separeted to simplify
		* cDirectionLight
		*/
	virtual void ActivateLight ();

	/**
	 * suppress transformation
	 	*/
	virtual void Transform ();

	/**
	 * A light is a visible object therefore it needs a drawing function
	 	*
		* It is used when the light is shown.
	 	*/
	virtual void DrawThisObject ();

	/**
	 * clean up after drawing (overloaded from cVisibleObject)
	 	*/
	virtual void Deactivate ();

	/**
	 * perform steps neccessary before freeing the light slot
	 * (e.g. disabling the light)
	 	*/
	virtual void DeactivateLight ();

	/**
	 * aquire a light slot (stored in mLightSlot)
	    * @return -1 on error (no free slot), 0 on success
		*/
	virtual int AllocateLightSlot ();

	/**
	 * free the light slot
	    * @return -1 on error (slot was not allocated), 0 on success
		*/
	virtual int FreeLightSlot ();

	/**
	 * we want to get switchon/switchoff events if we're selected
		*/
	virtual void SubscribeToActiveEvents ();

	/**
	 * unsubscribe from switchon/switchoff if we get deselected
		*/
	virtual void UnsubscribeFromActiveEvents ();

	/**
	 * identify an instance of this class if it's got no name
	 	*/
	virtual const char *GetDefaultName () const
	{
		return "cLight";
	}

	/**
	 * current status of light (LIGHT_ON or LIGHT_OFF)
	 	*/
	teLightState mState;
	
	/**
	 * ambient color component of light
	 	*/
	cADSEColor mLightColor;

	/**
	 * keep track of status of OpenGL lights
	 	*
		* As OpenGL allows 8 lights at once, we need to keep track
		* of which lights are currently in use and which are not.
		*
		* At runtime, to enable a light, we look for a free "slot"
		* and use it for our light source.
		*/
	static teLightState mgLightSlots[8];

	/**
	 * keep track of how many lights are currently active
	 	*/
	static int mgActiveLights;

	/**
	 * actually used light slot (-1 = no slot used)
	 	*/
	int mLightSlot;

	/**
	 * only used if the light source is to be drawn
	 	*/
	GLUquadricObj *mQuadric;
};

#endif	// ifndef cLight_hh