/*
* Copyright (c)  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:   ?Description
*
*/



#ifndef C_ALFMESH_H
#define C_ALFMESH_H

#include <e32base.h>
#include <alf/alfmaterial.h>

class CAlfGenComponent;
class TAlfImage;

/**
 * Mesh types.
 * These types identify concrete mesh - derived object types.
 */
enum TAlfMeshType
    {
    /** Procedural mesh. @see CAlfProceduralMesh */
    EAlfMeshTypeProcedural,
    
    /** M3G mesh. @see CAlfM3GMesh */
    EAlfMeshTypeM3G
    };


/**
 * Mesh class.
 * Base class for M3G and Procedural Mesh
 * 
 * Usage:
 * @code
 * //Create procedural Mesh
 * meshVisual->CreateMeshL( EAlfMeshTypeProcedural ); 
 * CAlfProceduralMesh* mesh = meshVisual->ProceduralMesh();
 * 
 * //Make it a cube
 *  mesh->MakeCubeL( 30000, 20000, 25000, 3000 );
 * 
 * //Stretch Mesh
 *  mesh->StretchUniformly( xLimit, xOffset, yLimit, yOffset, zLimit, zOffset );
 *  
 * @endcode
 * 
 * @see CAlfMeshVisual::CreateMeshL()
 * @see CAlfProceduralMesh
 * @see CAlfM3GMesh
 *
 * @lib alfclient.lib
 * @since S60 v3.2
 */
NONSHARABLE_CLASS( CAlfMesh ): public CBase
    {

public:

    static CAlfMesh* NewL( CAlfGenComponent& aComms );

    ~CAlfMesh();

    /**
     * Determines the concrete mesh type this CAlfMesh instance implements.
     *
     * @return TAlfMeshType The mesh type implemented by this object,  
     * possible values are e.g EAlfMeshTypeProcedural and EAlfMeshTypeM3G, but
     * in the future also other types may be supported.
     */
    IMPORT_C TInt MeshType() const;

    /**
     * Resets the mesh. All contents are destroyed.
     */
    IMPORT_C void Reset();
    
    /**
     * Stretch the mesh uniformly along the X, Y, and Z axes. Negative side
     * of each axis is offseted negatively. Positive side of each side is 
     * offseted positively. Normals are not affected.
     *
     * @param aXLimit
     * @param aXOffset
     * @param aYLimit
     * @param aYOffset
     * @param aZLimit
     * @param aZOffset
     */
    IMPORT_C void StretchUniformly(
        TReal32 aXLimit, 
        TReal32 aXOffset, 
        TReal32 aYLimit, 
        TReal32 aYOffset,
        TReal32 aZLimit, 
        TReal32 aZOffset) __SOFTFP;
                                
    /**
     * Scale the mesh uniformly along each axis. Normals are also scaled and
     * renormalized.
     *
     * @param aX  X scaling factor.
     * @param aY  Y scaling factor.
     * @param aZ  Z scaling factor.
     */                                
    IMPORT_C void ScaleUniformly(TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP;
    
	/**
	 * Returns number of ALF animation controllers
	 */
	IMPORT_C virtual TInt AnimationControllerCount() const;
	
	/**
	 * Set position of animation in animation controller.
	 *
	 * @param aControllerId  ID of the controller.
	 * @param aTarget  Target position in the timeline (seconds)
	 * @param aTime  Time to be used in animation
	 */
	IMPORT_C virtual void SetAnimationPosition(TInt aControllerId, TReal32 aTarget, TInt aTime) __SOFTFP;

	/**
	 * Start animation of the controller
	 *
	 * @param aControllerId  ID of the animation controller.
	 */
	IMPORT_C virtual void StartAnimationController(TInt aControllerId);
	
	/**
	 * Stop animation of the controller
	 *
	 * @param aControllerId  ID of the animation controller.
	 */
    IMPORT_C virtual void StopAnimationController(TInt aControllerId);
    
    
protected:

    CAlfMesh();

    /**
     * The second phase constructor. CAlfMesh - derived objects
     * have to pass the mesh type they represent in a call to
     * this method.
     */
    void ConstructL( CAlfGenComponent& aComms, TInt aMeshType = EAlfMeshTypeProcedural );

private:

    void StretchUniformlyL(
        TReal32 aXLimit, 
        TReal32 aXOffset, 
        TReal32 aYLimit, 
        TReal32 aYOffset,
        TReal32 aZLimit, 
        TReal32 aZOffset);
                                
    void ScaleUniformlyL(TReal32 aX, TReal32 aY, TReal32 aZ);

	virtual TInt DoAnimationControllerCount() const;
	
	virtual void SetAnimationPositionL(TInt aControllerId, TReal32 aTarget, TInt aTime);

	virtual void StartAnimationControllerL(TInt aControllerId);
	
	virtual void StopAnimationControllerL(TInt aControllerId);


private: // data

    struct TMeshPrivateData;
    TMeshPrivateData* iData;

    };


#endif // C_ALFMESH_H