3dr.h

Windows上的MUD客户端程序

#define	R3D_SI_RIGHT				0x0001
#endif	/* R3D_FUTURES */

#define	R3D_SI_SCISSOR				0x0004

/*
// Possible values for:	ClearInfo in the R3dClearBuffers() prototype below
// Logical OR of ...
*/
#define	R3D_CI_DRAW_BUFFER			0x0001

#ifdef	R3D_FUTURES 
#define	R3D_CI_DRAW_BUFFER_LEFT		0x0001
#define	R3D_CI_DRAW_BUFFER_RIGHT	0x0002
#endif	/* R3D_FUTURES */

#define	R3D_CI_ZBUFFER				0x0004	

/*
// Possible values for:	TexInfo in the R3dNewTexture() prototype below.
// Logical OR of ...
*/
#define R3D_TI_DEFAULT				0x0000
#define	R3D_TI_MIPMAP				0x0001
#define	R3D_TI_HIRES				0x0002
#define	R3D_TI_KEEP					0x0004
#define	R3D_TI_INDEX				0x0010
#define	R3D_TI_CHROMAKEY			0x0020
#define	R3D_TI_ALPHA				0x0040

/*
// Possible values for:	R3dMsgHdr.MsgHdrVersion field
// Pick ONE of ...
*/
#define	R3D_MSG_VERSION				1

/*
// Maximum No of vertices to be passed using R3dPrimitive()
*/
#define	R3D_MAX_VERTICES			256

/*
//	3DR Function Prototypes :
*/

Dword_t	WINAPI
R3dBegin		(	);

Void_t	WINAPI
R3dEnd			(	);

Dword_t	WINAPI	
R3dCreateRC		(	R3dHandle_t	hDC, 
					Word_t	   	RCInfo		);

Dword_t WINAPI	
R3dDeleteRC		(	R3dHandle_t	hRC		);

Void_t WINAPI 
R3dPrimitive	(	R3dHandle_t	hRC, 
					Word_t		PrmType, 
					Word_t		VtxInfo, 
					Word_t		VtxCount, 
					Word_t		VtxSize,
					LPByte_t	VtxPtr		);

Dword_t	WINAPI 
R3dGetState		(	R3dHandle_t	hRC,
					Word_t		State		);

Void_t	WINAPI 
R3dSetState		(	R3dHandle_t	hRC,
					Word_t		State, 
					Dword_t		Data		);

Dword_t	WINAPI 
R3dNewTexture	(	R3dHandle_t	hRC, 
					Word_t		TexInfo,
					Word_t		TexBitsPixel,
					Word_t		TexWidth, 
					Word_t		TexHeight	);

Dword_t	WINAPI 
R3dLoadTexture	(	R3dHandle_t	hRC, 
					Word_t		TexInfo,
					Word_t		TexBitsPixel, 
					Word_t		TexMipLevel, 
					Word_t		TexWidth, 
					Word_t		TexRows, 
					Short_t		TexWidthBytes, 
					Dword_t		TexId, 
					Dword_t		TexData,
					LPByte_t	TexBuffer	);

Void_t 	WINAPI 
R3dFreeTexture	( 	R3dHandle_t	hRC, 
					R3dHandle_t	TexId		);

#ifdef	R3D_FUTURES
Dword_t	WINAPI 
R3dNewBitmap	(	R3dHandle_t	hRC, 
					Word_t		BmpInfo,
					Word_t		BmpBitsPixel,
					Word_t		BmpWidth, 
					Word_t		BmpHeight	);

Void_t	WINAPI 
R3dFreeBitmap	(	R3dHandle_t	hRC, 
					Dword_t		BmpId		);

Dword_t	WINAPI 
R3dLoadBitmap	(	R3dHandle_t	hRC, 
					Word_t		BmpInfo,
					Word_t		BmpBitsPixel,
					Word_t		BmpWidth, 
					Word_t		BmpHeight, 
					Short_t		BmpWidthBytes, 
					Dword_t		BmpData,
					LPByte_t	BmpBuffer	);

