MultiresolutionObject.h

Go to the documentation of this file.

//! @file MultiresolutionObject.h
//! The CMultiresolutionObject class is a kind of object that can be used to modify the level of detail in real time.
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_MULTIRESOLUTIONOBJECT_H__D5DC4844_4F14_11D3_A382_E4DDA37A4B21__INCLUDED_)
#define AFX_MULTIRESOLUTIONOBJECT_H__D5DC4844_4F14_11D3_A382_E4DDA37A4B21__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "3DObject.h"
#include "SceneOptimizer.h"
#include "MRCommon.h"
#ifndef MOOTOOLS_NO_MR
#include "MRBaseObject.h"
#endif
 
BEGIN_MOOTOOLS_NAMESPACE
 
class C3DExtObject;
class CSceneOptimizer;
class CTrackContractions;
 
//! @class CMultiresolutionObject
//! @brief CMultiresolutionObject is the base class for multiresolution object.
//! There is two kind of multiresolution object:
//! * CMultiresolutionObject1 which is provided by CSceneOptimizer::GetScene.
//! * CMultiresolutionObject2 which offers capability to stream a 3D mesh over the network.
//! 
class DLLFUNCTION CMultiresolutionObject : public C3DObject
{
protected:
    C3DSceneNode *refSrcNode;
    C3DExtObject *refExtObject;
    CSceneOptimizer *sceneOptimizer;
 
    CUVWFaceList **uvChnFaces;
    CUVWPointList **uvChnPoints;
 
    unsigned int magicTarget;
    bool unknownRatio;
    double currentRatio;
 
    virtual bool InternalCopy(C3DBaseObject *&dstObject, int flags = OBJECT_COPY_DEFAULT, C3DObjectCreator *objectCreator = NULL) const;
    virtual void Init();
 
public:
    DECLARE_DYNAMIC_XOBJECT(CMultiresolutionObject);
 
    CMultiresolutionObject();
    virtual ~CMultiresolutionObject();
 
    CSceneOptimizer *GetOptimizer() { return sceneOptimizer; }
    void DetachOptimizer();
 
    C3DSceneNode *GetSrcNode() const { return refSrcNode; } //!< Return the node of the original scene (if any) to which the object refers. (note: if the original scene has been deleted the node pointer might be invalid, and should not be used.)
    C3DExtObject *GetExtObject() const { return refExtObject; } //!< Return the optimized undynamic object (if any)
 
    void SetExtObject(C3DExtObject *object);
    void SetSrcNode(C3DSceneNode *node);
 
    void SetOptimizer(CSceneOptimizer *sceneOptimizer) { this->sceneOptimizer = sceneOptimizer; }
 
    ///////////////////////////////////////////////////////////////
    // Information about geometry
    virtual unsigned int GetMagicTarget() const = 0;
    virtual void SetMagicTarget(unsigned int ratio) = 0;
    virtual double GetCurrentRatio() const =  0;
    virtual int GetRemovableFaceNbr() const = 0;
    virtual int GetRemovablePtNbr() const = 0;
    virtual void GetMinSize(int& minFaceSize, int& minPointSize) const = 0;
    virtual void GetMaxSize(int& maxFaceSize, int& maxPointSize) const = 0;
    virtual void GetCurrentSize(int& currentFaceSize, int& currentPointSize) const = 0;
    virtual int GetTargetCount(double ratio, unsigned int mode, bool& canBeOptimizedButleftUnoptimized) const = 0;  //!< return the approx. final number of point or faces giving a ratio accordingly to target mode (OPTIMIZE_TO_POINT | OPTIMIZE_TO_FACE).
    virtual void SetMinSize(int minFaceSize, int minPointSize) = 0; //!< Set the minimum point/face size the objet have at lowest ratio
    virtual void SetMaxSize(int maxFaceSize, int maxPointSize) = 0; //!< Set the maximum point/face size the objet have at highest ratio
 
    virtual void LockRatio(bool lock) = 0; //!< the ratio is locked and cannot be changed 
    virtual bool IsRatioLocked() const = 0;
 
    virtual bool IsMultiResFlagSet(MROBJECT_PROPERTIES flag) const = 0;
    virtual void SetMultiResFlag(MROBJECT_PROPERTIES flag, bool set) = 0;
 
    virtual void SetProgressive(bool set) = 0; //!< The object uses the provided progressive threshold (set MROBJECT_PROGRESSIVE_RATIO flag which is used only if the MRObject is used directly without the optimizer) 
    virtual void SetProgressiveThreshold(double threshold) = 0;
    virtual double GetProgressiveThreshold() const = 0;
 
    // virtual void ShowSelectedFaces(bool hideFrozenFaces);
    virtual int SetObjectRatio(double ratio, int requiredNbr, unsigned int mode = OPTIMIZE_TO_FACE|OPTIMIZE_TO_RATIO) = 0;
    virtual void FreezeObject(); //!< This remove the multiresolution data, freezes the object at its given level of details and clean it, removing some invalid faces. SetObjectRatio cannot be called anymore.
 
