/*
============================================================================
    * Name : C3DRenderer.cpp
    * Part of : Example3D
    * Description : Definition of C3DRenderer
    * Copyright (c) 2007 Nokia Corporation
============================================================================
    */

// INCLUDES
#include "C3DRenderer.h"
#include "C3DBase.h"
#include "M3dObject.h"
#include <e32svr.h>

// MEMBER FUNCTIONS
C3DRenderer* C3DRenderer::NewL( C3DBase* a3DBase, TInt aMaxObjects )
    {
    C3DRenderer* self = new( ELeave )C3DRenderer( a3DBase, aMaxObjects );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
C3DRenderer::~C3DRenderer()
    {
    delete[] iObject;
    delete[] iObjectPosition;
    delete[] iObjectMatrix;
    delete[] iObjectRotMatrix;
    delete[] iObjectPriority;

    delete[] iObjectZ;
    delete[] iObjectN;
    }
    
void C3DRenderer::ConstructL()
    {
    // make room for object parameters for all objects:
    iObject = new( ELeave )M3dObject*[ iMaxObjects ];
    iObjectPosition = new( ELeave )TVertex[ iMaxObjects ];
    iObjectMatrix = new( ELeave )TMatrix[ iMaxObjects ];
    iObjectRotMatrix = new( ELeave )TMatrix[ iMaxObjects ];
    iObjectPriority = new( ELeave )TInt[ iMaxObjects ];

    // and put default values where needed:
    iObjectZ = new( ELeave )TInt[ iMaxObjects ];
    iObjectN = new( ELeave )TInt[ iMaxObjects ];
    TInt i;
    for( i=0; i<iMaxObjects; i++ )
        {
        iObject[ i ] = NULL;
        iObjectPriority[ i ] = 0;
        }
    }

C3DRenderer::C3DRenderer( C3DBase* a3DBase, TInt aMaxObjects )
    : i3DBase( a3DBase )
    , iMaxObjects( aMaxObjects )
    , iCos( a3DBase->CosTable() )
    , iSin( a3DBase->SinTable() )
    {
    }

TInt C3DRenderer::AddObject( M3dObject* aObject )
    {
    // scan object list for empty position and put new object there.
    TBool found = EFalse;
    TInt i = 0;
    while( ( i<iMaxObjects ) && ( !found ) )
        {
        if( iObject[ i ] == NULL )
            {
            found = ETrue;
            }
        else
            {
            i++;
            }
        }

    if( found )
        {
        iObject[ i ] = aObject;
        iObjectPosition[ i ] = TVertex( 0,0,0 );
        SetObjectAngle( i, TVertex( 0,0,0 ) );
        }

    return i;
    }

void C3DRenderer::RemoveObject( TInt aIndex )
    {
    iObject[ aIndex ] = NULL;
    }

void C3DRenderer::SetObjectPosition( TInt aIndex, const TVertex& aPosition )
    {
    iObjectPosition[ aIndex ] = aPosition;
    }

void C3DRenderer::SetObjectAngle( TInt aIndex, const TVertex& aAngle )
    {
    // when object has new angle, the rotate matrix must be updated:

    TInt c1 = iCos[ aAngle.iZ & 4095 ];
    TInt s1 = iSin[ aAngle.iZ & 4095 ];

    TInt c2 = iCos[ aAngle.iX & 4095 ];
    TInt s2 = iSin[ aAngle.iX & 4095 ];

    TInt c3 = iCos[ aAngle.iY & 4095 ];
    TInt s3 = iSin[ aAngle.iY & 4095 ];

    TInt v1 = 1 << KShift;

    // rotation order around axises: Z, X, Y
    // order can be changed here ( order is backwards to definition )

    TMatrix objRot( c3, 0,  -s3, 0,         // rotation matrix around Y-axis
                     0, v1,   0, 0,
                    s3,  0,  c3, 0 );

    objRot *= TMatrix( v1,  0,   0, 0,      // rotation matrix around X-axis
                        0, c2, -s2, 0,
                        0, s2,  c2, 0 );
        
    objRot *= TMatrix( c1, -s1,  0,  0,     // rotation matrix around Z-axis
                       s1,  c1,  0,  0,
                        0,   0, v1,  0 );

    iObjectMatrix[ aIndex ] = objRot;
    }

void C3DRenderer::SetObjectPriority( TInt aIndex, TInt aPriority )
    {
    iObjectPriority[ aIndex ] = aPriority;
    }

void C3DRenderer::SetCameraPosition( const TVertex& aPosition )
    {
    iCameraPosition = aPosition;
    }

void C3DRenderer::SetCameraAngle( const TVertex& aAngle )
    {
    iCameraAngle = aAngle;
    }

void C3DRenderer::Draw( const TBitmap& aScreen )
    {
    i3DBase->ResetPolygonCount();

    TInt i;

    TInt v1 = 1 << KShift;
    
    TInt c1 = iCos[ iCameraAngle.iY & 4095 ];
    TInt s1 = iSin[ iCameraAngle.iY & 4095 ];

    TInt c2 = iCos[ iCameraAngle.iX & 4095 ];
    TInt s2 = iSin[ iCameraAngle.iX & 4095 ];

    TInt c3 = iCos[ iCameraAngle.iZ & 4095 ];
    TInt s3 = iSin[ iCameraAngle.iZ & 4095 ];

    // Calculate camera rotation matrix:
    
    TMatrix camRot( c3, -s3,  0,  0,        // Z-axis
                    s3,  c3,  0,  0,
                     0,   0, v1,  0 );
    
    camRot *= TMatrix( v1, 0,   0,  0,      // X-axis
                        0, c2, -s2, 0,
                        0, s2,  c2, 0 );
    
    camRot *= TMatrix( c1, 0, -s1, 0,       // Y-axis
                        0,v1,   0, 0,
                       s1, 0,  c1, 0 );
     
    // and add camera position
    
    camRot *= TMatrix ( v1, 0, 0, -iCameraPosition.iX,
                        0, v1, 0, -iCameraPosition.iY,
                        0, 0, v1, -iCameraPosition.iZ );

    
    TFrustum frustum( i3DBase->ViewFrustum() );

    // rotate all objects to their place in space

    TInt numObjects = 0;
    for( i=0; i<iMaxObjects; i++ )
        {
        if( iObject[ i ] != NULL )      // objectlist can contain empty indexes
            {
            iObjectMatrix[ i ][ 3 ] = iObjectPosition[ i ].iX;
            iObjectMatrix[ i ][ 7 ] = iObjectPosition[ i ].iY;
            iObjectMatrix[ i ][ 11] = iObjectPosition[ i ].iZ;
            
            TMatrix& obj = iObjectRotMatrix[ numObjects ];

            obj = camRot;
            obj *= iObjectMatrix[ i ];

            TVertex objPos( obj[ 3 ], obj[ 7 ], obj[ 11 ] );

            // check if object is inside view frustum

            TBool visible = ETrue;

            for( TInt n=0; n<frustum.iNumPlanes; n++ )
                {
                TVertex& mv1 = frustum.iPlane[ n ].iNormal;
                
                // calculate dot product to get point distance to plane:
                TInt l = mv1.iX * objPos.iX + mv1.iY * objPos.iY + mv1.iZ * objPos.iZ;
                l += frustum.iPlane[ n ].iDistance;
                l >>= KShift;
                l += iObject[ i ]->iBoundingRadius;

                if( l < 0 ) 
                    {
                    visible = EFalse;
                    break;
                    }
                }

            if( visible )
                {
                // calculate object distance from camera
                // used for object sorting

                TInt v = objPos.iX >> KShift;
                TInt d = v*v;
                v = objPos.iY >> KShift;
                d += v*v;
                v = objPos.iZ >> KShift;
                d += v*v;
                d += iObjectPriority[ i ];
                
                iObjectZ[ numObjects ] = d;
                iObjectN[ numObjects ] = ( i << 16 ) + numObjects;
                
                numObjects++;
                }           
            }
        }

    // sort
    i3DBase->QSort( iObjectZ, iObjectN, 0, numObjects-1 );

    // draw sorted back to front
    for( i=numObjects-1; i>=0; i-- )
        {
        TInt n1 = iObjectN[ i ] & 0xffff;
        TInt n2 = iObjectN[ i ] >> 16;
        iObject[ n2 ]->Draw( aScreen, &iObjectRotMatrix[ n1 ] );
        }

    }