chrenderdata.h

Windows上的MUD客户端程序

class ChQvTexture2TransformRenderData : public ChQvRenderBaseData
{	   
							

	protected:
		bool 	m_boolDefault;
		float	m_cosa;
		float	m_sina;

		ChQvTexture2TransformRenderData *CheckForDefault();
	public:
		ChQvTexture2TransformRenderData(QvNode* pNode);
		virtual ~ChQvTexture2TransformRenderData() {};
		
		ChQvTexture2TransformRenderData *Transform(float &s, float& t);
		virtual void SetDirty(bool boolDirty = true); 

};


/*----------------------------------------------------------------------------
	ChQvPCameraRenderData class
----------------------------------------------------------------------------*/
class ChQvBuildState;
class ChQvPCameraRenderData : public ChQvRenderBaseData
{	   // Perspective Camera
	friend class QvPerspectiveCamera;
	friend class QvOrthographicCamera;
										 
	private:
		bool		m_boolSynchEnabled;
		inline const bool IsSynchEnabled() {return m_boolSynchEnabled ;};
		inline void EnableSynch(bool boolEnabled = true) {m_boolSynchEnabled = boolEnabled;};

	protected:
		bool boolInfinite;
		GxVec3f 	m_loc;
		GxVec3f		m_dir;	
		GxVec3f		m_up;
		GxVec3f 	m_startLoc;
		GxVec3f		m_startDir;	
		GxVec3f		m_startUp;
		QvPerspectiveCamera *m_pCamera;
		#if defined(CH_USE_3DR)
		GxTransformF_t	m_invCameraTransform;
		GxTransformF_t	m_cameraTransform;
		#else
		GxTransform3Wf	m_cameraTransform;
		GxTransform3Wf	m_transform; // to world
		#endif
		string 			m_strName;
		ChRenderContext *m_pRC;

		bool m_boolRendererDirty;

		float	m_left;
		float	m_top;
		float	m_right;
		float	m_bottom;

		bool	m_boolPerspective;
		bool	m_boolNew;

		GxTransform3Wf m_camClipTransform;

		static ChVrmlDispatcher		*m_pDispatcher;

	public:
		ChQvPCameraRenderData(QvPerspectiveCamera *pCamera, ChQvBuildState* state );
		ChQvPCameraRenderData(QvOrthographicCamera *pCamera, ChQvBuildState* state );
		virtual ~ChQvPCameraRenderData();

		virtual void SetDirty(bool boolDirty = true); 

		inline bool IsPerspective() { return m_boolPerspective; };
		ChQvPCameraRenderData *SetLoc(GxVec3f &loc)	;
		ChQvPCameraRenderData *SetDir(GxVec3f &dir)	;
		ChQvPCameraRenderData *SetUp(GxVec3f &up);

		ChQvPCameraRenderData *SetStartLoc(GxVec3f &loc)	{m_startLoc = loc; return this;};
		ChQvPCameraRenderData *SetStartDir(GxVec3f &dir)	{m_startDir = dir; return this;};
		ChQvPCameraRenderData *SetStartUp(GxVec3f &up)	{m_startUp = up; return this;};
		ChQvPCameraRenderData *Reset();
		string MakeName(ChQvBuildState* state);


		const GxVec3f &GetLoc()	{return m_loc;};
		const GxVec3f	&GetDir()	{return m_dir;};
		const GxVec3f	&GetUp()	{return m_up;};

		const GxVec3f &GetStartLoc()	{return m_startLoc;};
		const GxVec3f	&GetStartDir()	{return m_startDir;};
		const GxVec3f	&GetStartUp()	{return m_startUp;};

		void TransformPoint( const GxVec3f &src, GxVec3f &dst );
		void InverseTransformPoint( const GxVec3f &src, GxVec3f &dst );
		void TransformNormal( const GxVec3f &src, GxVec3f &dst );
		void InverseTransformNormal( const GxVec3f &src, GxVec3f &dst );

