/*
* 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:   Procedural 3D Mesh
*
*/



#include "alf/alfproceduralmesh.h"
#include "alf/alfgencomponent.h"
#include "alflogger.h"
#include "alf/alfconstants.h"
#include "alf/alfenv.h"
#include "alfskinnableimage.h"

#include <uiacceltk/HuiUtil.h>

struct CAlfProceduralMesh::TProceduralMeshPrivateData
    {
    CAlfGenComponent* iComms; // Not owned
    TAlfMaterial iMaterial;      
    CAlfSkinnableImage* iMaterialTextureImage;
    CAlfSkinnableImage* iMaterialSpecularImage;
    };

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


// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CAlfProceduralMesh::CAlfProceduralMesh()
    {
    }


// ---------------------------------------------------------------------------
// Second phase constructor
// ---------------------------------------------------------------------------
//
void CAlfProceduralMesh::ConstructL( CAlfGenComponent& aComms )
    {
    // Construct the base class
    CAlfMesh::ConstructL(aComms, EAlfMeshTypeProcedural);
    
    // Create object data.
    iData = new (ELeave) TProceduralMeshPrivateData;
    
    // Zero all object data
    iData->iComms = NULL;
    iData->iMaterialTextureImage = NULL;
    iData->iMaterialSpecularImage = NULL;
    
    // Fill data
    iData->iComms = &aComms;
    iData->iMaterial.iPreset = EAlfMaterialChrome;  
    
    CAlfEnv* env = CAlfEnv::Static();
    iData->iMaterialTextureImage = new (ELeave) CAlfSkinnableImage(env);
    iData->iMaterialSpecularImage = new (ELeave) CAlfSkinnableImage(env);  
    
    // Create input and output buffers for inter-process communication
    TBuf8<1> outDummy;
    TInt param = EAlfMeshTypeProcedural;
    TPckgC<TInt> buf(param);
        
    // Call a synchronous command to create an associated server-side procedural mesh.
    TInt err = iData->iComms->DoSynchronousCmd(EAlfMeshVisualCreateMesh, buf, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfProceduralMesh::ConstructL leave error %d", err )
        User::Leave( err );
        }   
    }


// ---------------------------------------------------------------------------
// Exposed constructor
// ---------------------------------------------------------------------------
//
CAlfProceduralMesh* CAlfProceduralMesh::NewL( CAlfGenComponent& aComms )
    {
    CAlfProceduralMesh* self = new( ELeave ) CAlfProceduralMesh;
    CleanupStack::PushL( self );
    self->ConstructL( aComms );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CAlfProceduralMesh::~CAlfProceduralMesh()
    {
    if ( iData )
        {
        delete iData->iMaterialTextureImage;
        iData->iMaterialTextureImage = NULL;
        
        delete iData->iMaterialSpecularImage;
        iData->iMaterialSpecularImage = NULL;
        }
    delete iData;
    iData = NULL;
    }

// ---------------------------------------------------------------------------
// Forms a cube mesh to this procedural mesh.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfProceduralMesh::MakeCubeL(
        TReal32 aSizeX, 
        TReal32 aSizeY, 
        TReal32 aSizeZ, 
        TReal32 aEdgeRadius) __SOFTFP
    {
    RArray<TReal32> array;
    CleanupClosePushL( array );
    
    array.AppendL( aSizeX );
    array.AppendL( aSizeY );
    array.AppendL( aSizeZ );
    array.AppendL( aEdgeRadius );
    
    HBufC8* buffer = ExternalizeLC(array);
    TBuf8<1> outDummy;
    
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshMakeCube, *buffer, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfProceduralMesh::MakeCubeL leave error %d", err )
        User::Leave( err );
        }
        
    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( &array );
    }

// ---------------------------------------------------------------------------
// Forms a sphere mesh to this procedural mesh.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfProceduralMesh::MakeSphereL(
        TReal32 aRadius, 
        TInt aColumns, 
        TInt aRows) __SOFTFP
    {
    RArray<TReal32> array;
    CleanupClosePushL( array );
    
    array.AppendL( aRadius );
    array.AppendL( (TReal32)aColumns );
    array.AppendL( (TReal32)aRows );
    
    HBufC8* buffer = ExternalizeLC(array);
    TBuf8<1> outDummy;
    
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshMakeSphere, *buffer, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfProceduralMesh::MakeSphereL leave error %d", err )
        User::Leave( err );
        }
        
    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( &array );
    }

