cvinstnc.h

Windows上的MUD客户端程序

};


class ChConstructionIterator : public ChQvInstanceIterator
{
	enum Constants { TimeToDirty = 1000 };

	public:
		ChConstructionIterator(ChRenderContext * pContext) : 
			ChQvInstanceIterator(pContext), m_boolWorkRemains(true)
			{};

		virtual ~ChConstructionIterator() {};

		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		virtual bool Iterate();	   // Just those in draw scope; respects lods,etc.
		virtual bool IterateAll();  // Exhaustive iteration
		bool IsOKToProceed(ChQvInstance *pInst);
		void DidAShape();
		chint32 GetWorkDone() { return m_workDone; };
		bool IsCompleted() { return m_boolWorkRemains;};
		#endif

		virtual int DoNode(ChQvInstance& inst);


   protected:

		bool		m_boolWorkRemains;	 // only used for rlab
		chuint32	m_startTime;		 // only used for rlab
		chint32		m_workDone;			 // only used for rlab
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		void SayProgress(bool boolDone = false);
		#endif

   private:
											/* Disable copy constructor and
												assignment operator */

      inline ChConstructionIterator( const ChConstructionIterator& ) : ChQvInstanceIterator(0) {}
      inline ChConstructionIterator& operator=( const ChConstructionIterator& )
      			{
      				return *this;
      			}
};


class ChDrawIterator : public ChQvInstanceIterator
{
	//enum Constants { TimeToDirty = 1000 };

	public:
		ChDrawIterator(ChRenderContext * pContext) : 
			ChQvInstanceIterator(pContext)
			{};

		virtual ~ChDrawIterator() {};

		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		virtual bool Iterate();	   // Just those in draw scope; respects lods,etc.
		virtual bool IterateAll();  // Exhaustive iteration
		//bool IsOKToProceed(ChQvInstance *pInst);
		void DidAShape();
		//chint32 GetWorkDone() { return m_workDone; };
		//bool IsCompleted() { return m_boolWorkRemains;};
		#endif

		virtual int DoNode(ChQvInstance& inst);


   protected:

		//bool		m_boolWorkRemains;	 // only used for rlab
		chuint32	m_startTime;		 // only used for rlab
		//chint32		m_workDone;			 // only used for rlab
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		//void SayProgress(bool boolDone = false);
		#endif

   private:
											/* Disable copy constructor and
												assignment operator */

      inline ChDrawIterator( const ChDrawIterator& ) : ChQvInstanceIterator(0) {}
      inline ChDrawIterator& operator=( const ChDrawIterator& )
      			{
      				return *this;
      			}
};

// Iterates thru a tree, returning the instances covering the 2d screen point
// The list is -not- sorted by depth.
// If options are set to "findFirst" only one instance is returned. This is the first found,
// not necessarily the closest.
class ChHittestIterator : public ChQvInstanceIterator
{
	public:
		class ChInstanceHit
		{
			public:
				ChQvInstance	*m_pInstance;
				GxVec3f			m_pt;

			public:
				ChInstanceHit() : m_pInstance(0) {};
				ChInstanceHit(ChQvInstance	*pInstance, const GxVec3f &pt) : 
					m_pInstance(pInstance), m_pt(pt) {};
		};

	typedef ChList<ChInstanceHit> ChInstanceHitList;

	public:
		ChHittestIterator(ChRenderContext * pContext, int iX, int iY) : 
			ChQvInstanceIterator(pContext),
			m_iX(iX), m_iY(iY)
			{};

		virtual ~ChHittestIterator() {};

		virtual int DoNode(ChQvInstance& inst);

		void Add(ChQvInstance *pInstance, const GxVec3f &pt);

		ChInstanceHitList	&GetHits() { return m_instances;};
		bool GetHit( ChQvInstance *& closest, GxVec3f &pt);

		inline void GetScreenPoint(int &iX, int &iY) {iX = m_iX; iY = m_iY;};

		#if !defined(CH_IMMED_MODE)
									// Do nothing
		virtual bool Iterate() {return false;};	   
		virtual bool IterateAll() {return false;}; 
		#endif



   protected:
		int				m_iX;
		int				m_iY;
		ChInstanceHitList	m_instances;

   private:
											/* Disable copy constructor and
												assignment operator */

      inline ChHittestIterator( const ChHittestIterator& ) : ChQvInstanceIterator(0) {}
      inline ChHittestIterator& operator=( const ChHittestIterator& )
      			{
      				return *this;
      			}
};

// Iterates thru a tree, returning the instances covering the 2d screen point
// The list is -not- sorted by depth.
// If options are set to "findFirst" only one instance is returned. This is the first found,
// not necessarily the closest.
class ChCollisionIterator : public ChQvInstanceIterator
{
	public:
		class ChInstanceHit
		{
			public:
				ChQvInstance	*m_pInstance;
				//GxVec3f			m_pt;	// actually, probably want an impact vector for bouncing
				float 			m_t;		// parameter for ray (loc, dir)

			public:
				ChInstanceHit() : m_pInstance(0) {};
				ChInstanceHit(ChQvInstance	*pInstance, float t) : 
					m_pInstance(pInstance), m_t(t) {};
		};

	typedef ChList<ChInstanceHit> ChInstanceHitList;

	public:
		ChCollisionIterator(ChRenderContext * pContext, const GxVec3f & loc,  const GxVec3f &dir, float radius) : 
			ChQvInstanceIterator(pContext),
			m_loc(loc), m_dir(dir), m_radius(radius)
			{};

		virtual ~ChCollisionIterator() {};

