/*
* 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: Camera implementation
*
*/


/*!
 * \internal
 * \file
 * \brief Camera implementation
 */

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

#include "m3g_camera.h"

/* Internal frustum plane enumeration (and testing order!) */

#define NEAR_PLANE      0
#define FAR_PLANE       1
#define LEFT_PLANE      2
#define RIGHT_PLANE     3
#define BOTTOM_PLANE    4
#define TOP_PLANE       5

/*----------------------------------------------------------------------
 * Private functions
 *--------------------------------------------------------------------*/

/*!
 * \internal
 * \brief Makes sure that the internal projection matrix is up-to-date
 *        and checks if the camera has a zero view volume.
 */
static void m3gValidateProjectionMatrix(Camera *camera)
{
    M3Gint projType = camera->projType;

    /* The generic matrix is always valid, but for perspective and
     * parallel we must regenerate the matrix */
    
    if (projType != M3G_GENERIC) {
        M3Gfloat m[16];

        M3Gfloat clipNear = camera->clipNear;
        M3Gfloat clipFar = camera->clipFar;

        if (projType == M3G_PERSPECTIVE) {
            
            M3Gfloat height = m3gTan(m3gMul(M3G_DEG2RAD * 0.5f,
                                            camera->heightFov));
            
            m[0] = m3gRcp(m3gMul(camera->aspect, height));
            m[1] = m[2] = m[3] = 0.f;
            
            m[4] = 0.f;
            m[5] = m3gRcp(height);
            m[6] = m[7] = 0.f;
            
            m[8] = m[9] = 0.f;
            m[10] = m3gDiv(-m3gAdd(clipFar, clipNear),
                           m3gSub(clipFar, clipNear));
            m[11] = -1.f;
            
            m[12] = m[13] = 0.f;
            m[14] = m3gDiv(m3gMul(m3gMul(-2.f, clipFar), clipNear),
                           m3gSub(clipFar, clipNear));
            m[15] = 0.f;
        }
        else if (projType == M3G_PARALLEL) {

            M3Gfloat height = camera->heightFov;
            
            m[0] = m3gDiv(2.f, m3gMul(camera->aspect, height));
            m[1] = m[2] = m[3] = 0.f;

            m[4] = 0.f;
            m[5] = m3gDiv(2.f, height);
            m[6] = m[7] = 0;
            
            m[8] = m[9] = 0;
            m[10] = m3gDiv(-2.f, m3gSub(clipFar, clipNear));
            m[11] = 0.f;
            
            m[12] = m[13] = 0.f;
            m[14] = m3gDiv(-m3gAdd(clipFar, clipNear),
                           m3gSub(clipFar, clipNear));
            m[15] = 1.f;
        }
        else {
            M3G_ASSERT(M3G_FALSE); /* unknown projection type! */
        }
        m3gSetMatrixColumns(&camera->projMatrix, m); 
    }

    {
        M3GMatrix im;
        if (!m3gMatrixInverse(&im, &camera->projMatrix)) {
            camera->zeroViewVolume = M3G_TRUE;
        }
        else {
            camera->zeroViewVolume = M3G_FALSE;
        }
    }

    camera->frustumPlanesValid = M3G_FALSE;
}

/*!
 * \internal
 * \brief Validates the cached view frustum planes
 */
static void m3gValidateFrustumPlanes(Camera *camera) 
{
    if (!camera->frustumPlanesValid) {
        Vec4 *plane;
        Vec4 rows[4];
        
        m3gGetMatrixRows(&camera->projMatrix, (M3Gfloat*) rows);

        plane = &camera->frustumPlanes[LEFT_PLANE];
        *plane = rows[3];
        m3gAddVec4(plane, &rows[0]);

        plane = &camera->frustumPlanes[RIGHT_PLANE];
        *plane = rows[3];
        m3gSubVec4(plane, &rows[0]);

        plane = &camera->frustumPlanes[BOTTOM_PLANE];
        *plane = rows[3];
        m3gAddVec4(plane, &rows[1]);

        plane = &camera->frustumPlanes[TOP_PLANE];
        *plane = rows[3];
        m3gSubVec4(plane, &rows[1]);

        plane = &camera->frustumPlanes[NEAR_PLANE];
        *plane = rows[3];
        m3gAddVec4(plane, &rows[2]);

        plane = &camera->frustumPlanes[FAR_PLANE];
        *plane = rows[3];
        m3gSubVec4(plane, &rows[2]);

        camera->frustumPlanesValid = M3G_TRUE;
    }
}