Void_t	WINAPI 
R3dCachedBitmap	(	R3dHandle_t	hRC, 
					Word_t		BmpInfo,
					Short_t		BmpSrcX, 
					Short_t		BmpSrcY,
					Short_t		BmpDstX, 
					Short_t		BmpDstY,
					Word_t		BmpWidth, 
					Word_t		BmpHeight,
					Dword_t		BmpData,
					Dword_t		BmpId		);
#endif	/* R3D_FUTURES */

Dword_t WINAPI
R3dSetPaletteEntry( Dword_t		hRC,
					Dword_t		PalEntry,
					Long_t		Exactness);
					
Void_t WINAPI
R3dApplyNewPalette(	Dword_t		hRC);

Void_t	WINAPI 
R3dBitmap		(	R3dHandle_t	hRC, 
					Word_t		BmpInfo,
					Word_t		BmpBitsPixel,
					Word_t		BmpWidth, 
					Word_t		BmpHeight, 
					Short_t		BmpWidthBytes, 
					Short_t		BmpSrcX, 
					Short_t		BmpSrcY,
					Short_t		BmpDstX, 
					Short_t		BmpDstY,
					Dword_t		BmpData,
					LPByte_t	BmpBuffer	);

Void_t	WINAPI
R3dSwapBuffers	(	R3dHandle_t	hRC, 
					Word_t		SwapInfo	);

Void_t	WINAPI	
R3dClearBuffers	(	R3dHandle_t	hRC, 
					Word_t		ClearInfo	);

Dword_t WINAPI 
R3dMessage		(	R3dHandle_t	hRC, 
					Dword_t		InDataSize, 
					LPByte_t	InDataPtr, 
					Dword_t		OutDataSize, 
					LPByte_t	OutDataPtr	);

#endif	/* R3D_TYPES_ONLY */

#ifdef	USE_3DR_PACKETS

#define R3D_BUF_SIZE		0x8000
#define R3D_BUF_PAD			0x0100
#define R3D_MAX_PKT_SIZE	(R3D_BUF_SIZE - R3D_BUF_PAD)

#define	R3dPacketsInit()													\
		Byte_t		R3dBufData[R3D_BUF_SIZE];								\
		LPByte_t	R3dBufPtr	= R3dBufData + sizeof(R3dMsgHdr_t);			\

#define	R3dPacketsExternInit()												\
extern	Byte_t		R3dBufData[];											\
extern	LPByte_t	R3dBufPtr;												\

/*
//	The following macros are for the support of the macros below.
//	Note R3dMemCopy() is a simple byte-at-a-time copy function.
*/
#define R3dMemCopy(DstPtr, SrcPtr, Size)									\
		while ((Dword_t)(Size)--) {											\
			 *(FPByte_t)(DstPtr)++ = *(FPByte_t)(SrcPtr)++;					\
		}

#define IsNotEnoughRoomInCurrentPacket(size)								\
	(((LPByte_t)(R3dBufPtr) + ((Dword_t)(size))) > 							\
				((LPByte_t)(R3dBufData) + R3D_MAX_PKT_SIZE)) 

