/*
* 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 mesh definition
*
*/



#ifndef C_ALFPROCEDURALMESH_H
#define C_ALFPROCEDURALMESH_H

#include <alf/alfmesh.h>

/**
 *  Procedural mesh support.
 *
 *  This is a CAlfMesh - derived mesh implementation that provides support
 *  for procedural meshes. There are collection of shapes that can be procedurally
 *  constructed using this object. This mesh can be used through CAlfMeshVisual
 *  and created with CAlfMeshVisual::CreateMeshL() method with argument EAlfMeshTypeProcedural.
 * Usage:
 * @code
 *  //Create Procedural Mesh and get it from Mesh Visual
 *  meshVisual->CreateMeshL( EAlfMeshTypeProcedural );                
 *  CAlfProceduralMesh* mesh = meshVisual->ProceduralMesh();
 * 
 *  //Make a cube
 *  int sizeX = 30000;
 *  int sizeY = 20000; 
 *  int sizeZ = 25000;
 *  int edgeRadius = 3000;
 *  mesh->MakeCubeL( sizeX, sizeY, sizeZ, edgeRadius );
 * 
 *  //Make a sphere
 *  int radius = 15000;
 *  int columns = 20;
 *  int rows = 20;
 *  mesh->MakeSphereL( radius, columns, rows );
 *           
 *  //Make a Torus
 *  int mainRadius = 15000;
 *  int outerRadius = 2000;
 *  int mainSegments = 20;
 *  int outerSegments = 20;
 *  float segmentAngleOffset = 0.0;
 *  mesh->MakeTorusL( mainRadius, outerRadius, mainSegments, outerSegments, segmentAngleOffset );
 *  
 *  //Material setting
 *  TAlfMaterial material;
 * 	material.iColor = Color( 128 );
 *  material.iPreset = EAlfMaterialShadow;
 *  const float KValueNow = 0.2;
 * 	const float KTargetValue = 0.5;
 * 	TAlfTimedValue tv( KValueNow );
 * 	tv.SetTarget( KTargetValue, 500 );    
 * 	material.iSpecular = tv;
 *  mesh->SetMaterial( material );               
 * 
 *  //Set glass preset with speculer image set.
 *  material.iSpecularImage = TAlfImage();
 *  material.iPreset = EAlfMaterialGlass;
 *  mesh->SetMaterial(material);  
 * 
 * @endcode
 * @see TAlfMaterial
 * @lib alfclient.lib
 * @since S60 v3.2
 */
NONSHARABLE_CLASS( CAlfProceduralMesh ): public CAlfMesh
    {

public:

    /**
     * Constructs a new CAlfProceduralMesh instance.
     */
    static CAlfProceduralMesh* NewL( CAlfGenComponent& aComms );

    /**
     * Destructor
     */
    ~CAlfProceduralMesh();

    /**
     * Creates a cube mesh.
     * @todo move.
     * @param aSizeX
     * @param aSizeY
     * @param aSizeZ
     * @param aEdgeRadius
     */
    IMPORT_C void MakeCubeL(
        TReal32 aSizeX, 
        TReal32 aSizeY, 
        TReal32 aSizeZ, 
        TReal32 aEdgeRadius) __SOFTFP;

    /**
     * Creates a sphere mesh.
     * @todo move
     * @param aRadius
     * @param aColumns
     * @param aRows
     */
    IMPORT_C void MakeSphereL(
        TReal32 aRadius, 
        TInt aColumns, 
        TInt aRows) __SOFTFP;

    /** 
     * Creates a torus mesh.
     * @todo move
     * @param aMainRadius
     * @param aOuterRadius
     * @param aMainSegments
     * @param aOuterSegments
     * @param aSegmentAngleOffset
     */
    IMPORT_C void MakeTorusL(
        TReal32 aMainRadius, 
        TReal32 aOuterRadius, 
        TInt aMainSegments, 
        TInt aOuterSegments,
        TReal32 aSegmentAngleOffset = 0) __SOFTFP;

    /**
     * Returns the material definition used by this procedural mesh.
     *
     * @return TAlfMaterial material definition.
     */
    IMPORT_C const TAlfMaterial& Material() const;
    
    /**
     * Sets the material definition used by this procedural mesh.
     *
     * @param aMaterial Material definition to be applied to this mesh.
     */    
    IMPORT_C void SetMaterial( const TAlfMaterial& aMaterial );

    /**
     * Sets the specular image of the mesh material.
     */
    void SetSpecularImage(const TAlfImage& aImage);

private:

    /**
     * Constructor
     */
    CAlfProceduralMesh();

    /**
     * Second phase constructor
     */
    void ConstructL( CAlfGenComponent& aComms );

private: // data

    struct TProceduralMeshPrivateData;
    TProceduralMeshPrivateData* iData;

    };


#endif // C_ALFPROCEDURALMESH_H