    virtual double GetLastKnownRatio(bool& unknownRatio) const; //!< Return the last requested ratio used with OPTIMIZE_TO_RATIO (progressiveThreshold adjustement is not taken into account)
};
 
//! @class CMultiresolutionObject1
//! @brief CMultiresolutionObject1 is a the multiresolution object class computed from C3DSceneOptimizer::GetScene
//! 
class CTrackContractions;
class DLLFUNCTION CMultiresolutionObject1 : public CMultiresolutionObject  
{
    friend C3DExtObject;
    friend CSceneOptimizer;
 
private:
    CTrackContractions *trackInfo;
 
    double progressiveThreshold;
    unsigned int multiresFlags;
 
    int maxFaceSize; // Maximum face number
    int minFaceSize; // Minimum face number (can be greater than 0, if some faces are "outstream")
    int currentFaceSize; // Current face number
 
    int maxPointSize; // Maximum point number for the object
    int minPointSize; // Minimum point number (can be greater than 0, if some points are "outstream")
    int currentPointSize;  // Current point number for the object
 
#ifdef _DEBUG
    bool keepOrder;
#endif
 
    bool firstTime, lockSetObjectRatio;
    bool increase;
 
protected:
    void Init();
 
    virtual void Clean(); //!< Override C3DGeomObject::Clean
 
    //virtual unsigned int *AddFace(unsigned int index) { return NULL; }
    //virtual unsigned int *GetFaceIndexes(unsigned int index) { return NULL; };
    //virtual void SetFaceMaterial(unsigned int index, unsigned short material) {};
    //virtual MRMaterialID GetFaceMaterial(unsigned int index) const { return MATERIAL_UNDEFINED; }
 
    //virtual float *AddPoint(unsigned int index) { return NULL; };
    //virtual float *GetPoint(unsigned int index) { return NULL; };
 
    //virtual unsigned int *AddUVFace(unsigned char channel, unsigned int index, bool unused) { return NULL; }
    //virtual unsigned int *GetUVIndexes(unsigned char channel, unsigned int index) { return NULL; };
    //virtual float *AddUVPoint(unsigned char channel, unsigned int index) { return NULL; };
    //virtual float *GetUVPoint(unsigned char channel, unsigned int index) { return NULL; };
 
public:
    DECLARE_DYNAMIC_XOBJECT(CMultiresolutionObject1);
 
    CMultiresolutionObject1(CSceneOptimizer *optimizer = NULL, C3DExtObject *extObject = NULL, C3DSceneNode *srcNode = NULL); //!< CMultiresolutionObject is usually created using CSceneOptimizer::GetScene or C3DExtObject::GetMultiresolutionObject
    virtual ~CMultiresolutionObject1();
 
    virtual unsigned int GetMagicTarget() const; //!< Called by MagicCruncher which set the ratio found to be optimal.
    virtual void SetMagicTarget(unsigned int ratio); //!< Get the optimal MagicCruncher found giving the MagicCruncher parameters.
    virtual double GetCurrentRatio() const; //!< Current optimization ratio
    virtual int GetRemovableFaceNbr() const; //!< Number of removable faces
    virtual int GetRemovablePtNbr() const; //!< Number of removable points
    virtual void GetMinSize(int& minFaceSize, int& minPointSize) const; //!< Minimal number of points and faces
    virtual void GetMaxSize(int& maxFaceSize, int& maxPointSize) const;  //!< Maximal number of points and faces
    virtual void GetCurrentSize(int& currentFaceSize, int& currentPointSize) const;  //!< Current number of points and faces
    virtual int GetTargetCount(double ratio, unsigned int mode, bool& canBeOptimizedButleftUnoptimized) const;  //!< return the approx. final number of point or faces giving a ratio accordingly to target mode (OPTIMIZE_TO_POINT | OPTIMIZE_TO_FACE).
    virtual void SetMinSize(int minFaceSize, int minPointSize); //!< Set the minimum point/face size the objet have at lowest ratio
    virtual void SetMaxSize(int maxFaceSize, int maxPointSize); //!< Set the maximum point/face size the objet have at highest ratio
 
    virtual void LockRatio(bool lock); //!< the ratio is locked and cannot be changed 
    virtual bool IsRatioLocked() const;
 
    virtual bool IsMultiResFlagSet(MROBJECT_PROPERTIES flag) const; //!< Set one of the 
    virtual void SetMultiResFlag(MROBJECT_PROPERTIES flag, bool set);
 
    virtual void SetProgressive(bool set); //!< The object uses the provided progressive threshold (set MROBJECT_PROGRESSIVE_RATIO flag which is used only if the MRObject is used directly without the optimizer) 
    virtual void SetProgressiveThreshold(double threshold);
    virtual double GetProgressiveThreshold() const;
 