		virtual int DoNode(ChQvInstance& inst);

		void Add(ChQvInstance *pInstance, float t);

		ChInstanceHitList	&GetHits() { return m_instances;};
		bool GetHit( ChQvInstance *& closest, float &t);

		inline GxVec3f & GetLoc() {return m_loc;};
		inline GxVec3f & GetDir() {return m_dir;};
		inline float GetRadius() {return m_radius;};

		#if !defined(CH_IMMED_MODE)
									// Do nothing
		virtual bool Iterate() {return false;};	   
		virtual bool IterateAll() {return false;}; 
		#endif

   protected:
		GxVec3f 	m_loc;
		GxVec3f 	m_dir;
		float 		m_radius;

		ChInstanceHitList	m_instances;

   private:
											/* Disable copy constructor and
												assignment operator */

      inline ChCollisionIterator( const ChCollisionIterator& ) : ChQvInstanceIterator(0) {}
      inline ChCollisionIterator& operator=( const ChCollisionIterator& )
      			{
      				return *this;
      			}
};

class ChBoundsIterator : public ChQvInstanceIterator
{
	class ChBoundsStack
	{
		public:
			ChBoundsStack(GxVec3f& upper, GxVec3f &lower, GxVec3f &center, int childCount, GxTransform3Wf &inverseTransform) :
				  m_upper(upper), m_lower(lower), m_center(center), 
				  m_childBoundsCount(childCount), m_inverseTransform(inverseTransform)
					{};
					         
	 		GxVec3f 	m_upper, m_lower, m_center;
			int 		m_childBoundsCount;
			GxTransform3Wf	m_inverseTransform;
		
	};
	public:
		ChBoundsIterator(ChRenderContext * pContext, ChQvBounds *pBounds) : 
			ChQvInstanceIterator(pContext), m_pBounds(pBounds)
			{
				LocalReset();
			};

		virtual ~ChBoundsIterator() {};

		virtual int DoNode(ChQvInstance& inst);

		ChQvBounds *GetBounds() {return m_pBounds;};

   protected:
 		GxVec3f 	m_upper, m_lower, m_center;
		int 		m_childBoundsCount;
		ChQvBounds* m_pBounds;
		ChPtrList<ChBoundsStack>	m_stack;
  		GxTransform3Wf	m_inverseTransform;

		ChBoundsIterator* LocalReset();
		void Push();
		bool Pop();
		void Accumulate();


   private:
											/* Disable copy constructor and
												assignment operator */

      inline ChBoundsIterator( const ChDrawIterator& ) : ChQvInstanceIterator(0) {}
      inline ChBoundsIterator& operator=( const ChDrawIterator& )
      			{
      				return *this;
      			}
};



class ChQvShapeInstance:public ChQvInstance, public ChQvInstanceHasProps
{
	protected:
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		ChNrMesh	m_mesh;
		bool	m_boolTransformDirty;
		#if defined(CH_IMMED_MODE)
		ChTextureHandle m_hTexture;
		#endif
		#endif

	public:
		ChQvShapeInstance();
		virtual ~ChQvShapeInstance();

		bool SetupTexture(ChRenderContext *pRC);
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		virtual void Build(ChRenderContext *pRC);
		virtual bool SetTexture(ChQvTextureRenderData *pTextureData, ChNrMesh mesh = 0 );
		virtual void CreateFrame();
		virtual ChQvInstance* SetTransformDirty(bool boolDirty = true);
		virtual IsTransformDirty() { return m_boolTransformDirty; };
		void SetColor(const ChColorA &color, ChNrMesh mesh = 0 );

		#endif
		virtual GxTransform3Wf  GetRendererTransform()
			{
				return GetTransform();
			}
		virtual void RemoveProperty(ChQvRenderBaseData *pData)
			{
				ChQvInstanceHasProps::RemoveProperty(pData);
			};



	protected:
		virtual void Init(ChQvBuildState *pState);

};


// Lights are properties, but they still have instances that can differ
class QvPointLight;
class QvDirectionalLight;
class QvSpotLight;

class ChQvLightInstance:public ChQvInstance
{
	friend class QvSpotLight;
	friend class QvPointLight;
	friend class QvDirectionalLight;

	protected:

	public:
		ChQvLightInstance();
		virtual ~ChQvLightInstance() {}

		#if defined(CH_USE_3DR)
		virtual bool traverse(ChRenderContext *pContext) = 0;
		#endif
 		virtual ChQvInstance* Attach(QvNode *pNode, ChQvBuildState *pState);
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		virtual void CreateFrame(GxVec3f &loc,  GxVec3f &dir);
		#endif

	protected:
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		ChNrLight	m_light;
		#endif
};

class ChQvSpotLightInstance:public ChQvLightInstance
{
	friend class QvSpotLight;

	protected:

	public:
		ChQvSpotLightInstance();
		virtual ~ChQvSpotLightInstance() {}

		#if defined(CH_USE_3DR)
		virtual bool traverse(ChRenderContext *pContext);
		#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		virtual void Build(ChRenderContext *pContext);
		#endif
	protected:
};

class ChQvPointLightInstance:public ChQvLightInstance
{

	protected:

	public:
		ChQvPointLightInstance();
		virtual ~ChQvPointLightInstance() {}

		#if defined(CH_USE_3DR)
		virtual bool traverse(ChRenderContext *pContext);
 		#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D))
		virtual void Build(ChRenderContext *pContext);
		#endif

	protected:
};

class ChQvDirectionalLightInstance:public ChQvLightInstance
{

	protected:

	public: