/*
* 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);
    }
}