#define R3dSendCurrentPacket(hRC)											\
{																			\
	const LPR3dMsgHdr_t hPtr = (LPR3dMsgHdr_t)  (LPByte_t)(R3dBufData);		\
	const LPR3dPktGen_t ePtr = (LPR3dPktGen_t)  (LPByte_t)(R3dBufPtr);		\
		  Dword_t	currentPktSize;											\
																			\
	currentPktSize = (Dword_t)((LPByte_t)(R3dBufPtr) - 						\
								(LPByte_t)(R3dBufData)) +					\
								sizeof(R3dPktGen_t);						\
																			\
	hPtr->MsgHdrType	= R3D_MSG_PACKET;									\
	hPtr->MsgHdrVersion	= R3D_MSG_VERSION;									\
	hPtr->MsgHdrSize	= currentPktSize;									\
	hPtr->MsgHdrRC 		= (R3dHandle_t)(hRC);								\
																			\
	ePtr->PktGenPktType	= R3D_PKT_END;										\
	ePtr->PktGenInfo	= 0;												\
																			\
	R3dMessage(	(Dword_t)	(hRC),											\
				(Dword_t)	currentPktSize,									\
				(LPByte_t)	(R3dBufData),									\
				(Dword_t)	8,												\
				(LPByte_t)	(R3dBufData));									\
																			\
	(LPByte_t)(R3dBufPtr) = (LPByte_t)(R3dBufData) + sizeof(R3dMsgHdr_t);	\
}


/*
// The following macros are intended to be used in exactly the same way that
// the API functions of the same name are used. One can consider the API 
// functions to be functions that create tiny messages just big enough to 
// contain the primitive in use. These following macros will fill the 
// message buffer until it reaches a high water mark, or, until the 
// R3dSwapBuffers() macro is used.
*/
#define R3dSetState(hRC, State, Value)										\
{																			\
	LPR3dPktSta_t StaPtr = (LPR3dPktSta_t ) (R3dBufPtr);					\
																			\
	if (IsNotEnoughRoomInCurrentPacket(sizeof(R3dPktSta_t))) {				\
		R3dSendCurrentPacket(hRC);											\
		StaPtr	= (LPR3dPktSta_t ) (R3dBufPtr);								\
	}																		\
																			\
	StaPtr->PktStaPktType	= R3D_PKT_SETSTATE;								\
	StaPtr->PktStaState		= (Word_t)(State);								\
	StaPtr->PktStaData		= (Dword_t)(Value);								\
																			\
	(LPByte_t)(R3dBufPtr)	+= sizeof(R3dPktSta_t);							\
																			\
}

#define R3dPrimitive(hRC, Prim, VtxInfo, Count, VtxSize, VtxDataPtr)		\
{																			\
	LPR3dPktPrm_t PrmPtr		= (LPR3dPktPrm_t ) (R3dBufPtr);				\
	const Dword_t curVtxSize	= (((Word_t)(Count))*((Word_t)(VtxSize)));	\
	const Dword_t curPktSize	= ((sizeof(R3dPktPrm_t) - 4) +	curVtxSize);	\
																			\
	if (IsNotEnoughRoomInCurrentPacket(curPktSize)) {						\
		R3dSendCurrentPacket(hRC);											\
		PrmPtr	= (LPR3dPktPrm_t ) (R3dBufPtr);								\
	}																		\
																			\
	PrmPtr->PktPrmPktType	= (Word_t) (Prim);								\
	PrmPtr->PktPrmVtxInfo	= (Word_t) (VtxInfo);							\
	PrmPtr->PktPrmVtxNum	= (Word_t) (Count);								\
	PrmPtr->PktPrmVtxSize	= (Word_t) (VtxSize);							\
																			\
	R3dMemCopy(	(LPByte_t)	PrmPtr->PktPrmBuffer, 							\
				(LPByte_t)	(VtxDataPtr), 									\
				(Dword_t)	curVtxSize);									\
																			\
	(LPByte_t)(R3dBufPtr)	+= curPktSize;									\
}

#define R3dClearBuffers(hRC, ClearInfo)										\
{																			\
	LPR3dPktGen_t GenPktPtr		= (LPR3dPktGen_t) (R3dBufPtr);				\
																			\
	if (IsNotEnoughRoomInCurrentPacket(sizeof(R3dPktGen_t))) {				\
		R3dSendCurrentPacket(hRC);											\
		GenPktPtr = (LPR3dPktGen_t) (R3dBufPtr);							\
	}																		\
																			\
	GenPktPtr->PktGenPktType	= R3D_PKT_CLEARBUFFERS;						\
	GenPktPtr->PktGenInfo		= (Word_t)ClearInfo;						\
																			\
	(LPByte_t)(R3dBufPtr)		+= sizeof(R3dPktGen_t);						\
}

