/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Light implementation

*

*/

/*!

 * \internal

 * \file

 * \brief Light implementation

 */

#ifndef M3G_CORE_INCLUDE

#   error included by m3g_core.c; do not compile separately.

#endif

#include "m3g_light.h"

#include "m3g_animationtrack.h"

/*----------------------------------------------------------------------

 * Internal functions

 *--------------------------------------------------------------------*/

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Insert light to render queue.

 *

 * \param self Light object

 * \param toCamera transform to camera

 * \param alphaFactor total alpha factor

 * \param caller caller node

 * \param renderQueue RenderQueue

 *

 * \retval M3G_TRUE continue render setup

 * \retval M3G_FALSE abort render setup

 */

static M3Gbool m3gLightSetupRender(Node *self,

                                   const Node *caller,

                                   SetupRenderState *s,

                                   RenderQueue *renderQueue)

{

    M3G_UNREF(caller);

    if (renderQueue->lightManager != NULL) {

        Light *light = (Light *)self;

        if (self->enableBits & NODE_RENDER_BIT) {

            if (m3gInsertLight(renderQueue->lightManager,

                               light, &s->toCamera, M3G_INTERFACE(light)) == -1)

                return M3G_FALSE;

        }

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param property      animation property

 * \retval M3G_TRUE     property supported

 * \retval M3G_FALSE    property not supported

 */

static M3Gbool m3gLightIsCompatible(M3Gint property)

{

    switch (property) {

    case M3G_ANIM_COLOR:

    case M3G_ANIM_INTENSITY:

    case M3G_ANIM_SPOT_ANGLE:

    case M3G_ANIM_SPOT_EXPONENT:

        return M3G_TRUE;

    default:

        return m3gNodeIsCompatible(property);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self          Light object

 * \param property      animation property

 * \param valueSize     size of value array

 * \param value         value array

 */

static void m3gLightUpdateProperty(Object *self,

                                   M3Gint property,

                                   M3Gint valueSize,

                                   const M3Gfloat *value)

{

    Light *light = (Light *)self;

    M3G_VALIDATE_OBJECT(light);

    M3G_ASSERT_PTR(value);

    switch (property) {

    case M3G_ANIM_COLOR:

        M3G_ASSERT(valueSize >= 3);

        light->color = m3gColor3f(value[0], value[1], value[2]);

        break;

    case M3G_ANIM_INTENSITY:

        M3G_ASSERT(valueSize >= 1);

        light->intensity = value[0];

        break;

    case M3G_ANIM_SPOT_ANGLE:

        M3G_ASSERT(valueSize >= 1);

        light->spotAngle = m3gClampFloat(value[0], 0.f, 90.f);

        break;

    case M3G_ANIM_SPOT_EXPONENT:

        M3G_ASSERT(valueSize >= 1);

        light->spotExponent = m3gClampFloat(value[0], 0.f, 128.f);

        break;

    default:

        m3gNodeUpdateProperty(self, property, valueSize, value);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original Light object

 * \param cloneObj pointer to cloned Light object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gLightDuplicate(const Object *originalObj,

                                 Object **cloneObj,

                                 Object **pairs,

                                 M3Gint *numPairs)

{

    const Light *original = (const Light *) originalObj;

    Light *clone;

    M3G_ASSERT(*cloneObj == NULL); /* no derived classes for light */

    /* Create the clone object and exit on failure */

    clone = (Light *)m3gCreateLight(originalObj->interface);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate base class data */

    if (!m3gNodeDuplicate(originalObj, cloneObj, pairs, numPairs)) {

        return M3G_FALSE;

    }

    /* Duplicate own data */

	clone->constantAttenuation = original->constantAttenuation;

	clone->linearAttenuation = original->linearAttenuation;

	clone->quadraticAttenuation = original->quadraticAttenuation;

	clone->intensity = original->intensity;

	clone->color = original->color;

	clone->mode = original->mode;

    clone->spotAngle = original->spotAngle;

	clone->spotExponent = original->spotExponent;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Initializes a Light object. See specification

 * for default values.

 *

 * \param m3g           M3G interface

 * \param light         Light object

 */

static void m3gInitLight(Interface *m3g, Light *light)

{

	/* Light is derived from node */

	m3gInitNode(m3g, &light->node, M3G_CLASS_LIGHT);

	light->constantAttenuation = 1.0f;

	light->intensity = 1.0f;

	light->color = 0x00ffffff;  /* Full white */

	light->mode = M3G_DIRECTIONAL;

	light->spotAngle = 45.0f;

}

/*!

 * \internal

 * \brief Applies this light to the current OpenGL context.

 *

 * \param self          Light object

 * \param glLight       OpenGL light index

 * \param pos           light position

 * \param spotDir       light direction

 */

static void m3gApplyLight(const Light *self,

                          GLenum glLight,

                          const Vec4 *pos,

                          const Vec4 *spotDir)

{

	static const M3Gfloat BLACK[] = { 0.0f, 0.0f, 0.0f, 0.0f };

	M3Gfloat light[4];

    M3G_ASSERT(m3gInRange(glLight, GL_LIGHT0, GL_LIGHT7));

    glEnable(glLight);

	m3gFloatColor(self->color, self->intensity, light);

    /* Set light position */

    if (self->mode == M3G_DIRECTIONAL) {

        GLfloat temp[4];

        temp[0] = -spotDir->x;

        temp[1] = -spotDir->y;

        temp[2] = -spotDir->z;

        temp[3] = 0.0f;

        glLightfv(glLight, GL_POSITION, temp);

    }

    else {

        glLightfv(glLight, GL_POSITION, &pos->x);

        if (self->mode == M3G_SPOT) {

            glLightfv(glLight, GL_SPOT_DIRECTION, &spotDir->x);

        }

    }

    /* Set ambient, diffuse, and specular contributions */

	if (self->mode == M3G_AMBIENT) {

		glLightfv(glLight, GL_AMBIENT, light);

		glLightfv(glLight, GL_DIFFUSE, BLACK);

		glLightfv(glLight, GL_SPECULAR, BLACK);

	}

	else {

		glLightfv(glLight, GL_AMBIENT, BLACK);

		glLightfv(glLight, GL_DIFFUSE, light);

		glLightfv(glLight, GL_SPECULAR, light);

	}

    /* Set spot parameters */

	if (self->mode == M3G_SPOT) {

		glLightf(glLight, GL_SPOT_EXPONENT, self->spotExponent);

		glLightf(glLight, GL_SPOT_CUTOFF, self->spotAngle);

	}

	else {

		glLightf(glLight, GL_SPOT_CUTOFF, 180.0f);

	}

    /* Set attenuation */

	if (self->mode == M3G_OMNI || self->mode == M3G_SPOT) {

		glLightf(glLight, GL_CONSTANT_ATTENUATION,  self->constantAttenuation);

		glLightf(glLight, GL_LINEAR_ATTENUATION,    self->linearAttenuation);

		glLightf(glLight, GL_QUADRATIC_ATTENUATION, self->quadraticAttenuation);

	}

	else if (self->mode == M3G_AMBIENT) {

		glLightf(glLight, GL_CONSTANT_ATTENUATION,  1.0f);

		glLightf(glLight, GL_LINEAR_ATTENUATION,    0.0f);

		glLightf(glLight, GL_QUADRATIC_ATTENUATION, 0.0f);

	}

}

/*----------------------------------------------------------------------

 * Virtual function table

 *--------------------------------------------------------------------*/

static const NodeVFTable m3gvf_Light = {

    {

        {

            m3gObjectApplyAnimation,

            m3gLightIsCompatible,

            m3gLightUpdateProperty,

            m3gObjectDoGetReferences,

            m3gObjectFindID,

            m3gLightDuplicate,

            m3gDestroyNode

        }

    },

    m3gNodeAlign,

    NULL, /* pure virtual DoRender */

    m3gNodeGetBBox,

    m3gNodeRayIntersect,

    m3gLightSetupRender,

    m3gNodeUpdateDuplicateReferences,

    m3gNodeValidate

};

/*----------------------------------------------------------------------

 * Public API functions

 *--------------------------------------------------------------------*/

/*!

 * \brief Creates a Light object.

 *

 * \param interface     M3G interface

 * \retval Light new Light object

 * \retval NULL Light creating failed

 */

M3G_API M3GLight m3gCreateLight(M3GInterface interface)

{

    Interface *m3g = (Interface *) interface;

    M3G_VALIDATE_INTERFACE(m3g);

	{

		Light *light =  m3gAllocZ(m3g, sizeof(Light));

        if (light != NULL) {

    		m3gInitLight(m3g, light);

        }

		return (M3GLight) light;

	}

}

/*!

 * \brief Set light intensity.

 *

 * \param handle        Light object

 * \param intensity     light intensity

 */

M3G_API void m3gSetIntensity(M3GLight handle, M3Gfloat intensity)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

	light->intensity = intensity;

}

/*!

 * \brief Set light color as RGB.

 *

 * \param handle        Light object

 * \param rgb           light color as RGB

 */

M3G_API void m3gSetLightColor(M3GLight handle, M3Guint rgb)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

	light->color = rgb & M3G_RGB_MASK;

}

/*!

 * \brief Set light mode.

 *

 * \param handle        Light object

 * \param mode          light mode

 */

M3G_API void m3gSetLightMode(M3GLight handle, M3Gint mode)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

	if (mode < M3G_AMBIENT || mode > M3G_SPOT) {

    	m3gRaiseError(M3G_INTERFACE(light), M3G_INVALID_VALUE);

        return;

    }

	light->mode = mode;

}

/*!

 * \brief Set light spot angle.

 *

 * \param handle        Light object

 * \param angle         spot angle

 */

M3G_API void m3gSetSpotAngle(M3GLight handle, M3Gfloat angle)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

	if (angle < 0.0f || angle > 90.f) {

    	m3gRaiseError(M3G_INTERFACE(light), M3G_INVALID_VALUE);

        return;

	}

	light->spotAngle = angle;

}

/*!

 * \brief Set light spot exponent.

 *

 * \param handle        Light object

 * \param exponent      spot exponent

 */

M3G_API void m3gSetSpotExponent(M3GLight handle, M3Gfloat exponent)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    if (exponent < 0.0f || exponent > 128.0f) {

    	m3gRaiseError(M3G_INTERFACE(light), M3G_INVALID_VALUE);

        return;

    }

    light->spotExponent = exponent;

}

/*!

 * \brief Set light attenuation factors.

 *

 * \param handle        Light object

 * \param constant      constant attenuation

 * \param linear        linear attenuation

 * \param quadratic     quadratic attenuation

 */

M3G_API void m3gSetAttenuation(M3GLight handle,

                               M3Gfloat constant,

                               M3Gfloat linear,

                               M3Gfloat quadratic)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    if (constant < 0.0f || linear < 0.0f || quadratic < 0.0f

        || (constant == 0.0f && linear == 0.0f && quadratic == 0.0f)) {

    	m3gRaiseError(M3G_INTERFACE(light), M3G_INVALID_VALUE);

        return;

    }

    light->constantAttenuation  = constant;

    light->linearAttenuation    = linear;

    light->quadraticAttenuation = quadratic;

}

/*!

 * \brief Get light intensity.

 *

 * \param handle        Light object

 * \return              light intensity

 */

M3G_API M3Gfloat m3gGetIntensity(M3GLight handle)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    return light->intensity;

}

/*!

 * \brief Get light color as RGB.

 *

 * \param handle        Light object

 * \return              light color as RGB

 */

M3G_API M3Guint m3gGetLightColor(M3GLight handle)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    return light->color;

}

/*!

 * \brief Get light mode.

 *

 * \param handle        Light object

 * \return              light mode

 */

M3G_API M3Gint m3gGetLightMode(M3GLight handle)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    return light->mode;

}

/*!

 * \brief Get light spot angle.

 *

 * \param handle        Light object

 * \return              light spot angle

 */

M3G_API M3Gfloat m3gGetSpotAngle(M3GLight handle)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    return light->spotAngle;

}

/*!

 * \brief Get light spot exponent.

 *

 * \param handle        Light object

 * \return              light spot exponent

 */

M3G_API M3Gfloat m3gGetSpotExponent(M3GLight handle)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

    return light->spotExponent;

}

/*!

 * \brief Get light attenuation factor.

 *

 * \param handle        Light object

 * \param type          which factor to return

 *                      \arg M3G_GET_CONSTANT

 *                      \arg M3G_GET_LINEAR

 *                      \arg M3G_GET_QUADRATIC

 * \return              light attenuation factor

 */

M3G_API M3Gfloat m3gGetAttenuation(M3GLight handle, M3Gint type)

{

	Light *light = (Light *) handle;

	M3G_VALIDATE_OBJECT(light);

	switch(type) {

	case M3G_GET_CONSTANT:

	    return light->constantAttenuation;

	case M3G_GET_LINEAR:

    	return light->linearAttenuation;

    case M3G_GET_QUADRATIC:

	default:

	    return light->quadraticAttenuation;

	}

}