#undef NEAR_PLANE
#undef FAR_PLANE
#undef LEFT_PLANE
#undef RIGHT_PLANE
#undef BOTTOM_PLANE
#undef TOP_PLANE

/*----------------------------------------------------------------------
 * Internal functions
 *--------------------------------------------------------------------*/

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param property      animation property
 * \retval M3G_TRUE     property supported
 * \retval M3G_FALSE    property not supported
 */
static M3Gbool m3gCameraIsCompatible(M3Gint property)
{
    switch (property) {
    case M3G_ANIM_FAR_DISTANCE:
    case M3G_ANIM_FIELD_OF_VIEW:
    case M3G_ANIM_NEAR_DISTANCE:
        return M3G_TRUE;
    default:
        return m3gNodeIsCompatible(property);
    }
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param obj          Camera object
 * \param property      animation property
 * \param valueSize     size of value array
 * \param value         value array
 */
static void m3gCameraUpdateProperty(Object *obj,
                                    M3Gint property,
                                    M3Gint valueSize,
                                    const M3Gfloat *value)
{
    Camera *camera = (Camera *) obj;
    M3G_VALIDATE_OBJECT(camera);
    M3G_ASSERT_PTR(value);

    switch (property) {
    case M3G_ANIM_FAR_DISTANCE:
        M3G_ASSERT(valueSize >= 1);
        camera->clipFar =   (camera->projType == M3G_PERSPECTIVE)
                            ? m3gClampFloatPositive(value[0])
                            : value[0];
        break;
    case M3G_ANIM_FIELD_OF_VIEW:
        M3G_ASSERT(valueSize >= 1);
        camera->heightFov = (camera->projType == M3G_PERSPECTIVE)
                            ? m3gClampFloat(value[0], 0.f, 180.f)
                            : m3gClampFloatPositive(value[0]);
        break;
    case M3G_ANIM_NEAR_DISTANCE:
        M3G_ASSERT(valueSize >= 1);
        camera->clipNear =  (camera->projType == M3G_PERSPECTIVE)
                            ? m3gClampFloatPositive(value[0])
                            : value[0];
        break;
    default:
        m3gNodeUpdateProperty(obj, property, valueSize, value);
        return; /* don't invalidate the matrix */
    }

    /* Validate the projection matrix if we changed any of the
     * camera parameters */

    m3gValidateProjectionMatrix(camera);
}

/*!
 * \internal
 * \brief Overloaded Node method.
 *
 * Start render setup scene traversal.
 *
 * \param node Camera 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 m3gCameraSetupRender(Node *self,
                                    const Node *caller,
                                    SetupRenderState *s,
                                    RenderQueue *renderQueue)
{
    Node *parent;
    M3Gbool success = M3G_TRUE;

    /* Just do the parent node.  Note that we won't be needing the old
     * state back after going up the tree, so we can overwrite it. */
    
    parent = self->parent;

    if (caller != parent && parent != NULL) {
        Matrix t;
        
        M3G_BEGIN_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_SETUP_TRANSFORMS);
        if (!m3gGetInverseNodeTransform(self, &t)) {
            return M3G_FALSE;
        }
        m3gMulMatrix(&s->toCamera, &t);
        M3G_END_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_SETUP_TRANSFORMS);

        /* The parent node will update the alpha factor and culling
         * mask if necessary, so we need not touch those */
        
        success = M3G_VFUNC(Node, parent, setupRender)(parent,
                                                       self, s, renderQueue);
    }

    return success;
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param originalObj original Camera object
 * \param cloneObj pointer to cloned Camera object
 * \param pairs array for all object-duplicate pairs
 * \param numPairs number of pairs
 */