		GxTransform3Wf GetTransform();
		GxTransform3Wf GetClipTransform();
		GxTransform3Wf GetInverseTransform();
		ChQvPCameraRenderData * GetPort(float &left, float &right, float &top, float &bottom)
		{
			left	=	m_left;   
			top		=	m_top;    
			right	=	m_right;  
			bottom	=	m_bottom; 
			return this;
		};

		void SynchCamera();		  // Set camera node fields to agree with this
		void Synch();  			// Set this' fields to agree with  camera node
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		ChQvPCameraRenderData * ChQvPCameraRenderData::SetRenderer(bool boolNow = false);
		ChQvPCameraRenderData * Select();
		void GetOrientationTransform(GxTransform3Wf &theTransform);
		float GetHither();
		float GetYon();

		bool OnTick();	  // 'move' tick
		#endif

 		virtual ChVrmlDispatcher *GetDispatcher() {return m_pDispatcher;};
		bool OnSetOrientation(ChRenderContext *pRC, ChApplet * pApplet, ChIVrmlEvent *pEvent);
		bool OnSetPosition(ChRenderContext *pRC, ChApplet * pApplet, ChIVrmlEvent *pEvent);

		void Init();

		static void Term();
};


/*----------------------------------------------------------------------------
	ChQvTextureRenderData class
----------------------------------------------------------------------------*/

class QvTexture2;
class ChRLImage;

class ChQvTextureRenderData : public ChQvRenderBaseData
{	   // Texture data
	friend class QvTexture2;

	protected:
		string m_strURL;
			// Chaco's 3dr fields
		ChTextureHandle m_texture;		// texture handle; set to null if delayed load
		#if defined(CH_USE_3DR)
		long int m_hRC;			// needed to free texture
		#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		ChRLImage *m_pImage;
		#endif	
		//QvTexture2 *m_pTexture2;

	protected:
		int GetURL(QvState *qvstate);	 // called from QvTexture2

	public:
		ChQvTextureRenderData(QvNode* txt);
		virtual ~ChQvTextureRenderData(); 

		string &GetCurrentURL() { return m_strURL; };
		ChTextureHandle GetTextureHandle() { return m_texture; };
		virtual bool IsEmpty();		// whether it will -never- have a texture
		#if defined(CH_USE_3DR)
		ChQvTextureRenderData* SetRC(long int hRC) 
			{ m_hRC = hRC; return this;};
		#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		#endif

		virtual ChQvTextureRenderData* LoadTexture(ChRenderContext *pContext, ChDib *pDibIn, chuint32 luChromaClr, chuint uOption);

		#if defined(CH_USE_3DR)
		virtual ChQvTextureRenderData* LoadTexture( ChRenderContext *pContext, ChTextureHandle texHandle );
		#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		virtual ChQvTextureRenderData* LoadTexture( ChRenderContext *pContext, ChRLImage* pRLImg );

		bool IsChromaKey();
		ChColor GetChromaKey();

		#endif


	#if defined(CH_USE_3DR)
	public:
	#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
	protected:
	#endif	
		ChQvTextureRenderData* SetTextureHandle(ChTextureHandle hText) 
			{ m_texture = hText; return this;};
};

class ChQvBackgroundData : public ChQvRenderBaseData
{	   // Texture data
	friend class QvTexture2;

	protected:
		string m_strURL;
		
		ChTextureHandle m_panTextures[6];		// texture handles for panorama; set to null initially
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		ChRLImage *m_pImage;
		#endif	

	protected:
		int GetURL(QvState *qvstate);	 // called when spawned

	public:
		ChQvBackgroundData();
		virtual ~ChQvBackgroundData(); 

		string &GetCurrentURL() { return m_strURL; };
		ChTextureHandle GetTextureHandle(int i) { return m_panTextures[i]; };
		bool IsEmpty();		// whether it will -never- have a texture