#define R3dSwapBuffers(hRC, SwapInfo)										\
{																			\
	LPR3dPktGen_t GenPktPtr = (LPR3dPktGen_t ) (R3dBufPtr);					\
																			\
	if (IsNotEnoughRoomInCurrentPacket(sizeof(R3dPktGen_t))) {				\
		R3dSendCurrentPacket(hRC);											\
		GenPktPtr = (LPR3dPktGen_t ) (R3dBufPtr);							\
	}																		\
																			\
	GenPktPtr->PktGenPktType	= R3D_PKT_SWAPBUFFERS;						\
	GenPktPtr->PktGenInfo		= (Word_t)SwapInfo;							\
																			\
	(LPByte_t)(R3dBufPtr)		+= sizeof(R3dPktGen_t);						\
																			\
	R3dSendCurrentPacket(hRC);												\
}

/*
// The following macros are intended to be used where it is known that the
// full size of each primitive fits within the remaining space in the buffer.
// In particular the R3dPrimitiveFAST() macro stuffs the header info for the
// primitive, the user MUST then fill the rest of the primitive structure
// out with vertex information etc.
*/
#define R3dSetStateFAST(StaPtr, State, Value)								\
	((LPR3dPktSta_t)(StaPtr))->PktStaPktType	= R3D_PKT_SETSTATE;			\
	((LPR3dPktSta_t)(StaPtr))->PktStaState		= (Word_t) (State);			\
	((LPR3dPktSta_t)(StaPtr))->PktStaData		= (Dword_t)(Value);			\
	(LPByte_t)(StaPtr)	+= sizeof(R3dPktSta_t);

#define R3dPrimitiveFAST(PrmPtr, Prim, VtxInfo, Count, VtxSize)				\
	((LPR3dPktPrm_t)(PrmPtr))->PktPrmPktType	= (Word_t) (Prim);			\
	((LPR3dPktPrm_t)(PrmPtr))->PktPrmVtxInfo	= (Word_t) (VtxInfo); 		\
	((LPR3dPktPrm_t)(PrmPtr))->PktPrmVtxNum		= (Word_t) (Count);   		\
	((LPR3dPktPrm_t)(PrmPtr))->PktPrmVtxSize	= (Word_t) (VtxSize); 		\
	(LPByte_t)(PrmPtr)	+= (sizeof(R3dPktPrm_t) - 4);	

#define R3dClearBuffersFAST(GenPktPtr, ClearInfo)			  				\
	((LPR3dPktGen_t)(GenPktPtr))->PktGenPktType	= R3D_PKT_CLEARBUFFERS; 	\
	((LPR3dPktGen_t)(GenPktPtr))->PktGenInfo	= (Word_t)(ClearInfo); 		\
	(LPByte_t)(GenPktPtr) += sizeof(R3dPktGen_t);

#define R3dSwapBuffersFAST(GenPktPtr, hRC, SwapInfo)		  	   			\
	((LPR3dPktGen_t)(GenPktPtr))->PktGenPktType = R3D_PKT_SWAPBUFFERS; 		\
	((LPR3dPktGen_t)(GenPktPtr))->PktGenInfo	= (Word_t)(SwapInfo);		\
	(LPByte_t)(GenPktPtr)	+= sizeof(R3dPktGen_t);							\
	R3dSendCurrentPacket(hRC);

#endif	/* USE_3DR_PACKETS */

#define	R3D_SE_SWAP_WITH_ZOOM		0x00080000L
#define R3D_SE_COLOR_INDEXED_MODE	0x00200000L

#define	R3D_STA_ZOOM_X				60
#define	R3D_STA_ZOOM_Y				61

#ifdef	__cplusplus
};
#endif	/* __ cplusplus */

#endif /* _3DR_H_ */