archive/brender-1997
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
brender-1997/ati/Ati3dcif.h
Foone Turing 5f8738d671 Adding BRender source
2022-05-03 14:31:40 -07:00

762 lines
29 KiB
C
Raw Blame History

// Filename: ati3dcif.h
// $Revision: 2.28 $
//
// Description: ATI 'C'interface (CIF) header to GT 3D hardware acceleration
//
// Trade secret of ATI Technologies, Inc.
// Copyright 1995, ATI Technologies, Inc., (unpublished)
//
// All rights reserved. This notice is intended as a precaution against
// inadvertent publication and does not imply publication or any waiver
// of confidentiality. The year included in the foregoing notice is the
// year of creation of the work.
//
//
#ifndef ATI_ATI3DCIF_H
#define ATI_ATI3DCIF_H
// Current Restrictions
// 1. Only support EV_VTCF floating point vertex type
// 2. Only one context may be exist at a time
// 3. RenderSwitch does not have meaning ( consequence of 2. )
// 4. C3D_ETFILT_MIPTRI_MAG2BY2 is not supported yet.
// 5. Coordinates should be pre-clipped by software to:
// -2048.0f +2047.0f in X
// -4096.0f +4095.0f in Y
#ifdef __cplusplus
extern "C" {
#endif
#if ! defined (BUILD_AS_DLL)
#define DLLEXPORT
#endif
#ifdef DOS_BUILD
#include "afxdos.h"
#include "i3debug.h"
#endif
#ifndef DOS_BUILD
#pragma pack(push) // push packing state
#pragma pack(8) // CIF requires structure data is naturally aligned
#endif
// Fundemental types
//
typedef unsigned int C3D_BOOL; // 0 indicates FALSE, >0 indicates TRUE
typedef unsigned int C3D_INT32; // 32 bit integer data
typedef unsigned int C3D_UINT32; // unsigned 32 bit integer data
typedef unsigned short C3D_UINT16; // unsigned 16 bit integer data
typedef unsigned char C3D_UINT8; // unsigned 8 bit integer data
typedef float C3D_FLOAT32; // 32 bit floating point data
typedef unsigned int* C3D_PBOOL; // points at C3D_BOOL;
typedef unsigned int* C3D_PINT32; // points at C3D_INT32;
typedef unsigned int* C3D_PUINT32; // points at C3D_UINT32;
typedef unsigned short* C3D_PUINT16; // points at C3D_UINT16;
typedef unsigned char* C3D_PUINT8; // points at C3D_UINT8;
typedef float* C3D_PFLOAT32; // points at C3D_FLOAT32;
typedef void * C3D_PVOID; // points at generic data
//ensure that enums are 32 bits in size. Allows optimization of non C3D enums.
#ifdef DOS_BUILD
#define C3D_FORCE_SIZE 0x7F
#else
#define C3D_FORCE_SIZE 0x7FFFFFFF
#endif
// Error codes
//
typedef enum {
C3D_EC_OK = 0, // Success
C3D_EC_GENFAIL = 1, // Generic Failure
C3D_EC_MEMALLOCFAIL = 2, // Memory allocation failure
C3D_EC_BADPARAM = 3, // Invalid parameter passed to function
C3D_EC_UNUSED0 = 4, // Reserved
C3D_EC_BADSTATE = 5, // Object entered invalid state
C3D_EC_NOTIMPYET = 6, // Functionality Not Implemented Yet
C3D_EC_UNUSED1 = 7, // Reserved
C3D_EC_CHIPCAPABILITY = 8, //Feature is not on this chip version (see C3D_CAPS)
C3D_EC_NUM = 9,
C3D_EC_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EC, * C3D_PEC;
// Rect: specs a rectangular region in 2 space
//
typedef struct {
C3D_INT32 top;
C3D_INT32 left;
C3D_INT32 bottom;
C3D_INT32 right;
} C3D_RECT , * C3D_PRECT;
// Color
//
typedef union {
struct {
unsigned r: 8; // 8 red bits
unsigned g: 8; // 8 green bits
unsigned b: 8; // 8 blue bits
unsigned a: 8; // 8 alpha bits
};
C3D_UINT32 u32All;
} C3D_COLOR , * C3D_PCOLOR;
// Palette Color
//
//values for the flag palette entry. Set the flag
// C3D_LOAD_PALETTE_ENTRY to use thse palette entry,
//C3D_NO_LOAD_PALETTE_ENTRY to skip the entry.
//This allows "virtual palettes" of other than 16/256 size.
#define C3D_LOAD_PALETTE_ENTRY 0x40
#define C3D_NO_LOAD_PALETTE_ENTRY 0x00
typedef union {
struct {
unsigned r: 8; // 8 red bits
unsigned g: 8; // 8 green bits
unsigned b: 8; // 8 blue bits
unsigned flags: 8; //flag bits - see above defines
};
C3D_UINT32 u32All;
} C3D_PALETTENTRY , * C3D_PPALETTENTRY;
// Module Capability Flags: These module capability flags should allow a client
// to function properly with any release of the 3D CIF library. C3D_CAPS_BASE
// indicates the availability of all functionality supported in the first
// release of 3DCIF build 17. Each flag indicates the existance of module
// features added after the first release. NB that u32CIFCaps field of the
// C3D_3DCIFINFO struct did not exist. Before using the u32CIFCaps field make
// sure the library is more recent than build 17
//
#define C3D_CAPS1_BASE 0x00000000 // base line functionality
#define C3D_CAPS1_FOG 0x00000001 // fog support
#define C3D_CAPS1_POINT 0x00000002 // point primitive
#define C3D_CAPS1_RECT 0x00000004 // screen aligned rect primitive
#define C3D_CAPS1_Z_BUFFER 0x00000008 // depth buffer support
#define C3D_CAPS1_CI4_TMAP 0x00000010 // 4 bit color index texture support
#define C3D_CAPS1_CI8_TMAP 0x00000020 // 8 bit color index texture support
#define C3D_CAPS1_LOAD_OBJECT 0x00000040 // bus-master data loading
#define C3D_CAPS1_DITHER_EN 0x00000080 // dithering can be turned on/off
#define C3D_CAPS1_ENH_PERSP 0x00000100 // enhanced perspective levels avail
#define C3D_CAPS1_SCISSOR 0x00000200 // set clip without setting origin
#define C3D_CAPS1_PROFILE_IF 0x01000000 // is the profile interface avail
// Module info structure
//
typedef struct {
C3D_UINT32 u32Size; // Sz of struct must be init'ed by client
C3D_UINT32 u32FrameBuffBase; // Host pointer to frame buffer base
C3D_UINT32 u32OffScreenHeap; // Host pointer to offscreen heap
C3D_UINT32 u32OffScreenSize; // Size of offscreen heap
C3D_UINT32 u32TotalRAM; // Total amount of RAM on the card
C3D_UINT32 u32ASICID; // ASIC Id. code
C3D_UINT32 u32ASICRevision; // ASIC revision
C3D_UINT32 u32CIFCaps1; // ATI3DCIF module capabilities (see flags)
C3D_UINT32 u32CIFCaps2; // ATI3DCIF module capabilities (see flags)
C3D_UINT32 u32CIFCaps3; // ATI3DCIF module capabilities (see flags)
C3D_UINT32 u32CIFCaps4; // ATI3DCIF module capabilities (see flags)
C3D_UINT32 u32CIFCaps5; // ATI3DCIF module capabilities (see flags)
} C3D_3DCIFINFO, * PC3D_3DCIFINFO;
//
// Vertex enumeration type : used to select vertex data format to be referenced
// when rendering primitives
//
// Nomenclature: V for Vertex (Always X,Y,Z)
// C for Color (Always R,G,B,A)
// T for Texture(Always S,T,W)
//
typedef enum {
C3D_EV_VF = 0,
C3D_EV_VCF = 1,
C3D_EV_VTF = 2,
C3D_EV_VTCF = 3,
C3D_EV_NUM = 4,
C3D_EV_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EVERTEX, * C3D_PEVERTEX;
//
// Vertex data types
//
typedef struct {
C3D_FLOAT32 x, y, z; // FLOATING point type
} C3D_VF, * C3D_PVF; // identified by C3D_EV_VF
typedef struct {
C3D_FLOAT32 x, y, z; // FLOATING point type
C3D_FLOAT32 r, g, b, a; // identified by C3D_EV_VCF
} C3D_VCF, * C3D_PVCF;
typedef struct {
C3D_FLOAT32 x, y, z; // FLOATING point type
C3D_FLOAT32 s, t, w; // identified by C3D_EV_VTF
} C3D_VTF, * C3D_PVTF;
typedef struct {
C3D_FLOAT32 x, y, z; // FLOATING point type
C3D_FLOAT32 s, t, w; // identified by C3D_EV_VTCF
C3D_FLOAT32 r, g, b, a;
} C3D_VTCF, * C3D_PVTCF;
// Primitive Sets: A primitive set is a sequence of vertex data used
// to represent a stream of geometric primitives: Quads,Tris or Lines.
// A Primitive Set can take two basic forms: Strips or Lists.
// A Primitive List is a doubly indirect array of pointers to actual vertex data.
// A Primitive Strip is a pointer to contiguous array of vertex data
// where adjacent primitives share vertex data.
//
// (e.g. a triangle strip with four vertices represents 2 triangles
//
// Primitive Set Pointers
typedef void * C3D_VSTRIP;
typedef void ** C3D_VLIST;
// Primitive Type: Specifies the geometric interpretation of a vertex set
// during rasterization. eg: if C3D_EPRIM_TRI is set in a rendering context
// then subsequent calls to ATI3DCIF_RenderPrimList will interpret the specified
// vertices as triangles and will consume 3 vertices for each triangle drawn.
//
typedef enum {
C3D_EPRIM_LINE = 0,
C3D_EPRIM_TRI = 1,
C3D_EPRIM_QUAD = 2,
C3D_EPRIM_RECT = 3,
C3D_EPRIM_POINT = 4,
C3D_EPRIM_NUM = 5, // invalid enumeration val
C3D_EPRIM_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EPRIM, * C3D_PEPRIM;
// Shading
//
typedef enum {
C3D_ESH_NONE = 0,
C3D_ESH_SOLID = 1, // shade using the clrSolid from the RC
C3D_ESH_FLAT = 2, // shade using the last vertex to flat shade.
C3D_ESH_SMOOTH = 3, // shade using linearly interpolating vert clr
C3D_ESH_NUM = 4, // invalid enumeration val
C3D_ESH_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ESHADE, * C3D_PESHADE;
// Alpha Blending
//
// clr_dst = clr_src * f(eAlphaSrcFactor) + clr_dst * f(eAlphaDstFactor)
// alpha blending source factor select
typedef enum {
C3D_EASRC_ZERO = 0,// Blend factor is (0, 0, 0)
C3D_EASRC_ONE = 1,// Blend factor is (1, 1, 1)
C3D_EASRC_DSTCLR = 2,// Blend factor is (Rd, Gd, Bd)
C3D_EASRC_INVDSTCLR = 3,// Blend factor is (1-Rd, 1-Gd, 1-Bd)
C3D_EASRC_SRCALPHA = 4,// Blend factor is (As, As, As)
C3D_EASRC_INVSRCALPHA = 5,// Blend factor is (1-As, 1-As, 1-As)
C3D_EASRC_NUM = 6, // invalid enumeration val
C3D_EASRC_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EASRC, *C3D_PEASRC;
// alpha blending destination factor select
//
typedef enum {
C3D_EADST_ZERO = 0, // Blend factor is (0, 0, 0)
C3D_EADST_ONE = 1, // Blend factor is (1, 1, 1)
C3D_EADST_SRCCLR = 2, // Blend factor is (Rs, Gs, Bs)
C3D_EADST_INVSRCCLR = 3, // Blend factor is (1-Rs, 1-Gs, 1-Bs)
C3D_EADST_SRCALPHA = 4, // Blend factor is (As, As, As)
C3D_EADST_INVSRCALPHA = 5, // Blend factor is (1-As, 1-As, 1-As)
C3D_EADST_NUM = 6, // invalid enumeration val
C3D_EADST_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EADST, *C3D_PEADST;
// Texture mapping
//
typedef void * C3D_HTX; // handle to a texture in the framebuffer
typedef C3D_HTX * C3D_PHTX; // pointer to handle to texture
typedef void * C3D_HTXPAL; // handle to a texture palette
typedef C3D_HTXPAL *C3D_PHTXPAL; // pointer to handle to a texture palette
typedef enum {
C3D_ECI_TMAP_TRUE_COLOR = 0, // no palette
C3D_ECI_TMAP_4BIT_HI = 1, // 16 entry palette
C3D_ECI_TMAP_4BIT_LOW = 2, // 16 entry palette
C3D_ECI_TMAP_8BIT = 3, // 256 entry palette
C3D_ECI_TMAP_NUM = 4, // invalid enumeration
C3D_ECI_TMAP_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ECI_TMAP_TYPE;
// Texel lighting
typedef enum {
C3D_ETL_NONE = 0, // TEXout = Tclr
C3D_ETL_MODULATE = 1, // TEXout = Tclr*CInt
C3D_ETL_ALPHA_DECAL = 2, // TEXout = (Tclr*Talp)+(CInt*(1-Talp))
C3D_ETL_NUM = 3, // invalid enumeration
C3D_ETL_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ETLIGHT, * C3D_PETLIGHT;
// specifies the level of perspective correction done by the hardware. This
// setting trades off image quality for better frame rates
typedef enum {
C3D_ETPC_NONE = 0, // no correction, best frame rate
C3D_ETPC_ONE = 1, //
C3D_ETPC_TWO = 2, //
C3D_ETPC_THREE = 3, // recommended correction
C3D_ETPC_FOUR = 4, //
C3D_ETPC_FIVE = 5, //
C3D_ETPC_SIX = 6, //
C3D_ETPC_SEVEN = 7, //
C3D_ETPC_EIGHT = 8, //
C3D_ETPC_NINE = 9, // full correction, worst frame rate
C3D_ETPC_NUM = 10, // invalid enumeration
C3D_ETPC_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ETPERSPCOR, * C3D_PETPERSPCOR;
// texture filtering modes
// ( NB: that GT supports 2x2 MIN only if 2x2 MAG is turned on )
// ( NB: modes identified by MIP are only valid with mip mapped textures )
typedef enum {
C3D_ETFILT_MINPNT_MAGPNT = 0,// pick nearest texel (pnt) min/mag
C3D_ETFILT_MINPNT_MAG2BY2 = 1,// pnt min/bi-linear mag
C3D_ETFILT_MIN2BY2_MAG2BY2 = 2,// 2x2 blend min/bi-linear mag
C3D_ETFILT_MIPLIN_MAGPNT = 3,// 1x1 blend min(between maps)/pnt mag
C3D_ETFILT_MIPLIN_MAG2BY2 = 4,// 1x1 blend min(between maps)/bi-linear mag
C3D_ETFILT_MIPTRI_MAG2BY2 = 5,// (2x2)x(2x2)(between maps)/bi-linear mag
C3D_ETFILT_NUM = 6, //
C3D_ETFILT_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ETEXFILTER, *C3D_PETEXFILTER;
// texel op modes: determines how which operations are applied to texels as
// they are read from the texture. By design theses are orthogonal to
// filtering modes.
//
typedef enum {
C3D_ETEXOP_NONE = 0, //
C3D_ETEXOP_CHROMAKEY = 1, // select texels not equal to the chroma key
C3D_ETEXOP_ALPHA = 2, // pass texel alpha to the alpha blender
C3D_ETEXOP_ALPHA_MASK = 3, // lw bit 0: tex not drawn otw: alpha int
C3D_ETEXOP_NUM = 4, //
C3D_ETEXOP_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ETEXOP, * C3D_PETEXOP;
// specifies the pixel format
typedef enum { // (sz)
C3D_EPF_RGB1555 = 3, // 1b Alpha, 5b Red, 5b Green, 5b Blue (16)
C3D_EPF_RGB565 = 4, // 0b Alpha, 5b Red, 6b Green, 5b Blue (16)
C3D_EPF_RGB8888 = 6, // 8b Alpha, 8b Red, 8b Green, 8b Blue (32)
C3D_EPF_RGB332 = 7, // 0b Alpha, 3b Red, 3b Green, 2b Blue (08)
C3D_EPF_Y8 = 8, // 8b Y (08)
C3D_EPF_YUV422 = 11, // YUV 422 Packed (YUYV) MS FOURCC_UYVY(16)
C3D_EPF_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EPIXFMT, * C3D_PEPIXFMT;
// specifies the texel format
typedef enum { // (sz)
C3D_ETF_CI4 = 1, // 4BPP Pseudocolor (not supported for SCALING)
C3D_ETF_CI8 = 2, // 8BPP Pseudocolor
C3D_ETF_RGB1555 = 3, // 1b Alpha, 5b Red, 5b Green, 5b Blue (16)
C3D_ETF_RGB565 = 4, // 0b Alpha, 5b Red, 6b Green, 5b Blue (16)
C3D_ETF_RGB8888 = 6, // 8b Alpha, 8b Red, 8b Green, 8b Blue (32)
C3D_ETF_RGB332 = 7, // 0b Alpha, 3b Red, 3b Green, 2b Blue (08)
C3D_ETF_Y8 = 8, // 8b Y (08)
C3D_ETF_YUV422 = 11, // YUV 422 Packed (YUYV) MS FOURCC_UYVY(16)
C3D_ETF_RGB4444 = 15, // 4b Alpha, 4b Red, 4b Green, 4b Blue (16)
C3D_ETF_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ETEXFMT, * C3D_PETEXFMT;
// the TMAP structure specifies how the hardware should interpret a texture
// stored in the frambuffer.
//
// apv32Offsets is an array of host pointers to the individual maps which
// compose a texture. Where if (bMipMap==TRUE) apv32Offsets contains one or
// more elements the first (index 0) points at the base map and subsequent
// elements point at the sequentially smaller maps. For the case of
// bMipMap == FALSE the array contains one valid element(the first)
// and the rest are ignored. When bMipMap == TRUE the array contains 2n+1
// pointers to mip levels, where
// n = max( log_base_2( width_of_base_map ), log_base_2( height_of_base_map ) )
//
// eg: for a mip map with a 256x128 eg: for a mip map with a 512x512
// base map the elements of apvLevels[] base map the elements of apvLevels[]
// points at the following mip levels point at the following mip levels
// Total of NINE mip levels Total of TEN mip levels
// apvLevels[0] = 256x128; apvLevels[0] = 512x512;
// apvLevels[1] = 128x64; apvLevels[1] = 256x256;
// apvLevels[2] = 64x32; apvLevels[2] = 128x128;
// apvLevels[3] = 32x16; apvLevels[3] = 64x64;
// apvLevels[4] = 16x8; apvLevels[4] = 32x32;
// apvLevels[5] = 8x4; apvLevels[5] = 16x16;
// apvLevels[6] = 4x2; apvLevels[6] = 8x8;
// apvLevels[7] = 2x1; apvLevels[7] = 4x4;
// apvLevels[8] = 1x1; apvLevels[8] = 2x2;
// apvLevels[9] = 1x1;
#define cu32MAX_TMAP_LEV 11
typedef struct {
C3D_UINT32 u32Size; // size of structure
C3D_BOOL bMipMap; // is texture a mip map
C3D_PVOID apvLevels[cu32MAX_TMAP_LEV];// array of pointer to map level
C3D_UINT32 u32MaxMapXSizeLg2; // log 2 X size of largest map
C3D_UINT32 u32MaxMapYSizeLg2; // log 2 Y size of largest map
C3D_ETEXFMT eTexFormat; // texel format
C3D_COLOR clrTexChromaKey; // specify texel transp. clr
C3D_HTXPAL htxpalTexPalette; // pointer to texture palette
} C3D_TMAP, * C3D_PTMAP;
// Z Testing mode:
//
typedef enum {
C3D_EZMODE_OFF = 0, // ignore z
C3D_EZMODE_TESTON = 1, // test z, but do not update the z buffer
C3D_EZMODE_TESTON_WRITEZ= 2, // test z and update the z buffer
C3D_EZMODE_MAX = 3,
C3D_EZMODE_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EZMODE, * C3D_PEZMODE;
// Z Comparison Function:
//
typedef enum {
C3D_EZCMP_NEVER = 0, // Z compare never passes
C3D_EZCMP_LESS = 1,
C3D_EZCMP_LEQUAL = 2,
C3D_EZCMP_EQUAL = 3,
C3D_EZCMP_GEQUAL = 4,
C3D_EZCMP_GREATER = 5,
C3D_EZCMP_NOTEQUAL = 6,
C3D_EZCMP_ALWAYS = 7, // Z compare always passes
C3D_EZCMP_MAX = 8,
C3D_EZCMP_FORCE_U32 = C3D_FORCE_SIZE
} C3D_EZCMP, * C3D_PEZCMP;
//
// Rendering Context
typedef void* C3D_HRC;
typedef void* C3D_PRSDATA;
// Rendering context field enumerations
// // DATA TYPE DEFAULT VALUE
typedef enum {
C3D_ERS_FG_CLR = 0, // C3D_COLOR {0,0,0,0}
C3D_ERS_VERTEX_TYPE = 1, // C3D_EVERTEX C3D_EV_VTCF
C3D_ERS_PRIM_TYPE = 2, // C3D_EPRIM C3D_EPRIM_TRI
C3D_ERS_SOLID_CLR = 3, // C3D_COLOR {0,0,0,0}
C3D_ERS_SHADE_MODE = 4, // C3D_ESHADE C3D_ESH_SMOOTH
C3D_ERS_TMAP_EN = 5, // C3D_BOOL FALSE
C3D_ERS_TMAP_SELECT = 6, // C3D_HTX NULL
C3D_ERS_TMAP_LIGHT = 7, // C3D_ETLIGHT C3D_ETL_NONE
C3D_ERS_TMAP_PERSP_COR = 8, // C3D_ETPERSPCOR C3D_ETPC_THREE
C3D_ERS_TMAP_FILTER = 9, // C3D_ETEXFILTER C3D_ETFILT_MINPNT_MAG2BY2
C3D_ERS_TMAP_TEXOP = 10, // C3D_ETEXOP C3D_ETEXOP_NONE
C3D_ERS_ALPHA_SRC = 11, // C3D_EASRC C3D_EASRC_ONE
C3D_ERS_ALPHA_DST = 12, // C3D_EADST C3D_EADST_ZERO
C3D_ERS_SURF_DRAW_PTR = 13, // C3D_PVOID Desktop Surface
C3D_ERS_SURF_DRAW_PITCH = 14, // C3D_UINT32 Desktop Surface
C3D_ERS_SURF_DRAW_PF = 15, // C3D_EPIXFMT Desktop Surface
C3D_ERS_SURF_VPORT = 16, // C3D_RECT Desktop Surface
C3D_ERS_FOG_EN = 17, // C3D_BOOL FALSE
C3D_ERS_DITHER_EN = 18, // C3D_BOOL TRUE
C3D_ERS_Z_CMP_FNC = 19, // C3D_EZCMP C3D_EZCMP_ALWAYS
C3D_ERS_Z_MODE = 20, // C3D_EZMODE C3D_EZMODE_OFF
C3D_ERS_SURF_Z_PTR = 21, // C3D_PVOID NULL
C3D_ERS_SURF_Z_PITCH = 22, // C3D_UINT32 Desktop Surface
C3D_ERS_SURF_SCISSOR = 23, // C3D_RECT Desktop clipping
C3D_ERS_NUM = 24, // invalid enumeration
C3D_ERS_FORCE_U32 = C3D_FORCE_SIZE
} C3D_ERSID, * C3D_PERSID;
//
// Inlines
//
#define SET_CIF_COLOR(exp, red, grn, blu, alp) \
(exp).r = (C3D_UINT8)(red); \
(exp).g = (C3D_UINT8)(grn); \
(exp).b = (C3D_UINT8)(blu); \
(exp).a = (C3D_UINT8)(alp);
//
// CIF3D Module Functions
//
#if defined (BUILD_AS_DLL)
//export both the function as is and a function pointer
//This allows a GetProcAddress() to work without name mangling
#define PROTOTYPE(function_name, return_type, parameters) \
return_type DLLEXPORT WINAPI function_name parameters; \
typedef return_type (WINAPI *function_name##_t) parameters; \
extern DLLEXPORT function_name##_t function_name##_lib
#else
#define PROTOTYPE(function_name, return_type, parameters) \
typedef return_type (WINAPI *function_name##_t) parameters; \
return_type DLLEXPORT WINAPI function_name parameters;
#endif
#if defined (DOS_BUILD) || defined (NT_BUILD)
// only needed for DOS but does nobody any harm
PROTOTYPE (ATI3DCIF_DosInit, C3D_EC, ( PVOID pPHXINFO ));
#else
// initializes the ATI3DCIF driver module
//
PROTOTYPE (ATI3DCIF_Init, C3D_EC, (void));
#endif
// terminates the ATI3DCIF driver module
//
PROTOTYPE (ATI3DCIF_Term, C3D_EC, (void));
// returns information about the 3DCIF module
//
PROTOTYPE (ATI3DCIF_GetInfo, C3D_EC, (PC3D_3DCIFINFO p3DCIFInfo));
//
// Texture Management Functions
//
// registers a texture with the CIF module.
//
// ptmapToReg is a client specified info on texture to be reg'ed
// phtmap is the returned handle to the registered texture
PROTOTYPE (ATI3DCIF_TextureReg, C3D_EC, (C3D_PTMAP ptmapToReg,C3D_PHTX phtmap));
// Unregisters a texture with the CIF module.
//
PROTOTYPE (ATI3DCIF_TextureUnreg, C3D_EC, (C3D_HTX htxToUnreg));
// Create a texture palette
//
// epalette ==> kind of palette
// pclrPalette ==> 16 or 256 entries (colors and flags)
// phtpalCreated ==> place to return handle to created palette
PROTOTYPE (ATI3DCIF_TexturePaletteCreate, C3D_EC, (C3D_ECI_TMAP_TYPE epalette,C3D_PPALETTENTRY pclrPalette, C3D_PHTXPAL phtpalCreated));
// Destroy a texture palette
//
PROTOTYPE (ATI3DCIF_TexturePaletteDestroy, C3D_EC, (C3D_HTXPAL htxpalToDestroy));
// Animate a texture palette. Low overhead function to update palette entries
//
PROTOTYPE (ATI3DCIF_TexturePaletteAnimate, C3D_EC, (C3D_HTXPAL htxpalToAnimate,C3D_UINT32 u32StartIndex,C3D_UINT32 u32NumEntries,C3D_PPALETTENTRY pclrPalette));
// Loads an object into the framebuffer using the bus-master DMA hardware.
// Available only if C3D_CAPS_LOAD_OBJECT bit is set in the u32CIFCaps field
// of the C3D_3DCIFINFO struct.
//
// pvObjSrc ==> pointer to object in system mem
// pvObjDst ==> pointer to dst in framebuffer
// u32Size ==> size of object to load in bytes
PROTOTYPE (ATI3DCIF_LoadObject, C3D_EC, (C3D_PVOID pvObjSrc,C3D_PVOID pvObjDst,C3D_UINT32 u32Size ));
//
// Context Functions
//
// Creates a ATI3DCIF rendering context initialized to the default state
// specified above
PROTOTYPE (ATI3DCIF_ContextCreate, C3D_HRC, (void));
// Destroys a ATI3DCIF rendering context.
//
PROTOTYPE (ATI3DCIF_ContextDestroy, C3D_EC, (C3D_HRC hRC));
// Set State in a ATI3DCIF rendering context
//
// hRC ==> handle to a created rendering context
// eRStateID ==> id of state to set
// pRStateData ==> data to set
#ifdef GAME_DEBUG
PROTOTYPE (ATI3DCIF_DoContextSetState, C3D_EC, (C3D_HRC hRC, C3D_ERSID eRStateID, C3D_PRSDATA pRStateData));
#else
PROTOTYPE (ATI3DCIF_ContextSetState, C3D_EC, (C3D_HRC hRC, C3D_ERSID eRStateID, C3D_PRSDATA pRStateData));
#endif
//
// Rendering Functions
//
// Prepares hardware to draw using the context referred to by the specified
// handle. RenderBegin must be called prior to any other Render* functions.
// RenderBegin will(may?) fail if the Primary Surface has been locked through
// DirectDraw.(?) Typically called prior to rendering each frame
//
PROTOTYPE (ATI3DCIF_RenderBegin, C3D_EC, (C3D_HRC hRC));
// Ends 3D hardware drawing operations. Frees up the graphics hardware for 2D
// operations.
// Typically called after rendering each frame
//
PROTOTYPE (ATI3DCIF_RenderEnd, C3D_EC, (void));
// Switches to a new rendering context. ATI3DCIF_RenderSwitch(hrc) is a
// lighter weight, functional equivalent to the the combination of
// ATI3DCIF_RenderEnd() followed by ATI3DCIF_RenderBegin(hrc)
// Only valid while in the 3D rendering state.
//
PROTOTYPE (ATI3DCIF_RenderSwitch, C3D_EC, (C3D_HRC hRC));
// RenderPrimStrip in the rendering context specified with the render begin call
// Only valid while in the 3D rendering state.
//
#ifdef GAME_DEBUG
PROTOTYPE (ATI3DCIF_DoRenderPrimStrip, C3D_EC, (C3D_VSTRIP vStrip, C3D_UINT32 u32NumVert));
#else
PROTOTYPE (ATI3DCIF_RenderPrimStrip, C3D_EC, (C3D_VSTRIP vStrip, C3D_UINT32 u32NumVert));
#endif
// RenderPrimList in the rendering context specified with the render begin call
// Only valid while in the 3D rendering state.
//
#ifdef GAME_DEBUG
PROTOTYPE (ATI3DCIF_DoRenderPrimList, C3D_EC, (C3D_VLIST vList, C3D_UINT32 u32NumVert));
#else
PROTOTYPE (ATI3DCIF_RenderPrimList, C3D_EC, (C3D_VLIST vList, C3D_UINT32 u32NumVert));
#endif
#ifndef DOS_BUILD
#pragma pack(pop) // restore packing state
#endif
#ifdef __cplusplus
}
#endif
#ifdef RCS_H_KEYS
static char *rcsid_h_ati3dcif_ati = "$Revision: 2.28 $" __FILE__;
#endif
#endif // ATI_ATI3DCIF_H
//
// $Author: xwu $
// $Revision: 2.28 $
// $Date: 05 Dec 1996 14:18:30 $
// $Modtime: 05 Dec 1996 14:05:56 $
// $Log: //finch/dvl/common/_vcs/ati3dcif.h_v $
//
// Rev 2.28 05 Dec 1996 14:18:30 xwu
// Add in GAME_DEBUG for GAME_DEBUG build
//
// Rev 2.27 Aug 28 1996 17:08:36 cjiang
// Restore the development tree since the changes made between
// Aug. 15 and Aug 23 are lost on the server but exist on
// my machine.
//
// Rev 2.26 Aug 21 1996 15:50:48 mmintz
// Chenged header to export functions
//
// Rev 2.25 Aug 15 1996 11:31:22 philr
// Changed PROTOTYPE definitions under mmintz direction.
//
// Rev 2.24 Aug 01 1996 16:59:40 mmintz
//
// Rev 2.23 Jul 26 1996 14:05:30 mmintz
// new static library
//
// Rev 2.22 Jul 23 1996 15:33:06 mmintz
//
// Rev 2.21 Jul 16 1996 11:42:04 mmintz
// changed enum force value
//
// Rev 2.20 Jul 16 1996 09:34:28 mmintz
// OPEN GL changes and added Memory control register
//
// Rev 2.19 Jun 27 1996 10:15:06 mmintz
// interface for scissors and stipple
//
// Rev 2.18 Jun 21 1996 16:39:44 mmintz
// ci4 work
//
// Rev 2.17 Jun 05 1996 13:26:52 mmintz
// added new error - chip capability to indicate that the chip cannot
// perform some functino (like Z buffering) even though the
// driver is aware of the feature.
//
// Rev 2.16 Jun 03 1996 08:39:10 mmintz
// z buffer
//
// Rev 2.15 May 15 1996 18:09:00 tomp
// Added new interface for palettized textures, Z buffer and Dither Control
//
// Rev 2.14 May 01 1996 16:37:12 philr
// changed UINT32 to C3D_UINT32
//
// Rev 2.13 Apr 26 1996 02:16:00 tomp
// fixed typo in C3D_ERSID enumeration
//
// Rev 2.12 Apr 26 1996 02:02:56 tomp
// Added 4 new states to enable fogging
// C3D_ERS_FG_CLR
// C3D_ERS_FOG_EN
// C3D_ERS_Z_CMP_FNC
// C3D_ERS_Z_MODE
// Modified ATI3DCIF.H interface header to support the followin
// new features when they are available in hardware:
// -Palettized Textures
// -Z Testing
// -Object Loading
// Added better documentation for TMap structure; examples on how to set
// up for mip maps.
//
// Rev 2.11 Mar 19 1996 21:21:26 philr
// Attempted to remove null chars at end which disturb Watcom
//
// Rev 2.10 Mar 04 1996 02:06:12 tomp
// Merged DOS ATI3DCIF code
//
// Rev 2.9 Mar 03 1996 15:55:28 tomp
// Added push and pop pragma to preserve the structure packing state
//
// Rev 2.8 Mar 02 1996 22:31:04 tomp
// Added structure packing pragma
//
// Rev 2.7 Feb 29 1996 11:46:58 tomp
// Added Texel Op modes to the 3D CIF. "Texel Op" is the name I'm using refer
// to the group of operations (other than filtering) the GT can apply to
// texels as they are read from a texture, such as:
// 1. Texel Chroma Key
// 2. Texel Alpha Mask
// 3. Texel Alpha Blending
// Added support for all filtering modes, but tri-linear
// Fixed a couple bugs found in the d6 release of 3D CIF
//
// Rev 2.6 Feb 15 1996 00:23:22 tomp
// D6 release
//
// Optimized
// Alpha Blender is turned off for the nop combinations of SRC and DST funct
// Alpha interpolators are not setup when neither the SRC nor the DST funct
// depend on source alpha
//
// Fixed
// texture chorma keying bug
//
// Added new Pixel and Texel Formats
//
// Rev 2.5 Jan 29 1996 18:00:38 tomp
// Added to list of restrictions based on testing done prior to beta II release
//
// Rev 2.4 Jan 08 1996 23:57:42 tomp
// Converted to the beta 3DCIF interface
//
// Rev 2.3 Dec 29 1995 16:19:38 tomp
// Cleaned up and added more comments
//
// Rev 2.2 Dec 22 1995 03:49:56 tomp
// Updated interface. Removed dependencies on external types and on Direct
// Draw. Replaced implicit Lock/explicit Unlock with Begin/End Render calls
// Added support for filtering mode selection.
//
// Rev 2.1 Dec 20 1995 17:47:54 tomp
// Inital Revision
Reference in a new issue View git blame Copy permalink