		ChQvBackgroundData* LoadTexture(ChRenderContext *pContext, ChDib *pDibIn, chuint32 luChromaClr, chuint uOption);

		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		ChQvBackgroundData* LoadTexture( ChRenderContext *pContext, ChRLImage* pRLImg );
		#endif

	#if defined(CH_USE_3DR)
	public:
	#elif (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
	protected:
	#endif
	#if 0	
		ChQvBackgroundData* SetTextureHandle(ChTextureHandle hText) 
			{ m_texture = hText; return this;};
	#endif
};

class ChQvBackgroundInfoData : public ChQvTextureRenderData
{	   // Texture data for Background Info node
	friend class QvInfo;

	protected:
		ChRLImage	*m_pTiledImage;
		int 		m_height;
		int 		m_width;
		GxVec3f		m_backCenter;
		bool		m_boolDirty;
		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		ChNrFrame		m_backgroundFrame;
		#endif

	protected:
		int GetURL(QvState *qvstate);	 // called when spawned

		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		int ComputeTiledWidth(ChRenderContext *pContext);
		int ComputeTiledHeight(ChRenderContext *pContext);
		void InitDecal(ChRenderContext *pContext);
		void Resize( ChRenderContext *pContext);
		#endif

	public:
		ChQvBackgroundInfoData(QvNode *pNode);
		virtual ~ChQvBackgroundInfoData(); 

		virtual bool IsEmpty();		// whether it will -never- have a texture

		virtual ChQvTextureRenderData* LoadTexture(ChRenderContext *pContext, ChDib *pDibIn, chuint32 luChromaClr, chuint uOption);

		#if (defined(CH_USE_RLAB) || defined(CH_USE_D3D)) || defined(CH_USE_D3D)
		virtual ChQvTextureRenderData* LoadTexture( ChRenderContext *pContext, ChRLImage* pRLImg );
		bool CreateTexture(ChRenderContext *pContext);
		void Justify(GxVec3f &pt, ChRenderContext *pContext);
		void Move( ChRenderContext *pContext);
		void OnResize( ChRenderContext *pContext);
		void OnDestroyTexture();

		#endif

};

class ChQvSwitchRenderData : public ChQvGroupRenderData
{	   
							

	private:
		static ChVrmlDispatcher		*m_pDispatcher;

	public:
		ChQvSwitchRenderData(QvNode* pNode);
		virtual ~ChQvSwitchRenderData();
		
		// VRML 2.0 Event Handlers
		bool OnSetWhichChild(ChRenderContext *pRC, ChApplet * pApplet, ChIVrmlEvent *pEvent);

 		virtual ChVrmlDispatcher *GetDispatcher() {return m_pDispatcher;};

		void Init();

		static void Term();

};

class ChQvSpinGroupInstance;

class ChQvSpinGroupRenderData : public ChQvGroupRenderData
{	   
							

	private:
		static ChVrmlDispatcher		*m_pDispatcher;
		float m_step;
		GxTransform3Wf	m_spinTransform;

	public:
		ChQvSpinGroupRenderData(QvNode* pNode);
		virtual ~ChQvSpinGroupRenderData();
		
		// VRML 2.0 Event Handlers
		bool OnSetRotation(ChRenderContext *pRC, ChApplet * pApplet, ChIVrmlEvent *pEvent);

		// Dispatch Table for this class
 		virtual ChVrmlDispatcher *GetDispatcher() {return m_pDispatcher;};

		void Init();

		static void Term();
		void Spin(ChQvSpinGroupInstance *pTarget);

};

		// VRML 2.0 Things
class ChQvTimeSensorRenderData : public ChQvRenderBaseData
{	   
							

	private:
		ChRenderContext *m_pRC;	// where installed

	public:
		ChQvTimeSensorRenderData(QvNode* pNode) : ChQvRenderBaseData(pNode), m_pRC(0) {};
		virtual ~ChQvTimeSensorRenderData();
		
		bool OnTick(double t);
		Install(ChRenderContext *pRC);
};


#endif // _CHRENDER_H