/*

* 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 manager implementation

*

*/

/*!

 * \internal

 * \file

 * \brief Light manager implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_lightmanager.h"

#include "m3g_light.h"

#include "m3g_rendercontext.h"

#include "m3g_math.h"

/*!

 * \internal

 * \brief Light array element

 */

typedef struct

{

    /*! \internal \brief eye space spot direction */

    Vec4 spotDir;

    /*! \internal \brief eye space position */

    Vec4 position;

    /*! \internal \brief reference to the Light node */

    Light *light;

} LightRecord;

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

 * Private functions

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

/*!

 * \internal

 * \brief Update a single light record

 *

 * Light position and spot direction are transformed into world space,

 * i.e. omitting the viewing transformation which is applied by OpenGL

 * when rendering. Both transformations are special cases and

 * accomplished by just reading a part of the matrix.

 *

 * \note We need to transform the spotlight direction even if the

 * light is not a spotlight, since in immediate mode, it may change

 * into a spotlight later on!

 */

static void m3gSetLightRecord(LightRecord *lrec,

                              Light *light,

                              const Matrix *tf)

{

    Vec4 v;

    M3G_ASSIGN_REF(lrec->light, light);

    if (tf != NULL) {

        m3gGetMatrixColumn(tf, 3, &lrec->position);

        m3gGetMatrixColumn(tf, 2, &v);

        lrec->spotDir.x = -v.x;

        lrec->spotDir.y = -v.y;

        lrec->spotDir.z = -v.z;

        lrec->spotDir.w = 0.0f;

    }

    else {

        lrec->spotDir.x = lrec->spotDir.y = lrec->spotDir.w = 0.0f;

        lrec->spotDir.z = -1.0f;

        lrec->position.x = lrec->position.y = lrec->position.z = 0.0f;

        lrec->position.w = 1.0f;

    }

}

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

 * Internal functions

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

/*!

 * \internal

 * \brief Clears all lights in the current pool of lights

 */

static void m3gClearLights2(LightManager *mgr)

{

    LightRecord *lrec;

    PointerArray *lights;

    int i, n;

    M3G_ASSERT_PTR(mgr);

    lights = &mgr->lights;

    n = m3gArraySize(lights);

    for (i = 0; i < n; ++i) {

        lrec = m3gGetArrayElement(lights, i);

        M3G_ASSIGN_REF(lrec->light, NULL);

    }

    mgr->numActive = 0;

}

/*!

 * \internal

 * \brief Destroys the light manager, freeing allocated resources

 */

static void m3gDestroyLightManager(LightManager *mgr, Interface *m3g)

{

    int i, n;

    M3G_ASSERT_PTR(mgr);

    M3G_VALIDATE_INTERFACE(m3g);

    /* First remove all light references */

    m3gClearLights2(mgr);

    /* Free the records currently in the light array */

    n = m3gArraySize(&mgr->lights);

    for (i = 0; i < n; ++i) {

        m3gFree(m3g, m3gGetArrayElement(&mgr->lights, i));

    }

    m3gDestroyArray(&mgr->lights, m3g);

}

/*!

 * \internal

 * \brief Appends a light at the end of the light manager array

 */

static M3Gint m3gInsertLight(LightManager *mgr,

                             Light *light,

                             const Matrix *tf,

                             Interface *m3g)

{

    LightRecord *lrec;

    PointerArray *lights;

    M3Gint idx;

    M3G_ASSERT_PTR(mgr);

    M3G_VALIDATE_INTERFACE(m3g);

    lights = &mgr->lights;

    /* Get the first unused light record, or add a new one */

    if (mgr->numActive < m3gArraySize(lights)) {

        lrec = m3gGetArrayElement(lights, mgr->numActive);

    }

    else {

        M3G_ASSERT(mgr->numActive == m3gArraySize(lights));

        lrec = m3gAllocZ(m3g, sizeof(LightRecord));

        if (lrec == NULL) {

            return -1;

        }

        if (m3gArrayAppend(lights, lrec, m3g) == -1) {

            return -1;

        }

    }

    idx = mgr->numActive++;

    m3gSetLightRecord(lrec, light, tf);

    return idx;

}

/*!

 * \internal

 * \brief

 */

static M3Gsizei m3gLightArraySize(const LightManager *mgr)

{

    M3G_ASSERT_PTR(mgr);

    return mgr->numActive;

}

/*!

 * \internal

 * \brief

 */

static Light *m3gGetLightTransformInternal(const LightManager *mgr, M3Gint idx, M3GMatrix *transform)

{

    M3Gfloat matrix[16];

    LightRecord *lrec;

    M3G_ASSERT_PTR(mgr);

    M3G_ASSERT(m3gInRange(idx, 0, mgr->numActive - 1));

    lrec = m3gGetArrayElement(&mgr->lights, idx);

    if (transform != NULL) {

        m3gZero(matrix, sizeof(matrix));

        matrix[0 * 4 + 0] = 1.f;

        matrix[1 * 4 + 1] = 1.f;

        matrix[2 * 4 + 0] = -lrec->spotDir.x;

        matrix[2 * 4 + 1] = -lrec->spotDir.y;

        matrix[2 * 4 + 2] = -lrec->spotDir.z;

        matrix[3 * 4 + 0] = lrec->position.x;

        matrix[3 * 4 + 1] = lrec->position.y;

        matrix[3 * 4 + 2] = lrec->position.z;

        matrix[3 * 4 + 3] = lrec->position.w;

        m3gSetMatrixColumns(transform, matrix);

    }

    return lrec->light;

}

/*!

 * \internal

 * \brief Replaces an existing light in the light array

 */

static void m3gReplaceLight(LightManager *mgr,

                            M3Gint idx,

                            Light *light,

                            const Matrix *tf)

{

    LightRecord *lrec;

    M3G_ASSERT_PTR(mgr);

    M3G_ASSERT(m3gInRange(idx, 0, mgr->numActive - 1));

    lrec = m3gGetArrayElement(&mgr->lights, idx);

    m3gSetLightRecord(lrec, light, tf);

}

/*!

 * \internal

 * \brief Selects a set of lights from the current light array for OpenGL

 *

 * Selects a maximum on \c maxNum lights from the array matching the

 * given scope, sets those into the current OpenGL context, and

 * disables the rest of the OpenGL lights GL_LIGHT0..GL_LIGHT7. A

 * maximum of 8 lights is ever used.

 *

 */

static void m3gSelectGLLights(const LightManager *mgr,

                              M3Gsizei maxNum,

                              M3Guint scope,

                              M3Gfloat x, M3Gfloat y, M3Gfloat z)

{

    const PointerArray *lights;

    int i, required, total;

    GLenum glIndex = GL_LIGHT0;

    M3G_ASSERT_PTR(mgr);

    M3G_UNREF(x);

    M3G_UNREF(y);

    M3G_UNREF(z);

    lights = &mgr->lights;

    required = m3gClampInt(maxNum, 0, 8);

    total = mgr->numActive;

    /* Select the first n lights that match the scope */

    for (i = 0; required > 0 && i < total; ++i) {

        const LightRecord *lrec;

        const Light *light;

        lrec = (const LightRecord *) m3gGetArrayElement(lights, i);

        M3G_ASSERT(lrec != NULL);

        light = lrec->light;

        if (light != NULL && (light->node.scope & scope) != 0) {

            m3gApplyLight(light, glIndex++, &lrec->position, &lrec->spotDir);

            --required;

        }

    }

    /* Disable the leftover lights */

    while (glIndex <= GL_LIGHT7) {

        glDisable(glIndex++);

    }

}

/*!

 * \internal

 * \brief Transforms all lights with the given matrix

 */

static void m3gTransformLights(LightManager *mgr, const Matrix *mtx)

{

    const PointerArray *lights;

    M3Gint i, n;

    lights = &mgr->lights;

    n = mgr->numActive;

    for (i = 0; i < n; ++i) {

        LightRecord *lrec = (LightRecord*) m3gGetArrayElement(lights, i);

        m3gTransformVec4(mtx, &lrec->position);

        m3gTransformVec4(mtx, &lrec->spotDir);

    }

}