/*

 * 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;

 }