ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/d3d8/d3d8_private.h

1347 lines
68 KiB
C
Raw Normal View History

Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/*
* Direct3D 8 private include file
*
* Copyright 2002 Jason Edmeades
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
- currently always use sloaw path as fast path have some problems - fix APIENTRY mismatched value used by gl func pointers (in d3dcore_gl.h)
2003-06-28 00:20:44 +02:00
#ifndef __WINE_D3D8_PRIVATE_H
#define __WINE_D3D8_PRIVATE_H
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
Header files must not include config.h.
2003-04-12 02:06:42 +02:00
#ifndef __WINE_CONFIG_H
# error You must include config.h to use this header
#endif
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* THIS FILE MUST NOT CONTAIN X11 or MESA DEFINES */
#define XMD_H /* This is to prevent the Xmd.h inclusion bug :-/ */
#include <GL/gl.h>
#include <GL/glx.h>
#ifdef HAVE_GL_GLEXT_H
# include <GL/glext.h>
#endif
#undef XMD_H
#undef APIENTRY
#undef CALLBACK
#undef WINAPI
/* Redefines the constants */
#define CALLBACK __stdcall
#define WINAPI __stdcall
#define APIENTRY WINAPI
/* X11 locking */
extern void (*wine_tsx11_lock_ptr)(void);
extern void (*wine_tsx11_unlock_ptr)(void);
/* As GLX relies on X, this is needed */
- currently always use sloaw path as fast path have some problems - fix APIENTRY mismatched value used by gl func pointers (in d3dcore_gl.h)
2003-06-28 00:20:44 +02:00
extern int num_lock;
#if 0
#define ENTER_GL() ++num_lock; TRACE("inc lock to: %d\n", num_lock); wine_tsx11_lock_ptr()
#define LEAVE_GL() if (num_lock > 2) TRACE("fucking locks: %d\n", num_lock); --num_lock; wine_tsx11_unlock_ptr()
#else
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
#define ENTER_GL() wine_tsx11_lock_ptr()
#define LEAVE_GL() wine_tsx11_unlock_ptr()
- currently always use sloaw path as fast path have some problems - fix APIENTRY mismatched value used by gl func pointers (in d3dcore_gl.h)
2003-06-28 00:20:44 +02:00
#endif
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
Fixed header dependencies to be fully compatible with the Windows headers (with help from Dimitrie O. Paun).
2003-09-06 01:08:26 +02:00
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
#include "d3d8.h"
/* Device caps */
- mor usefull debug functions debug_d3dusage and debug_d3ddevicetype - fix a crash in pixel shader parser (happened with unreal2) - currently desactive pixel shaders caps (with #define) while hw shaders code isn't merged - when we have a special debug channel for shader, use it ;) - fix again some stubs return value - more more readable traces now (principaly IDirect3D8 capacities check and surface locking code) using new debug functions - fix/cleaning the surface locking code - now we support D3DTOP_SUBSTRACT so declare it in caps - now support true 32bit (well X 24 bit can be used as 32 bit in caps code) - first try to get D3DTSS_TCI_CAMERASPACENORMAL and D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR look good - native support 32 bit support (now application can choose 16 or 32 bit support) if current resolution is 24 bit (as we can only launch games in windowed mode) - textures palettes support - fix reflexion placement code (the sdk sample begin to work) - fix a stupid crash when using traces in vshaderdeclaration - more more readable traces (init/caps) - more cubetextures fixes
2003-05-17 20:33:02 +02:00
#define MAX_PALETTES 256
Reserve space for 16 streams in the stateblock.
2003-04-30 00:44:18 +02:00
#define MAX_STREAMS 16
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
#define MAX_CLIPPLANES D3DMAXUSERCLIPPLANES
- mor usefull debug functions debug_d3dusage and debug_d3ddevicetype - fix a crash in pixel shader parser (happened with unreal2) - currently desactive pixel shaders caps (with #define) while hw shaders code isn't merged - when we have a special debug channel for shader, use it ;) - fix again some stubs return value - more more readable traces now (principaly IDirect3D8 capacities check and surface locking code) using new debug functions - fix/cleaning the surface locking code - now we support D3DTOP_SUBSTRACT so declare it in caps - now support true 32bit (well X 24 bit can be used as 32 bit in caps code) - first try to get D3DTSS_TCI_CAMERASPACENORMAL and D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR look good - native support 32 bit support (now application can choose 16 or 32 bit support) if current resolution is 24 bit (as we can only launch games in windowed mode) - textures palettes support - fix reflexion placement code (the sdk sample begin to work) - fix a stupid crash when using traces in vshaderdeclaration - more more readable traces (init/caps) - more cubetextures fixes
2003-05-17 20:33:02 +02:00
#define MAX_LEVELS 256
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* Other useful values */
#define HIGHEST_RENDER_STATE 174
#define HIGHEST_TEXTURE_STATE 29
#define HIGHEST_TRANSFORMSTATE 512
#define D3DSBT_RECORDED 0xfffffffe
Only reapply the texture states necessary when a different texture gets bound to the same texture unit.
2003-08-05 21:18:58 +02:00
/* Performance changes - Only reapply what is necessary */
#define REAPPLY_ALPHAOP 0x0001
#define REAPPLY_ALL 0xFFFF
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
/* CreateVertexShader can return > 0xFFFF */
#define VS_HIGHESTFIXEDFXF 0xF0000000
#define VERTEX_SHADER(Handle) \
((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(VertexShaders) / sizeof(IDirect3DVertexShaderImpl*)) ? NULL : VertexShaders[Handle]) : VertexShaders[Handle - VS_HIGHESTFIXEDFXF])
#define VERTEX_SHADER_DECL(Handle) \
((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(VertexShaderDeclarations) / sizeof(IDirect3DVertexShaderDeclarationImpl*)) ? NULL : VertexShaderDeclarations[Handle]) : VertexShaderDeclarations[Handle - VS_HIGHESTFIXEDFXF])
#define PIXEL_SHADER(Handle) \
((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(PixelShaders) / sizeof(IDirect3DPixelShaderImpl*)) ? NULL : PixelShaders[Handle]) : PixelShaders[Handle - VS_HIGHESTFIXEDFXF])
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
/* Direct3D8 Interfaces: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
typedef struct IDirect3DBaseTexture8Impl IDirect3DBaseTexture8Impl;
typedef struct IDirect3DVolumeTexture8Impl IDirect3DVolumeTexture8Impl;
typedef struct IDirect3D8Impl IDirect3D8Impl;
typedef struct IDirect3DDevice8Impl IDirect3DDevice8Impl;
typedef struct IDirect3DTexture8Impl IDirect3DTexture8Impl;
typedef struct IDirect3DCubeTexture8Impl IDirect3DCubeTexture8Impl;
typedef struct IDirect3DIndexBuffer8Impl IDirect3DIndexBuffer8Impl;
typedef struct IDirect3DSurface8Impl IDirect3DSurface8Impl;
typedef struct IDirect3DSwapChain8Impl IDirect3DSwapChain8Impl;
typedef struct IDirect3DResource8Impl IDirect3DResource8Impl;
typedef struct IDirect3DVolume8Impl IDirect3DVolume8Impl;
typedef struct IDirect3DVertexBuffer8Impl IDirect3DVertexBuffer8Impl;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/** Private Interfaces: */
typedef struct IDirect3DStateBlockImpl IDirect3DStateBlockImpl;
typedef struct IDirect3DVertexShaderImpl IDirect3DVertexShaderImpl;
typedef struct IDirect3DPixelShaderImpl IDirect3DPixelShaderImpl;
typedef struct IDirect3DVertexShaderDeclarationImpl IDirect3DVertexShaderDeclarationImpl;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
typedef struct D3DSHADERVECTOR {
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
float x;
float y;
float z;
float w;
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
} D3DSHADERVECTOR;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
typedef struct D3DSHADERSCALAR {
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
float x;
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
} D3DSHADERSCALAR;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
#define D3D8_VSHADER_MAX_CONSTANTS 96
typedef D3DSHADERVECTOR VSHADERCONSTANTS8[D3D8_VSHADER_MAX_CONSTANTS];
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
typedef struct VSHADERDATA8 {
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/** Run Time Shader Function Constants */
- some fixes in CreateDevice init - vertex shader declaration parser (with output dump) and interpretation (generate the FVF descriptor for program input) - vertex shader program parser (with output dump) - software vertex shader program emulation
2002-12-18 06:05:41 +01:00
/*D3DXBUFFER* constants;*/
- integration with DrawPrimitive - remove non-esthetic c++ comments into c comments block ;) - more more debug - indent, cleanups - trying to use DIFFUSE and SPECULAR for vertex shader - many fixes - integration with Jason's texture patch
2003-01-02 18:59:01 +01:00
VSHADERCONSTANTS8 C;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/** Shader Code as char ... */
CONST DWORD* code;
UINT codeLength;
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
} VSHADERDATA8;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
- move input and output data in VertexShader struct - better traces - specific input data filling function for vertex shaders using vertex shader declaration (and not FVF ... maybe FVF will return for fast path with simples vertex shader declarations) - huge vertex shader fixes: - add and fix many vs (1.0->2.0) used opcodes in complex shaders - improvements to programs parser: parse comments, version, .. - add a vertex shader input filler function (parsing vertex shader declaration): almost complete - comments most of the traces (else flood ...) - add more urls in comments - indent, cleanups
2003-01-14 21:29:33 +01:00
/** temporary here waiting for buffer code */
typedef struct VSHADERINPUTDATA8 {
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
D3DSHADERVECTOR V[17];
- move input and output data in VertexShader struct - better traces - specific input data filling function for vertex shaders using vertex shader declaration (and not FVF ... maybe FVF will return for fast path with simples vertex shader declarations) - huge vertex shader fixes: - add and fix many vs (1.0->2.0) used opcodes in complex shaders - improvements to programs parser: parse comments, version, .. - add a vertex shader input filler function (parsing vertex shader declaration): almost complete - comments most of the traces (else flood ...) - add more urls in comments - indent, cleanups
2003-01-14 21:29:33 +01:00
} VSHADERINPUTDATA8;
/** temporary here waiting for buffer code */
typedef struct VSHADEROUTPUTDATA8 {
D3DSHADERVECTOR oPos;
D3DSHADERVECTOR oD[2];
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
D3DSHADERVECTOR oT[8];
- move input and output data in VertexShader struct - better traces - specific input data filling function for vertex shaders using vertex shader declaration (and not FVF ... maybe FVF will return for fast path with simples vertex shader declarations) - huge vertex shader fixes: - add and fix many vs (1.0->2.0) used opcodes in complex shaders - improvements to programs parser: parse comments, version, .. - add a vertex shader input filler function (parsing vertex shader declaration): almost complete - comments most of the traces (else flood ...) - add more urls in comments - indent, cleanups
2003-01-14 21:29:33 +01:00
D3DSHADERVECTOR oFog;
D3DSHADERVECTOR oPts;
} VSHADEROUTPUTDATA8;
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
#define D3D8_PSHADER_MAX_CONSTANTS 32
typedef D3DSHADERVECTOR PSHADERCONSTANTS8[D3D8_PSHADER_MAX_CONSTANTS];
typedef struct PSHADERDATA8 {
/** Run Time Shader Function Constants */
/*D3DXBUFFER* constants;*/
PSHADERCONSTANTS8 C;
/** Shader Code as char ... */
CONST DWORD* code;
UINT codeLength;
} PSHADERDATA8;
/** temporary here waiting for buffer code */
typedef struct PSHADERINPUTDATA8 {
D3DSHADERVECTOR V[2];
D3DSHADERVECTOR T[8];
D3DSHADERVECTOR S[16];
/*D3DSHADERVECTOR R[12];*/
} PSHADERINPUTDATA8;
/** temporary here waiting for buffer code */
typedef struct PSHADEROUTPUTDATA8 {
D3DSHADERVECTOR oC[4];
D3DSHADERVECTOR oDepth;
} PSHADEROUTPUTDATA8;
MaxActiveLights means number of concurrent lights, but any number can be set up. Change support for lights into a linked list and only set up an equivalent gl light when the light is enabled.
2003-09-30 02:21:07 +02:00
/*
* Private definitions for internal use only
*/
typedef struct PLIGHTINFOEL PLIGHTINFOEL;
struct PLIGHTINFOEL {
D3DLIGHT8 OriginalParms;
DWORD OriginalIndex;
LONG glIndex;
BOOL lightEnabled;
BOOL changed;
BOOL enabledChanged;
/* Converted parms to speed up swapping lights */
float lightPosn[4];
float lightDirn[4];
float exponent;
float cutoff;
PLIGHTINFOEL *next;
PLIGHTINFOEL *prev;
};
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/*
* Macros
*/
#define checkGLcall(A) \
{ \
GLint err = glGetError(); \
if (err != GL_NO_ERROR) { \
FIXME(">>>>>>>>>>>>>>>>> %x from %s @ %s / %d\n", err, A, __FILE__, __LINE__); \
} else { \
TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \
} \
}
- Disable some 'classic' debug traces (avoid useless flood of traces while debugging games). - Fix the texture size caps using GL_MAX_TEXTURE_SIZE.
2003-05-08 19:36:00 +02:00
#define vcheckGLcall(A) \
{ \
GLint err = glGetError(); \
if (err != GL_NO_ERROR) { \
FIXME(">>>>>>>>>>>>>>>>> %x from %s @ %s / %d\n", err, A, __FILE__, __LINE__); \
} else { \
VTRACE(("%s call ok %s / %d\n", A, __FILE__, __LINE__)); \
} \
}
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- add a new private header d3dcore_gl.h that declares needed opengl defines and the caps defines - cleanup of device.c using the caps defines (avoid the #ifdef nigthmare) - add {Set,Get}GammaRamp support
2003-06-05 01:01:49 +02:00
#include "d3dcore_gl.h"
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
- add a new private header d3dcore_gl.h that declares needed opengl defines and the caps defines - cleanup of device.c using the caps defines (avoid the #ifdef nigthmare) - add {Set,Get}GammaRamp support
2003-06-05 01:01:49 +02:00
#define GL_LIMITS(ExtName) (This->direct3d8->gl_info.max_##ExtName)
#define GL_SUPPORT(ExtName) (TRUE == This->direct3d8->gl_info.supported[ExtName])
#define GL_SUPPORT_DEV(ExtName, dev) (TRUE == (dev)->direct3d8->gl_info.supported[ExtName])
#define GL_EXTCALL(FuncName) (This->direct3d8->gl_info.FuncName)
- move input and output data in VertexShader struct - better traces - specific input data filling function for vertex shaders using vertex shader declaration (and not FVF ... maybe FVF will return for fast path with simples vertex shader declarations) - huge vertex shader fixes: - add and fix many vs (1.0->2.0) used opcodes in complex shaders - improvements to programs parser: parse comments, version, .. - add a vertex shader input filler function (parsing vertex shader declaration): almost complete - comments most of the traces (else flood ...) - add more urls in comments - indent, cleanups
2003-01-14 21:29:33 +01:00
#define D3DCOLOR_R(dw) (((float) (((dw) >> 16) & 0xFF)) / 255.0f)
#define D3DCOLOR_G(dw) (((float) (((dw) >> 8) & 0xFF)) / 255.0f)
#define D3DCOLOR_B(dw) (((float) (((dw) >> 0) & 0xFF)) / 255.0f)
#define D3DCOLOR_A(dw) (((float) (((dw) >> 24) & 0xFF)) / 255.0f)
#define D3DCOLORTOCOLORVALUE(dw, col) \
(col).r = D3DCOLOR_R(dw); \
(col).g = D3DCOLOR_G(dw); \
(col).b = D3DCOLOR_B(dw); \
(col).a = D3DCOLOR_A(dw);
#define D3DCOLORTOVECTOR4(dw, vec) \
(vec).x = D3DCOLOR_R(dw); \
(vec).y = D3DCOLOR_G(dw); \
(vec).z = D3DCOLOR_B(dw); \
(vec).w = D3DCOLOR_A(dw);
- declare a new debug chanel for vertex shaders - some useful debug functions for textures format - correct DrawPrimitive (RHW correctness and vshader RHW) - more copyrects fixes (only two unimplemented behavior remain) - fix GetFrontBuffer to get screenshots samples working - add D3DCOLORTOGLFLOAT4 and use it - first try of D3DRS_FOGTABLEMODE support
2003-05-14 21:33:35 +02:00
#define D3DCOLORTOGLFLOAT4(dw, vec) \
(vec)[0] = D3DCOLOR_R(dw); \
(vec)[1] = D3DCOLOR_G(dw); \
(vec)[2] = D3DCOLOR_B(dw); \
(vec)[3] = D3DCOLOR_A(dw);
- move input and output data in VertexShader struct - better traces - specific input data filling function for vertex shaders using vertex shader declaration (and not FVF ... maybe FVF will return for fast path with simples vertex shader declarations) - huge vertex shader fixes: - add and fix many vs (1.0->2.0) used opcodes in complex shaders - improvements to programs parser: parse comments, version, .. - add a vertex shader input filler function (parsing vertex shader declaration): almost complete - comments most of the traces (else flood ...) - add more urls in comments - indent, cleanups
2003-01-14 21:29:33 +01:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* ===========================================================================
The interfactes themselves
=========================================================================== */
/* ---------- */
/* IDirect3D8 */
/* ---------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3D8) Direct3D8_Vtbl;
/*****************************************************************************
* IDirect3D implementation structure
*/
struct IDirect3D8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3D8);
DWORD ref;
/* IDirect3D8 fields */
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
GL_Info gl_info;
Check for advertized vertex blend support before querying device capabilities, which silences issues about vertex blending.
2003-10-03 06:35:07 +02:00
BOOL isGLInfoValid;
DXT1/3/5 support was broken, but unnoticeable since we also indicated it wasn't supported.
2003-08-15 05:50:08 +02:00
IDirect3D8Impl *direct3d8;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern HRESULT WINAPI IDirect3D8Impl_QueryInterface(LPDIRECT3D8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3D8Impl_AddRef(LPDIRECT3D8 iface);
extern ULONG WINAPI IDirect3D8Impl_Release(LPDIRECT3D8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3d8: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3D8Impl_RegisterSoftwareDevice(LPDIRECT3D8 iface, void* pInitializeFunction);
extern UINT WINAPI IDirect3D8Impl_GetAdapterCount(LPDIRECT3D8 iface);
extern HRESULT WINAPI IDirect3D8Impl_GetAdapterIdentifier(LPDIRECT3D8 iface, UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier);
extern UINT WINAPI IDirect3D8Impl_GetAdapterModeCount(LPDIRECT3D8 iface, UINT Adapter);
extern HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes(LPDIRECT3D8 iface, UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode);
extern HRESULT WINAPI IDirect3D8Impl_GetAdapterDisplayMode(LPDIRECT3D8 iface, UINT Adapter, D3DDISPLAYMODE* pMode);
extern HRESULT WINAPI IDirect3D8Impl_CheckDeviceType(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat,
D3DFORMAT BackBufferFormat, BOOL Windowed);
extern HRESULT WINAPI IDirect3D8Impl_CheckDeviceFormat(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat);
extern HRESULT WINAPI IDirect3D8Impl_CheckDeviceMultiSampleType(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat,
BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType);
extern HRESULT WINAPI IDirect3D8Impl_CheckDepthStencilMatch(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat);
extern HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps);
extern HMONITOR WINAPI IDirect3D8Impl_GetAdapterMonitor(LPDIRECT3D8 iface, UINT Adapter);
extern HRESULT WINAPI IDirect3D8Impl_CreateDevice(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters,
IDirect3DDevice8** ppReturnedDeviceInterface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* ---------------- */
/* IDirect3DDevice8 */
/* ---------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DDevice8) Direct3DDevice8_Vtbl;
/*****************************************************************************
* IDirect3DDevice8 implementation structure
*/
struct IDirect3DDevice8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DDevice8);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
DWORD ref;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* IDirect3DDevice8 fields */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
IDirect3D8Impl *direct3d8;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
- minor COM fixes (fixes some crashes on stupid games) - minor indentation changes - fix SELECTARG2 behavior (with help from Lionel Ulmer) - surface locking/unlocking (only rendering and textures surfaces supported now) - beginning of Target/Front surface support - try to get D3DTOP_SELECTARG_* working - implemented D3DTOP_SUBTRACT: currently only if OpenGL1.3 is used, we have to use GL_SUBTRACT_ARB for other versions
2003-05-11 05:35:27 +02:00
IDirect3DSurface8Impl *frontBuffer;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
IDirect3DSurface8Impl *backBuffer;
Handle creation of a depth/stencil buffer when creating a device. Implement IDirect3D8DeviceImpl_GetDepthStencilBuffer.
2003-04-17 04:16:07 +02:00
IDirect3DSurface8Impl *depthStencilBuffer;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
IDirect3DSurface8Impl *renderTarget;
IDirect3DSurface8Impl *stencilBufferTarget;
Various fixes, typos corrected and clarifying trace points.
2002-10-07 20:24:28 +02:00
D3DPRESENT_PARAMETERS PresentParms;
D3DDEVICE_CREATION_PARAMETERS CreateParms;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
UINT adapterNo;
D3DDEVTYPE devType;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
UINT srcBlend;
UINT dstBlend;
Avoid the use of glGet when we know the information locally.
2003-06-05 00:02:06 +02:00
UINT alphafunc;
UINT stencilfunc;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* State block related */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
BOOL isRecordingState;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
IDirect3DStateBlockImpl *StateBlock;
IDirect3DStateBlockImpl *UpdateStateBlock;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- mor usefull debug functions debug_d3dusage and debug_d3ddevicetype - fix a crash in pixel shader parser (happened with unreal2) - currently desactive pixel shaders caps (with #define) while hw shaders code isn't merged - when we have a special debug channel for shader, use it ;) - fix again some stubs return value - more more readable traces now (principaly IDirect3D8 capacities check and surface locking code) using new debug functions - fix/cleaning the surface locking code - now we support D3DTOP_SUBSTRACT so declare it in caps - now support true 32bit (well X 24 bit can be used as 32 bit in caps code) - first try to get D3DTSS_TCI_CAMERASPACENORMAL and D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR look good - native support 32 bit support (now application can choose 16 or 32 bit support) if current resolution is 24 bit (as we can only launch games in windowed mode) - textures palettes support - fix reflexion placement code (the sdk sample begin to work) - fix a stupid crash when using traces in vshaderdeclaration - more more readable traces (init/caps) - more cubetextures fixes
2003-05-17 20:33:02 +02:00
/* palettes texture management */
PALETTEENTRY palettes[MAX_PALETTES][256];
UINT currentPalette;
Only reapply the world, view or projection transform changes if we really have to.
2003-04-22 01:53:03 +02:00
/* Optimization */
Add fps debug channel, so we can see how the d3d code is performing and their impact of performance changes. SetTransform almost rewritten in a much neater way, and in coordination with drawprim it significantly reduces the number of times that we reload the matrixes.
2003-07-19 05:02:42 +02:00
BOOL modelview_valid;
BOOL proj_valid;
BOOL view_ident; /* true iff view matrix is identity */
BOOL last_was_rhw; /* true iff last draw_primitive was in xyzrhw mode */
glColorMaterial enable/disable setup is only done when really necessary. If glColorMaterial is set to track current color and none is supplied, it gets disabled. glMaterial is reset when I think it is necessary. Slow mode now has defaults for when fvf parms are not supplied (as per fast mode). Slow mode now sets up the specular color (forgot that bit previously, I think!). Trace now lists the front, back and stencil buffers for ease of debugging.
2003-08-05 20:29:20 +02:00
GLenum tracking_parm; /* Which source is tracking current colour */
LONG tracking_color; /* used iff GL_COLOR_MATERIAL was enabled */
#define DISABLED_TRACKING 0 /* Disabled */
#define IS_TRACKING 1 /* tracking_parm is tracking diffuse color */
#define NEEDS_TRACKING 2 /* Tracking needs to be enabled when needed */
#define NEEDS_DISABLE 3 /* Tracking needs to be disabled when needed*/
Only reapply the world, view or projection transform changes if we really have to.
2003-04-22 01:53:03 +02:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* OpenGL related */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
GLXContext glCtx;
XVisualInfo *visInfo;
Display *display;
- some cleanup and warning fixes - split of CreateDevice gl/gxl detection code into FillGLCaps - implementation of resolution change (using ChangeDisplaySettings) but desactived as ChangeDisplaySettings don't seem to work well - begin of swap chain support (now need to split/clean gxlpbuffer/glxpixmap code for swap chain use)
2003-06-05 00:55:19 +02:00
HWND win_handle;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
Window win;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
GLXContext render_ctx;
Drawable drawable;
MaxActiveLights means number of concurrent lights, but any number can be set up. Change support for lights into a linked list and only set up an equivalent gl light when the light is enabled.
2003-09-30 02:21:07 +02:00
GLint maxConcurrentLights;
- Initialize the texture state information. - Add dummy textures so texture operations which dont reference the texture can work. - Support 2d and 3d textures properly. - Reapply the texture state information as textures get set, as opengl stores the state along with the bound texture whereas directx uses the current state information during the draw stage. - 3rd attempt to sort out lighting, for programs which dont set normals. - Temporarily silence some unnecessary fixmes.
2002-10-28 20:00:23 +01:00
Query opengl to ensure it supports multitexture, and honour the number of supported texture units. Especially important for NVidia drivers which only support 2 texture units.
2002-12-23 02:34:59 +01:00
/* OpenGL Extension related */
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
/* Cursor management */
BOOL bCursorVisible;
UINT xHotSpot;
UINT yHotSpot;
UINT xScreenSpace;
UINT yScreenSpace;
GLint cursor;
Query opengl to ensure it supports multitexture, and honour the number of supported texture units. Especially important for NVidia drivers which only support 2 texture units.
2002-12-23 02:34:59 +01:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
UINT dummyTextureName[8];
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface, REFIID refiid, LPVOID *obj);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern ULONG WINAPI IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface);
extern ULONG WINAPI IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DDevice8: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface);
extern UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface);
extern HRESULT WINAPI IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface, DWORD Bytes);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface, IDirect3D8** ppD3D8);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface, D3DCAPS8* pCaps);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface, D3DDISPLAYMODE* pMode);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface, D3DDEVICE_CREATION_PARAMETERS* pParameters);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern void WINAPI IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface, UINT XScreenSpace, UINT YScreenSpace, DWORD Flags);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain);
extern HRESULT WINAPI IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8** ppBackBuffer);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface, D3DRASTER_STATUS* pRasterStatus);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern void WINAPI IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface, DWORD Flags, CONST D3DGAMMARAMP* pRamp);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture8** ppTexture);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateVolumeTexture(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture8** ppVolumeTexture);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateCubeTexture(LPDIRECT3DDEVICE8 iface, UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture8** ppCubeTexture);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer8** ppVertexBuffer);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateIndexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer8** ppIndexBuffer);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, BOOL Lockable, IDirect3DSurface8** ppSurface);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, IDirect3DSurface8** ppSurface);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, IDirect3DSurface8** ppSurface);
extern HRESULT WINAPI IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pSourceSurface, CONST RECT* pSourceRectsArray, UINT cRects, IDirect3DSurface8* pDestinationSurface, CONST POINT* pDestPointsArray);
extern HRESULT WINAPI IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface, IDirect3DBaseTexture8* pSourceTexture, IDirect3DBaseTexture8* pDestinationTexture);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pRenderTarget, IDirect3DSurface8* pNewZStencil);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppRenderTarget);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppZStencilSurface);
extern HRESULT WINAPI IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface);
extern HRESULT WINAPI IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface, CONST D3DVIEWPORT8* pViewport);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface, D3DVIEWPORT8* pViewport);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface, CONST D3DMATERIAL8* pMaterial);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface, D3DMATERIAL8* pMaterial);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index, CONST D3DLIGHT8* pLight);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface, DWORD Index, D3DLIGHT8* pLight);
extern HRESULT WINAPI IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index, BOOL Enable);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index, BOOL* pEnable);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index, CONST float* pPlane);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index, float* pPlane);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State, DWORD Value);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State, DWORD* pValue);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface);
extern HRESULT WINAPI IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface, DWORD* pToken);
extern HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token);
extern HRESULT WINAPI IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token);
extern HRESULT WINAPI IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateStateBlock(LPDIRECT3DDEVICE8 iface, D3DSTATEBLOCKTYPE Type,DWORD* pToken);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface, CONST D3DCLIPSTATUS8* pClipStatus);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface, D3DCLIPSTATUS8* pClipStatus);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage, IDirect3DBaseTexture8** ppTexture);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage, IDirect3DBaseTexture8* pTexture);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface, DWORD* pNumPasses);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_GetInfo(LPDIRECT3DDEVICE8 iface, DWORD DevInfoID, void* pDevInfoStruct, DWORD DevInfoStructSize);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber, PALETTEENTRY* pEntries);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT *PaletteNumber);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount);
extern HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType, UINT minIndex, UINT NumVertices, UINT startIndex, UINT primCount);
extern HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride);
extern HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle);
extern HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData,DWORD ConstantCount);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData,DWORD ConstantCount);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData,UINT BaseVertexIndex);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex);
extern HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pFunction,DWORD* pHandle);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle);
extern HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle);
extern HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData,DWORD ConstantCount);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData,DWORD ConstantCount);
extern HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo);
extern HRESULT WINAPI IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo);
extern HRESULT WINAPI IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface, UINT Handle);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
/* internal Interfaces */
extern HRESULT WINAPI IDirect3DDevice8Impl_CleanRender(LPDIRECT3DDEVICE8 iface);
extern HRESULT WINAPI IDirect3DDevice8Impl_ActiveRender(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* RenderSurface, IDirect3DSurface8* StencilSurface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* ---------------- */
/* IDirect3DVolume8 */
/* ---------------- */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DVolume8) Direct3DVolume8_Vtbl;
/*****************************************************************************
* IDirect3DVolume8 implementation structure
*/
struct IDirect3DVolume8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DVolume8);
DWORD ref;
/* IDirect3DVolume8 fields */
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
- minor COM fixes (fixes some crashes on stupid games) - minor indentation changes - fix SELECTARG2 behavior (with help from Lionel Ulmer) - surface locking/unlocking (only rendering and textures surfaces supported now) - beginning of Target/Front surface support - try to get D3DTOP_SELECTARG_* working - implemented D3DTOP_SUBTRACT: currently only if OpenGL1.3 is used, we have to use GL_SUBTRACT_ARB for other versions
2003-05-11 05:35:27 +02:00
IUnknown *Container;
Add the basic support for volume textures / volumes (3d textures).
2002-10-21 20:21:59 +02:00
D3DVOLUME_DESC myDesc;
BYTE *allocatedMemory;
UINT textureName;
UINT bytesPerPixel;
- cleaning of volume.c/volumetexture.c as done previously for surface.c/*texture.c (with add of lockable, locked and Dirty flags) - add of dirtyRect/dirtyBox for better dirtification management (not used yet, but huge optimisation can be possible now) - fix some debug traces (well it's better to use debug_d3dpool) - fix some stupid regression on point parameters (forgot to check extension on fillcaps)
2003-06-05 01:05:46 +02:00
BOOL lockable;
BOOL locked;
D3DBOX lockedBox;
D3DBOX dirtyBox;
BOOL Dirty;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
extern HRESULT WINAPI IDirect3DVolume8Impl_QueryInterface(LPDIRECT3DVOLUME8 iface,REFIID refiid,LPVOID *obj);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern ULONG WINAPI IDirect3DVolume8Impl_AddRef(LPDIRECT3DVOLUME8 iface);
extern ULONG WINAPI IDirect3DVolume8Impl_Release(LPDIRECT3DVOLUME8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DVolume8: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DVolume8Impl_GetDevice(LPDIRECT3DVOLUME8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DVolume8Impl_SetPrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DVolume8Impl_GetPrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DVolume8Impl_FreePrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid);
extern HRESULT WINAPI IDirect3DVolume8Impl_GetContainer(LPDIRECT3DVOLUME8 iface, REFIID riid, void** ppContainer);
extern HRESULT WINAPI IDirect3DVolume8Impl_GetDesc(LPDIRECT3DVOLUME8 iface, D3DVOLUME_DESC* pDesc);
- cleaning of volume.c/volumetexture.c as done previously for surface.c/*texture.c (with add of lockable, locked and Dirty flags) - add of dirtyRect/dirtyBox for better dirtification management (not used yet, but huge optimisation can be possible now) - fix some debug traces (well it's better to use debug_d3dpool) - fix some stupid regression on point parameters (forgot to check extension on fillcaps)
2003-06-05 01:05:46 +02:00
extern HRESULT WINAPI IDirect3DVolume8Impl_LockBox(LPDIRECT3DVOLUME8 iface, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DVolume8Impl_UnlockBox(LPDIRECT3DVOLUME8 iface);
- cleaning of volume.c/volumetexture.c as done previously for surface.c/*texture.c (with add of lockable, locked and Dirty flags) - add of dirtyRect/dirtyBox for better dirtification management (not used yet, but huge optimisation can be possible now) - fix some debug traces (well it's better to use debug_d3dpool) - fix some stupid regression on point parameters (forgot to check extension on fillcaps)
2003-06-05 01:05:46 +02:00
/* internal Interfaces */
extern HRESULT WINAPI IDirect3DVolume8Impl_CleanDirtyBox(LPDIRECT3DVOLUME8 iface);
extern HRESULT WINAPI IDirect3DVolume8Impl_AddDirtyBox(LPDIRECT3DVOLUME8 iface, CONST D3DBOX* pDirtyBox);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* ------------------- */
/* IDirect3DSwapChain8 */
/* ------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DSwapChain8) Direct3DSwapChain8_Vtbl;
/*****************************************************************************
* IDirect3DSwapChain8 implementation structure
*/
struct IDirect3DSwapChain8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DSwapChain8);
DWORD ref;
/* IDirect3DSwapChain8 fields */
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
IDirect3DSurface8Impl *frontBuffer;
IDirect3DSurface8Impl *backBuffer;
- some cleanup and warning fixes - split of CreateDevice gl/gxl detection code into FillGLCaps - implementation of resolution change (using ChangeDisplaySettings) but desactived as ChangeDisplaySettings don't seem to work well - begin of swap chain support (now need to split/clean gxlpbuffer/glxpixmap code for swap chain use)
2003-06-05 00:55:19 +02:00
IDirect3DSurface8Impl *depthStencilBuffer;
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
D3DPRESENT_PARAMETERS PresentParms;
- some cleanup and warning fixes - split of CreateDevice gl/gxl detection code into FillGLCaps - implementation of resolution change (using ChangeDisplaySettings) but desactived as ChangeDisplaySettings don't seem to work well - begin of swap chain support (now need to split/clean gxlpbuffer/glxpixmap code for swap chain use)
2003-06-05 00:55:19 +02:00
/* OpenGL/GLX related */
GLXContext swap_ctx;
Drawable swap_drawable;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
extern HRESULT WINAPI IDirect3DSwapChain8Impl_QueryInterface(LPDIRECT3DSWAPCHAIN8 iface, REFIID refiid, LPVOID *obj);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern ULONG WINAPI IDirect3DSwapChain8Impl_AddRef(LPDIRECT3DSWAPCHAIN8 iface);
extern ULONG WINAPI IDirect3DSwapChain8Impl_Release(LPDIRECT3DSWAPCHAIN8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DSwapChain8: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DSwapChain8Impl_Present(LPDIRECT3DSWAPCHAIN8 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
extern HRESULT WINAPI IDirect3DSwapChain8Impl_GetBackBuffer(LPDIRECT3DSWAPCHAIN8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* ----------------- */
/* IDirect3DSurface8 */
/* ----------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DSurface8) Direct3DSurface8_Vtbl;
/*****************************************************************************
* IDirect3DSurface8 implementation structure
*/
struct IDirect3DSurface8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DSurface8);
DWORD ref;
/* IDirect3DSurface8 fields */
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
Beginning of more COM compliant behavior: - AddRef/Release where needed - use IUnknown* instead void* - fix many GetDevice using AddRef - fix IDirect3DSurface8Impl_GetContainer using QueryInterface
2003-01-15 00:05:39 +01:00
IUnknown *Container;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
D3DSURFACE_DESC myDesc;
BYTE *allocatedMemory;
UINT textureName;
UINT bytesPerPixel;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
- minor COM fixes (fixes some crashes on stupid games) - minor indentation changes - fix SELECTARG2 behavior (with help from Lionel Ulmer) - surface locking/unlocking (only rendering and textures surfaces supported now) - beginning of Target/Front surface support - try to get D3DTOP_SELECTARG_* working - implemented D3DTOP_SUBTRACT: currently only if OpenGL1.3 is used, we have to use GL_SUBTRACT_ARB for other versions
2003-05-11 05:35:27 +02:00
BOOL lockable;
BOOL locked;
RECT lockedRect;
- cleaning of volume.c/volumetexture.c as done previously for surface.c/*texture.c (with add of lockable, locked and Dirty flags) - add of dirtyRect/dirtyBox for better dirtification management (not used yet, but huge optimisation can be possible now) - fix some debug traces (well it's better to use debug_d3dpool) - fix some stupid regression on point parameters (forgot to check extension on fillcaps)
2003-06-05 01:05:46 +02:00
RECT dirtyRect;
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
BOOL Dirty;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
extern HRESULT WINAPI IDirect3DSurface8Impl_QueryInterface(LPDIRECT3DSURFACE8 iface,REFIID refiid,LPVOID *obj);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern ULONG WINAPI IDirect3DSurface8Impl_AddRef(LPDIRECT3DSURFACE8 iface);
extern ULONG WINAPI IDirect3DSurface8Impl_Release(LPDIRECT3DSURFACE8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DSurface8: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(LPDIRECT3DSURFACE8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DSurface8Impl_SetPrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid,CONST void* pData,DWORD SizeOfData,DWORD Flags);
extern HRESULT WINAPI IDirect3DSurface8Impl_GetPrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid,void* pData,DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DSurface8Impl_FreePrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid);
extern HRESULT WINAPI IDirect3DSurface8Impl_GetContainer(LPDIRECT3DSURFACE8 iface, REFIID riid,void** ppContainer);
extern HRESULT WINAPI IDirect3DSurface8Impl_GetDesc(LPDIRECT3DSURFACE8 iface, D3DSURFACE_DESC *pDesc);
extern HRESULT WINAPI IDirect3DSurface8Impl_LockRect(LPDIRECT3DSURFACE8 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect,DWORD Flags);
extern HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(LPDIRECT3DSURFACE8 iface);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
/* internal Interfaces */
- some cleanups - more cubetextures fixes (now d3d8 sdk cubemap sample work almost perfectly) - add a new debug function "debug_d3dpool" and use it - add a new param (the device) for the conversions functions (because we need to check caps to see how to convert) - some crashes fixed in render to surface code with no stencil-depth surface - a very simple cliplane fix - a stupid palettes fix (stupid language) - begin of anisotropic filter support - begin of compressed textures support - a very useful debug functions: IDirect3DSurface8Impl_SaveSnapshot to dump surfaces as png ;) - many useful surfaces debug code (using SaveSnapshot)
2003-06-05 00:12:34 +02:00
extern HRESULT WINAPI IDirect3DSurface8Impl_LoadTexture(LPDIRECT3DSURFACE8 iface, GLenum gl_target, GLenum gl_level);
extern HRESULT WINAPI IDirect3DSurface8Impl_SaveSnapshot(LPDIRECT3DSURFACE8 iface, const char* filename);
- cleaning of volume.c/volumetexture.c as done previously for surface.c/*texture.c (with add of lockable, locked and Dirty flags) - add of dirtyRect/dirtyBox for better dirtification management (not used yet, but huge optimisation can be possible now) - fix some debug traces (well it's better to use debug_d3dpool) - fix some stupid regression on point parameters (forgot to check extension on fillcaps)
2003-06-05 01:05:46 +02:00
extern HRESULT WINAPI IDirect3DSurface8Impl_CleanDirtyRect(LPDIRECT3DSURFACE8 iface);
extern HRESULT WINAPI IDirect3DSurface8Impl_AddDirtyRect(LPDIRECT3DSURFACE8 iface, CONST RECT* pDirtyRect);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* ------------------ */
/* IDirect3DResource8 */
/* ------------------ */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DResource8) Direct3DResource8_Vtbl;
/*****************************************************************************
* IDirect3DResource8 implementation structure
*/
struct IDirect3DResource8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DResource8);
DWORD ref;
/* IDirect3DResource8 fields */
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
};
/* IUnknown: */
extern HRESULT WINAPI IDirect3DResource8Impl_QueryInterface(LPDIRECT3DRESOURCE8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DResource8Impl_AddRef(LPDIRECT3DRESOURCE8 iface);
extern ULONG WINAPI IDirect3DResource8Impl_Release(LPDIRECT3DRESOURCE8 iface);
/* IDirect3DResource8: */
extern HRESULT WINAPI IDirect3DResource8Impl_GetDevice(LPDIRECT3DRESOURCE8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DResource8Impl_SetPrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DResource8Impl_GetPrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DResource8Impl_FreePrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DResource8Impl_SetPriority(LPDIRECT3DRESOURCE8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DResource8Impl_GetPriority(LPDIRECT3DRESOURCE8 iface);
extern void WINAPI IDirect3DResource8Impl_PreLoad(LPDIRECT3DRESOURCE8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DResource8Impl_GetType(LPDIRECT3DRESOURCE8 iface);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
/* internal Interfaces */
extern D3DPOOL WINAPI IDirect3DResource8Impl_GetPool(LPDIRECT3DRESOURCE8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* ---------------------- */
/* IDirect3DVertexBuffer8 */
/* ---------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DVertexBuffer8) Direct3DVertexBuffer8_Vtbl;
/*****************************************************************************
* IDirect3DVertexBuffer8 implementation structure
*/
struct IDirect3DVertexBuffer8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DVertexBuffer8);
DWORD ref;
/* IDirect3DResource8 fields */
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
/* IDirect3DVertexBuffer8 fields */
BYTE *allocatedMemory;
D3DVERTEXBUFFER_DESC currentDesc;
};
/* IUnknown: */
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_QueryInterface(LPDIRECT3DVERTEXBUFFER8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DVertexBuffer8Impl_AddRef(LPDIRECT3DVERTEXBUFFER8 iface);
extern ULONG WINAPI IDirect3DVertexBuffer8Impl_Release(LPDIRECT3DVERTEXBUFFER8 iface);
/* IDirect3DVertexBuffer8: (Inherited from IDirect3DResource8) */
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDevice(LPDIRECT3DVERTEXBUFFER8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_SetPrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetPrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_FreePrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DVertexBuffer8Impl_SetPriority(LPDIRECT3DVERTEXBUFFER8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DVertexBuffer8Impl_GetPriority(LPDIRECT3DVERTEXBUFFER8 iface);
extern void WINAPI IDirect3DVertexBuffer8Impl_PreLoad(LPDIRECT3DVERTEXBUFFER8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer8Impl_GetType(LPDIRECT3DVERTEXBUFFER8 iface);
/* IDirect3DVertexBuffer8: */
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_Lock(LPDIRECT3DVERTEXBUFFER8 iface, UINT OffsetToLock, UINT SizeToLock, BYTE** ppbData, DWORD Flags);
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_Unlock(LPDIRECT3DVERTEXBUFFER8 iface);
extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDesc(LPDIRECT3DVERTEXBUFFER8 iface, D3DVERTEXBUFFER_DESC *pDesc);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* --------------------- */
/* IDirect3DIndexBuffer8 */
/* --------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DIndexBuffer8) Direct3DIndexBuffer8_Vtbl;
/*****************************************************************************
* IDirect3DIndexBuffer8 implementation structure
*/
struct IDirect3DIndexBuffer8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DIndexBuffer8);
DWORD ref;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DResource8 fields */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DIndexBuffer8 fields */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
void *allocatedMemory;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
D3DINDEXBUFFER_DESC currentDesc;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_QueryInterface(LPDIRECT3DINDEXBUFFER8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DIndexBuffer8Impl_AddRef(LPDIRECT3DINDEXBUFFER8 iface);
extern ULONG WINAPI IDirect3DIndexBuffer8Impl_Release(LPDIRECT3DINDEXBUFFER8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DIndexBuffer8: (Inherited from IDirect3DResource8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDevice(LPDIRECT3DINDEXBUFFER8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_SetPrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetPrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_FreePrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DIndexBuffer8Impl_SetPriority(LPDIRECT3DINDEXBUFFER8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DIndexBuffer8Impl_GetPriority(LPDIRECT3DINDEXBUFFER8 iface);
extern void WINAPI IDirect3DIndexBuffer8Impl_PreLoad(LPDIRECT3DINDEXBUFFER8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer8Impl_GetType(LPDIRECT3DINDEXBUFFER8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DIndexBuffer8: */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_Lock(LPDIRECT3DINDEXBUFFER8 iface, UINT OffsetToLock, UINT SizeToLock, BYTE** ppbData, DWORD Flags);
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_Unlock(LPDIRECT3DINDEXBUFFER8 iface);
extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDesc(LPDIRECT3DINDEXBUFFER8 iface, D3DINDEXBUFFER_DESC *pDesc);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* --------------------- */
/* IDirect3DBaseTexture8 */
/* --------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DBaseTexture8) Direct3DBaseTexture8_Vtbl;
/*****************************************************************************
* IDirect3DBaseTexture8 implementation structure
*/
struct IDirect3DBaseTexture8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DBaseTexture8);
DWORD ref;
/* IDirect3DResource8 fields */
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
/* IDirect3DBaseTexture8 fields */
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
BOOL Dirty;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
D3DFORMAT format;
UINT levels;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/*
*BOOL isManaged;
*DWORD lod;
*/
};
/* IUnknown: */
extern HRESULT WINAPI IDirect3DBaseTexture8Impl_QueryInterface(LPDIRECT3DBASETEXTURE8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DBaseTexture8Impl_AddRef(LPDIRECT3DBASETEXTURE8 iface);
extern ULONG WINAPI IDirect3DBaseTexture8Impl_Release(LPDIRECT3DBASETEXTURE8 iface);
/* IDirect3DBaseTexture8: (Inherited from IDirect3DResource8) */
extern HRESULT WINAPI IDirect3DBaseTexture8Impl_GetDevice(LPDIRECT3DBASETEXTURE8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DBaseTexture8Impl_SetPrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DBaseTexture8Impl_GetPrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DBaseTexture8Impl_FreePrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DBaseTexture8Impl_SetPriority(LPDIRECT3DBASETEXTURE8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DBaseTexture8Impl_GetPriority(LPDIRECT3DBASETEXTURE8 iface);
extern void WINAPI IDirect3DBaseTexture8Impl_PreLoad(LPDIRECT3DBASETEXTURE8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DBaseTexture8Impl_GetType(LPDIRECT3DBASETEXTURE8 iface);
/* IDirect3DBaseTexture8: */
extern DWORD WINAPI IDirect3DBaseTexture8Impl_SetLOD(LPDIRECT3DBASETEXTURE8 iface, DWORD LODNew);
extern DWORD WINAPI IDirect3DBaseTexture8Impl_GetLOD(LPDIRECT3DBASETEXTURE8 iface);
extern DWORD WINAPI IDirect3DBaseTexture8Impl_GetLevelCount(LPDIRECT3DBASETEXTURE8 iface);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
/* internal Interfaces */
extern BOOL WINAPI IDirect3DBaseTexture8Impl_IsDirty(LPDIRECT3DBASETEXTURE8 iface);
extern BOOL WINAPI IDirect3DBaseTexture8Impl_SetDirty(LPDIRECT3DBASETEXTURE8 iface, BOOL dirty);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* --------------------- */
/* IDirect3DCubeTexture8 */
/* --------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DCubeTexture8) Direct3DCubeTexture8_Vtbl;
/*****************************************************************************
* IDirect3DCubeTexture8 implementation structure
*/
struct IDirect3DCubeTexture8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DCubeTexture8);
DWORD ref;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DResource8 fields */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DBaseTexture8 fields */
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
BOOL Dirty;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
D3DFORMAT format;
UINT levels;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DCubeTexture8 fields */
UINT edgeLength;
DWORD usage;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
IDirect3DSurface8Impl *surfaces[6][MAX_LEVELS];
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_QueryInterface(LPDIRECT3DCUBETEXTURE8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DCubeTexture8Impl_AddRef(LPDIRECT3DCUBETEXTURE8 iface);
extern ULONG WINAPI IDirect3DCubeTexture8Impl_Release(LPDIRECT3DCUBETEXTURE8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DCubeTexture8: (Inherited from IDirect3DResource8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetDevice(LPDIRECT3DCUBETEXTURE8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_SetPrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetPrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_FreePrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DCubeTexture8Impl_SetPriority(LPDIRECT3DCUBETEXTURE8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DCubeTexture8Impl_GetPriority(LPDIRECT3DCUBETEXTURE8 iface);
extern void WINAPI IDirect3DCubeTexture8Impl_PreLoad(LPDIRECT3DCUBETEXTURE8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DCubeTexture8Impl_GetType(LPDIRECT3DCUBETEXTURE8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DCubeTexture8: (Inherited from IDirect3DBaseTexture8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern DWORD WINAPI IDirect3DCubeTexture8Impl_SetLOD(LPDIRECT3DCUBETEXTURE8 iface, DWORD LODNew);
extern DWORD WINAPI IDirect3DCubeTexture8Impl_GetLOD(LPDIRECT3DCUBETEXTURE8 iface);
extern DWORD WINAPI IDirect3DCubeTexture8Impl_GetLevelCount(LPDIRECT3DCUBETEXTURE8 iface);
/* IDirect3DCubeTexture8 */
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE8 iface, UINT Level, D3DSURFACE_DESC* pDesc);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetCubeMapSurface(LPDIRECT3DCUBETEXTURE8 iface, D3DCUBEMAP_FACES FaceType, UINT Level, IDirect3DSurface8** ppCubeMapSurface);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_LockRect(LPDIRECT3DCUBETEXTURE8 iface, D3DCUBEMAP_FACES FaceType, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_UnlockRect(LPDIRECT3DCUBETEXTURE8 iface, D3DCUBEMAP_FACES FaceType, UINT Level);
extern HRESULT WINAPI IDirect3DCubeTexture8Impl_AddDirtyRect(LPDIRECT3DCUBETEXTURE8 iface, D3DCUBEMAP_FACES FaceType, CONST RECT* pDirtyRect);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* ----------------- */
/* IDirect3DTexture8 */
/* ----------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DTexture8) Direct3DTexture8_Vtbl;
/*****************************************************************************
* IDirect3DTexture8 implementation structure
*/
struct IDirect3DTexture8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DTexture8);
DWORD ref;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DResourc8 fields */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DBaseTexture8 fields */
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
BOOL Dirty;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
D3DFORMAT format;
UINT levels;
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DTexture8 fields */
UINT width;
UINT height;
DWORD usage;
IDirect3DSurface8Impl *surfaces[MAX_LEVELS];
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern HRESULT WINAPI IDirect3DTexture8Impl_QueryInterface(LPDIRECT3DTEXTURE8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DTexture8Impl_AddRef(LPDIRECT3DTEXTURE8 iface);
extern ULONG WINAPI IDirect3DTexture8Impl_Release(LPDIRECT3DTEXTURE8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DTexture8: (Inherited from IDirect3DResource8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DTexture8Impl_GetDevice(LPDIRECT3DTEXTURE8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DTexture8Impl_SetPrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DTexture8Impl_GetPrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DTexture8Impl_FreePrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DTexture8Impl_SetPriority(LPDIRECT3DTEXTURE8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DTexture8Impl_GetPriority(LPDIRECT3DTEXTURE8 iface);
extern void WINAPI IDirect3DTexture8Impl_PreLoad(LPDIRECT3DTEXTURE8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DTexture8Impl_GetType(LPDIRECT3DTEXTURE8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DTexture8: (Inherited from IDirect3DBaseTexture8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern DWORD WINAPI IDirect3DTexture8Impl_SetLOD(LPDIRECT3DTEXTURE8 iface, DWORD LODNew);
extern DWORD WINAPI IDirect3DTexture8Impl_GetLOD(LPDIRECT3DTEXTURE8 iface);
extern DWORD WINAPI IDirect3DTexture8Impl_GetLevelCount(LPDIRECT3DTEXTURE8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DTexture8: */
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DTexture8Impl_GetLevelDesc(LPDIRECT3DTEXTURE8 iface, UINT Level, D3DSURFACE_DESC* pDesc);
extern HRESULT WINAPI IDirect3DTexture8Impl_GetSurfaceLevel(LPDIRECT3DTEXTURE8 iface, UINT Level, IDirect3DSurface8** ppSurfaceLevel);
extern HRESULT WINAPI IDirect3DTexture8Impl_LockRect(LPDIRECT3DTEXTURE8 iface, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DTexture8Impl_UnlockRect(LPDIRECT3DTEXTURE8 iface, UINT Level);
extern HRESULT WINAPI IDirect3DTexture8Impl_AddDirtyRect(LPDIRECT3DTEXTURE8 iface, CONST RECT* pDirtyRect);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
/* ----------------------- */
/* IDirect3DVolumeTexture8 */
/* ----------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
extern ICOM_VTABLE(IDirect3DVolumeTexture8) Direct3DVolumeTexture8_Vtbl;
/*****************************************************************************
* IDirect3DVolumeTexture8 implementation structure
*/
struct IDirect3DVolumeTexture8Impl
{
/* IUnknown fields */
ICOM_VFIELD(IDirect3DVolumeTexture8);
DWORD ref;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DResource8 fields */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
IDirect3DDevice8Impl *Device;
D3DRESOURCETYPE ResourceType;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DBaseTexture8 fields */
- surface pool init fixes - minor indentation and traces fixes - fix locking/unlocking/dirty behavior (dirtify on lock) + optimisations (only copy when dirty) - fix IDirect3DDevice8::Clear behavior (problem seen after a locking/unlocking code error) - begin to fix volume and cube textures management
2003-05-12 05:10:27 +02:00
BOOL Dirty;
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
D3DFORMAT format;
UINT levels;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DVolumeTexture8 fields */
Add the basic support for volume textures / volumes (3d textures).
2002-10-21 20:21:59 +02:00
UINT width;
UINT height;
UINT depth;
DWORD usage;
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
IDirect3DVolume8Impl *volumes[MAX_LEVELS];
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
};
/* IUnknown: */
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_QueryInterface(LPDIRECT3DVOLUMETEXTURE8 iface,REFIID refiid,LPVOID *obj);
extern ULONG WINAPI IDirect3DVolumeTexture8Impl_AddRef(LPDIRECT3DVOLUMETEXTURE8 iface);
extern ULONG WINAPI IDirect3DVolumeTexture8Impl_Release(LPDIRECT3DVOLUMETEXTURE8 iface);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DVolumeTexture8: (Inherited from IDirect3DResource8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetDevice(LPDIRECT3DVOLUMETEXTURE8 iface, IDirect3DDevice8** ppDevice);
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_SetPrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetPrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_FreePrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid);
extern DWORD WINAPI IDirect3DVolumeTexture8Impl_SetPriority(LPDIRECT3DVOLUMETEXTURE8 iface, DWORD PriorityNew);
extern DWORD WINAPI IDirect3DVolumeTexture8Impl_GetPriority(LPDIRECT3DVOLUMETEXTURE8 iface);
extern void WINAPI IDirect3DVolumeTexture8Impl_PreLoad(LPDIRECT3DVOLUMETEXTURE8 iface);
extern D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture8Impl_GetType(LPDIRECT3DVOLUMETEXTURE8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DVolumeTexture8: (Inherited from IDirect3DBaseTexture8) */
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern DWORD WINAPI IDirect3DVolumeTexture8Impl_SetLOD(LPDIRECT3DVOLUMETEXTURE8 iface, DWORD LODNew);
extern DWORD WINAPI IDirect3DVolumeTexture8Impl_GetLOD(LPDIRECT3DVOLUMETEXTURE8 iface);
extern DWORD WINAPI IDirect3DVolumeTexture8Impl_GetLevelCount(LPDIRECT3DVOLUMETEXTURE8 iface);
- some D3D8 fixes - beginning of shaders support (Vertex and Pixel Shaders 1.1 on DirectX8) - beginning of D3DX8 support the D3D8 utility API (very basic, only the core header)
2002-12-17 02:15:15 +01:00
/* IDirect3DVolumeTexture8: */
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level, D3DVOLUME_DESC *pDesc);
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetVolumeLevel(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level, IDirect3DVolume8** ppVolumeLevel);
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_LockBox(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags);
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_UnlockBox(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level);
extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_AddDirtyBox(LPDIRECT3DVOLUMETEXTURE8 iface, CONST D3DBOX* pDirtyBox);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/* ==============================================================================
Private interfactes: beginning of cleaning/splitting for HAL and d3d9 support
============================================================================== */
/* State Block for Begin/End/Capture/Create/Apply State Block */
/* Note: Very long winded but I do not believe gl Lists will */
/* resolve everything we need, so doing it manually for now */
typedef struct SAVEDSTATES {
BOOL Indices;
BOOL material;
BOOL stream_source[MAX_STREAMS];
BOOL textures[8];
BOOL transform[HIGHEST_TRANSFORMSTATE];
BOOL viewport;
BOOL vertexShader;
- Defer of IDirect3DVertexShader_SetConstant, waiting for DrawPrimitive call. - Beginning of VertexShader constants support into stateblock (only stored, not captured yet). - Fix compiation with nivdia GL/gl.h and mesa Gl/glext headers as reported by Andrew John Hughes. - One glActiveTexture/glActiveTextureARB missing.
2003-01-30 01:18:27 +01:00
BOOL vertexShaderConstant;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
BOOL vertexShaderDecl;
BOOL pixelShader;
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
BOOL pixelShaderConstant;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
BOOL renderstate[HIGHEST_RENDER_STATE];
BOOL texture_state[8][HIGHEST_TEXTURE_STATE];
BOOL clipplane[MAX_CLIPPLANES];
} SAVEDSTATES;
/* ----------------------- */
/* IDirect3DStateBlockImpl */
/* ----------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
/*extern ICOM_VTABLE(IDirect3DStateBlock9) Direct3DStateBlock9_Vtbl;*/
/*****************************************************************************
* IDirect3DStateBlock implementation structure
*/
struct IDirect3DStateBlockImpl {
/* IUnknown fields */
/*ICOM_VFIELD(IDirect3DStateBlock9);*/
DWORD ref;
/* The device, to be replaced by a IDirect3DDeviceImpl */
IDirect3DDevice8Impl* device;
D3DSTATEBLOCKTYPE blockType;
SAVEDSTATES Changed;
SAVEDSTATES Set;
/* ClipPlane */
double clipplane[MAX_CLIPPLANES][4];
/* Stream Source */
UINT stream_stride[MAX_STREAMS];
IDirect3DVertexBuffer8 *stream_source[MAX_STREAMS];
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
BOOL streamIsUP;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/* Indices */
IDirect3DIndexBuffer8* pIndexData;
UINT baseVertexIndex;
/* Texture */
IDirect3DBaseTexture8 *textures[8];
int textureDimensions[8];
/* Texture State Stage */
DWORD texture_state[8][HIGHEST_TEXTURE_STATE];
/* Lights */
MaxActiveLights means number of concurrent lights, but any number can be set up. Change support for lights into a linked list and only set up an equivalent gl light when the light is enabled.
2003-09-30 02:21:07 +02:00
PLIGHTINFOEL *lights; /* NOTE: active GL lights must be front of the chain */
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/* Material */
D3DMATERIAL8 material;
/* RenderState */
DWORD renderstate[HIGHEST_RENDER_STATE];
/* Transform */
D3DMATRIX transforms[HIGHEST_TRANSFORMSTATE];
/* ViewPort */
D3DVIEWPORT8 viewport;
/* Vertex Shader */
DWORD VertexShader;
/* Vertex Shader Declaration */
IDirect3DVertexShaderDeclarationImpl* vertexShaderDecl;
/* Pixel Shader */
DWORD PixelShader;
/* Indexed Vertex Blending */
D3DVERTEXBLENDFLAGS vertex_blend;
FLOAT tween_factor;
- Defer of IDirect3DVertexShader_SetConstant, waiting for DrawPrimitive call. - Beginning of VertexShader constants support into stateblock (only stored, not captured yet). - Fix compiation with nivdia GL/gl.h and mesa Gl/glext headers as reported by Andrew John Hughes. - One glActiveTexture/glActiveTextureARB missing.
2003-01-30 01:18:27 +01:00
/* Vertex Shader Constant */
D3DSHADERVECTOR vertexShaderConstant[D3D8_VSHADER_MAX_CONSTANTS];
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
/* Pixel Shader Constant */
D3DSHADERVECTOR pixelShaderConstant[D3D8_PSHADER_MAX_CONSTANTS];
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
};
/* exported Interfaces */
/* internal Interfaces */
/* temporary internal Interfaces */
extern HRESULT WINAPI IDirect3DDeviceImpl_InitStartupStateBlock(IDirect3DDevice8Impl* This);
extern HRESULT WINAPI IDirect3DDeviceImpl_CreateStateBlock(IDirect3DDevice8Impl* This, D3DSTATEBLOCKTYPE Type, IDirect3DStateBlockImpl** ppStateBlock);
extern HRESULT WINAPI IDirect3DDeviceImpl_DeleteStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl* pSB);
extern HRESULT WINAPI IDirect3DDeviceImpl_BeginStateBlock(IDirect3DDevice8Impl* This);
extern HRESULT WINAPI IDirect3DDeviceImpl_EndStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl** ppStateBlock);
extern HRESULT WINAPI IDirect3DDeviceImpl_ApplyStateBlock(IDirect3DDevice8Impl* iface, IDirect3DStateBlockImpl* pSB);
extern HRESULT WINAPI IDirect3DDeviceImpl_CaptureStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl* pSB);
/* ------------------------------------ */
/* IDirect3DVertexShaderDeclarationImpl */
/* ------------------------------------ */
/*****************************************************************************
* Predeclare the interface implementation structures
- some fixes in CreateDevice init - vertex shader declaration parser (with output dump) and interpretation (generate the FVF descriptor for program input) - vertex shader program parser (with output dump) - software vertex shader program emulation
2002-12-18 06:05:41 +01:00
*/
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/*extern ICOM_VTABLE(IDirect3DVertexShaderDeclaration9) Direct3DVertexShaderDeclaration9_Vtbl;*/
/*****************************************************************************
* IDirect3DVertexShaderDeclaration implementation structure
*/
struct IDirect3DVertexShaderDeclarationImpl {
/* IUnknown fields */
/*ICOM_VFIELD(IDirect3DVertexShaderDeclaration9);*/
DWORD ref;
/* The device, to be replaced by a IDirect3DDeviceImpl */
IDirect3DDevice8Impl* device;
/** precomputed fvf if simple declaration */
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
DWORD fvf[MAX_STREAMS];
DWORD allFVF;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/** dx8 compatible Declaration fields */
DWORD* pDeclaration8;
DWORD declaration8Length;
};
/* exported Interfaces */
extern HRESULT WINAPI IDirect3DVertexShaderDeclarationImpl_GetDeclaration8(IDirect3DVertexShaderDeclarationImpl* This, DWORD* pData, UINT* pSizeOfData);
/*extern HRESULT IDirect3DVertexShaderDeclarationImpl_GetDeclaration9(IDirect3DVertexShaderDeclarationImpl* This, D3DVERTEXELEMENT9* pData, UINT* pNumElements);*/
/* internal Interfaces */
/* temporary internal Interfaces */
extern HRESULT WINAPI IDirect3DDeviceImpl_CreateVertexShaderDeclaration8(IDirect3DDevice8Impl* This, CONST DWORD* pDeclaration8, IDirect3DVertexShaderDeclarationImpl** ppVertexShaderDecl);
/* ------------------------- */
/* IDirect3DVertexShaderImpl */
/* ------------------------- */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
/*extern ICOM_VTABLE(IDirect3DVertexShader9) Direct3DVertexShader9_Vtbl;*/
/*****************************************************************************
* IDirect3DVertexShader implementation structure
*/
struct IDirect3DVertexShaderImpl {
/*ICOM_VFIELD(IDirect3DVertexShader9);*/
DWORD ref;
/* The device, to be replaced by a IDirect3DDeviceImpl */
IDirect3DDevice8Impl* device;
DWORD* function;
UINT functionLength;
DWORD usage; /* 0 || D3DUSAGE_SOFTWAREPROCESSING */
DWORD version;
/* run time datas */
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
VSHADERDATA8* data;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
VSHADERINPUTDATA8 input;
VSHADEROUTPUTDATA8 output;
};
/* exported Interfaces */
extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetFunction(IDirect3DVertexShaderImpl* This, VOID* pData, UINT* pSizeOfData);
/*extern HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantB(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST BOOL* pConstantData, UINT BoolCount);*/
/*extern HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantI(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST INT* pConstantData, UINT Vector4iCount);*/
extern HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount);
/*extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantB(IDirect3DVertexShaderImpl* This, UINT StartRegister, BOOL* pConstantData, UINT BoolCount);*/
/*extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantI(IDirect3DVertexShaderImpl* This, UINT StartRegister, INT* pConstantData, UINT Vector4iCount);*/
extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount);
/* internal Interfaces */
extern DWORD WINAPI IDirect3DVertexShaderImpl_GetVersion(IDirect3DVertexShaderImpl* This);
extern HRESULT WINAPI IDirect3DVertexShaderImpl_ExecuteSW(IDirect3DVertexShaderImpl* This, VSHADERINPUTDATA8* input, VSHADEROUTPUTDATA8* output);
/* temporary internal Interfaces */
extern HRESULT WINAPI IDirect3DDeviceImpl_CreateVertexShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, DWORD Usage, IDirect3DVertexShaderImpl** ppVertexShader);
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
extern HRESULT WINAPI IDirect3DDeviceImpl_FillVertexShaderInput(IDirect3DDevice8Impl* This, IDirect3DVertexShaderImpl* vshader, DWORD SkipnStrides);
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/* ------------------------ */
/* IDirect3DPixelShaderImpl */
/* ------------------------ */
/*****************************************************************************
* Predeclare the interface implementation structures
*/
/*extern ICOM_VTABLE(IDirect3DPixelShader9) Direct3DPixelShader9_Vtbl;*/
/*****************************************************************************
* IDirect3DPixelShader implementation structure
*/
struct IDirect3DPixelShaderImpl {
/*ICOM_VFIELD(IDirect3DPixelShader9);*/
DWORD ref;
/* The device, to be replaced by a IDirect3DDeviceImpl */
IDirect3DDevice8Impl* device;
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
DWORD* function;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
UINT functionLength;
DWORD version;
/* run time datas */
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
PSHADERDATA8* data;
PSHADERINPUTDATA8 input;
PSHADEROUTPUTDATA8 output;
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
};
/* exported Interfaces */
extern HRESULT WINAPI IDirect3DPixelShaderImpl_GetFunction(IDirect3DPixelShaderImpl* This, VOID* pData, UINT* pSizeOfData);
/* internal Interfaces */
extern DWORD WINAPI IDirect3DPixelShaderImpl_GetVersion(IDirect3DPixelShaderImpl* This);
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
/* temporary internal Interfaces */
extern HRESULT WINAPI IDirect3DDeviceImpl_CreatePixelShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, IDirect3DPixelShaderImpl** ppPixelShader);
Some needed cleanups for future dx9 and d3d common layer support: - stateblocks to IDirect3DStateBlockImpl interface and moving into a new file (stateblock.c) - shaders to IDirect3D*ShaderImpl interfaces - splitting vshader and vshader declaration as in dx9 into 2 interfaces (for future common layer use) - vshader declaration code to a new file (vsaderdeclaration.c) - device calls to new interfaces (redirect stubs) Simple texture fix for a little regression after last Jason's patches. Some caps code using the GL/glext.h defines (GL_VERSION_*).
2003-01-28 02:12:23 +01:00
/**
* Internals functions
*
* to see how not defined it here
*/
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
void GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand);
Only reapply the texture states necessary when a different texture gets bound to the same texture unit.
2003-08-05 21:18:58 +02:00
void setupTextureStates(LPDIRECT3DDEVICE8 iface, DWORD Stage, DWORD Flags);
- pixel shader program dump code - pixel shader code split into a new "COM object" (as done before for vertex shader) - some fixes on Validate* functions call types - add pixel shader (ie fragment_program) detection on caps code
2003-06-05 00:45:57 +02:00
void set_tex_op(LPDIRECT3DDEVICE8 iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3);
- some cleanups - more cubetextures fixes (now d3d8 sdk cubemap sample work almost perfectly) - add a new debug function "debug_d3dpool" and use it - add a new param (the device) for the conversions functions (because we need to check caps to see how to convert) - some crashes fixed in render to surface code with no stencil-depth surface - a very simple cliplane fix - a stupid palettes fix (stupid language) - begin of anisotropic filter support - begin of compressed textures support - a very useful debug functions: IDirect3DSurface8Impl_SaveSnapshot to dump surfaces as png ;) - many useful surfaces debug code (using SaveSnapshot)
2003-06-05 00:12:34 +02:00
SHORT D3DFmtGetBpp(IDirect3DDevice8Impl* This, D3DFORMAT fmt);
GLint D3DFmt2GLIntFmt(IDirect3DDevice8Impl* This, D3DFORMAT fmt);
GLenum D3DFmt2GLFmt(IDirect3DDevice8Impl* This, D3DFORMAT fmt);
GLenum D3DFmt2GLType(IDirect3DDevice8Impl* This, D3DFORMAT fmt);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
GLenum D3DFmt2GLDepthFmt(D3DFORMAT fmt);
GLenum D3DFmt2GLDepthType(D3DFORMAT fmt);
int D3DPrimitiveListGetVertexSize(D3DPRIMITIVETYPE PrimitiveType, int iNumPrim);
int D3DPrimitive2GLenum(D3DPRIMITIVETYPE PrimitiveType);
int D3DFVFGetSize(D3DFORMAT fvf);
int SOURCEx_RGB_EXT(DWORD arg);
int OPERANDx_RGB_EXT(DWORD arg);
int SOURCEx_ALPHA_EXT(DWORD arg);
int OPERANDx_ALPHA_EXT(DWORD arg);
GLenum StencilOp(DWORD op);
- some fixes in CreateDevice init - vertex shader declaration parser (with output dump) and interpretation (generate the FVF descriptor for program input) - vertex shader program parser (with output dump) - software vertex shader program emulation
2002-12-18 06:05:41 +01:00
- declare a new debug chanel for vertex shaders - some useful debug functions for textures format - correct DrawPrimitive (RHW correctness and vshader RHW) - more copyrects fixes (only two unimplemented behavior remain) - fix GetFrontBuffer to get screenshots samples working - add D3DCOLORTOGLFLOAT4 and use it - first try of D3DRS_FOGTABLEMODE support
2003-05-14 21:33:35 +02:00
/**
* Internals debug functions
*/
- mor usefull debug functions debug_d3dusage and debug_d3ddevicetype - fix a crash in pixel shader parser (happened with unreal2) - currently desactive pixel shaders caps (with #define) while hw shaders code isn't merged - when we have a special debug channel for shader, use it ;) - fix again some stubs return value - more more readable traces now (principaly IDirect3D8 capacities check and surface locking code) using new debug functions - fix/cleaning the surface locking code - now we support D3DTOP_SUBSTRACT so declare it in caps - now support true 32bit (well X 24 bit can be used as 32 bit in caps code) - first try to get D3DTSS_TCI_CAMERASPACENORMAL and D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR look good - native support 32 bit support (now application can choose 16 or 32 bit support) if current resolution is 24 bit (as we can only launch games in windowed mode) - textures palettes support - fix reflexion placement code (the sdk sample begin to work) - fix a stupid crash when using traces in vshaderdeclaration - more more readable traces (init/caps) - more cubetextures fixes
2003-05-17 20:33:02 +02:00
const char* debug_d3ddevicetype(D3DDEVTYPE devtype);
const char* debug_d3dusage(DWORD usage);
- declare a new debug chanel for vertex shaders - some useful debug functions for textures format - correct DrawPrimitive (RHW correctness and vshader RHW) - more copyrects fixes (only two unimplemented behavior remain) - fix GetFrontBuffer to get screenshots samples working - add D3DCOLORTOGLFLOAT4 and use it - first try of D3DRS_FOGTABLEMODE support
2003-05-14 21:33:35 +02:00
const char* debug_d3dformat(D3DFORMAT fmt);
const char* debug_d3dressourcetype(D3DRESOURCETYPE res);
- implemented render to surfaces (and render to new rendertargets) using glx pbuffers (with a useful debug code to display rendered surface into window drawable) - better cubetextures - split utilities functions into utils.c and added more - more readable debug again - a better caps code (not perfect but i'll use glx code later) - use of the new caps code - begin of UpdateTexture - begin of Cursor support - cleaning most of deprecated #if 0/#endif - correct some lockable/unlockable behavior - correct some returns code
2003-06-04 23:55:29 +02:00
const char* debug_d3dprimitivetype(D3DPRIMITIVETYPE PrimitiveType);
- some cleanups - more cubetextures fixes (now d3d8 sdk cubemap sample work almost perfectly) - add a new debug function "debug_d3dpool" and use it - add a new param (the device) for the conversions functions (because we need to check caps to see how to convert) - some crashes fixed in render to surface code with no stencil-depth surface - a very simple cliplane fix - a stupid palettes fix (stupid language) - begin of anisotropic filter support - begin of compressed textures support - a very useful debug functions: IDirect3DSurface8Impl_SaveSnapshot to dump surfaces as png ;) - many useful surfaces debug code (using SaveSnapshot)
2003-06-05 00:12:34 +02:00
const char* debug_d3dpool(D3DPOOL Pool);
Fix the texture operations to resolve glitches shown in UT2003 when get quad damage. checkGLcall must not supply a \n as that is supplied by its expansion. Performance fixes to save applying the same states 6 times and to reduce function calls when accessing front/back buffers. Make traces more readable by more constants -> english descriptions.
2003-06-13 21:14:34 +02:00
const char *debug_d3drenderstate(DWORD State);
const char *debug_d3dtexturestate(DWORD State);
- declare a new debug chanel for vertex shaders - some useful debug functions for textures format - correct DrawPrimitive (RHW correctness and vshader RHW) - more copyrects fixes (only two unimplemented behavior remain) - fix GetFrontBuffer to get screenshots samples working - add D3DCOLORTOGLFLOAT4 and use it - first try of D3DRS_FOGTABLEMODE support
2003-05-14 21:33:35 +02:00
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
/* Some #defines for additional diagnostics */
#if 0 /* NOTE: Must be 0 in cvs */
/* To avoid having to get gigabytes of trace, the following can be compiled in, and at the start
- dsound and d3d works better when x11drv locks/unlocks are correct - more traces
2003-06-18 05:17:42 +02:00
of each frame, a check is made for the existence of C:\D3DTRACE, and if if exists d3d trace
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
is enabled, and if it doesnt exists it is disabled. */
# define FRAME_DEBUGGING
/* Adding in the SINGLE_FRAME_DEBUGGING gives a trace of just what makes up a single frame, before
the file is deleted */
Implement UpdateTexture for 2D textures only. Handle alphaop disabled but color op not-disable in a more appropriate way (Docs say this is an illegal state and then proceed to use it). Trace out textures as they are created. Update the comments around the debug code and complete the debugging set so textures which are used in the game can also be viewed.
2003-07-03 20:10:22 +02:00
# if 1 /* NOTE: Must be 1 in cvs, as this is mostly more useful than a trace from program start */
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
# define SINGLE_FRAME_DEBUGGING
# endif
/* The following, when enabled, lets you see the makeup of the frame, by drawprimitive calls.
Implement UpdateTexture for 2D textures only. Handle alphaop disabled but color op not-disable in a more appropriate way (Docs say this is an illegal state and then proceed to use it). Trace out textures as they are created. Update the comments around the debug code and complete the debugging set so textures which are used in the game can also be viewed.
2003-07-03 20:10:22 +02:00
It can only be enabled when FRAME_DEBUGGING is also enabled
The contents of the back buffer are written into /tmp/backbuffer_* after each primitive
array is drawn. */
# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
# define SHOW_FRAME_MAKEUP 1
Implement UpdateTexture for 2D textures only. Handle alphaop disabled but color op not-disable in a more appropriate way (Docs say this is an illegal state and then proceed to use it). Trace out textures as they are created. Update the comments around the debug code and complete the debugging set so textures which are used in the game can also be viewed.
2003-07-03 20:10:22 +02:00
# endif
/* The following, when enabled, lets you see the makeup of the all the textures used during each
of the drawprimitive calls. It can only be enabled when SHOW_FRAME_MAKEUP is also enabled.
The contents of the textures assigned to each stage are written into
/tmp/texture_*_<Stage>.ppm after each primitive array is drawn. */
# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
# define SHOW_TEXTURE_MAKEUP 0
Make the fixed function pipeline support multiple streams for created vertex shaders with no function supplied. Also split down draw primitive along the lines of the d3dcore requirements and put in some diagnostic aids.
2003-06-13 20:09:05 +02:00
# endif
extern BOOL isOn;
extern BOOL isDumpingFrames;
extern LONG primCounter;
#endif
/* Per-vertex trace: */
#if 0 /* NOTE: Must be 0 in cvs */
# define VTRACE(A) TRACE A
#else
# define VTRACE(A)
#endif
#define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
#define TRACE_STRIDED(sd,name) TRACE( #name "=(data:%p, stride:%ld, type:%ld)\n", sd->u.s.name.lpData, sd->u.s.name.dwStride, sd->u.s.name.dwType);
MaxActiveLights means number of concurrent lights, but any number can be set up. Change support for lights into a linked list and only set up an equivalent gl light when the light is enabled.
2003-09-30 02:21:07 +02:00
#define DUMP_LIGHT_CHAIN() \
{ \
PLIGHTINFOEL *el = This->StateBlock->lights;\
while (el) { \
TRACE("Light %p (glIndex %ld, d3dIndex %ld, enabled %d)\n", el, el->glIndex, el->OriginalIndex, el->lightEnabled);\
el = el->next; \
} \
}
Initial D3D8 implementation.
2002-09-28 00:46:16 +02:00
#endif /* __WINE_D3DX8_PRIVATE_H */