// ---------------------------------------------------------------------------
// Forms a torus mesh to this procedural mesh.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfProceduralMesh::MakeTorusL(
        TReal32 aMainRadius, 
        TReal32 aOuterRadius, 
        TInt aMainSegments, 
        TInt aOuterSegments,
        TReal32 aSegmentAngleOffset ) __SOFTFP
    {
    RArray<TReal32> array;
    CleanupClosePushL( array );
    
    array.AppendL( aMainRadius );
    array.AppendL( aOuterRadius );
    array.AppendL( (TReal32)aMainSegments );
    array.AppendL( (TReal32)aOuterSegments );
    array.AppendL( aSegmentAngleOffset );
    
    HBufC8* buffer = ExternalizeLC(array);
    TBuf8<1> outDummy;
    
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshMakeTorus, *buffer, outDummy);
    if (err)
        {
        __ALFLOGSTRING1( "CAlfProceduralMesh::MakeTorusL leave error %d", err )
        User::Leave( err );
        }
    
    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PopAndDestroy( &array );
    }
    
// ---------------------------------------------------------------------------
// Returns the material definition of this mesh.
// ---------------------------------------------------------------------------
//
EXPORT_C const TAlfMaterial& CAlfProceduralMesh::Material() const
    {
    TAlfMaterialParams params; 
    TPckg<TAlfMaterialParams> buf(params);
    TInt err = iData->iComms->DoSynchronousCmd( EAlfMeshMaterial, KNullDesC8, buf);

    if ( err != KErrNone )
        {
        __ALFLOGSTRING1( "CAlfProceduralMesh::Material panic error %d", err )
        USER_INVARIANT();
        }
    
    iData->iMaterial.iSpecular = params.iSpecular;
    iData->iMaterial.iTextureImage = iData->iMaterialTextureImage->Image();
    iData->iMaterial.iSpecularImage = iData->iMaterialSpecularImage->Image();
    
    return iData->iMaterial;
    }
    
// ---------------------------------------------------------------------------
// Sets the material definition used with this mesh.
// ---------------------------------------------------------------------------
//    
EXPORT_C void CAlfProceduralMesh::SetMaterial( const TAlfMaterial& aMaterial )
    {
    iData->iMaterialTextureImage->SetImage( aMaterial.iTextureImage );
    iData->iMaterialSpecularImage->SetImage( aMaterial.iSpecularImage );

    TAlfMaterialParams params;
    TPckgC<TAlfMaterialParams> buf(params);
    
    params.iPreset = aMaterial.iPreset;
    params.iColor = aMaterial.iColor;
    params.iTextureImage.iTextureHandle = 
        iData->iMaterialTextureImage->Image().HasTexture() ? 
            iData->iMaterialTextureImage->Image().Texture().ServerHandle() 
            : 0 ;
    params.iTextureImage.iTl = iData->iMaterialTextureImage->Image().TimedTopLeft();
    params.iTextureImage.iBr = iData->iMaterialTextureImage->Image().TimedBottomRight();
    params.iSpecularImage.iTextureHandle = 
        iData->iMaterialSpecularImage->Image().HasTexture() ? 
            iData->iMaterialSpecularImage->Image().Texture().ServerHandle() 
            : 0 ;
    params.iSpecularImage.iTl = iData->iMaterialSpecularImage->Image().TimedTopLeft();
    params.iSpecularImage.iBr = iData->iMaterialSpecularImage->Image().TimedBottomRight();
    params.iSpecular = aMaterial.iSpecular;
    
    TInt err = iData->iComms->DoCmdNoReply( EAlfMeshSetMaterial, buf );

    if ( err == KErrNone )
        {
        iData->iMaterial = aMaterial;
        }
    else
        {
        __ALFLOGSTRING1( "CAlfProceduralMesh::SetMaterial panic error %d", err )
        USER_INVARIANT();
        }
    }
    
// ---------------------------------------------------------------------------
// Sets specular image of the material.
// ---------------------------------------------------------------------------
//     
void CAlfProceduralMesh::SetSpecularImage(const TAlfImage& aImage)
    {
    iData->iMaterial.iSpecularImage = aImage;
    }