static M3Gbool m3gCameraDuplicate(const Object *originalObj,
                                  Object **cloneObj,
                                  Object **pairs,
                                  M3Gint *numPairs)
{
    Camera *original = (Camera *)originalObj;
    Camera *clone = (Camera *)m3gCreateCamera(originalObj->interface);
    *cloneObj = (Object *)clone;
    if (*cloneObj == NULL) {
        return M3G_FALSE;
    }

    if (m3gNodeDuplicate(originalObj, cloneObj, pairs, numPairs)) {
        clone->projType = original->projType;
        clone->projMatrix = original->projMatrix;
        clone->heightFov = original->heightFov;
        clone->aspect = original->aspect;
        clone->clipNear = original->clipNear;
        clone->clipFar = original->clipFar;
        clone->zeroViewVolume = original->zeroViewVolume;
        return M3G_TRUE;
    }
    else {
        return M3G_FALSE;
    }
}

/*!
 * \internal
 * \brief Initializes a Camera object. See specification
 * for default values.
 *
 * \param m3g           M3G interface
 * \param camera        Camera object
 */
static void m3gInitCamera(Interface *m3g, Camera *camera)
{
    M3GMatrix m;

    /* Camera is derived from node */
    m3gInitNode(m3g, &camera->node, M3G_CLASS_CAMERA);

    /* GENERIC, Identity */
    m3gIdentityMatrix(&m);
    m3gSetProjectionMatrix(camera, (const M3GMatrix *)&m);
}

/*!
 * \internal
 * \brief Sets camera matrix to OpenGL
 * projection matrix.
 *
 * \param camera Camera object
 */
static void m3gApplyProjection(const Camera *camera)
{
    M3Gfloat t[16];

    m3gGetMatrixColumns(&camera->projMatrix, t);
    
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(t);
    glMatrixMode(GL_MODELVIEW);
}

/*!
 * \internal
 * \brief Returns a pointer to the camera projection matrix
 *
 * The matrix <em>must not</em> be accessed directly, as only this
 * function will ensure that the returned matrix has valid values in
 * it.
 * 
 * \param camera Camera object
 * \return a pointer to the projection matrix
 */
static const Matrix *m3gProjectionMatrix(const Camera *camera)
{
    M3G_VALIDATE_OBJECT(camera);

    return &camera->projMatrix;
}

/*!
 * \internal
 * \brief Retrieves a pointer to the six camera space view frustum planes
 */
static const Vec4 *m3gFrustumPlanes(const Camera *camera)
{
    M3G_VALIDATE_OBJECT(camera);
    m3gValidateFrustumPlanes((Camera*) camera);
    return camera->frustumPlanes;
}

/*----------------------------------------------------------------------
 * Virtual function table
 *--------------------------------------------------------------------*/

static const NodeVFTable m3gvf_Camera = {
    {
        {
            m3gObjectApplyAnimation,
            m3gCameraIsCompatible,
            m3gCameraUpdateProperty,
            m3gObjectDoGetReferences,
            m3gObjectFindID,
            m3gCameraDuplicate,
            m3gDestroyNode /* no extra clean-up for Camera */
        }
    },
    m3gNodeAlign,
    NULL, /* pure virtual DoRender */
    m3gNodeGetBBox,
    m3gNodeRayIntersect,
    m3gCameraSetupRender,
    m3gNodeUpdateDuplicateReferences,
    m3gNodeValidate
};


/*----------------------------------------------------------------------
 * Public API functions
 *--------------------------------------------------------------------*/

/*!
 * \brief Creates a Camera object.
 *
 * \param interface     M3G interface
 * \retval Camera new Camera object
 * \retval NULL Camera creating failed
 */
M3G_API M3GCamera m3gCreateCamera(M3GInterface interface)
{
    Interface *m3g = (Interface *) interface;
    M3G_VALIDATE_INTERFACE(m3g);

    {
        Camera *camera =  m3gAllocZ(m3g, sizeof(Camera));

        if (camera != NULL) {
            m3gInitCamera(m3g, camera);
        }

        return (M3GCamera) camera;
    }
}

