mirror of
https://github.com/isledecomp/isle-portable.git
synced 2026-01-11 10:31:16 +00:00
379 lines
14 KiB
C
379 lines
14 KiB
C
#pragma once
|
|
|
|
#include "miniwin_d3d.h"
|
|
|
|
// --- Defines and Macros ---
|
|
#define D3DRM_OK DD_OK
|
|
#define MAXSHORT ((short) 0x7fff)
|
|
#define SUCCEEDED(hr) ((hr) >= D3DRM_OK)
|
|
#define D3DPTFILTERCAPS_LINEAR 0x00000001
|
|
#define D3DPSHADECAPS_ALPHAFLATBLEND 0x00000100
|
|
|
|
// --- Typedefs ---
|
|
typedef DWORD D3DRMMAPPING, *LPD3DRMMAPPING;
|
|
typedef float D3DVAL;
|
|
typedef void* LPD3DRM_APPDATA;
|
|
typedef unsigned long D3DRMGROUPINDEX;
|
|
typedef DWORD D3DRMRENDERQUALITY, *LPD3DRMRENDERQUALITY;
|
|
typedef DWORD D3DCOLOR, *LPD3DCOLOR;
|
|
typedef float D3DVALUE, *LPD3DVALUE;
|
|
|
|
// --- Enums ---
|
|
enum D3DRMCOMBINETYPE {
|
|
D3DRMCOMBINE_REPLACE,
|
|
D3DRMCOMBINE_BEFORE,
|
|
D3DRMCOMBINE_AFTER
|
|
};
|
|
typedef D3DRMCOMBINETYPE* LPD3DRMCOMBINETYPE;
|
|
|
|
enum D3DRMPALETTEFLAGS {
|
|
D3DRMPALETTE_READONLY
|
|
};
|
|
typedef D3DRMPALETTEFLAGS* LPD3DRMPALETTEFLAGS;
|
|
|
|
enum D3DRMTEXTUREQUALITY {
|
|
D3DRMTEXTURE_NEAREST,
|
|
D3DRMTEXTURE_LINEAR,
|
|
D3DRMTEXTURE_MIPNEAREST,
|
|
D3DRMTEXTURE_MIPLINEAR,
|
|
D3DRMTEXTURE_LINEARMIPNEAREST,
|
|
D3DRMTEXTURE_LINEARMIPLINEAR
|
|
};
|
|
typedef D3DRMTEXTUREQUALITY* LPD3DRMTEXTUREQUALITY;
|
|
|
|
enum D3DRMRENDERMODE {
|
|
D3DRMRENDERMODE_BLENDEDTRANSPARENCY
|
|
};
|
|
|
|
enum D3DRMMappingFlag {
|
|
D3DRMMAP_WRAPU = 1,
|
|
D3DRMMAP_WRAPV = 2,
|
|
D3DRMMAP_PERSPCORRECT = 4
|
|
};
|
|
|
|
enum D3DRMLIGHTTYPE {
|
|
D3DRMLIGHT_AMBIENT,
|
|
D3DRMLIGHT_POINT,
|
|
D3DRMLIGHT_SPOT,
|
|
D3DRMLIGHT_DIRECTIONAL,
|
|
D3DRMLIGHT_PARALLELPOINT
|
|
};
|
|
typedef D3DRMLIGHTTYPE* LPD3DRMLIGHTTYPE;
|
|
|
|
enum D3DRMMATERIALMODE {
|
|
D3DRMMATERIAL_FROMPARENT,
|
|
D3DRMMATERIAL_FROMFRAME,
|
|
D3DRMMATERIAL_FROMMESH
|
|
};
|
|
|
|
enum D3DRMRenderMode {
|
|
D3DRMRENDER_WIREFRAME = 0,
|
|
D3DRMRENDER_UNLITFLAT = 1,
|
|
D3DRMRENDER_FLAT = 2,
|
|
D3DRMRENDER_GOURAUD = 4,
|
|
D3DRMRENDER_PHONG = 8
|
|
};
|
|
|
|
enum D3DRMPROJECTIONTYPE {
|
|
D3DRMPROJECT_PERSPECTIVE,
|
|
D3DRMPROJECT_ORTHOGRAPHIC
|
|
};
|
|
typedef D3DRMPROJECTIONTYPE* LPD3DRMPROJECTIONTYPE;
|
|
|
|
// --- GUIDs ---
|
|
DEFINE_GUID(IID_IDirect3DRM2, 0x4516ec41, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
|
|
DEFINE_GUID(IID_IDirect3DRMWinDevice, 0x0eb16e60, 0xcbf4, 0x11cf, 0xa5, 0x3c, 0x00, 0x20, 0xaf, 0x70, 0x7e, 0xfd);
|
|
DEFINE_GUID(IID_IDirect3DRMMesh, 0x4516ec78, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
|
|
DEFINE_GUID(IID_IDirect3DRMMeshBuilder, 0x4516ec7b, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
|
|
DEFINE_GUID(IID_IDirect3DRMTexture2, 0x120f30c0, 0x1629, 0x11d1, 0x94, 0x26, 0x00, 0x60, 0x97, 0x0c, 0xf4, 0x0d);
|
|
|
|
// --- Structs ---
|
|
typedef struct D3DRMVECTOR4D {
|
|
float x, y, z, w;
|
|
} D3DRMVECTOR4D;
|
|
|
|
typedef struct D3DRMPALETTEENTRY {
|
|
unsigned char red, green, blue, flags;
|
|
} D3DRMPALETTEENTRY;
|
|
|
|
typedef struct D3DRMIMAGE {
|
|
unsigned int width, height, depth, bytes_per_line;
|
|
unsigned int red_mask, green_mask, blue_mask, alpha_mask;
|
|
unsigned int palette_size;
|
|
D3DRMPALETTEENTRY* palette;
|
|
void* buffer1;
|
|
void* buffer2;
|
|
void* data;
|
|
int rgb;
|
|
int aspectx, aspecty;
|
|
unsigned int format;
|
|
} D3DRMIMAGE;
|
|
|
|
typedef struct D3DRMMATRIX4D {
|
|
double* operator[](size_t i) { return 0; }
|
|
const double* operator[](size_t i) const { return 0; }
|
|
} D3DRMMATRIX4D;
|
|
|
|
struct D3DRMBOX {
|
|
D3DVECTOR min;
|
|
D3DVECTOR max;
|
|
};
|
|
|
|
struct D3DRMVERTEX {
|
|
D3DVECTOR position;
|
|
D3DVECTOR normal;
|
|
float tu, tv;
|
|
};
|
|
|
|
struct IDirect3DRMVisual : public IUnknown {};
|
|
typedef IDirect3DRMVisual* LPDIRECT3DRMVISUAL;
|
|
|
|
struct IDirect3DRMObject : public IUnknown {
|
|
virtual HRESULT Clone(void** ppObject) { return DDERR_GENERIC; }
|
|
virtual HRESULT AddDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) { return D3DRM_OK; }
|
|
virtual HRESULT DeleteDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) { return D3DRM_OK; }
|
|
virtual HRESULT SetAppData(LPD3DRM_APPDATA appData) { return D3DRM_OK; }
|
|
virtual DWORD GetAppData() = 0;
|
|
virtual HRESULT SetName(const char* name) { return D3DRM_OK; }
|
|
virtual HRESULT GetName(DWORD* size, char* name) { return D3DRM_OK; }
|
|
virtual HRESULT GetClassName(DWORD* size, char* name) { return D3DRM_OK; }
|
|
};
|
|
struct IDirect3DRMTexture : public IUnknown {
|
|
virtual HRESULT AddDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) { return D3DRM_OK; }
|
|
virtual DWORD GetAppData() { return 0; }
|
|
virtual HRESULT SetAppData(LPD3DRM_APPDATA appData) { return D3DRM_OK; }
|
|
virtual HRESULT SetTexture(const IDirect3DRMTexture* texture) { return D3DRM_OK; }
|
|
virtual HRESULT Changed(BOOL arg1, BOOL arg2) { return D3DRM_OK; }
|
|
};
|
|
typedef IDirect3DRMTexture* LPDIRECT3DRMTEXTURE;
|
|
|
|
struct IDirect3DRMTexture2 : public IDirect3DRMTexture {};
|
|
typedef IDirect3DRMTexture2* LPDIRECT3DRMTEXTURE2;
|
|
|
|
typedef struct IDirect3DRMMaterial *LPDIRECT3DRMMATERIAL, **LPLPDIRECT3DRMMATERIAL;
|
|
|
|
struct IDirect3DRMMesh {
|
|
virtual ULONG Release() { return 0; }
|
|
virtual HRESULT Clone(int flags, GUID iid, void** object) { return DDERR_GENERIC; }
|
|
virtual HRESULT GetBox(D3DRMBOX* box) { return D3DRM_OK; }
|
|
virtual HRESULT AddGroup(
|
|
int vertexCount,
|
|
int faceCount,
|
|
int vertexPerFace,
|
|
void* faceBuffer,
|
|
D3DRMGROUPINDEX* groupIndex
|
|
)
|
|
{
|
|
return D3DRM_OK;
|
|
}
|
|
virtual HRESULT GetGroup(
|
|
int groupIndex,
|
|
unsigned int* vertexCount,
|
|
unsigned int* faceCount,
|
|
unsigned int* vertexPerFace,
|
|
DWORD* dataSize,
|
|
unsigned int* data
|
|
)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
virtual HRESULT SetGroupColor(int groupIndex, D3DCOLOR color) { return D3DRM_OK; }
|
|
virtual HRESULT SetGroupColorRGB(int groupIndex, float r, float g, float b) { return D3DRM_OK; }
|
|
virtual HRESULT SetGroupTexture(int groupIndex, const IDirect3DRMTexture* texture) { return D3DRM_OK; }
|
|
virtual HRESULT SetGroupMaterial(int groupIndex, IDirect3DRMMaterial* material) { return D3DRM_OK; }
|
|
virtual HRESULT SetGroupMapping(int groupIndex, int mapping) { return D3DRM_OK; }
|
|
virtual HRESULT SetGroupQuality(int groupIndex, D3DRMRENDERQUALITY quality) { return D3DRM_OK; }
|
|
virtual HRESULT SetVertices(int groupIndex, int offset, int count, D3DRMVERTEX* vertices) { return D3DRM_OK; }
|
|
virtual HRESULT GetGroupTexture(int groupIndex, LPDIRECT3DRMTEXTURE* texture) { return DDERR_GENERIC; }
|
|
virtual HRESULT GetGroupMapping(int groupIndex) { return D3DRM_OK; }
|
|
virtual HRESULT GetGroupQuality(int groupIndex) { return D3DRM_OK; }
|
|
virtual HRESULT GetGroupColor(D3DRMGROUPINDEX index) { return D3DRM_OK; }
|
|
virtual HRESULT GetVertices(int groupIndex, int startIndex, int count, D3DRMVERTEX* vertices) { return D3DRM_OK; }
|
|
};
|
|
|
|
struct IDirect3DRMLight {
|
|
virtual ULONG AddRef() { return 0; }
|
|
virtual ULONG Release() { return 0; }
|
|
virtual HRESULT SetColorRGB(float r, float g, float b) { return D3DRM_OK; }
|
|
};
|
|
|
|
struct IDirect3DRMLightArray {
|
|
virtual ULONG Release() { return 0; }
|
|
virtual DWORD GetSize() { return 0; }
|
|
virtual HRESULT GetElement(int index, IDirect3DRMLight** light) const { return DDERR_GENERIC; }
|
|
};
|
|
|
|
struct IDirect3DRMVisualArray {
|
|
virtual ULONG Release() { return 0; }
|
|
virtual DWORD GetSize() { return 0; }
|
|
virtual HRESULT GetElement(int index, IDirect3DRMVisual** visual) const { return DDERR_GENERIC; }
|
|
};
|
|
|
|
typedef struct IDirect3DRMFrameArray* LPDIRECT3DRMFRAMEARRAY;
|
|
struct IDirect3DRMFrame {
|
|
virtual ULONG AddRef() { return 0; }
|
|
virtual ULONG Release() { return 0; }
|
|
virtual HRESULT SetAppData(LPD3DRM_APPDATA appData) { return D3DRM_OK; }
|
|
virtual DWORD GetAppData() { return 0; }
|
|
virtual HRESULT AddChild(IDirect3DRMFrame* child) { return D3DRM_OK; }
|
|
virtual HRESULT DeleteChild(IDirect3DRMFrame* child) { return D3DRM_OK; }
|
|
virtual HRESULT SetSceneBackgroundRGB(float r, float g, float b) { return D3DRM_OK; }
|
|
virtual HRESULT AddLight(IDirect3DRMLight* light) { return D3DRM_OK; }
|
|
virtual HRESULT GetLights(IDirect3DRMLightArray** lightArray) { return DDERR_GENERIC; }
|
|
virtual HRESULT AddTransform(int combine, D3DRMMATRIX4D matrix) { return D3DRM_OK; }
|
|
virtual HRESULT GetPosition(int index, D3DVECTOR* position) { return D3DRM_OK; }
|
|
virtual HRESULT AddVisual(IDirect3DRMVisual* visual) { return D3DRM_OK; }
|
|
virtual HRESULT DeleteVisual(IDirect3DRMVisual* visual) { return D3DRM_OK; }
|
|
virtual HRESULT AddVisual(IDirect3DRMMesh* visual) { return D3DRM_OK; }
|
|
virtual HRESULT DeleteVisual(IDirect3DRMMesh* visual) { return D3DRM_OK; }
|
|
virtual HRESULT AddVisual(IDirect3DRMFrame* visual) { return D3DRM_OK; }
|
|
virtual HRESULT DeleteVisual(IDirect3DRMFrame* visual) { return D3DRM_OK; }
|
|
virtual HRESULT GetVisuals(IDirect3DRMVisualArray** visuals) { return DDERR_GENERIC; }
|
|
virtual HRESULT SetTexture(const IDirect3DRMTexture* texture) { return D3DRM_OK; }
|
|
virtual HRESULT GetTexture(IDirect3DRMTexture** texture) { return DDERR_GENERIC; }
|
|
virtual HRESULT SetColor(float r, float g, float b, float a) { return D3DRM_OK; }
|
|
virtual HRESULT SetColor(D3DCOLOR) { return D3DRM_OK; }
|
|
virtual HRESULT SetColorRGB(float r, float g, float b) { return D3DRM_OK; }
|
|
virtual HRESULT SetMaterialMode(D3DRMMATERIALMODE mode) { return D3DRM_OK; }
|
|
virtual HRESULT GetChildren(IDirect3DRMFrameArray** children) { return DDERR_GENERIC; }
|
|
};
|
|
typedef IDirect3DRMFrame* LPDIRECT3DRMFRAME;
|
|
|
|
struct IDirect3DRMFrame2 : public IDirect3DRMFrame {};
|
|
typedef IDirect3DRMFrame2* LPDIRECT3DRMFRAME2;
|
|
|
|
struct IDirect3DRMFrameArray : public IUnknown {
|
|
virtual DWORD GetSize() { return 0; }
|
|
virtual HRESULT GetElement(DWORD index, IDirect3DRMFrame** frame) { return DDERR_GENERIC; }
|
|
};
|
|
|
|
struct D3DRMPICKDESC {
|
|
IDirect3DRMVisual* visual;
|
|
IDirect3DRMFrame* frame;
|
|
float dist;
|
|
};
|
|
|
|
struct IDirect3DRMPickedArray {
|
|
virtual ULONG Release() { return 0; }
|
|
DWORD GetSize() { return 0; }
|
|
HRESULT GetPick(DWORD index, IDirect3DRMVisual** visual, IDirect3DRMFrameArray** frameArray, D3DRMPICKDESC* desc)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
};
|
|
typedef IDirect3DRMPickedArray* LPDIRECT3DRMPICKEDARRAY;
|
|
|
|
struct IDirect3DRMViewport : public IDirect3DRMObject {
|
|
virtual HRESULT Render(IDirect3DRMFrame* group) { return D3DRM_OK; }
|
|
virtual HRESULT ForceUpdate(int x, int y, int w, int h) { return D3DRM_OK; }
|
|
virtual HRESULT Clear() { return D3DRM_OK; }
|
|
virtual HRESULT SetCamera(IDirect3DRMFrame* camera) { return D3DRM_OK; }
|
|
virtual HRESULT GetCamera(IDirect3DRMFrame** camera) { return DDERR_GENERIC; }
|
|
virtual HRESULT SetProjection(D3DRMPROJECTIONTYPE type) { return D3DRM_OK; }
|
|
virtual D3DRMPROJECTIONTYPE GetProjection() { return D3DRMPROJECT_PERSPECTIVE; }
|
|
virtual HRESULT SetFront(D3DVALUE z) { return D3DRM_OK; }
|
|
virtual D3DVALUE GetFront() { return 1.0f; }
|
|
virtual HRESULT SetBack(D3DVALUE z) { return D3DRM_OK; }
|
|
virtual D3DVALUE GetBack() { return 100.0f; }
|
|
virtual HRESULT SetField(D3DVALUE field) { return D3DRM_OK; }
|
|
virtual D3DVALUE GetField() { return 1.0f; }
|
|
virtual int GetWidth() { return 640; }
|
|
virtual int GetHeight() { return 480; }
|
|
virtual HRESULT Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world) { return D3DRM_OK; }
|
|
virtual HRESULT InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen) { return D3DRM_OK; }
|
|
virtual HRESULT Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray) { return D3DRM_OK; }
|
|
};
|
|
|
|
struct IDirect3DRMWinDevice : public IUnknown {
|
|
virtual HRESULT Activate() { return D3DRM_OK; }
|
|
virtual HRESULT Paint() { return D3DRM_OK; }
|
|
virtual void HandleActivate(WORD wParam) {}
|
|
virtual void HandlePaint(void* p_dc) {}
|
|
};
|
|
|
|
struct IDirect3DRMViewportArray {
|
|
virtual ULONG AddRef() { return 0; }
|
|
virtual ULONG Release() { return 0; }
|
|
virtual DWORD GetSize() { return 0; }
|
|
virtual HRESULT GetElement(int index, IDirect3DRMViewport** viewport) { return DDERR_GENERIC; }
|
|
};
|
|
|
|
struct IDirect3DRMDevice2 : public IUnknown {
|
|
virtual unsigned long GetWidth() { return 640; }
|
|
virtual unsigned long GetHeight() { return 480; }
|
|
virtual HRESULT SetBufferCount(int count) { return D3DRM_OK; }
|
|
virtual HRESULT GetBufferCount() { return D3DRM_OK; }
|
|
virtual HRESULT SetShades(unsigned long shadeCount) { return D3DRM_OK; }
|
|
virtual HRESULT GetShades() { return D3DRM_OK; }
|
|
virtual HRESULT SetQuality(int quality) { return D3DRM_OK; }
|
|
virtual HRESULT GetQuality() { return D3DRM_OK; }
|
|
virtual HRESULT SetDither(int dither) { return D3DRM_OK; }
|
|
virtual HRESULT GetDither() { return D3DRM_OK; }
|
|
virtual HRESULT SetTextureQuality(D3DRMTEXTUREQUALITY quality) { return D3DRM_OK; }
|
|
virtual D3DRMTEXTUREQUALITY GetTextureQuality() { return D3DRMTEXTURE_NEAREST; }
|
|
virtual HRESULT SetRenderMode(int mode) { return D3DRM_OK; }
|
|
virtual HRESULT GetRenderMode() { return D3DRM_OK; }
|
|
virtual HRESULT Update() { return D3DRM_OK; }
|
|
virtual HRESULT GetViewports(IDirect3DRMViewportArray** ppViewportArray) { return DDERR_GENERIC; }
|
|
};
|
|
|
|
struct IDirect3DRM : public IUnknown {
|
|
virtual HRESULT CreateDeviceFromD3D(
|
|
const IDirect3D2* d3d,
|
|
IDirect3DDevice2* d3dDevice,
|
|
IDirect3DRMDevice2** outDevice
|
|
)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
virtual HRESULT CreateDeviceFromSurface(
|
|
const GUID* guid,
|
|
IDirectDraw* dd,
|
|
IDirectDrawSurface* surface,
|
|
IDirect3DRMDevice2** outDevice
|
|
)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
virtual HRESULT CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) { return DDERR_GENERIC; }
|
|
virtual HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
virtual HRESULT CreateMesh(IDirect3DRMMesh** outMesh) { return DDERR_GENERIC; }
|
|
virtual HRESULT CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) { return DDERR_GENERIC; }
|
|
virtual HRESULT CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
virtual HRESULT CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) { return DDERR_GENERIC; }
|
|
virtual HRESULT CreateViewport(
|
|
IDirect3DRMDevice2* device,
|
|
IDirect3DRMFrame* camera,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
int height,
|
|
IDirect3DRMViewport** outViewport
|
|
)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
virtual HRESULT SetDefaultTextureShades(unsigned int count) { return D3DRM_OK; }
|
|
virtual HRESULT SetDefaultTextureColors(unsigned int count) { return D3DRM_OK; }
|
|
};
|
|
typedef IDirect3DRM *LPDIRECT3DRM, **LPLPDIRECT3DRM;
|
|
|
|
struct IDirect3DRM2 : public IDirect3DRM {};
|
|
|
|
// Functions
|
|
inline HRESULT WINAPI Direct3DRMCreate(IDirect3DRM** direct3DRM)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
|
|
inline D3DCOLOR D3DRMCreateColorRGBA(D3DVALUE red, D3DVALUE green, D3DVALUE blue, D3DVALUE alpha)
|
|
{
|
|
return 0;
|
|
}
|