    // virtual void ShowSelectedFaces(bool hideFrozenFaces);
 
    bool PrepareGeometry(bool serializedTrackInfo);
 
    int SetObjectRatio(double ratio, int requiredNbr, unsigned int mode = OPTIMIZE_TO_FACE|OPTIMIZE_TO_RATIO); //!< Modify the level of details of the object using a ratio and/or mode defined by MRRATIO_MODE
    void FreezeObject(); //!< Freeze the object at a given ratio and clean the object. Removes any multiresolution data and further ability to change the LOD. override C3DGeomObject::FreezeObject.
 
    // Specifics
    void SetTrackInfo(CTrackContractions *info);
    const CTrackContractions *GetTrackInfo() const { return trackInfo; }
};
 
#ifndef MOOTOOLS_NO_MR
class CMRManager;
class CTrackContractions2;
//! @class CMultiresolutionObject2
//! CMultiresolutionObject2 provides a streamable 3D mesh using data provided by C3DExtObject
//! 
class DLLFUNCTION CMultiresolutionObject2 : public CMultiresolutionObject, public CMRBaseObject
{
    friend C3DExtObject;
 
protected:
    virtual void FreezeObject();
    virtual bool PrepareGeometry();
    virtual bool AdjustGeometry();
    virtual void PrepareChanges(CMRContractions::ParsingInfo& parsing, unsigned int targetPointSize, bool rebuild);
    virtual void ReleaseChanges(CMRContractions::ParsingInfo& parsing);
 
    virtual void MaterialChanged(MRMaterialID matid);
 
    virtual unsigned int *AddFace(unsigned int index);
    virtual unsigned int *GetFaceIndexes(unsigned int index);
 
    virtual void SetFaceMaterial(unsigned int index, unsigned short material);
    virtual MRMaterialID GetFaceMaterial(unsigned int index) const;
 
    virtual float *AddPoint(unsigned int index);
    virtual float *GetPoint(unsigned int index);
 
    virtual unsigned int *AddUVFace(unsigned char channel, unsigned int index, bool unused);
    virtual unsigned int *GetUVIndexes(unsigned char channel, unsigned int index);
    virtual float *AddUVPoint(unsigned char channel, unsigned int index);
    virtual float *GetUVPoint(unsigned char channel, unsigned int index);
 
public:
    DECLARE_DYNAMIC_XOBJECT(CMultiresolutionObject2);
 
    CMultiresolutionObject2(CSceneOptimizer *optimizer = NULL);
    virtual ~CMultiresolutionObject2();
 
    virtual double GetMagicRatio() const;
    virtual unsigned int GetMagicTarget() const;
    virtual void SetMagicTarget(unsigned int ratio);
    virtual double GetCurrentRatio() const;
    virtual double GetPreviousRatio() const;
    virtual int GetRemovableFaceNbr() const;
    virtual int GetRemovablePtNbr() const;
    virtual void GetMinSize(int& minFaceSize, int& minPointSize) const;
    virtual void GetMaxSize(int& maxFaceSize, int& maxPointSize) const;
    virtual void GetCurrentSize(int& currentFaceSize, int& currentPointSize) const;
    virtual int GetTargetCount(double ratio, unsigned int mode, bool& canBeOptimizedButleftUnoptimized) const;  // return the approx. final number of point or faces giving a ratio accordingly to target mode (OPTIMIZE_TO_POINT | OPTIMIZE_TO_FACE).
    virtual void SetMinSize(int minFaceSize, int minPointSize); // Set the minimum point/face size the objet have at lowest ratio
    virtual void SetMaxSize(int maxFaceSize, int maxPointSize); // Set the maximum point/face size the objet have at highest ratio
 
    virtual void LockRatio(bool lock); // the ratio is locked and cannot be changed 
    virtual bool IsRatioLocked() const;
 
    virtual bool IsMultiResFlagSet(MROBJECT_PROPERTIES flag) const;
    virtual void SetMultiResFlag(MROBJECT_PROPERTIES flag, bool set);
 
    virtual void SetProgressive(bool set); // The object uses the provided progressive threshold (set MROBJECT_PROGRESSIVE_RATIO flag which is used only if the MRObject is used directly without the optimizer) 
    virtual void SetProgressiveThreshold(double threshold);
    virtual double GetProgressiveThreshold() const;
 
    bool NeedUpdate() const;
    bool Update(C3DScene *scene, unsigned int updateMode);
 
    int SetObjectRatio(double ratio, int requiredNbr, unsigned int mode = OPTIMIZE_TO_FACE|OPTIMIZE_TO_RATIO);
 
    virtual void Clean();
};
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_MULTIRESOLUTIONOBJECT_H__D5DC4844_4F14_11D3_A382_E4DDA37A4B21__INCLUDED_)