You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
725 lines
23 KiB
725 lines
23 KiB
/* $Id: driver.h,v 1.71 1995/12/04 11:31:51 sjl Exp $
|
|
*
|
|
* Copyright (c) RenderMorphics Ltd. 1993, 1994
|
|
* Version 1.1
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* This file contains private, unpublished information and may not be
|
|
* copied in part or in whole without express permission of
|
|
* RenderMorphics Ltd.
|
|
*
|
|
*/
|
|
|
|
#ifndef __DRIVER_H__
|
|
#define __DRIVER_H__
|
|
|
|
#define USE_FLOAT
|
|
|
|
#ifdef WIN32
|
|
//#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
#include <stddef.h>
|
|
#include <wtypes.h>
|
|
|
|
typedef struct _RLDDIDriver RLDDIDriver;
|
|
typedef struct _RLDDIDriverStack RLDDIDriverStack;
|
|
|
|
#ifdef USE_FLOAT
|
|
#include "fltval.h"
|
|
#else
|
|
#include "fixval.h"
|
|
#endif
|
|
#include "osdep.h"
|
|
|
|
#ifdef D3D
|
|
typedef enum _RLRenderQuality {
|
|
RLRenderWireframe, /* display just the edges */
|
|
RLRenderUnlitFlat, /* flat shaded without lighting */
|
|
RLRenderFlat, /* flat shaded */
|
|
RLRenderGouraud, /* gouraud shaded */
|
|
RLRenderPhong /* phong shaded */
|
|
} RLRenderQuality;
|
|
|
|
typedef enum _RLColorModel {
|
|
RLColorRamp, RLColorRGB
|
|
} RLColorModel;
|
|
|
|
typedef enum _RLLightType {
|
|
RLLightAmbient,
|
|
RLLightPoint,
|
|
RLLightSpot,
|
|
RLLightDirectional,
|
|
RLLightParallelPoint
|
|
} RLLightType;
|
|
|
|
#if 0
|
|
/*
|
|
* Error codes
|
|
*/
|
|
typedef enum _RLError {
|
|
RLNoError = 0, /* no error */
|
|
RLBadObject, /* object expected in argument */
|
|
RLBadType, /* bad argument type passed */
|
|
RLBadAlloc, /* out of memory */
|
|
RLFaceUsed, /* face already used in a mesh */
|
|
RLNotFound, /* object not found in specified place */
|
|
RLNotDoneYet, /* unimplemented */
|
|
RLFileNotFound, /* file cannot be opened */
|
|
RLBadFile, /* data file is corrupt */
|
|
RLBadDevice, /* device is not compatible with renderer */
|
|
RLBadValue, /* bad argument value */
|
|
RLBadMajorVersion, /* bad dll major version */
|
|
RLBadMinorVersion, /* bad dll minor version */
|
|
RLMaxError
|
|
} RLErrorXXX;
|
|
#endif
|
|
|
|
#else
|
|
#include "rl.h"
|
|
#endif D3D
|
|
|
|
/*
|
|
* Normal precision used to store numbers.
|
|
*/
|
|
#define NORMAL_PREC 16
|
|
#define DTOVAL(d) DTOVALP(d,NORMAL_PREC)
|
|
#define VALTOD(f) VALPTOD(f,NORMAL_PREC)
|
|
#define ITOVAL(i) ITOVALP(i,NORMAL_PREC)
|
|
#define VALTOI(f) VALPTOI(f,NORMAL_PREC)
|
|
#define VALROUND(f) VALPROUND(f,NORMAL_PREC)
|
|
#define VALTOFX(f) VALTOFXP(f,NORMAL_PREC)
|
|
#define FXTOVAL(f) FXPTOVAL(f,NORMAL_PREC)
|
|
#define ITOFX(i) ITOFXP(i,NORMAL_PREC)
|
|
#define FXTOI(f) FXPTOI(f,NORMAL_PREC)
|
|
#define FXROUND(f) FXPROUND(f,NORMAL_PREC)
|
|
#define FXFLOOR(f) FXPTOI(f,NORMAL_PREC)
|
|
#define FXCEIL(f) FXPCEIL(f,NORMAL_PREC)
|
|
#define VALTOFX24(f) VALTOFXP(f,24)
|
|
#define FX24TOVAL(f) FXPTOVAL(f,24)
|
|
#define VALTOFX20(f) VALTOFXP(f,20)
|
|
#define FX20TOVAL(f) FXPTOVAL(f,20)
|
|
#define VALTOFX12(f) VALTOFXP(f,12)
|
|
#define FX12TOVAL(f) FXPTOVAL(f,12)
|
|
#define VALTOFX8(f) VALTOFXP(f,8)
|
|
#define FX8TOVAL(f) FXPTOVAL(f,8)
|
|
|
|
/*
|
|
* A handy macro.
|
|
*/
|
|
#define RLDDIAbs(N) (((N) < 0) ? -(N) : (N))
|
|
|
|
#if defined(__DOS__) || defined(__WINDOWS_386__)
|
|
#define RLFAR far
|
|
#else
|
|
#define RLFAR
|
|
#endif
|
|
|
|
#ifndef UNUSED
|
|
#if defined(__WATCOMC__)
|
|
#define UNUSED(v) (v)
|
|
#else
|
|
#define UNUSED(v)
|
|
#endif
|
|
#endif
|
|
|
|
typedef enum _RLDDIServiceType {
|
|
/*
|
|
* Notify a module after it has been pushed into a stack.
|
|
*
|
|
* The module may also register fast service functions;
|
|
* to register a fast service, set the appropriate table entry.
|
|
* Note: the module must either register *no* services (old style),
|
|
* or *all* the services it supports (including RLDDIPush)
|
|
*/
|
|
/* HRESULT */ RLDDIPush, /* 0, RLDDIServiceProc[] */
|
|
|
|
/*
|
|
* Get a set of functions to create transform, render and lighting
|
|
* drivers compatible with the given windowing system driver and color
|
|
* model.
|
|
*/
|
|
/* HRESULT */ RLDDIGetCreateDriverFunctions,/* RLColorModel, &result */
|
|
|
|
/*
|
|
* Notify a module before it is popped from a stack.
|
|
*/
|
|
/* HRESULT */ RLDDIPop, /* NULL, NULL */
|
|
|
|
/*
|
|
* Set various rendering parameters.
|
|
*/
|
|
/* HRESULT */ RLDDISetRenderParams, /* 0, RLDDIRenderParams* */
|
|
|
|
/*
|
|
* Set the current viewport.
|
|
*/
|
|
/* HRESULT */ RLDDISetViewport, /* id, D3DVIEWPORT2* */
|
|
|
|
/*
|
|
* Deal with matrices
|
|
*/
|
|
/* HRESULT */ RLDDICreateMatrix, /* 0, LPD3DMATRIXHANDLE */
|
|
/* HRESULT */ RLDDISetMatrix, /* D3DMATRIXHANDLE, LPD3DMATRIX */
|
|
/* HRESULT */ RLDDIGetMatrix, /* D3DMATRIXHANDLE, LPD3DMATRIX */
|
|
/* HRESULT */ RLDDIDeleteMatrix, /* D3DMATRIXHANDLE, NULL */
|
|
/*
|
|
* Set one of the transformation matrices
|
|
*/
|
|
/* HRESULT */ RLDDISetMatrixView, /* type, D3DMATRIXHANDLE */
|
|
/* HRESULT */ RLDDISetMatrixProj, /* type, D3DMATRIXHANDLE */
|
|
/* HRESULT */ RLDDISetMatrixWorld, /* type, D3DMATRIXHANDLE */
|
|
#if 0
|
|
/* HRESULT */ RLDDISetMatrixTrans, /* type, D3DMATRIXHANDLE */
|
|
#endif
|
|
|
|
/* HRESULT */ RLDDIMultiplyMatrices, /* count, RLDDIMatrix** */
|
|
|
|
/*
|
|
* Transform some vertices.
|
|
*/
|
|
/* ClipFlags */ RLDDITransform, /* count, RLDDITransformData* */
|
|
/* ClipFlags */ RLDDITransformClipped, /* count, RLDDITransformData* */
|
|
/* ClipFlags */ RLDDITransformUnclipped, /* count, RLDDITransformData* */
|
|
|
|
/*
|
|
* Set the current lighting configuration. All normals are given
|
|
* in the current model coordinate system.
|
|
*/
|
|
/* HRESULT */ RLDDISetLight, /* which_light, D3DI_LIGHTDATA* */
|
|
|
|
/*
|
|
* Set the current fog configuration.
|
|
*/
|
|
/* HRESULT */ RLDDISetFogMode, /* 0, D3DFOGMODE* */
|
|
/* HRESULT */ RLDDISetFogStart, /* 0, RLDDIValue* */
|
|
/* HRESULT */ RLDDISetFogEnd, /* 0, RLDDIValue* */
|
|
/* HRESULT */ RLDDISetFogDensity, /* 0, RLDDIValue* */
|
|
|
|
/* HRESULT */ RLDDISetFogEnable, /* 0, D3DFOGMODE* */
|
|
/* HRESULT */ RLDDISetFogColor, /* 0, D3DFOGMODE* */
|
|
|
|
/*
|
|
* Calculate pixel values for some primitives with lighting.
|
|
*/
|
|
/* HRESULT */ RLDDIApplyMaterialsLit, /* count, D3DLIGHTDATA* */
|
|
|
|
/*
|
|
* Calculate pixel values for some primitives without lighting.
|
|
*/
|
|
/* HRESULT */ RLDDIApplyMaterialsUnlit, /* count, D3DLIGHTDATA* */
|
|
|
|
/*
|
|
* Calculate vertex values for some primitives without lighting.
|
|
*/
|
|
/* HRESULT */ RLDDIApplyMaterialShade, /* count, D3DLIGHTDATA* */
|
|
|
|
/*
|
|
* Called to update dynamic color allocation state for materials
|
|
* which are still being used but not lit. Returns TRUE if the
|
|
* results of the previous lighting calls can be reused or FALSE
|
|
* if the object should be relit anyway due to color entries being
|
|
* reclaimed.
|
|
*/
|
|
/* Boolean */ RLDDIUpdateMaterial,
|
|
|
|
/*
|
|
* Clear a drivers pick records
|
|
*/
|
|
/* HRESULT */ RLDDIClearPickRecords, /* 0, NULL */
|
|
|
|
/* HRESULT */ RLDDIGetPickRecords, /* 0, NULL */
|
|
/*
|
|
* pick a display list.
|
|
*/
|
|
/* HRESULT */ RLDDIPickExecuteBuffer, /* stak top, RLDDIPickData* */
|
|
|
|
/*
|
|
* Execute a display list.
|
|
*/
|
|
/* HRESULT */ RLDDIExecuteUnclipped, /* stak top, RLDDIExecuteData* */
|
|
/* HRESULT */ RLDDIExecuteClipped, /* stak top, RLDDIExecuteData* */
|
|
|
|
/*
|
|
* Get the current pixmaps used for drawing (used by software
|
|
* renderers to interface with low level drivers).
|
|
*/
|
|
/* HRESULT */ RLDDIGetColorPixmap, /* NULL, &pixmap */
|
|
/* HRESULT */ RLDDIGetDepthPixmap, /* NULL, &pixmap */
|
|
|
|
/*
|
|
* Release the current pixmaps used for drawing (used by software
|
|
* renderers to interface with low level drivers).
|
|
*/
|
|
/* HRESULT */ RLDDIReleaseColorPixmap, /* NULL NULL */
|
|
/* HRESULT */ RLDDIReleaseDepthPixmap, /* NULL NULL */
|
|
|
|
/*
|
|
* Find a color allocator to use for mapping rgb values to pixels.
|
|
*/
|
|
/* HRESULT */ RLDDIFindColorAllocator, /* NULL, &alloc */
|
|
|
|
/*
|
|
* Find a rampmap to use for color allocation in color index
|
|
* drivers. This does not need to be supported if color index
|
|
* rendering is not used.
|
|
*/
|
|
/* HRESULT */ RLDDIFindRampmap, /* NULL, &rampmap */
|
|
|
|
/*
|
|
* Release a rampmap (from RLDDIFindRampmap), freeing all
|
|
* resources.
|
|
*/
|
|
/* HRESULT */ RLDDIReleaseRampmap, /* NULL, rampmap */
|
|
|
|
/*
|
|
* Get the color index -> pixel value mapping (if any).
|
|
*/
|
|
/* HRESULT */ RLDDIGetColorMapping, /* NULL, &unsigned_long_ptr */
|
|
|
|
/*
|
|
* Convert a texture handle into a pointer (private to ramp driver)
|
|
*/
|
|
/* HRESULT */ RLDDILookupTexture, /* NULL, handle */
|
|
|
|
/*
|
|
* Update the screen with a region which has changed. May involve
|
|
* copying into the window, swapping double buffers, etc.
|
|
*/
|
|
/* HRESULT */ RLDDIUpdate, /* count, D3DRECTANGLE* */
|
|
|
|
/*
|
|
* Lock against vsync, if necessary, for a given driver.
|
|
*/
|
|
/* HRESULT */ RLDDISync,
|
|
|
|
/*
|
|
* Clear the viewport.
|
|
*/
|
|
/* HRESULT */ RLDDIClear, /* */
|
|
|
|
/*
|
|
* Clear the zbuffer.
|
|
*/
|
|
/* HRESULT */ RLDDIClearZ, /* */
|
|
|
|
/*
|
|
* Clear the both the z and viewport.
|
|
*/
|
|
/* HRESULT */ RLDDIClearBoth, /* */
|
|
|
|
/*
|
|
* Get the dimensions of the device.
|
|
*/
|
|
/* HRESULT */ RLDDIGetDriverParams, /* 0, RLDDIDriverParams* */
|
|
|
|
/*
|
|
* Set a material to be used to clear the viewport in RLDDIClear.
|
|
*/
|
|
/* HRESULT */ RLDDISetBackgroundMaterial, /* 0, D3DMATERIALHANDLE */
|
|
|
|
/*
|
|
* Set an image to be used to clear the viewport depth planes
|
|
* in RLDDIClear.
|
|
*/
|
|
/* HRESULT */ RLDDISetBackgroundDepth, /* 0, RLImage* */
|
|
|
|
/*
|
|
* Ask the driver whether it can support the given RLImage as a
|
|
* texture map. If the image can be supported directly, the
|
|
* driver should return RLNoError. If another image format is
|
|
* preferred, the driver should modify the pointer to point to an
|
|
* RLImage structure of the required format and return RLNoError. Note
|
|
* that this need not be a complete image. The buffer1 and
|
|
* palette fields are ignored.
|
|
*
|
|
* If the driver does not support texture mapping at all, then it
|
|
* should return RLBadDevice.
|
|
*
|
|
* If arg1 is not null, the driver will point at an array of DDSURFACEDESC
|
|
* structures and return the size of the array.
|
|
*/
|
|
/* HRESULT | int */ RLDDIQueryTextureFormat, /* LPDDSURFACEDESC*, RLImage** */
|
|
|
|
/* HRESULT */ RLDDIActivatePalette, /* WM_ACTIVATE */
|
|
|
|
/*
|
|
* Set the current material for the lighting module.
|
|
*/
|
|
/* HRESULT */ RLDDISetMaterial, /* 0, D3DMATERIALHANDLE */
|
|
|
|
/*
|
|
* Set the color of the ambient light. The format is:
|
|
* (white << 24) | (red << 16) | (green << 8) | blue
|
|
* where white is the equivalent white shade for monochrome lighting.
|
|
*/
|
|
/* HRESULT */ RLDDISetAmbientLight, /* color, NULL */
|
|
|
|
/*
|
|
* Create a texture from the given image. The image must be in a format
|
|
* approved by RLDDIQueryTextureFormat. The texture may use the memory
|
|
* of the image for the pixel values or it may copy the image. Returns
|
|
* a handle for the texture.
|
|
*/
|
|
/* HRESULT */ RLDDICreateTexture, /* LPDIRECTDRAWSURFACE, &D3DTEXTUREHANDLE */
|
|
|
|
/*
|
|
* Destroy a texture previously created using RLDDICreateTexture.
|
|
*/
|
|
/* HRESULT */ RLDDIDestroyTexture, /* D3DTEXTUREHANDLE, 0 */
|
|
|
|
/*
|
|
* Load a texture previously created using RLDDICreateTexture.
|
|
* arg1 - src, arg2 = dst
|
|
*/
|
|
/* HRESULT */ RLDDILoadTexture, /* D3DTEXTUREHANDLE, D3DTEXTUREHANDLE*/
|
|
|
|
/*
|
|
* Lock a texture previously created using RLDDICreateTexture.
|
|
*/
|
|
/* HRESULT */ RLDDILockTexture, /* D3DTEXTUREHANDLE, 0 */
|
|
|
|
/*
|
|
* Unlock a texture previously created using RLDDICreateTexture.
|
|
*/
|
|
/* HRESULT */ RLDDIUnlockTexture, /* D3DTEXTUREHANDLE, 0 */
|
|
|
|
/*
|
|
* Swap two textures.
|
|
*/
|
|
/* HRESULT */ RLDDISwapTextureHandles, /* D3DTEXTUREHANDLE, D3DTEXTUREHANDLE */
|
|
|
|
/*
|
|
* Update any private copies of the pixels in a texture when it has been
|
|
* changed by the application. The flags argument is a bitfield:
|
|
*
|
|
* flags & 1 the image pixels have changed
|
|
* flags & 2 the image palette has changed
|
|
*/
|
|
/* HRESULT */ RLDDIUpdateTexture, /* flags, handle */
|
|
|
|
/*
|
|
*
|
|
*/
|
|
/* HRESULT */ RLDDISetTextureOpacity, /* 0, RLDDISetTextureOpacityParams */
|
|
|
|
/*
|
|
* Used in ramp color module for interfacing between renderer and
|
|
* lighting.
|
|
*/
|
|
/* HRESULT */ RLDDILookupMaterial,
|
|
|
|
/*
|
|
* Create a material
|
|
*/
|
|
/* HRESULT */ RLDDICreateMaterial, /* D3DMATERIALHANDLE*, D3DMATERIAL* */
|
|
|
|
/*
|
|
* Destroy a material
|
|
*/
|
|
/* HRESULT */ RLDDIDestroyMaterial, /* D3DMATERIALHANDLE, NULL */
|
|
|
|
/*
|
|
* Used by renderer to map material handles to materials.
|
|
*/
|
|
/* HRESULT */ RLDDIFindMaterial, /* D3DMATERIALHANDLE, LPD3DMATERIAL* */
|
|
|
|
/*
|
|
* Used by Direct3D to inform the driver that a material has changed.
|
|
*/
|
|
/* HRESULT */ RLDDIMaterialChanged, /* D3DMATERIALHANDLE, LPD3DMATERIAL */
|
|
|
|
/*
|
|
* Used by Direct3D to reserve a material
|
|
*/
|
|
/* HRESULT */ RLDDIMaterialReserve, /* D3DMATERIALHANDLE, NULL */
|
|
|
|
/*
|
|
* Used by Direct3D to unreserve a material
|
|
*/
|
|
/* HRESULT */ RLDDIMaterialUnreserve,/* D3DMATERIALHANDLE, NULL */
|
|
|
|
/*
|
|
* Used with frame materials to override the settings of a
|
|
* display list.
|
|
*/
|
|
/* HRESULT */ RLDDISetOverrideFillParams, /* 0, &override_params */
|
|
|
|
/*
|
|
* Used with frame materials to override the settings of a
|
|
* display list.
|
|
*/
|
|
/* HRESULT */ RLDDISetOverrideMaterial, /* 0, override_material */
|
|
|
|
/*
|
|
* Create an Execute Buffer
|
|
*/
|
|
/* HRESULT */ RLDDIAllocateBuffer, /* LPD3DI_BUFFERHANDLE, LPD3DEXECUTEBUFFERDESC */
|
|
|
|
/*
|
|
* Destroy an Execute Buffer
|
|
*/
|
|
/* HRESULT */ RLDDIDeallocateBuffer, /* D3DI_BUFFERHANDLE, (LPVOID)0 */
|
|
|
|
/*
|
|
* Lock an Execute Buffer
|
|
*/
|
|
/* HRESULT */ RLDDILockBuffer, /* D3DI_BUFFERHANDLE, (LPVOID)0 */
|
|
|
|
/*
|
|
* Unlock an Execute Buffer
|
|
*/
|
|
/* HRESULT */ RLDDIUnlockBuffer, /* D3DI_BUFFERHANDLE, (LPVOID)0 */
|
|
|
|
/*
|
|
* Set all 256 palette entries in an 8 bit device.
|
|
*/
|
|
/* HRESULT */ RLDDISetPalette, /* 0, RLPalettEntry* */
|
|
|
|
/*
|
|
* Get all 256 palette entries of an 8 bit device.
|
|
*/
|
|
/* HRESULT */ RLDDIGetPalette, /* 0, RLPaletteEntry* */
|
|
|
|
/*
|
|
* Generic platform specific driver extension type thing.
|
|
*/
|
|
/* HRESULT */ RLDDIDriverExtension, /* code, (void *) */
|
|
|
|
#ifdef __psx__
|
|
/*
|
|
* Set various PSX specific flags, to increase speed
|
|
*/
|
|
/* HRESULT */ RLDDIPSXSetUpdateFlags,
|
|
|
|
/*
|
|
* allow people to reserve space in VRAM for their own use
|
|
*/
|
|
/* HRESULT */ RLDDIPSXReserveTextureSpace,
|
|
/* HRESULT */ RLDDIPSXReserveCLUTSpace,
|
|
|
|
/*
|
|
* so that people can access ordering table info
|
|
*/
|
|
|
|
/* HRESULT */ RLDDIPSXQuery,
|
|
#endif
|
|
|
|
/*
|
|
* Inform of beginning/end of a scene.
|
|
*/
|
|
/* HRESULT */ RLDDISceneCapture, /* BOOL, NULL */
|
|
|
|
/*
|
|
* Get an item of state from a particular module.
|
|
*/
|
|
/* HRESULT */ RLDDIGetState, /* long, LPD3DSTATE */
|
|
|
|
/*
|
|
* Get stats from a driver
|
|
*/
|
|
/* HRESULT */ RLDDIGetStats, /* 0, LPD3DSTATS */
|
|
|
|
/*
|
|
* Not a service call
|
|
*/
|
|
RLDDIServiceCount /* assumes none of the other enums are given initializers */
|
|
|
|
} RLDDIServiceType;
|
|
|
|
|
|
#ifdef D3D
|
|
typedef enum _RLPaletteFlags {
|
|
RLPaletteFree, /* renderer may use this entry freely */
|
|
RLPaletteReadOnly, /* fixed but may be used by renderer */
|
|
RLPaletteReserved /* may not be used by renderer */
|
|
} RLPaletteFlags;
|
|
|
|
|
|
typedef struct _RLPaletteEntry {
|
|
unsigned char red; /* 0 .. 255 */
|
|
unsigned char green; /* 0 .. 255 */
|
|
unsigned char blue; /* 0 .. 255 */
|
|
unsigned char flags; /* one of RLPaletteFlags */
|
|
} RLPaletteEntry;
|
|
|
|
typedef struct _RLImage {
|
|
int width, height; /* width and height in pixels */
|
|
int aspectx, aspecty; /* aspect ratio for non-square pixels */
|
|
int depth; /* bits per pixel */
|
|
int rgb; /* if false, pixels are indices into a
|
|
palette otherwise, pixels encode
|
|
RGB values. */
|
|
int bytes_per_line; /* number of bytes of memory for a
|
|
scanline. This must be a multiple
|
|
of 4. */
|
|
void* buffer1; /* memory to render into (first buffer). */
|
|
void* buffer2; /* second rendering buffer for double
|
|
buffering, set to NULL for single
|
|
buffering. */
|
|
unsigned long red_mask;
|
|
unsigned long green_mask;
|
|
unsigned long blue_mask;
|
|
unsigned long alpha_mask;
|
|
/* if rgb is true, these are masks for
|
|
the red, green and blue parts of a
|
|
pixel. Otherwise, these are masks
|
|
for the significant bits of the
|
|
red, green and blue elements in the
|
|
palette. For instance, most SVGA
|
|
displays use 64 intensities of red,
|
|
green and blue, so the masks should
|
|
all be set to 0xfc. */
|
|
int palette_size; /* number of entries in palette */
|
|
RLPaletteEntry* palette; /* description of the palette (only if
|
|
rgb is false). Must be (1<<depth)
|
|
elements. */
|
|
} RLImage;
|
|
|
|
|
|
|
|
|
|
#endif /* D3D */
|
|
|
|
|
|
#ifdef WIN32
|
|
#define RLDDIAPI __stdcall
|
|
#else
|
|
#define RLDDIAPI
|
|
#endif
|
|
|
|
typedef void (*RLDDIDestroyProc)(RLDDIDriver* driver);
|
|
typedef long (*RLDDIServiceProc)(RLDDIDriver* driver,
|
|
RLDDIServiceType type,
|
|
long arg1,
|
|
void* arg2);
|
|
|
|
typedef HRESULT (RLDDIAPI *RLDDIMallocFn)(void**, size_t);
|
|
typedef HRESULT (RLDDIAPI *RLDDIReallocFn)(void**, size_t);
|
|
typedef void (RLDDIAPI *RLDDIFreeFn)(void*);
|
|
typedef HRESULT (*RLDDIRaiseFn)(HRESULT);
|
|
|
|
#ifndef DLL_IMPORTS_GEN
|
|
__declspec( dllexport ) extern RLDDIRaiseFn RLDDIRaise;
|
|
__declspec( dllexport ) extern RLDDIMallocFn RLDDIMalloc;
|
|
__declspec( dllexport ) extern RLDDIReallocFn RLDDIRealloc;
|
|
__declspec( dllexport ) extern RLDDIFreeFn RLDDIFree;
|
|
#else
|
|
__declspec( dllimport ) RLDDIRaiseFn RLDDIRaise;
|
|
__declspec( dllimport ) RLDDIMallocFn RLDDIMalloc;
|
|
__declspec( dllimport ) RLDDIReallocFn RLDDIRealloc;
|
|
__declspec( dllimport ) RLDDIFreeFn RLDDIFree;
|
|
#endif
|
|
|
|
#include "d3di.h"
|
|
#include "dditypes.h"
|
|
|
|
typedef struct _RLDDIGlobalDriverData {
|
|
/*
|
|
* Pointers to driver modules
|
|
*/
|
|
RLDDIDriver *transform;
|
|
RLDDIDriver *lighting;
|
|
RLDDIDriver *raster;
|
|
} RLDDIGlobalDriverData;
|
|
|
|
struct _RLDDIDriver {
|
|
RLDDIDriver* prev;
|
|
RLDDIDriver* next;
|
|
RLDDIDriverStack* top; /* top of the driver stack */
|
|
|
|
int width, height; /* dimensions */
|
|
|
|
RLDDIDestroyProc destroy; /* clean up */
|
|
RLDDIServiceProc service; /* do something */
|
|
|
|
RLDDIGlobalDriverData* data; /* pointer to global data */
|
|
/* Driver private data may follow */
|
|
};
|
|
|
|
struct _RLDDIDriverStack {
|
|
RLDDIDriver *top;
|
|
struct {
|
|
RLDDIServiceProc call;
|
|
RLDDIDriver *driver;
|
|
} fastService[RLDDIServiceCount];
|
|
int polygons_drawn;
|
|
RLDDIGlobalDriverData data;
|
|
};
|
|
|
|
#include "d3drlddi.h"
|
|
#include "dlist.h"
|
|
|
|
#define RLDDIService(stackp, type, arg1, arg2) \
|
|
(*((stackp)->fastService[type].call)) \
|
|
((stackp)->fastService[type].driver, (type), (arg1), (arg2))
|
|
|
|
/* old macro
|
|
(*((stackp)->top->service))((stackp)->top, (type), (arg1), (arg2))
|
|
*/
|
|
|
|
#ifdef DLL_IMPORTS_GEN
|
|
__declspec( dllimport ) int RLDDILog2[];
|
|
#else
|
|
extern int RLDDILog2[];
|
|
#endif
|
|
|
|
#ifdef _DLL
|
|
void RLDDIInit2(RLDDIMallocFn, RLDDIReallocFn, RLDDIFreeFn, RLDDIRaiseFn, RLDDIValue**, int, int);
|
|
#endif
|
|
void RLDDIInit(RLDDIMallocFn, RLDDIReallocFn, RLDDIFreeFn, RLDDIRaiseFn, RLDDIValue**, int, int);
|
|
void RLDDIPushDriver(RLDDIDriverStack* stack, RLDDIDriver* driver);
|
|
void RLDDIPopDriver(RLDDIDriverStack* stack);
|
|
|
|
HRESULT RLDDICreatePixmap(RLDDIPixmap** result,
|
|
int width, int height, int depth);
|
|
HRESULT RLDDICreatePixmapFrom(RLDDIPixmap** result,
|
|
int width, int height, int depth,
|
|
void RLFAR* data, int bytes_per_line);
|
|
HRESULT RLDDICreatePixmapFromSurface(RLDDIPixmap** result,
|
|
LPDIRECTDRAWSURFACE lpDDS);
|
|
void RLDDIDestroyPixmap(RLDDIPixmap* pm);
|
|
void RLDDIPixmapFill(RLDDIPixmap* pm, unsigned long value,
|
|
int x1, int y1, int x2, int y2);
|
|
void RLDDIPixmapCopy(RLDDIPixmap* dstpm, RLDDIPixmap* srcpm,
|
|
int x1, int y1, int x2, int y2,
|
|
int dstx, int dsty);
|
|
void RLDDIPixmapScale(RLDDIPixmap* dstpm, LPDDSURFACEDESC srcim,
|
|
RLDDIValue scalex, RLDDIValue scaley,
|
|
int x1, int y1, int x2, int y2,
|
|
int dstx, int dsty);
|
|
HRESULT RLDDIPixmapLock(RLDDIPixmap* pm);
|
|
void RLDDIPixmapUnlock(RLDDIPixmap* pm);
|
|
void RLDDIPixmapUpdatePalette(RLDDIPixmap* pm);
|
|
|
|
RLDDIDriver* RLDDICreateTransformDriver(int width, int height);
|
|
RLDDIDriver* RLDDICreateRampLightingDriver(int width, int height);
|
|
RLDDIDriver* RLDDICreateRampDriver(int width, int height);
|
|
RLDDIDriver* RLDDICreateRGBLightingDriver(int width, int height);
|
|
RLDDIDriver* RLDDICreateRGBDriver(int width, int height);
|
|
|
|
extern HRESULT WINAPI DDInternalLock( LPDDRAWI_DDRAWSURFACE_LCL this_lcl, LPVOID* lpBits );
|
|
extern HRESULT WINAPI DDInternalUnlock( LPDDRAWI_DDRAWSURFACE_LCL this_lcl );
|
|
|
|
/*
|
|
* RLDDIDriverExtension codes
|
|
*/
|
|
#define RLDDIDDrawGetObjects 0x1234
|
|
#define RLDDIDDrawWinMove 0x1235
|
|
|
|
/*
|
|
* Six standard clipping planes plus six user defined clipping planes.
|
|
* See rl\d3d\d3d\d3dtypes.h.
|
|
*/
|
|
|
|
#define MAX_CLIPPING_PLANES 12
|
|
|
|
/* Space for vertices generated/copied while clipping one triangle */
|
|
|
|
#define MAX_CLIP_VERTICES (( 2 * MAX_CLIPPING_PLANES ) + 3 )
|
|
|
|
/* 3 verts. -> 1 tri, 4 v -> 2 t, N vertices -> (N - 2) triangles */
|
|
|
|
#define MAX_CLIP_TRIANGLES ( MAX_CLIP_VERTICES - 2 )
|
|
|
|
#endif /* driver.h */
|