/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:   Mesh base class
*
*/



#include "alf/alfmesh.h"
#include "alf/alfgencomponent.h"
#include "alf/alfconstants.h"
#include "alflogger.h"
#include "alf/alftexture.h"

#include <uiacceltk/HuiUtil.h>

struct CAlfMesh::TMeshPrivateData
    {
    CAlfGenComponent* iComms; // not own
    TInt iMeshType;
    };

// ======== MEMBER FUNCTIONS ========


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CAlfMesh::CAlfMesh()
    {
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CAlfMesh::ConstructL( CAlfGenComponent& aComms, TInt aMeshType )
    {
    iData = new (ELeave) TMeshPrivateData;
    iData->iComms = &aComms;
    
    iData->iMeshType = aMeshType;
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CAlfMesh* CAlfMesh::NewL( CAlfGenComponent& aComms )
    {
    CAlfMesh* self = new( ELeave ) CAlfMesh;
    CleanupStack::PushL( self );
    self->ConstructL( aComms );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CAlfMesh::~CAlfMesh()
    {
    delete iData;
    iData = NULL;
    }

// ---------------------------------------------------------------------------
// Returns the mesh type definition of this mesh.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CAlfMesh::MeshType() const
    {
    return iData->iMeshType;
    }

// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfMesh::Reset()
    {
    TBuf8<1> outDummy;
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshReset, KNullDesC8(), outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMesh::Reset panic error %d", err )
        USER_INVARIANT();
        }
    }
   
EXPORT_C void CAlfMesh::StretchUniformly(
        TReal32 aXLimit, 
        TReal32 aXOffset, 
        TReal32 aYLimit, 
        TReal32 aYOffset,
        TReal32 aZLimit, 
        TReal32 aZOffset) __SOFTFP
    {
    TRAP_IGNORE(StretchUniformlyL(aXLimit, aXOffset,aYLimit, aYOffset, aZLimit, aZOffset))
    }

void CAlfMesh::StretchUniformlyL(
        TReal32 aXLimit, 
        TReal32 aXOffset, 
        TReal32 aYLimit, 
        TReal32 aYOffset,
        TReal32 aZLimit, 
        TReal32 aZOffset)
    {
    RArray<TReal32> array;
    CleanupClosePushL( array );
    
    array.AppendL( aXLimit );
    array.AppendL( aXOffset );
    array.AppendL( aYLimit );
    array.AppendL( aYOffset );
    array.AppendL( aZLimit );
    array.AppendL( aZOffset );
    
    HBufC8* buffer = ExternalizeLC(array);
    TBuf8<1> outDummy;
    
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshStretchUniformly, *buffer, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMesh::StretchUniformly panic error %d", err )
        USER_INVARIANT();
        }
    
    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( &array );
    }
                                
EXPORT_C void CAlfMesh::ScaleUniformly(TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP
    {
    TRAP_IGNORE(ScaleUniformlyL(aX, aY, aZ))
    }

void CAlfMesh::ScaleUniformlyL(TReal32 aX, TReal32 aY, TReal32 aZ)
    {
    RArray<TReal32> array;
    CleanupClosePushL( array );
    
    array.AppendL( aX );
    array.AppendL( aY );
    array.AppendL( aZ );
    
    HBufC8* buffer = ExternalizeLC(array);
    TBuf8<1> outDummy;
    
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshScaleUniformly, *buffer, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMesh::ScaleUniformly panic error %d", err )
        USER_INVARIANT();
        }
    
    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( &array );
    }


EXPORT_C TInt CAlfMesh::AnimationControllerCount() const
    {
    return DoAnimationControllerCount();
    }

TInt CAlfMesh::DoAnimationControllerCount() const
    {
    TInt result = 0;
    TPckg<TBool> outBuf( result );
    
    TInt err = iData->iComms->DoSynchronousCmd(
        EAlfMeshAnimationControllerCount, 
        KNullDesC8(), 
        outBuf );
        
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMesh::AnimationControllerCount panic error %d", err )
        USER_INVARIANT();
        }
        
    return result;
    }

EXPORT_C void CAlfMesh::SetAnimationPosition(TInt aControllerId, TReal32 aTarget, TInt aTime) __SOFTFP
    {
    TRAP_IGNORE(SetAnimationPositionL(aControllerId, aTarget, aTime))
    }

void CAlfMesh::SetAnimationPositionL(TInt aControllerId, TReal32 aTarget, TInt aTime)
    {
    ASSERT(iData != NULL);
    
    // Create input and output buffers for inter-process communication
    TAlfMeshAnimationPositionParams params;
    params.iControllerId = aControllerId;    
	params.iTarget = aTarget;
	params.iTime = aTime;
    
    TPckg<TAlfMeshAnimationPositionParams > paramsPckg(params);
    
    // Call a synchronous command
    TInt err = iData->iComms->DoCmdNoReply(EAlfMeshSetAnimationPosition, paramsPckg );
    if (err)
        {
        __ALFLOGSTRING1( "CAlfM3GMesh::SetAnimationPosition leave error %d", err )
        User::Leave( err );
        }    
    }
    
EXPORT_C void CAlfMesh::StartAnimationController(TInt aControllerId)
    {
    TRAP_IGNORE(StartAnimationControllerL(aControllerId))
    }

void CAlfMesh::StartAnimationControllerL(TInt aControllerId)
    {
    ASSERT(iData != NULL);
        
    TBuf8<1> outDummy;
    TInt params = aControllerId;
    
    TPckg<TInt> paramsPckg(params);
    
    // Call a synchronous command
    TInt err = iData->iComms->DoSynchronousCmd(EAlfMeshStartAnimationController, paramsPckg, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfM3GMesh::StartAnimationController leave error %d", err )
        User::Leave( err );
        }    
    }    
    
EXPORT_C void CAlfMesh::StopAnimationController(TInt aControllerId)
    {
    TRAP_IGNORE(StopAnimationControllerL(aControllerId))
    }

void CAlfMesh::StopAnimationControllerL(TInt aControllerId)
    {
    ASSERT(iData != NULL);
        
    TBuf8<1> outDummy;
    TInt params = aControllerId;
    
    TPckg<TInt> paramsPckg(params);
    
    // Call a synchronous command
    TInt err = iData->iComms->DoSynchronousCmd(EAlfMeshStopAnimationController, paramsPckg, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfM3GMesh::StopAnimationController leave error %d", err )
        User::Leave( err );
        }    
    }