summaryrefslogtreecommitdiffstats
path: root/dxsdk/Include/d3drmdef.h
diff options
context:
space:
mode:
Diffstat (limited to 'dxsdk/Include/d3drmdef.h')
-rw-r--r--dxsdk/Include/d3drmdef.h695
1 files changed, 695 insertions, 0 deletions
diff --git a/dxsdk/Include/d3drmdef.h b/dxsdk/Include/d3drmdef.h
new file mode 100644
index 00000000..9da4b18a
--- /dev/null
+++ b/dxsdk/Include/d3drmdef.h
@@ -0,0 +1,695 @@
+/*==========================================================================;
+ *
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ *
+ * File: d3drm.h
+ * Content: Direct3DRM include file
+ *
+ ***************************************************************************/
+
+#ifndef __D3DRMDEFS_H__
+#define __D3DRMDEFS_H__
+
+#include <stddef.h>
+#include "d3dtypes.h"
+
+#ifdef WIN32
+#define D3DRMAPI __stdcall
+#else
+#define D3DRMAPI
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#ifndef TRUE
+#define FALSE 0
+#define TRUE 1
+#endif
+
+typedef struct _D3DRMVECTOR4D
+{ D3DVALUE x, y, z, w;
+} D3DRMVECTOR4D, *LPD3DRMVECTOR4D;
+
+typedef D3DVALUE D3DRMMATRIX4D[4][4];
+
+typedef struct _D3DRMQUATERNION
+{ D3DVALUE s;
+ D3DVECTOR v;
+} D3DRMQUATERNION, *LPD3DRMQUATERNION;
+
+typedef struct _D3DRMRAY
+{ D3DVECTOR dvDir;
+ D3DVECTOR dvPos;
+} D3DRMRAY, *LPD3DRMRAY;
+
+typedef struct _D3DRMBOX
+{ D3DVECTOR min, max;
+} D3DRMBOX, *LPD3DRMBOX;
+
+typedef void (*D3DRMWRAPCALLBACK)
+ (LPD3DVECTOR, int* u, int* v, LPD3DVECTOR a, LPD3DVECTOR b, LPVOID);
+
+typedef enum _D3DRMLIGHTTYPE
+{ D3DRMLIGHT_AMBIENT,
+ D3DRMLIGHT_POINT,
+ D3DRMLIGHT_SPOT,
+ D3DRMLIGHT_DIRECTIONAL,
+ D3DRMLIGHT_PARALLELPOINT
+} D3DRMLIGHTTYPE, *LPD3DRMLIGHTTYPE;
+
+typedef enum _D3DRMSHADEMODE {
+ D3DRMSHADE_FLAT = 0,
+ D3DRMSHADE_GOURAUD = 1,
+ D3DRMSHADE_PHONG = 2,
+
+ D3DRMSHADE_MASK = 7,
+ D3DRMSHADE_MAX = 8
+} D3DRMSHADEMODE, *LPD3DRMSHADEMODE;
+
+typedef enum _D3DRMLIGHTMODE {
+ D3DRMLIGHT_OFF = 0 * D3DRMSHADE_MAX,
+ D3DRMLIGHT_ON = 1 * D3DRMSHADE_MAX,
+
+ D3DRMLIGHT_MASK = 7 * D3DRMSHADE_MAX,
+ D3DRMLIGHT_MAX = 8 * D3DRMSHADE_MAX
+} D3DRMLIGHTMODE, *LPD3DRMLIGHTMODE;
+
+typedef enum _D3DRMFILLMODE {
+ D3DRMFILL_POINTS = 0 * D3DRMLIGHT_MAX,
+ D3DRMFILL_WIREFRAME = 1 * D3DRMLIGHT_MAX,
+ D3DRMFILL_SOLID = 2 * D3DRMLIGHT_MAX,
+
+ D3DRMFILL_MASK = 7 * D3DRMLIGHT_MAX,
+ D3DRMFILL_MAX = 8 * D3DRMLIGHT_MAX
+} D3DRMFILLMODE, *LPD3DRMFILLMODE;
+
+typedef DWORD D3DRMRENDERQUALITY, *LPD3DRMRENDERQUALITY;
+
+#define D3DRMRENDER_WIREFRAME (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_WIREFRAME)
+#define D3DRMRENDER_UNLITFLAT (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_SOLID)
+#define D3DRMRENDER_FLAT (D3DRMSHADE_FLAT+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+#define D3DRMRENDER_GOURAUD (D3DRMSHADE_GOURAUD+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+#define D3DRMRENDER_PHONG (D3DRMSHADE_PHONG+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+
+#define D3DRMRENDERMODE_BLENDEDTRANSPARENCY 1
+#define D3DRMRENDERMODE_SORTEDTRANSPARENCY 2
+#define D3DRMRENDERMODE_LIGHTINMODELSPACE 8
+#define D3DRMRENDERMODE_VIEWDEPENDENTSPECULAR 16
+#define D3DRMRENDERMODE_DISABLESORTEDALPHAZWRITE 32
+
+typedef enum _D3DRMTEXTUREQUALITY
+{ D3DRMTEXTURE_NEAREST, /* choose nearest texel */
+ D3DRMTEXTURE_LINEAR, /* interpolate 4 texels */
+ D3DRMTEXTURE_MIPNEAREST, /* nearest texel in nearest mipmap */
+ D3DRMTEXTURE_MIPLINEAR, /* interpolate 2 texels from 2 mipmaps */
+ D3DRMTEXTURE_LINEARMIPNEAREST, /* interpolate 4 texels in nearest mipmap */
+ D3DRMTEXTURE_LINEARMIPLINEAR /* interpolate 8 texels from 2 mipmaps */
+} D3DRMTEXTUREQUALITY, *LPD3DRMTEXTUREQUALITY;
+
+/*
+ * Texture flags
+ */
+#define D3DRMTEXTURE_FORCERESIDENT 0x00000001 /* texture should be kept in video memory */
+#define D3DRMTEXTURE_STATIC 0x00000002 /* texture will not change */
+#define D3DRMTEXTURE_DOWNSAMPLEPOINT 0x00000004 /* point filtering should be used when downsampling */
+#define D3DRMTEXTURE_DOWNSAMPLEBILINEAR 0x00000008 /* bilinear filtering should be used when downsampling */
+#define D3DRMTEXTURE_DOWNSAMPLEREDUCEDEPTH 0x00000010 /* reduce bit depth when downsampling */
+#define D3DRMTEXTURE_DOWNSAMPLENONE 0x00000020 /* texture should never be downsampled */
+#define D3DRMTEXTURE_CHANGEDPIXELS 0x00000040 /* pixels have changed */
+#define D3DRMTEXTURE_CHANGEDPALETTE 0x00000080 /* palette has changed */
+#define D3DRMTEXTURE_INVALIDATEONLY 0x00000100 /* dirty regions are invalid */
+
+/*
+ * Shadow flags
+ */
+#define D3DRMSHADOW_TRUEALPHA 0x00000001 /* shadow should render without artifacts when true alpha is on */
+
+typedef enum _D3DRMCOMBINETYPE
+{ D3DRMCOMBINE_REPLACE,
+ D3DRMCOMBINE_BEFORE,
+ D3DRMCOMBINE_AFTER
+} D3DRMCOMBINETYPE, *LPD3DRMCOMBINETYPE;
+
+typedef D3DCOLORMODEL D3DRMCOLORMODEL, *LPD3DRMCOLORMODEL;
+
+typedef enum _D3DRMPALETTEFLAGS
+{ D3DRMPALETTE_FREE, /* renderer may use this entry freely */
+ D3DRMPALETTE_READONLY, /* fixed but may be used by renderer */
+ D3DRMPALETTE_RESERVED /* may not be used by renderer */
+} D3DRMPALETTEFLAGS, *LPD3DRMPALETTEFLAGS;
+
+typedef struct _D3DRMPALETTEENTRY
+{ unsigned char red; /* 0 .. 255 */
+ unsigned char green; /* 0 .. 255 */
+ unsigned char blue; /* 0 .. 255 */
+ unsigned char flags; /* one of D3DRMPALETTEFLAGS */
+} D3DRMPALETTEENTRY, *LPD3DRMPALETTEENTRY;
+
+typedef struct _D3DRMIMAGE
+{ 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 */
+ D3DRMPALETTEENTRY* palette; /* description of the palette (only if
+ rgb is false). Must be (1<<depth)
+ elements. */
+} D3DRMIMAGE, *LPD3DRMIMAGE;
+
+typedef enum _D3DRMWRAPTYPE
+{ D3DRMWRAP_FLAT,
+ D3DRMWRAP_CYLINDER,
+ D3DRMWRAP_SPHERE,
+ D3DRMWRAP_CHROME,
+ D3DRMWRAP_SHEET,
+ D3DRMWRAP_BOX
+} D3DRMWRAPTYPE, *LPD3DRMWRAPTYPE;
+
+#define D3DRMWIREFRAME_CULL 1 /* cull backfaces */
+#define D3DRMWIREFRAME_HIDDENLINE 2 /* lines are obscured by closer objects */
+
+/*
+ * Do not use righthanded perspective in Viewport2::SetProjection().
+ * Set up righthanded mode by using IDirect3DRM3::SetOptions().
+ */
+typedef enum _D3DRMPROJECTIONTYPE
+{ D3DRMPROJECT_PERSPECTIVE,
+ D3DRMPROJECT_ORTHOGRAPHIC,
+ D3DRMPROJECT_RIGHTHANDPERSPECTIVE, /* Only valid pre-DX6 */
+ D3DRMPROJECT_RIGHTHANDORTHOGRAPHIC /* Only valid pre-DX6 */
+} D3DRMPROJECTIONTYPE, *LPD3DRMPROJECTIONTYPE;
+
+#define D3DRMOPTIONS_LEFTHANDED 0x00000001L /* Default */
+#define D3DRMOPTIONS_RIGHTHANDED 0x00000002L
+
+typedef enum _D3DRMXOFFORMAT
+{ D3DRMXOF_BINARY,
+ D3DRMXOF_COMPRESSED,
+ D3DRMXOF_TEXT
+} D3DRMXOFFORMAT, *LPD3DRMXOFFORMAT;
+
+typedef DWORD D3DRMSAVEOPTIONS;
+#define D3DRMXOFSAVE_NORMALS 1
+#define D3DRMXOFSAVE_TEXTURECOORDINATES 2
+#define D3DRMXOFSAVE_MATERIALS 4
+#define D3DRMXOFSAVE_TEXTURENAMES 8
+#define D3DRMXOFSAVE_ALL 15
+#define D3DRMXOFSAVE_TEMPLATES 16
+#define D3DRMXOFSAVE_TEXTURETOPOLOGY 32
+
+typedef enum _D3DRMCOLORSOURCE
+{ D3DRMCOLOR_FROMFACE,
+ D3DRMCOLOR_FROMVERTEX
+} D3DRMCOLORSOURCE, *LPD3DRMCOLORSOURCE;
+
+typedef enum _D3DRMFRAMECONSTRAINT
+{ D3DRMCONSTRAIN_Z, /* use only X and Y rotations */
+ D3DRMCONSTRAIN_Y, /* use only X and Z rotations */
+ D3DRMCONSTRAIN_X /* use only Y and Z rotations */
+} D3DRMFRAMECONSTRAINT, *LPD3DRMFRAMECONSTRAINT;
+
+typedef enum _D3DRMMATERIALMODE
+{ D3DRMMATERIAL_FROMMESH,
+ D3DRMMATERIAL_FROMPARENT,
+ D3DRMMATERIAL_FROMFRAME
+} D3DRMMATERIALMODE, *LPD3DRMMATERIALMODE;
+
+typedef enum _D3DRMFOGMODE
+{ D3DRMFOG_LINEAR, /* linear between start and end */
+ D3DRMFOG_EXPONENTIAL, /* density * exp(-distance) */
+ D3DRMFOG_EXPONENTIALSQUARED /* density * exp(-distance*distance) */
+} D3DRMFOGMODE, *LPD3DRMFOGMODE;
+
+typedef enum _D3DRMZBUFFERMODE {
+ D3DRMZBUFFER_FROMPARENT, /* default */
+ D3DRMZBUFFER_ENABLE, /* enable zbuffering */
+ D3DRMZBUFFER_DISABLE /* disable zbuffering */
+} D3DRMZBUFFERMODE, *LPD3DRMZBUFFERMODE;
+
+typedef enum _D3DRMSORTMODE {
+ D3DRMSORT_FROMPARENT, /* default */
+ D3DRMSORT_NONE, /* don't sort child frames */
+ D3DRMSORT_FRONTTOBACK, /* sort child frames front-to-back */
+ D3DRMSORT_BACKTOFRONT /* sort child frames back-to-front */
+} D3DRMSORTMODE, *LPD3DRMSORTMODE;
+
+typedef struct _D3DRMMATERIALOVERRIDE
+{
+ DWORD dwSize; /* Size of this structure */
+ DWORD dwFlags; /* Indicate which fields are valid */
+ D3DCOLORVALUE dcDiffuse; /* RGBA */
+ D3DCOLORVALUE dcAmbient; /* RGB */
+ D3DCOLORVALUE dcEmissive; /* RGB */
+ D3DCOLORVALUE dcSpecular; /* RGB */
+ D3DVALUE dvPower;
+ LPUNKNOWN lpD3DRMTex;
+} D3DRMMATERIALOVERRIDE, *LPD3DRMMATERIALOVERRIDE;
+
+#define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAONLY 0x00000001L
+#define D3DRMMATERIALOVERRIDE_DIFFUSE_RGBONLY 0x00000002L
+#define D3DRMMATERIALOVERRIDE_DIFFUSE 0x00000003L
+#define D3DRMMATERIALOVERRIDE_AMBIENT 0x00000004L
+#define D3DRMMATERIALOVERRIDE_EMISSIVE 0x00000008L
+#define D3DRMMATERIALOVERRIDE_SPECULAR 0x00000010L
+#define D3DRMMATERIALOVERRIDE_POWER 0x00000020L
+#define D3DRMMATERIALOVERRIDE_TEXTURE 0x00000040L
+#define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAMULTIPLY 0x00000080L
+#define D3DRMMATERIALOVERRIDE_ALL 0x000000FFL
+
+#define D3DRMFPTF_ALPHA 0x00000001L
+#define D3DRMFPTF_NOALPHA 0x00000002L
+#define D3DRMFPTF_PALETTIZED 0x00000004L
+#define D3DRMFPTF_NOTPALETTIZED 0x00000008L
+
+#define D3DRMSTATECHANGE_UPDATEONLY 0x000000001L
+#define D3DRMSTATECHANGE_VOLATILE 0x000000002L
+#define D3DRMSTATECHANGE_NONVOLATILE 0x000000004L
+#define D3DRMSTATECHANGE_RENDER 0x000000020L
+#define D3DRMSTATECHANGE_LIGHT 0x000000040L
+
+/*
+ * Values for flags in RM3::CreateDeviceFromSurface
+ */
+#define D3DRMDEVICE_NOZBUFFER 0x00000001L
+
+/*
+ * Values for flags in Object2::SetClientData
+ */
+#define D3DRMCLIENTDATA_NONE 0x00000001L
+#define D3DRMCLIENTDATA_LOCALFREE 0x00000002L
+#define D3DRMCLIENTDATA_IUNKNOWN 0x00000004L
+
+/*
+ * Values for flags in Frame2::AddMoveCallback.
+ */
+#define D3DRMCALLBACK_PREORDER 0
+#define D3DRMCALLBACK_POSTORDER 1
+
+/*
+ * Values for flags in MeshBuilder2::RayPick.
+ */
+#define D3DRMRAYPICK_ONLYBOUNDINGBOXES 1
+#define D3DRMRAYPICK_IGNOREFURTHERPRIMITIVES 2
+#define D3DRMRAYPICK_INTERPOLATEUV 4
+#define D3DRMRAYPICK_INTERPOLATECOLOR 8
+#define D3DRMRAYPICK_INTERPOLATENORMAL 0x10
+
+/*
+ * Values for flags in MeshBuilder3::AddFacesIndexed.
+ */
+#define D3DRMADDFACES_VERTICESONLY 1
+
+/*
+ * Values for flags in MeshBuilder2::GenerateNormals.
+ */
+#define D3DRMGENERATENORMALS_PRECOMPACT 1
+#define D3DRMGENERATENORMALS_USECREASEANGLE 2
+
+/*
+ * Values for MeshBuilder3::GetParentMesh
+ */
+#define D3DRMMESHBUILDER_DIRECTPARENT 1
+#define D3DRMMESHBUILDER_ROOTMESH 2
+
+/*
+ * Flags for MeshBuilder3::Enable
+ */
+#define D3DRMMESHBUILDER_RENDERENABLE 0x00000001L
+#define D3DRMMESHBUILDER_PICKENABLE 0x00000002L
+
+/*
+ * Flags for MeshBuilder3::AddMeshBuilder
+ */
+#define D3DRMADDMESHBUILDER_DONTCOPYAPPDATA 1
+#define D3DRMADDMESHBUILDER_FLATTENSUBMESHES 2
+#define D3DRMADDMESHBUILDER_NOSUBMESHES 4
+
+/*
+ * Flags for Object2::GetAge when used with MeshBuilders
+ */
+#define D3DRMMESHBUILDERAGE_GEOMETRY 0x00000001L
+#define D3DRMMESHBUILDERAGE_MATERIALS 0x00000002L
+#define D3DRMMESHBUILDERAGE_TEXTURES 0x00000004L
+
+/*
+ * Format flags for MeshBuilder3::AddTriangles.
+ */
+#define D3DRMFVF_TYPE 0x00000001L
+#define D3DRMFVF_NORMAL 0x00000002L
+#define D3DRMFVF_COLOR 0x00000004L
+#define D3DRMFVF_TEXTURECOORDS 0x00000008L
+
+#define D3DRMVERTEX_STRIP 0x00000001L
+#define D3DRMVERTEX_FAN 0x00000002L
+#define D3DRMVERTEX_LIST 0x00000004L
+
+/*
+ * Values for flags in Viewport2::Clear2
+ */
+#define D3DRMCLEAR_TARGET 0x00000001L
+#define D3DRMCLEAR_ZBUFFER 0x00000002L
+#define D3DRMCLEAR_DIRTYRECTS 0x00000004L
+#define D3DRMCLEAR_ALL (D3DRMCLEAR_TARGET | \
+ D3DRMCLEAR_ZBUFFER | \
+ D3DRMCLEAR_DIRTYRECTS)
+
+/*
+ * Values for flags in Frame3::SetSceneFogMethod
+ */
+#define D3DRMFOGMETHOD_VERTEX 0x00000001L
+#define D3DRMFOGMETHOD_TABLE 0x00000002L
+#define D3DRMFOGMETHOD_ANY 0x00000004L
+
+/*
+ * Values for flags in Frame3::SetTraversalOptions
+ */
+#define D3DRMFRAME_RENDERENABLE 0x00000001L
+#define D3DRMFRAME_PICKENABLE 0x00000002L
+
+typedef DWORD D3DRMANIMATIONOPTIONS;
+#define D3DRMANIMATION_OPEN 0x01L
+#define D3DRMANIMATION_CLOSED 0x02L
+#define D3DRMANIMATION_LINEARPOSITION 0x04L
+#define D3DRMANIMATION_SPLINEPOSITION 0x08L
+#define D3DRMANIMATION_SCALEANDROTATION 0x00000010L
+#define D3DRMANIMATION_POSITION 0x00000020L
+
+typedef DWORD D3DRMINTERPOLATIONOPTIONS;
+#define D3DRMINTERPOLATION_OPEN 0x01L
+#define D3DRMINTERPOLATION_CLOSED 0x02L
+#define D3DRMINTERPOLATION_NEAREST 0x0100L
+#define D3DRMINTERPOLATION_LINEAR 0x04L
+#define D3DRMINTERPOLATION_SPLINE 0x08L
+#define D3DRMINTERPOLATION_VERTEXCOLOR 0x40L
+#define D3DRMINTERPOLATION_SLERPNORMALS 0x80L
+
+typedef DWORD D3DRMLOADOPTIONS;
+
+#define D3DRMLOAD_FROMFILE 0x00L
+#define D3DRMLOAD_FROMRESOURCE 0x01L
+#define D3DRMLOAD_FROMMEMORY 0x02L
+#define D3DRMLOAD_FROMSTREAM 0x04L
+#define D3DRMLOAD_FROMURL 0x08L
+
+#define D3DRMLOAD_BYNAME 0x10L
+#define D3DRMLOAD_BYPOSITION 0x20L
+#define D3DRMLOAD_BYGUID 0x40L
+#define D3DRMLOAD_FIRST 0x80L
+
+#define D3DRMLOAD_INSTANCEBYREFERENCE 0x100L
+#define D3DRMLOAD_INSTANCEBYCOPYING 0x200L
+
+#define D3DRMLOAD_ASYNCHRONOUS 0x400L
+
+typedef struct _D3DRMLOADRESOURCE {
+ HMODULE hModule;
+ LPCTSTR lpName;
+ LPCTSTR lpType;
+} D3DRMLOADRESOURCE, *LPD3DRMLOADRESOURCE;
+
+typedef struct _D3DRMLOADMEMORY {
+ LPVOID lpMemory;
+ DWORD dSize;
+} D3DRMLOADMEMORY, *LPD3DRMLOADMEMORY;
+
+#define D3DRMPMESHSTATUS_VALID 0x01L
+#define D3DRMPMESHSTATUS_INTERRUPTED 0x02L
+#define D3DRMPMESHSTATUS_BASEMESHCOMPLETE 0x04L
+#define D3DRMPMESHSTATUS_COMPLETE 0x08L
+#define D3DRMPMESHSTATUS_RENDERABLE 0x10L
+
+#define D3DRMPMESHEVENT_BASEMESH 0x01L
+#define D3DRMPMESHEVENT_COMPLETE 0x02L
+
+typedef struct _D3DRMPMESHLOADSTATUS {
+ DWORD dwSize; // Size of this structure
+ DWORD dwPMeshSize; // Total Size (bytes)
+ DWORD dwBaseMeshSize; // Total Size of the Base Mesh
+ DWORD dwBytesLoaded; // Total bytes loaded
+ DWORD dwVerticesLoaded; // Number of vertices loaded
+ DWORD dwFacesLoaded; // Number of faces loaded
+ HRESULT dwLoadResult; // Result of the load operation
+ DWORD dwFlags;
+} D3DRMPMESHLOADSTATUS, *LPD3DRMPMESHLOADSTATUS;
+
+typedef enum _D3DRMUSERVISUALREASON {
+ D3DRMUSERVISUAL_CANSEE,
+ D3DRMUSERVISUAL_RENDER
+} D3DRMUSERVISUALREASON, *LPD3DRMUSERVISUALREASON;
+
+
+typedef struct _D3DRMANIMATIONKEY
+{
+ DWORD dwSize;
+ DWORD dwKeyType;
+ D3DVALUE dvTime;
+ DWORD dwID;
+#if (!defined __cplusplus) || (!defined D3D_OVERLOADS)
+ union
+ {
+ D3DRMQUATERNION dqRotateKey;
+ D3DVECTOR dvScaleKey;
+ D3DVECTOR dvPositionKey;
+ };
+#else
+ /*
+ * We do this as D3D_OVERLOADS defines constructors for D3DVECTOR,
+ * this can then not be used in a union. Use the inlines provided
+ * to extract and set the required component.
+ */
+ D3DVALUE dvK[4];
+#endif
+} D3DRMANIMATIONKEY;
+typedef D3DRMANIMATIONKEY *LPD3DRMANIMATIONKEY;
+
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+inline VOID
+D3DRMAnimationGetRotateKey(const D3DRMANIMATIONKEY& rmKey,
+ D3DRMQUATERNION& rmQuat)
+{
+ rmQuat.s = rmKey.dvK[0];
+ rmQuat.v = D3DVECTOR(rmKey.dvK[1], rmKey.dvK[2], rmKey.dvK[3]);
+}
+
+inline VOID
+D3DRMAnimationGetScaleKey(const D3DRMANIMATIONKEY& rmKey,
+ D3DVECTOR& dvVec)
+{
+ dvVec = D3DVECTOR(rmKey.dvK[0], rmKey.dvK[1], rmKey.dvK[2]);
+}
+
+inline VOID
+D3DRMAnimationGetPositionKey(const D3DRMANIMATIONKEY& rmKey,
+ D3DVECTOR& dvVec)
+{
+ dvVec = D3DVECTOR(rmKey.dvK[0], rmKey.dvK[1], rmKey.dvK[2]);
+}
+inline VOID
+D3DRMAnimationSetRotateKey(D3DRMANIMATIONKEY& rmKey,
+ const D3DRMQUATERNION& rmQuat)
+{
+ rmKey.dvK[0] = rmQuat.s;
+ rmKey.dvK[1] = rmQuat.v.x;
+ rmKey.dvK[2] = rmQuat.v.y;
+ rmKey.dvK[3] = rmQuat.v.z;
+}
+
+inline VOID
+D3DRMAnimationSetScaleKey(D3DRMANIMATIONKEY& rmKey,
+ const D3DVECTOR& dvVec)
+{
+ rmKey.dvK[0] = dvVec.x;
+ rmKey.dvK[1] = dvVec.y;
+ rmKey.dvK[2] = dvVec.z;
+}
+
+inline VOID
+D3DRMAnimationSetPositionKey(D3DRMANIMATIONKEY& rmKey,
+ const D3DVECTOR& dvVec)
+{
+ rmKey.dvK[0] = dvVec.x;
+ rmKey.dvK[1] = dvVec.y;
+ rmKey.dvK[2] = dvVec.z;
+}
+#endif
+
+#define D3DRMANIMATION_ROTATEKEY 0x01
+#define D3DRMANIMATION_SCALEKEY 0x02
+#define D3DRMANIMATION_POSITIONKEY 0x03
+
+
+typedef DWORD D3DRMMAPPING, D3DRMMAPPINGFLAG, *LPD3DRMMAPPING;
+static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPU = 1;
+static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPV = 2;
+static const D3DRMMAPPINGFLAG D3DRMMAP_PERSPCORRECT = 4;
+
+typedef struct _D3DRMVERTEX
+{ D3DVECTOR position;
+ D3DVECTOR normal;
+ D3DVALUE tu, tv;
+ D3DCOLOR color;
+} D3DRMVERTEX, *LPD3DRMVERTEX;
+
+typedef LONG D3DRMGROUPINDEX; /* group indexes begin a 0 */
+static const D3DRMGROUPINDEX D3DRMGROUP_ALLGROUPS = -1;
+
+/*
+ * Create a color from three components in the range 0-1 inclusive.
+ */
+extern D3DCOLOR D3DRMAPI D3DRMCreateColorRGB(D3DVALUE red,
+ D3DVALUE green,
+ D3DVALUE blue);
+
+/*
+ * Create a color from four components in the range 0-1 inclusive.
+ */
+extern D3DCOLOR D3DRMAPI D3DRMCreateColorRGBA(D3DVALUE red,
+ D3DVALUE green,
+ D3DVALUE blue,
+ D3DVALUE alpha);
+
+/*
+ * Get the red component of a color.
+ */
+extern D3DVALUE D3DRMAPI D3DRMColorGetRed(D3DCOLOR);
+
+/*
+ * Get the green component of a color.
+ */
+extern D3DVALUE D3DRMAPI D3DRMColorGetGreen(D3DCOLOR);
+
+/*
+ * Get the blue component of a color.
+ */
+extern D3DVALUE D3DRMAPI D3DRMColorGetBlue(D3DCOLOR);
+
+/*
+ * Get the alpha component of a color.
+ */
+extern D3DVALUE D3DRMAPI D3DRMColorGetAlpha(D3DCOLOR);
+
+/*
+ * Add two vectors. Returns its first argument.
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorAdd(LPD3DVECTOR d,
+ LPD3DVECTOR s1,
+ LPD3DVECTOR s2);
+
+/*
+ * Subtract two vectors. Returns its first argument.
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorSubtract(LPD3DVECTOR d,
+ LPD3DVECTOR s1,
+ LPD3DVECTOR s2);
+/*
+ * Reflect a ray about a given normal. Returns its first argument.
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorReflect(LPD3DVECTOR d,
+ LPD3DVECTOR ray,
+ LPD3DVECTOR norm);
+
+/*
+ * Calculate the vector cross product. Returns its first argument.
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorCrossProduct(LPD3DVECTOR d,
+ LPD3DVECTOR s1,
+ LPD3DVECTOR s2);
+/*
+ * Return the vector dot product.
+ */
+extern D3DVALUE D3DRMAPI D3DRMVectorDotProduct(LPD3DVECTOR s1,
+ LPD3DVECTOR s2);
+
+/*
+ * Scale a vector so that its modulus is 1. Returns its argument or
+ * NULL if there was an error (e.g. a zero vector was passed).
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorNormalize(LPD3DVECTOR);
+#define D3DRMVectorNormalise D3DRMVectorNormalize
+
+/*
+ * Return the length of a vector (e.g. sqrt(x*x + y*y + z*z)).
+ */
+extern D3DVALUE D3DRMAPI D3DRMVectorModulus(LPD3DVECTOR v);
+
+/*
+ * Set the rotation part of a matrix to be a rotation of theta radians
+ * around the given axis.
+ */
+
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorRotate(LPD3DVECTOR r, LPD3DVECTOR v, LPD3DVECTOR axis, D3DVALUE theta);
+
+/*
+ * Scale a vector uniformly in all three axes
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorScale(LPD3DVECTOR d, LPD3DVECTOR s, D3DVALUE factor);
+
+/*
+ * Return a random unit vector
+ */
+extern LPD3DVECTOR D3DRMAPI D3DRMVectorRandom(LPD3DVECTOR d);
+
+/*
+ * Returns a unit quaternion that represents a rotation of theta radians
+ * around the given axis.
+ */
+
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromRotation(LPD3DRMQUATERNION quat,
+ LPD3DVECTOR v,
+ D3DVALUE theta);
+
+/*
+ * Calculate the product of two quaternions
+ */
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION q,
+ LPD3DRMQUATERNION a,
+ LPD3DRMQUATERNION b);
+
+/*
+ * Interpolate between two quaternions
+ */
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION q,
+ LPD3DRMQUATERNION a,
+ LPD3DRMQUATERNION b,
+ D3DVALUE alpha);
+
+/*
+ * Calculate the matrix for the rotation that a unit quaternion represents
+ */
+extern void D3DRMAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D dmMat, LPD3DRMQUATERNION lpDqQuat);
+
+/*
+ * Calculate the quaternion that corresponds to a rotation matrix
+ */
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromMatrix(LPD3DRMQUATERNION, D3DRMMATRIX4D);
+
+
+#if defined(__cplusplus)
+};
+#endif
+
+#endif
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-02 23:32:12 +0100