/*!
 * \brief Sets a parallel projection.
 *
 * \param handle        Camera object
 * \param height        height (=fovy)
 * \param aspectRatio   viewport aspect ratio
 * \param clipNear      near clipping plane
 * \param clipFar       far clipping plane
 */
M3G_API void m3gSetParallel(M3GCamera handle,
                            M3Gfloat height,
                            M3Gfloat aspectRatio,
                            M3Gfloat clipNear, M3Gfloat clipFar)
{
    Camera *camera = (Camera *) handle;
    M3G_VALIDATE_OBJECT(camera);

    if (height <= 0 || aspectRatio <= 0.0f) {
        m3gRaiseError(M3G_INTERFACE(camera), M3G_INVALID_VALUE);
        return;
    }

    camera->projType   = M3G_PARALLEL;
    camera->heightFov  = height;
    camera->aspect     = aspectRatio;
    camera->clipNear   = clipNear;
    camera->clipFar    = clipFar;

    m3gValidateProjectionMatrix(camera);
}

/*!
 * \brief Sets a perspective projection.
 *
 * \param handle        Camera object
 * \param fovy          fovy
 * \param aspectRatio   viewport aspect ratio
 * \param clipNear      near clipping plane
 * \param clipFar       far clipping plane
 */
M3G_API void m3gSetPerspective(M3GCamera handle,
                               M3Gfloat fovy,
                               M3Gfloat aspectRatio,
                               M3Gfloat clipNear, M3Gfloat clipFar)
{
    Camera *camera = (Camera *) handle;
    M3G_VALIDATE_OBJECT(camera);

    if (fovy <= 0.0f || fovy >= 180.f
        || aspectRatio <= 0.0f
        || clipNear <= 0.0f || clipFar <= 0.0f) {
        m3gRaiseError(M3G_INTERFACE(camera), M3G_INVALID_VALUE);
        return;
    }

    camera->projType   = M3G_PERSPECTIVE;
    camera->heightFov  = fovy;
    camera->aspect     = aspectRatio;
    camera->clipNear   = clipNear;
    camera->clipFar    = clipFar;

    m3gValidateProjectionMatrix(camera);
}

/*!
 * \brief Sets a generic projection.
 *
 * \param handle        Camera object
 * \param transform     projection matrix
 */
M3G_API void m3gSetProjectionMatrix(M3GCamera handle,
                                    const M3GMatrix *transform)
{
    Camera *camera = (Camera *) handle;
    M3G_VALIDATE_OBJECT(camera);

    if (transform == NULL) {
        m3gRaiseError(M3G_INTERFACE(camera), M3G_NULL_POINTER);
        return;
    }
    
    camera->projType = M3G_GENERIC;    
    m3gCopyMatrix(&camera->projMatrix, transform);
    
    m3gValidateProjectionMatrix(camera);
}

/*!
 * \brief Gets camera matrix.
 *
 * \param handle        Camera object
 * \param transform     projection matrix to fill in
 * \return              projection type
 */
M3G_API M3Gint m3gGetProjectionAsMatrix(M3GCamera handle,
                                        M3GMatrix *transform)
{
    Camera *camera = (Camera *) handle;
    M3G_VALIDATE_OBJECT(camera);

    if (transform != NULL) {
        /* Check for impossible projection matrix */
        if (camera->projType != M3G_GENERIC && 
            camera->clipFar == camera->clipNear) {
            m3gRaiseError(M3G_INTERFACE(camera), M3G_ARITHMETIC_ERROR);
            return 0;
        }

        m3gCopyMatrix(transform, m3gProjectionMatrix(camera));
    }

    return camera->projType;
}

/*!
 * \brief Gets camera parameters.
 *
 * \param handle        Camera object
 * \param params        camera parameters to fill in
 * \return              projection type
 */
M3G_API M3Gint m3gGetProjectionAsParams(M3GCamera handle, M3Gfloat *params)
{
    Camera *camera = (Camera *) handle;
    M3G_VALIDATE_OBJECT(camera);

    if (params != NULL && camera->projType != M3G_GENERIC) {
        params[0] = camera->heightFov;
        params[1] = camera->aspect;
        params[2] = camera->clipNear;
        params[3] = camera->clipFar;
    }

    return camera->projType;
}