diff options
| author | Joe Ludwig <[email protected]> | 2013-07-17 18:26:59 -0700 |
|---|---|---|
| committer | Joe Ludwig <[email protected]> | 2013-07-17 18:26:59 -0700 |
| commit | e16ea21dc8a710237ade8413207f58d403c616a3 (patch) | |
| tree | 85dcfbda9881e4e022dedafefbc2727e2fd2aa59 /mp/src/public | |
| parent | Merge pull request #36 from AnAkIn1/fogplayerparams_fix (diff) | |
| download | source-sdk-2013-e16ea21dc8a710237ade8413207f58d403c616a3.tar.xz source-sdk-2013-e16ea21dc8a710237ade8413207f58d403c616a3.zip | |
* Added support for building shaders in your mod
* Added nav mesh support
* fixed many warnings and misc bugs
* Fixed the create*projects scripts in mp
* Added a bunch of stuff to .gitignore
Diffstat (limited to 'mp/src/public')
53 files changed, 14143 insertions, 116 deletions
diff --git a/mp/src/public/appframework/ilaunchermgr.h b/mp/src/public/appframework/ilaunchermgr.h index 5d38b15a..7fa5dc76 100644 --- a/mp/src/public/appframework/ilaunchermgr.h +++ b/mp/src/public/appframework/ilaunchermgr.h @@ -10,7 +10,7 @@ #pragma once
#endif
-#if defined( USE_SDL ) || defined( OSX )
+#if defined( USE_SDL )
#include "tier0/threadtools.h"
#include "appframework/IAppSystem.h"
@@ -29,18 +29,12 @@ class CShowPixelsParams; #endif
// if you rev this version also update materialsystem/cmaterialsystem.cpp CMaterialSystem::Connect as it defines the string directly
-#if defined( USE_SDL )
- #define SDLMGR_INTERFACE_VERSION "SDLMgrInterface001"
-#elif defined( OSX )
- #define COCOAMGR_INTERFACE_VERSION "CocoaMgrInterface006"
-#endif
+#define SDLMGR_INTERFACE_VERSION "SDLMgrInterface001"
class CCocoaEvent;
class CStackCrawlParams;
-#if defined( USE_SDL )
typedef struct SDL_Cursor SDL_Cursor;
-#endif
class ILauncherMgr : public IAppSystem
{
@@ -103,11 +97,9 @@ public: virtual void *GetWindowRef() = 0;
virtual void SetMouseVisible( bool bState ) = 0;
-#ifdef USE_SDL
virtual void SetMouseCursor( SDL_Cursor *hCursor ) = 0;
virtual void SetForbidMouseGrab( bool bForbidMouseGrab ) = 0;
virtual void OnFrameRendered() = 0;
-#endif
virtual void SetGammaRamp( const uint16 *pRed, const uint16 *pGreen, const uint16 *pBlue ) = 0;
@@ -163,6 +155,6 @@ public: int m_MouseButton; // which of the CocoaMouseButton_t buttons this is for from above
};
-#endif // USE_SDL || OSX
+#endif // defined( USE_SDL )
#endif // ILAUNCHERMGR_H
diff --git a/mp/src/public/cdll_int.h b/mp/src/public/cdll_int.h index 1757d5d7..1801c383 100644 --- a/mp/src/public/cdll_int.h +++ b/mp/src/public/cdll_int.h @@ -525,7 +525,7 @@ public: virtual void SetGamestatsData( CGamestatsData *pGamestatsData ) = 0;
virtual CGamestatsData *GetGamestatsData() = 0;
-#if defined( USE_SDL ) || defined( OSX )
+#if defined( USE_SDL )
// we need to pull delta's from the cocoa mgr, the engine vectors this for us
virtual void GetMouseDelta( int &x, int &y, bool bIgnoreNextMouseDelta = false ) = 0;
#endif
diff --git a/mp/src/public/eiface.h b/mp/src/public/eiface.h index ea0a4ab7..821df8d6 100644 --- a/mp/src/public/eiface.h +++ b/mp/src/public/eiface.h @@ -407,6 +407,9 @@ public: // Server version from the steam.inf, this will be compared to the GC version
virtual int GetServerVersion() const = 0;
+
+ // Get sv.GetTime()
+ virtual float GetServerTime() const = 0;
};
diff --git a/mp/src/public/engine/ivdebugoverlay.h b/mp/src/public/engine/ivdebugoverlay.h index 51aeafd1..0b24c777 100644 --- a/mp/src/public/engine/ivdebugoverlay.h +++ b/mp/src/public/engine/ivdebugoverlay.h @@ -25,7 +25,7 @@ class Vector; // When used as a duration by a server-side NDebugOverlay:: call,
// causes the overlay to persist until the next server update.
-#define NDEBUG_PERSIST_TILL_NEXT_SERVER (0.01023f)
+#define NDEBUG_PERSIST_TILL_NEXT_SERVER (0.0f)
class OverlayText_t;
diff --git a/mp/src/public/headtrack/iheadtrack.h b/mp/src/public/headtrack/iheadtrack.h deleted file mode 100644 index 4f5fcced..00000000 --- a/mp/src/public/headtrack/iheadtrack.h +++ /dev/null @@ -1,84 +0,0 @@ -//===== Copyright (c), Valve Corporation, All rights reserved. ======//
-//
-// Purpose: Contains the IHeadTrack interface, which is implemented in headtrack.dll
-//
-// $NoKeywords: $
-//
-//===========================================================================//
-
-#ifndef IHEADTRACK_H
-#define IHEADTRACK_H
-
-#ifdef _WIN32
-#pragma once
-#endif
-
-#include "tier1/interface.h"
-#include "tier1/refcount.h"
-#include "appframework/IAppSystem.h"
-#include "mathlib/vmatrix.h"
-#include "view_shared.h"
-
-//-----------------------------------------------------------------------------
-// forward declarations
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// important enumeration
-//-----------------------------------------------------------------------------
-
-// NOTE NOTE NOTE!!!! If you up this, grep for "NEW_INTERFACE" to see if there is anything
-// waiting to be enabled during an interface revision.
-#define HEAD_TRACK_INTERFACE_VERSION "VHeadTrack001"
-
-//-----------------------------------------------------------------------------
-//
-//-----------------------------------------------------------------------------
-
-abstract_class IHeadTrack : public IAppSystem
-{
-public:
- virtual ~IHeadTrack() {}
-
- // Placeholder for API revision
- virtual bool Connect( CreateInterfaceFn factory ) = 0;
- virtual void Disconnect() = 0;
- virtual void *QueryInterface( const char *pInterfaceName ) = 0;
- virtual InitReturnVal_t Init() = 0;
- virtual void Shutdown() = 0;
-
- //-----------------------------------------------------------------------------
- // Tracking section
- //-----------------------------------------------------------------------------
- // All methods return true on success, false on failure.
-
- // Also sets the zero pose
- virtual bool ResetTracking() = 0;
-
- // Set the current pose as the "zero"
- virtual bool SetCurrentCameraAsZero() = 0;
-
- // Raw interfaces - one one or other of these, not both (GetCameraPoseZeroFromCurrent calls GetCameraFromWorldPose );
- virtual bool GetCameraFromWorldPose ( VMatrix *pResultCameraFromWorldPose, VMatrix *pResultCameraFromWorldPoseUnpredicted = NULL, double *pflAcquireTime = NULL ) = 0;
- virtual bool GetCameraPoseZeroFromCurrent ( VMatrix *pResultMatrix ) = 0;
-
- // All-in-one interfaces (they call GetCameraPoseZeroFromCurrent)
- // Grabs the current tracking data and sets up state for the Override* calls.
- virtual bool ProcessCurrentTrackingState ( float PlayerGameFov ) = 0;
-
- // Performs the distortion post-processing.
- virtual bool DoDistortionProcessing ( const vrect_t *SrcRect ) = 0;
-
-};
-
-
-
-//-----------------------------------------------------------------------------
-
-extern IHeadTrack *g_pHeadTrack;
-
-inline bool UseHeadTracking()
-{
- return g_pHeadTrack != NULL;
-}
-#endif // IHEADTRACK_H
diff --git a/mp/src/public/materialsystem/materialsystem_config.h b/mp/src/public/materialsystem/materialsystem_config.h index 1cdca782..1a8d1d1d 100644 --- a/mp/src/public/materialsystem/materialsystem_config.h +++ b/mp/src/public/materialsystem/materialsystem_config.h @@ -32,6 +32,7 @@ enum MaterialSystem_Config_Flags_t MATSYS_VIDCFG_FLAGS_LIMIT_WINDOWED_SIZE = ( 1 << 13 ),
MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION = ( 1 << 14 ),
MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS = ( 1 << 15 ),
+ MATSYS_VIDCFG_FLAGS_DISABLE_PHONG = ( 1 << 16 ),
};
struct MaterialSystemHardwareIdentifier_t
@@ -62,6 +63,7 @@ struct MaterialSystem_Config_t bool LimitWindowedSize() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_LIMIT_WINDOWED_SIZE ) != 0; }
bool ScaleToOutputResolution() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION ) != 0; }
bool UsingMultipleWindows() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS ) != 0; }
+ bool UsePhong() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_DISABLE_PHONG ) == 0; }
bool ShadowDepthTexture() const { return m_bShadowDepthTexture; }
bool MotionBlur() const { return m_bMotionBlur; }
bool SupportFlashlight() const { return m_bSupportFlashlight; }
@@ -157,6 +159,7 @@ struct MaterialSystem_Config_t SetFlag( MATSYS_VIDCFG_FLAGS_LIMIT_WINDOWED_SIZE, false );
SetFlag( MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION, false );
SetFlag( MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS, false );
+ SetFlag( MATSYS_VIDCFG_FLAGS_DISABLE_PHONG, false );
m_VideoMode.m_Width = 640;
m_VideoMode.m_Height = 480;
diff --git a/mp/src/public/mathlib/mathlib.h b/mp/src/public/mathlib/mathlib.h index 83fdb6a0..e1873cd0 100644 --- a/mp/src/public/mathlib/mathlib.h +++ b/mp/src/public/mathlib/mathlib.h @@ -97,7 +97,9 @@ private: #ifdef DEBUG // stop crashing edit-and-continue
FORCEINLINE float clamp( float val, float minVal, float maxVal )
{
- if( val < minVal )
+ if ( maxVal < minVal )
+ return maxVal;
+ else if( val < minVal )
return minVal;
else if( val > maxVal )
return maxVal;
@@ -115,8 +117,8 @@ FORCEINLINE float clamp( float val, float minVal, float maxVal ) _mm_load_ss(&minVal) ),
_mm_load_ss(&maxVal) ) );
#else
- val = fpmin(maxVal, val);
val = fpmax(minVal, val);
+ val = fpmin(maxVal, val);
#endif
return val;
}
@@ -128,7 +130,9 @@ FORCEINLINE float clamp( float val, float minVal, float maxVal ) template< class T >
inline T clamp( T const &val, T const &minVal, T const &maxVal )
{
- if( val < minVal )
+ if ( maxVal < minVal )
+ return maxVal;
+ else if( val < minVal )
return minVal;
else if( val > maxVal )
return maxVal;
@@ -2172,9 +2176,9 @@ bool AlmostEqual(float a, float b, int maxUlps = 10); inline bool AlmostEqual( const Vector &a, const Vector &b, int maxUlps = 10)
{
- return AlmostEqual( a.x, a.x, maxUlps ) &&
- AlmostEqual( a.y, a.y, maxUlps ) &&
- AlmostEqual( a.z, a.z, maxUlps );
+ return AlmostEqual( a.x, b.x, maxUlps ) &&
+ AlmostEqual( a.y, b.y, maxUlps ) &&
+ AlmostEqual( a.z, b.z, maxUlps );
}
diff --git a/mp/src/public/optimize.h b/mp/src/public/optimize.h index b473a65d..b71dc895 100644 --- a/mp/src/public/optimize.h +++ b/mp/src/public/optimize.h @@ -226,7 +226,7 @@ struct FileHeader_t int maxBonesPerVert;
// must match checkSum in the .mdl
- long checkSum;
+ int checkSum;
int numLODs; // garymcthack - this is also specified in ModelHeader_t and should match
diff --git a/mp/src/public/renderparm.h b/mp/src/public/renderparm.h index 32c0fbc0..91c9cfd5 100644 --- a/mp/src/public/renderparm.h +++ b/mp/src/public/renderparm.h @@ -26,6 +26,7 @@ enum RenderParamVector_t VECTOR_RENDERPARM_HMDWARP_GROW_OUTIN,
VECTOR_RENDERPARM_HMDWARP_GROW_ABOVEBELOW,
VECTOR_RENDERPARM_HMDWARP_ASPECT,
+ INT_RENDERPARM_DISTORTION_TYPE,
MAX_VECTOR_RENDER_PARMS = 20
};
diff --git a/mp/src/public/steam/steam_api.h b/mp/src/public/steam/steam_api.h index fe021f80..e16f226b 100644 --- a/mp/src/public/steam/steam_api.h +++ b/mp/src/public/steam/steam_api.h @@ -512,8 +512,8 @@ inline bool CSteamAPIContext::Init() #if defined(USE_BREAKPAD_HANDLER) || defined(STEAM_API_EXPORTS)
// this should be called before the game initialized the steam APIs
-// pchDate should be of the format "Mmm dd yyyy" (such as from the __DATE__ macro )
-// pchTime should be of the format "hh:mm:ss" (such as from the __TIME__ macro )
+// pchDate should be of the format "Mmm dd yyyy" (such as from the __DATE __ macro )
+// pchTime should be of the format "hh:mm:ss" (such as from the __TIME __ macro )
// bFullMemoryDumps (Win32 only) -- writes out a uuid-full.dmp in the client/dumps folder
// pvContext-- can be NULL, will be the void * context passed into m_pfnPreMinidumpCallback
// PFNPreMinidumpCallback m_pfnPreMinidumpCallback -- optional callback which occurs just before a .dmp file is written during a crash. Applications can hook this to allow adding additional information into the .dmp comment stream.
diff --git a/mp/src/public/studio.h b/mp/src/public/studio.h index 7770c2af..9b58ab0c 100644 --- a/mp/src/public/studio.h +++ b/mp/src/public/studio.h @@ -1816,7 +1816,7 @@ struct vertexFileHeader_t DECLARE_BYTESWAP_DATADESC();
int id; // MODEL_VERTEX_FILE_ID
int version; // MODEL_VERTEX_FILE_VERSION
- long checksum; // same as studiohdr_t, ensures sync
+ int checksum; // same as studiohdr_t, ensures sync
int numLODs; // num of valid lods
int numLODVertexes[MAX_NUM_LODS]; // num verts for desired root lod
int numFixups; // num of vertexFileFixup_t
@@ -1991,7 +1991,7 @@ struct studiohdr_t int id;
int version;
- long checksum; // this has to be the same in the phy and vtx files to load!
+ int checksum; // this has to be the same in the phy and vtx files to load!
inline const char * pszName( void ) const { if (studiohdr2index && pStudioHdr2()->pszName()) return pStudioHdr2()->pszName(); else return name; }
char name[64];
diff --git a/mp/src/public/studio_virtualmodel.cpp b/mp/src/public/studio_virtualmodel.cpp index 748ed3b2..269e7cdf 100644 --- a/mp/src/public/studio_virtualmodel.cpp +++ b/mp/src/public/studio_virtualmodel.cpp @@ -572,4 +572,23 @@ void virtualmodel_t::AppendIKLocks( int group, const studiohdr_t *pStudioHdr ) }
m_iklock = iklock;
+
+ // copy knee directions for uninitialized knees
+ if ( group != 0 )
+ {
+ studiohdr_t *pBaseHdr = (studiohdr_t *)m_group[ 0 ].GetStudioHdr();
+ if ( pStudioHdr->numikchains == pBaseHdr->numikchains )
+ {
+ for (j = 0; j < pStudioHdr->numikchains; j++)
+ {
+ if ( pBaseHdr->pIKChain( j )->pLink(0)->kneeDir.LengthSqr() == 0.0f )
+ {
+ if ( pStudioHdr->pIKChain( j )->pLink(0)->kneeDir.LengthSqr() > 0.0f )
+ {
+ pBaseHdr->pIKChain( j )->pLink(0)->kneeDir = pStudioHdr->pIKChain( j )->pLink(0)->kneeDir;
+ }
+ }
+ }
+ }
+ }
}
diff --git a/mp/src/public/tier0/memalloc.h b/mp/src/public/tier0/memalloc.h index 52578760..2840d095 100644 --- a/mp/src/public/tier0/memalloc.h +++ b/mp/src/public/tier0/memalloc.h @@ -535,7 +535,7 @@ inline void MemAlloc_GlobalMemoryStatus( size_t *pusedMemory, size_t *pfreeMemor *pusedMemory = 0;
*pfreeMemory = 0;
}
-#define MemAlloc_MemoryAllocFailed() 1
+#define MemAlloc_MemoryAllocFailed() 0
#define MemAlloc_GetDebugInfoSize() 0
#define MemAlloc_SaveDebugInfo( pvDebugInfo ) ((void)0)
diff --git a/mp/src/public/tier0/platform.h b/mp/src/public/tier0/platform.h index 914cd39a..38e6b563 100644 --- a/mp/src/public/tier0/platform.h +++ b/mp/src/public/tier0/platform.h @@ -1085,7 +1085,7 @@ PLATFORM_INTERFACE bool Plat_IsInBenchmarkMode(); PLATFORM_INTERFACE double Plat_FloatTime(); // Returns time in seconds since the module was loaded.
-PLATFORM_INTERFACE unsigned long Plat_MSTime(); // Time in milliseconds.
+PLATFORM_INTERFACE unsigned int Plat_MSTime(); // Time in milliseconds.
PLATFORM_INTERFACE char * Plat_asctime( const struct tm *tm, char *buf );
PLATFORM_INTERFACE char * Plat_ctime( const time_t *timep, char *buf, size_t bufsize );
PLATFORM_INTERFACE struct tm * Plat_gmtime( const time_t *timep, struct tm *result );
diff --git a/mp/src/public/tier1/checksum_crc.h b/mp/src/public/tier1/checksum_crc.h index a8ef71e5..130577ee 100644 --- a/mp/src/public/tier1/checksum_crc.h +++ b/mp/src/public/tier1/checksum_crc.h @@ -10,7 +10,7 @@ #pragma once
#endif
-typedef unsigned long CRC32_t;
+typedef unsigned int CRC32_t;
void CRC32_Init( CRC32_t *pulCRC );
void CRC32_ProcessBuffer( CRC32_t *pulCRC, const void *p, int len );
diff --git a/mp/src/public/tier1/ilocalize.h b/mp/src/public/tier1/ilocalize.h index 348986ad..a3dd6bb8 100644 --- a/mp/src/public/tier1/ilocalize.h +++ b/mp/src/public/tier1/ilocalize.h @@ -135,7 +135,7 @@ private: typedef char locchar_t;
#define loc_snprintf Q_snprintf
- #define loc_sprintf_safe V_snprintf_safe
+ #define loc_sprintf_safe V_sprintf_safe
#define loc_sncat Q_strncat
#define loc_scat_safe V_strcat_safe
#define loc_sncpy Q_strncpy
@@ -148,7 +148,7 @@ private: typedef wchar_t locchar_t;
#define loc_snprintf V_snwprintf
- #define loc_sprintf_safe V_snwprintf_safe
+ #define loc_sprintf_safe V_swprintf_safe
#define loc_sncat V_wcsncat
#define loc_scat_safe V_wcscat_safe
#define loc_sncpy Q_wcsncpy
diff --git a/mp/src/public/tier1/lzmaDecoder.h b/mp/src/public/tier1/lzmaDecoder.h index eb501c10..8aa1f2ca 100644 --- a/mp/src/public/tier1/lzmaDecoder.h +++ b/mp/src/public/tier1/lzmaDecoder.h @@ -1,4 +1,3 @@ -//========= Copyright Valve Corporation, All rights reserved. ============//
//
// LZMA Decoder. Designed for run time decoding.
//
diff --git a/mp/src/public/tier1/strtools.h b/mp/src/public/tier1/strtools.h index 8e38436f..6089a8f4 100644 --- a/mp/src/public/tier1/strtools.h +++ b/mp/src/public/tier1/strtools.h @@ -290,7 +290,7 @@ template <size_t maxLenInCharacters> int V_vsprintf_safe( OUT_Z_ARRAY char (&pDe int V_snprintf( OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars, PRINTF_FORMAT_STRING const char *pFormat, ... ) FMTFUNCTION( 3, 4 );
// gcc insists on only having format annotations on declarations, not definitions, which is why I have both.
template <size_t maxLenInChars> int V_sprintf_safe( OUT_Z_ARRAY char (&pDest)[maxLenInChars], PRINTF_FORMAT_STRING const char *pFormat, ... ) FMTFUNCTION( 2, 3 );
-template <size_t maxLenInChars> int V_sprintf_safe( OUT_Z_ARRAY char (&pDest)[maxLenInChars], const char *pFormat, ... )
+template <size_t maxLenInChars> int V_sprintf_safe( OUT_Z_ARRAY char (&pDest)[maxLenInChars], PRINTF_FORMAT_STRING const char *pFormat, ... )
{
va_list params;
va_start( params, pFormat );
diff --git a/mp/src/public/tier1/utlrbtree.h b/mp/src/public/tier1/utlrbtree.h index b2665194..6ea22614 100644 --- a/mp/src/public/tier1/utlrbtree.h +++ b/mp/src/public/tier1/utlrbtree.h @@ -1350,7 +1350,7 @@ int CUtlRBTree<T, I, L, M>::Depth( I node ) const int depthright = Depth( RightChild(node) );
int depthleft = Depth( LeftChild(node) );
- return max(depthright, depthleft) + 1;
+ return Max(depthright, depthleft) + 1;
}
diff --git a/mp/src/public/togl/glfuncs.inl b/mp/src/public/togl/glfuncs.inl new file mode 100644 index 00000000..dafd0949 --- /dev/null +++ b/mp/src/public/togl/glfuncs.inl @@ -0,0 +1,7 @@ +#if defined(LINUX) || defined(_WIN32)
+#include "togl/linuxwin/glfuncs.h"
+#endif
+#if defined(OSX)
+#include "togl/osx/glfuncs.h"
+#endif
+
diff --git a/mp/src/public/togl/linuxwin/cglmbuffer.h b/mp/src/public/togl/linuxwin/cglmbuffer.h new file mode 100644 index 00000000..ffec2742 --- /dev/null +++ b/mp/src/public/togl/linuxwin/cglmbuffer.h @@ -0,0 +1,190 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmprogram.h
+// GLMgr buffers (index / vertex)
+// ... maybe add PBO later as well
+//===============================================================================
+
+#ifndef CGLMBUFFER_H
+#define CGLMBUFFER_H
+
+#pragma once
+
+//===============================================================================
+
+extern bool g_bUsePseudoBufs;
+
+// forward declarations
+
+class GLMContext;
+
+enum EGLMBufferType
+{
+ kGLMVertexBuffer,
+ kGLMIndexBuffer,
+ kGLMUniformBuffer, // for bindable uniform
+ kGLMPixelBuffer, // for PBO
+
+ kGLMNumBufferTypes
+};
+
+// pass this in "options" to constructor to make a dynamic buffer
+#define GLMBufferOptionDynamic 0x00000001
+
+struct GLMBuffLockParams
+{
+ uint m_nOffset;
+ uint m_nSize;
+ bool m_bNoOverwrite;
+ bool m_bDiscard;
+};
+
+#define GL_STATIC_BUFFER_SIZE ( 2048 * 1024 )
+#define GL_MAX_STATIC_BUFFERS 2
+
+extern void glBufferSubDataMaxSize( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data, uint nMaxSizePerCall = 128 * 1024 );
+
+//===============================================================================
+
+#if GL_ENABLE_INDEX_VERIFICATION
+
+struct GLDynamicBuf_t
+{
+ GLenum m_nGLType;
+ uint m_nHandle;
+ uint m_nActualBufSize;
+ uint m_nSize;
+
+ uint m_nLockOffset;
+ uint m_nLockSize;
+};
+
+class CGLMBufferSpanManager
+{
+ CGLMBufferSpanManager( const CGLMBufferSpanManager& );
+ CGLMBufferSpanManager& operator= ( const CGLMBufferSpanManager& );
+
+public:
+ CGLMBufferSpanManager();
+ ~CGLMBufferSpanManager();
+
+ void Init( GLMContext *pContext, EGLMBufferType nBufType, uint nInitialCapacity, uint nBufSize, bool bDynamic );
+ void Deinit();
+
+ inline GLMContext *GetContext() const { return m_pCtx; }
+
+ inline GLenum GetGLBufType() const { return ( m_nBufType == kGLMVertexBuffer ) ? GL_ARRAY_BUFFER_ARB : GL_ELEMENT_ARRAY_BUFFER_ARB; }
+
+ struct ActiveSpan_t
+ {
+ uint m_nStart;
+ uint m_nEnd;
+
+ GLDynamicBuf_t m_buf;
+ bool m_bOriginalAlloc;
+
+ inline ActiveSpan_t() { }
+ inline ActiveSpan_t( uint nStart, uint nEnd, GLDynamicBuf_t &buf, bool bOriginalAlloc ) : m_nStart( nStart ), m_nEnd( nEnd ), m_buf( buf ), m_bOriginalAlloc( bOriginalAlloc ) { Assert( nStart <= nEnd ); }
+ };
+
+ ActiveSpan_t *AddSpan( uint nOffset, uint nMaxSize, uint nActualSize, bool bDiscard, bool bNoOverwrite );
+
+ void DiscardAllSpans();
+
+ bool IsValid( uint nOffset, uint nSize ) const;
+
+private:
+ bool AllocDynamicBuf( uint nSize, GLDynamicBuf_t &buf );
+ void ReleaseDynamicBuf( GLDynamicBuf_t &buf );
+
+ GLMContext *m_pCtx;
+
+ EGLMBufferType m_nBufType;
+
+ uint m_nBufSize;
+ bool m_bDynamic;
+
+ CUtlVector<ActiveSpan_t> m_ActiveSpans;
+ CUtlVector<ActiveSpan_t> m_DeletedSpans;
+
+ int m_nSpanEndMax;
+
+ int m_nNumAllocatedBufs;
+ int m_nTotalBytesAllocated;
+};
+
+#endif // GL_ENABLE_INDEX_VERIFICATION
+
+class CGLMBuffer
+{
+public:
+ void Lock( GLMBuffLockParams *pParams, char **pAddressOut );
+ void Unlock( int nActualSize = -1, const void *pActualData = NULL );
+
+ friend class GLMContext; // only GLMContext can make CGLMBuffer objects
+ friend class GLMTester;
+ friend struct IDirect3D9;
+ friend struct IDirect3DDevice9;
+
+ CGLMBuffer( GLMContext *pCtx, EGLMBufferType type, uint size, uint options );
+ ~CGLMBuffer();
+
+ void SetModes( bool bAsyncMap, bool bExplicitFlush, bool bForce = false );
+ void FlushRange( uint offset, uint size );
+
+#if GL_ENABLE_INDEX_VERIFICATION
+ bool IsSpanValid( uint nOffset, uint nSize ) const;
+#endif
+
+ GLMContext *m_pCtx; // link back to parent context
+ EGLMBufferType m_type;
+ uint m_nSize;
+ uint m_nActualSize;
+
+ bool m_bDynamic;
+
+ GLenum m_buffGLTarget; // GL_ARRAY_BUFFER_ARB / GL_ELEMENT_BUFFER_ARB
+ GLuint m_nHandle; // name of this program in the context
+
+ uint m_nRevision; // bump anytime the size changes or buffer is orphaned
+
+ bool m_bEnableAsyncMap; // mirror of the buffer state
+ bool m_bEnableExplicitFlush; // mirror of the buffer state
+
+ bool m_bMapped; // is it currently mapped
+
+ uint m_dirtyMinOffset; // when equal, range is empty
+ uint m_dirtyMaxOffset;
+
+ float *m_pLastMappedAddress;
+
+ int m_nPinnedMemoryOfs;
+
+ bool m_bPseudo; // true if the m_name is 0, and the backing is plain RAM
+
+ // in pseudo mode, there is just one RAM buffer that acts as the backing.
+ // expectation is that this mode would only be used for dynamic indices.
+ // since indices have to be consumed (copied to command stream) prior to return from a drawing call,
+ // there's no need to do any fencing or multibuffering. orphaning in particular becomes a no-op.
+
+ char *m_pActualPseudoBuf; // storage for pseudo buffer
+ char *m_pPseudoBuf; // storage for pseudo buffer
+ char *m_pStaticBuffer;
+
+ GLMBuffLockParams m_LockParams;
+
+ static char ALIGN16 m_StaticBuffers[ GL_MAX_STATIC_BUFFERS ][ GL_STATIC_BUFFER_SIZE ] ALIGN16_POST;
+ static bool m_bStaticBufferUsed[ GL_MAX_STATIC_BUFFERS ];
+
+#if GL_ENABLE_INDEX_VERIFICATION
+ CGLMBufferSpanManager m_BufferSpanManager;
+#endif
+
+#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
+ uint m_nDirtyRangeStart;
+ uint m_nDirtyRangeEnd;
+#endif
+};
+
+#endif // CGLMBUFFER_H
+
diff --git a/mp/src/public/togl/linuxwin/cglmfbo.h b/mp/src/public/togl/linuxwin/cglmfbo.h new file mode 100644 index 00000000..f3415795 --- /dev/null +++ b/mp/src/public/togl/linuxwin/cglmfbo.h @@ -0,0 +1,82 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmfbo.h
+// GLMgr FBO's (render targets)
+//
+//===============================================================================
+
+#ifndef CGLMFBO_H
+#define CGLMFBO_H
+
+#pragma once
+
+// good FBO references / recaps
+// http://www.songho.ca/opengl/gl_fbo.html
+// http://www.gamedev.net/reference/articles/article2331.asp
+
+// ext links
+
+// http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt
+// http://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+#ifndef GL_DEPTH_STENCIL_ATTACHMENT_EXT
+ #define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+
+enum EGLMFBOAttachment
+{
+ kAttColor0, kAttColor1, kAttColor2, kAttColor3,
+ kAttDepth, kAttStencil, kAttDepthStencil,
+ kAttCount
+};
+
+struct GLMFBOTexAttachParams
+{
+ CGLMTex *m_tex;
+ int m_face; // keep zero if not cube map
+ int m_mip; // keep zero if notmip mapped
+ int m_zslice; // keep zero if not a 3D tex
+};
+
+class CGLMFBO
+{
+ friend class GLMContext;
+ friend class GLMTester;
+ friend class CGLMTex;
+
+ friend struct IDirect3D9;
+ friend struct IDirect3DDevice9;
+
+public:
+ CGLMFBO( GLMContext *ctx );
+ ~CGLMFBO( );
+
+protected:
+ void TexAttach( GLMFBOTexAttachParams *params, EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
+ void TexDetach( EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
+ // you can also pass GL_READ_FRAMEBUFFER_EXT or GL_DRAW_FRAMEBUFFER_EXT to selectively bind the receiving FBO to one or the other.
+
+ void TexScrub( CGLMTex *tex );
+ // search and destroy any attachment for the named texture
+
+ bool IsReady( void ); // aka FBO completeness check - ready to draw
+
+ GLMContext *m_ctx; // link back to parent context
+
+ GLuint m_name; // name of this FBO in the context
+
+ GLMFBOTexAttachParams m_attach[ kAttCount ]; // indexed by EGLMFBOAttachment
+};
+
+
+#endif
\ No newline at end of file diff --git a/mp/src/public/togl/linuxwin/cglmprogram.h b/mp/src/public/togl/linuxwin/cglmprogram.h new file mode 100644 index 00000000..ca32af00 --- /dev/null +++ b/mp/src/public/togl/linuxwin/cglmprogram.h @@ -0,0 +1,420 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmprogram.h
+// GLMgr programs (ARBVP/ARBfp)
+//
+//===============================================================================
+
+#ifndef CGLMPROGRAM_H
+#define CGLMPROGRAM_H
+
+#include <sys/stat.h>
+
+#pragma once
+
+// good ARB program references
+// http://petewarden.com/notes/archives/2005/05/fragment_progra_2.html
+// http://petewarden.com/notes/archives/2005/06/fragment_progra_3.html
+
+// ext links
+
+// http://www.opengl.org/registry/specs/ARB/vertex_program.txt
+// http://www.opengl.org/registry/specs/ARB/fragment_program.txt
+// http://www.opengl.org/registry/specs/EXT/gpu_program_parameters.txt
+
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+//#ifndef GL_DEPTH_STENCIL_ATTACHMENT_EXT
+// #define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+//#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class CGLMShaderPair;
+class CGLMShaderPairCache;
+
+// CGLMProgram can contain two flavors of the same program, one in assembler, one in GLSL.
+// these flavors are pretty different in terms of the API's that are used to activate them -
+// for example, assembler programs can just get bound to the context, whereas GLSL programs
+// have to be linked. To some extent we try to hide that detail inside GLM.
+
+// for now, make CGLMProgram a container, it does not set policy or hold a preference as to which
+// flavor you want to use. GLMContext has to handle that.
+
+enum EGLMProgramType
+{
+ kGLMVertexProgram,
+ kGLMFragmentProgram,
+
+ kGLMNumProgramTypes
+};
+
+enum EGLMProgramLang
+{
+ kGLMARB,
+ kGLMGLSL,
+
+ kGLMNumProgramLangs
+};
+
+struct GLMShaderDesc
+{
+ union
+ {
+ GLuint arb; // ARB program object name
+ GLhandleARB glsl; // GLSL shader object handle (void*)
+ } m_object;
+
+ // these can change if shader text is edited
+ bool m_textPresent; // is this flavor(lang) of text present in the buffer?
+ int m_textOffset; // where is it
+ int m_textLength; // how big
+
+ bool m_compiled; // has this text been through a compile attempt
+ bool m_valid; // and if so, was the compile successful
+
+ int m_slowMark; // has it been flagged during a non native draw batch before. increment every time it's slow.
+
+ int m_highWater; // count of vec4's in the major uniform array ("vc" on vs, "pc" on ps)
+ // written by dxabstract.... gross!
+ int m_VSHighWaterBone; // count of vec4's in the bone-specific uniform array (only valid for vertex shaders)
+};
+
+GLenum GLMProgTypeToARBEnum( EGLMProgramType type ); // map vert/frag to ARB asm bind target
+GLenum GLMProgTypeToGLSLEnum( EGLMProgramType type ); // map vert/frag to ARB asm bind target
+
+#define GL_SHADER_PAIR_CACHE_STATS 0
+
+class CGLMProgram
+{
+public:
+ friend class CGLMShaderPairCache;
+ friend class CGLMShaderPair;
+ friend class GLMContext; // only GLMContext can make CGLMProgram objects
+ friend class GLMTester;
+ friend struct IDirect3D9;
+ friend struct IDirect3DDevice9;
+
+ //===============================
+
+ // constructor is very light, it just makes one empty program object per flavor.
+ CGLMProgram( GLMContext *ctx, EGLMProgramType type );
+ ~CGLMProgram( );
+
+ void SetProgramText ( char *text ); // import text to GLM object - invalidate any prev compiled program
+ void SetShaderName ( const char *name ); // only used for debugging/telemetry markup
+
+ bool CompileActiveSources ( void ); // compile only the flavors that were provided.
+ bool Compile ( EGLMProgramLang lang );
+ bool CheckValidity ( EGLMProgramLang lang );
+
+ void LogSlow ( EGLMProgramLang lang ); // detailed spew when called for first time; one liner or perhaps silence after that
+
+ void GetLabelIndexCombo ( char *labelOut, int labelOutMaxChars, int *indexOut, int *comboOut );
+ void GetComboIndexNameString ( char *stringOut, int stringOutMaxChars ); // mmmmmmmm-nnnnnnnn-filename
+
+#if GLMDEBUG
+ bool PollForChanges( void ); // check mirror for changes.
+ void ReloadStringFromEditable( void ); // populate m_string from editable item (react to change)
+ bool SyncWithEditable( void );
+#endif
+
+ //===============================
+
+ // common stuff
+
+ GLMContext *m_ctx; // link back to parent context
+
+ EGLMProgramType m_type; // vertex or pixel
+
+ uint m_nHashTag; // serial number for hashing
+
+ char *m_text; // copy of text passed into constructor. Can change if editable shaders is enabled.
+ // note - it can contain multiple flavors, so use CGLMTextSectioner to scan it and locate them
+#if GLMDEBUG
+ CGLMEditableTextItem *m_editable; // editable text item for debugging
+#endif
+
+ GLMShaderDesc m_descs[ kGLMNumProgramLangs ];
+
+ uint m_samplerMask; // (1<<n) mask of sampler active locs, if this is a fragment shader (dxabstract sets this field)
+ uint m_samplerTypes; // SAMPLER_2D, etc.
+ uint m_nNumUsedSamplers;
+ uint m_maxSamplers;
+ uint m_maxVertexAttrs;
+ uint m_nCentroidMask;
+ uint m_nShadowDepthSamplerMask;
+
+ bool m_bTranslatedProgram;
+
+ char m_shaderName[64];
+};
+
+//===============================================================================
+
+struct GLMShaderPairInfo
+{
+ int m_status; // -1 means req'd index was out of bounds (loop stop..) 0 means not present. 1 means present/active.
+
+ char m_vsName[ 128 ];
+ int m_vsStaticIndex;
+ int m_vsDynamicIndex;
+
+ char m_psName[ 128 ];
+ int m_psStaticIndex;
+ int m_psDynamicIndex;
+};
+
+class CGLMShaderPair // a container for a linked GLSL shader pair, and metadata obtained post-link
+{
+
+public:
+
+ friend class CGLMProgram;
+ friend class GLMContext;
+ friend class CGLMShaderPairCache;
+
+ //===============================
+
+ // constructor just sets up a GLSL program object and leaves it empty.
+ CGLMShaderPair( GLMContext *ctx );
+ ~CGLMShaderPair( );
+
+ bool SetProgramPair ( CGLMProgram *vp, CGLMProgram *fp );
+ // true result means successful link and query
+
+ bool RefreshProgramPair ( void );
+ // re-link and re-query the uniforms
+
+ FORCEINLINE void UpdateScreenUniform( uint nWidthHeight )
+ {
+ if ( m_nScreenWidthHeight == nWidthHeight )
+ return;
+
+ m_nScreenWidthHeight = nWidthHeight;
+
+ uint nWidth = nWidthHeight & 0xFFFF, nHeight = nWidthHeight >> 16;
+ // Apply half pixel offset to output vertices to account for the pixel center difference between D3D9 and OpenGL.
+ // We output vertices in clip space, which ranges from [-1,1], so 1.0/width in clip space transforms into .5/width in screenspace, see: "Viewports and Clipping (Direct3D 9)" in the DXSDK
+ float v[4] = { 1.0f / nWidth, 1.0f / nHeight, nWidth, nHeight };
+ if ( m_locVertexScreenParams >= 0 )
+ gGL->glUniform4fv( m_locVertexScreenParams, 1, v );
+ }
+
+ //===============================
+
+ // common stuff
+
+ GLMContext *m_ctx; // link back to parent context
+
+ CGLMProgram *m_vertexProg;
+ CGLMProgram *m_fragmentProg;
+
+ GLhandleARB m_program; // linked program object
+
+ // need meta data for attribs / samplers / params
+ // actually we only need it for samplers and params.
+ // attributes are hardwired.
+
+ // vertex stage uniforms
+ GLint m_locVertexParams; // "vc" per dx9asmtogl2 convention
+ GLint m_locVertexBoneParams; // "vcbones"
+ GLint m_locVertexInteger0; // "i0"
+
+ GLint m_locVertexBool0; // "b0"
+ GLint m_locVertexBool1; // "b1"
+ GLint m_locVertexBool2; // "b2"
+ GLint m_locVertexBool3; // "b3"
+ bool m_bHasBoolOrIntUniforms;
+
+ // fragment stage uniforms
+ GLint m_locFragmentParams; // "pc" per dx9asmtogl2 convention
+
+ int m_NumUniformBufferParams[kGLMNumProgramTypes];
+ GLint m_UniformBufferParams[kGLMNumProgramTypes][256];
+
+ GLint m_locFragmentFakeSRGBEnable; // "flSRGBWrite" - set to 1.0 to effect sRGB encoding on output
+ float m_fakeSRGBEnableValue; // shadow to avoid redundant sets of the m_locFragmentFakeSRGBEnable uniform
+ // init it to -1.0 at link or relink, so it will trip on any legit incoming value (0.0 or 1.0)
+
+ GLint m_locSamplers[ 16 ]; // "sampler0 ... sampler1..."
+
+ // other stuff
+ bool m_valid; // true on successful link
+ uint m_revision; // if this pair is relinked, bump this number.
+
+ GLint m_locVertexScreenParams; // vcscreen
+ uint m_nScreenWidthHeight;
+
+};
+
+//===============================================================================
+
+// N-row, M-way associative cache with LRU per row.
+// still needs some metric dump ability and some parameter tuning.
+// extra credit would be to make an auto-tuner.
+
+struct CGLMPairCacheEntry
+{
+ long long m_lastMark; // a mark of zero means an empty entry
+ CGLMProgram *m_vertexProg;
+ CGLMProgram *m_fragmentProg;
+ uint m_extraKeyBits;
+ CGLMShaderPair *m_pair;
+};
+
+class CGLMShaderPairCache // cache for linked GLSL shader pairs
+{
+
+public:
+
+protected:
+ friend class CGLMShaderPair;
+ friend class CGLMProgram;
+ friend class GLMContext;
+
+ //===============================
+
+ CGLMShaderPairCache( GLMContext *ctx );
+ ~CGLMShaderPairCache( );
+
+ FORCEINLINE CGLMShaderPair *SelectShaderPair ( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
+ void QueryShaderPair ( int index, GLMShaderPairInfo *infoOut );
+
+ // shoot down linked pairs that use the program in the arg
+ // return true if any had to be skipped due to conflict with currently bound pair
+ bool PurgePairsWithShader( CGLMProgram *prog );
+
+ // purge everything (when would GLM know how to do this ? at context destroy time, but any other times?)
+ // return true if any had to be skipped due to conflict with currently bound pair
+ bool Purge ( void );
+
+ // stats
+ void DumpStats ( void );
+
+ //===============================
+
+ FORCEINLINE uint HashRowIndex( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits ) const;
+ FORCEINLINE CGLMPairCacheEntry* HashRowPtr( uint hashRowIndex ) const;
+
+ FORCEINLINE void HashRowProbe( CGLMPairCacheEntry *row, CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int &hitway, int &emptyway, int &oldestway );
+
+ CGLMShaderPair *SelectShaderPairInternal( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int rowIndex );
+ //===============================
+
+ // common stuff
+
+ GLMContext *m_ctx; // link back to parent context
+
+ long long m_mark;
+
+ uint m_rowsLg2;
+ uint m_rows;
+ uint m_rowsMask;
+
+ uint m_waysLg2;
+ uint m_ways;
+
+ uint m_entryCount;
+
+ CGLMPairCacheEntry *m_entries; // array[ m_rows ][ m_ways ]
+
+ uint *m_evictions; // array[ m_rows ];
+
+#if GL_SHADER_PAIR_CACHE_STATS
+ uint *m_hits; // array[ m_rows ];
+#endif
+};
+
+FORCEINLINE uint CGLMShaderPairCache::HashRowIndex( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits ) const
+{
+ return ( vp->m_nHashTag + fp->m_nHashTag + extraKeyBits * 7 ) & m_rowsMask;
+}
+
+FORCEINLINE CGLMPairCacheEntry* CGLMShaderPairCache::HashRowPtr( uint hashRowIndex ) const
+{
+ return &m_entries[ hashRowIndex * m_ways ];
+}
+
+FORCEINLINE void CGLMShaderPairCache::HashRowProbe( CGLMPairCacheEntry *row, CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int& hitway, int& emptyway, int& oldestway )
+{
+ hitway = -1;
+ emptyway = -1;
+ oldestway = -1;
+
+ // scan this row to see if the desired pair is present
+ CGLMPairCacheEntry *cursor = row;
+ long long oldestmark = 0xFFFFFFFFFFFFFFFFLL;
+
+ for( uint way = 0; way < m_ways; ++way )
+ {
+ if ( cursor->m_lastMark != 0 ) // occupied slot
+ {
+ // check if this is the oldest one on the row - only occupied slots are checked
+ if ( cursor->m_lastMark < oldestmark )
+ {
+ oldestway = way;
+ oldestmark = cursor->m_lastMark;
+ }
+
+ if ( ( cursor->m_vertexProg == vp ) && ( cursor->m_fragmentProg == fp ) && ( cursor->m_extraKeyBits == extraKeyBits ) ) // match?
+ {
+ // found it
+ hitway = way;
+ break;
+ }
+ }
+ else
+ {
+ // empty way, log it if first one seen
+ if (emptyway<0)
+ {
+ emptyway = way;
+ }
+ }
+ cursor++;
+ }
+}
+
+FORCEINLINE CGLMShaderPair *CGLMShaderPairCache::SelectShaderPair( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits )
+{
+ // select row where pair would be found if it exists
+ uint rowIndex = HashRowIndex( vp, fp, extraKeyBits );
+
+ CGLMPairCacheEntry *pCursor = HashRowPtr( rowIndex );
+
+ if ( ( pCursor->m_fragmentProg != fp ) || ( pCursor->m_vertexProg != vp ) || ( pCursor->m_extraKeyBits != extraKeyBits ) )
+ {
+ CGLMPairCacheEntry *pLastCursor = pCursor + m_ways;
+
+ ++pCursor;
+
+ while ( pCursor != pLastCursor )
+ {
+ if ( ( pCursor->m_fragmentProg == fp ) && ( pCursor->m_vertexProg == vp ) && ( pCursor->m_extraKeyBits == extraKeyBits ) ) // match?
+ break;
+ ++pCursor;
+ };
+
+ if ( pCursor == pLastCursor )
+ return SelectShaderPairInternal( vp, fp, extraKeyBits, rowIndex );
+ }
+
+ // found it. mark it and return
+ pCursor->m_lastMark = m_mark++;
+
+#if GL_SHADER_PAIR_CACHE_STATS
+ // count the hit
+ m_hits[ rowIndex ] ++;
+#endif
+
+ return pCursor->m_pair;
+}
+
+#endif
diff --git a/mp/src/public/togl/linuxwin/cglmquery.h b/mp/src/public/togl/linuxwin/cglmquery.h new file mode 100644 index 00000000..3cf6f79e --- /dev/null +++ b/mp/src/public/togl/linuxwin/cglmquery.h @@ -0,0 +1,90 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmquery.h
+// GLMgr queries
+//
+//===============================================================================
+
+#ifndef CGLMQUERY_H
+#define CGLMQUERY_H
+
+#pragma once
+
+#ifdef OSX
+#include "glmgr/glmgrbasics.h"
+#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class CGLMQuery;
+
+//===============================================================================
+
+enum EGLMQueryType
+{
+ EOcclusion,
+ EFence,
+ EGLMQueryCount
+};
+
+struct GLMQueryParams
+{
+ EGLMQueryType m_type;
+};
+
+class CGLMQuery
+{
+ // leave everything public til it's running
+public:
+ friend class GLMContext; // only GLMContext can make CGLMTex objects
+ friend struct IDirect3DDevice9;
+ friend struct IDirect3DQuery9;
+
+ GLMContext *m_ctx; // link back to parent context
+ GLMQueryParams m_params; // params created with
+
+ GLuint m_name; // name of the query object per se - could be fence, could be query object ... NOT USED WITH GL_ARB_sync!
+#ifdef HAVE_GL_ARB_SYNC
+ GLsync m_syncobj; // GL_ARB_sync object. NOT USED WITH GL_NV_fence or GL_APPLE_fence!
+#else
+ GLuint m_syncobj;
+#endif
+
+ bool m_started;
+ bool m_stopped;
+ bool m_done;
+
+ bool m_nullQuery; // was gl_nullqueries true at Start time - if so, continue to act like a null query through Stop/IsDone/Complete time
+ // restated - only Start should examine the convar.
+ static uint s_nTotalOcclusionQueryCreatesOrDeletes;
+
+ CGLMQuery( GLMContext *ctx, GLMQueryParams *params );
+ ~CGLMQuery( );
+
+ // for an occlusion query:
+ // Start = BeginQuery query-start goes into stream
+ // Stop = EndQuery query-end goes into stream - a fence is also set so we can probe for completion
+ // IsDone = TestFence use the added fence to ask if query-end has passed (i.e. will Complete block?)
+ // Complete = GetQueryObjectuivARB(uint id, enum pname, uint *params) - extract the sample count
+
+ // for a fence query:
+ // Start = SetFence fence goes into command stream
+ // Stop = NOP fences are self finishing - no need to call Stop on a fence
+ // IsDone = TestFence ask if fence passed
+ // Complete = FinishFence
+
+ void Start ( void );
+ void Stop ( void );
+ bool IsDone ( void );
+ void Complete ( uint *result );
+
+ // accessors for the started/stopped state
+ bool IsStarted ( void );
+ bool IsStopped ( void );
+};
+
+
+#endif
diff --git a/mp/src/public/togl/linuxwin/cglmtex.h b/mp/src/public/togl/linuxwin/cglmtex.h new file mode 100644 index 00000000..bdb83776 --- /dev/null +++ b/mp/src/public/togl/linuxwin/cglmtex.h @@ -0,0 +1,502 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmtex.h
+// GLMgr textures
+//
+//===============================================================================
+
+#ifndef CGLMTEX_H
+#define CGLMTEX_H
+
+#pragma once
+
+#ifdef OSX
+#include "glmgr/glmgrbasics.h"
+#endif
+#include "tier1/utlhash.h"
+#include "tier1/utlmap.h"
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class GLMTester;
+class CGLMTexLayoutTable;
+class CGLMTex;
+class CGLMFBO;
+
+struct IDirect3DSurface9;
+
+#if GLMDEBUG
+extern CGLMTex *g_pFirstCGMLTex;
+#endif
+
+// For GL_EXT_texture_sRGB_decode
+#ifndef GL_TEXTURE_SRGB_DECODE_EXT
+#define GL_TEXTURE_SRGB_DECODE_EXT 0x8A48
+#endif
+
+#ifndef GL_DECODE_EXT
+#define GL_DECODE_EXT 0x8A49
+#endif
+
+#ifndef GL_SKIP_DECODE_EXT
+#define GL_SKIP_DECODE_EXT 0x8A4A
+#endif
+
+//===============================================================================
+
+struct GLMTexFormatDesc
+{
+ const char *m_formatSummary; // for debug visibility
+
+ D3DFORMAT m_d3dFormat; // what D3D knows it as; see public/bitmap/imageformat.h
+
+ GLenum m_glIntFormat; // GL internal format
+ GLenum m_glIntFormatSRGB; // internal format if SRGB flavor
+ GLenum m_glDataFormat; // GL data format
+ GLenum m_glDataType; // GL data type
+
+ int m_chunkSize; // 1 or 4 - 4 is used for compressed textures
+ int m_bytesPerSquareChunk; // how many bytes for the smallest quantum (m_chunkSize x m_chunkSize)
+ // this description lets us calculate size cleanly without conditional logic for compression
+};
+const GLMTexFormatDesc *GetFormatDesc( D3DFORMAT format );
+
+//===============================================================================
+
+// utility function for generating slabs of texels. mostly for test.
+typedef struct
+{
+ // in
+ D3DFORMAT m_format;
+ void *m_dest; // dest address
+ int m_chunkCount; // square chunk count (single texels or compressed blocks)
+ int m_byteCountLimit; // caller expectation of max number of bytes to write out
+ float r,g,b,a; // color desired
+
+ // out
+ int m_bytesWritten;
+} GLMGenTexelParams;
+
+// return true if successful
+bool GLMGenTexels( GLMGenTexelParams *params );
+
+
+//===============================================================================
+
+struct GLMTexLayoutSlice
+{
+ int m_xSize,m_ySize,m_zSize; //texel dimensions of this slice
+ int m_storageOffset; //where in the storage slab does this slice live
+ int m_storageSize; //how much storage does this slice occupy
+};
+
+enum EGLMTexFlags
+{
+ kGLMTexMipped = 0x01,
+ kGLMTexMippedAuto = 0x02,
+ kGLMTexRenderable = 0x04,
+ kGLMTexIsStencil = 0x08,
+ kGLMTexIsDepth = 0x10,
+ kGLMTexSRGB = 0x20,
+ kGLMTexMultisampled = 0x40, // has an RBO backing it. Cannot combine with Mipped, MippedAuto. One slice maximum, only targeting GL_TEXTURE_2D.
+ // actually not 100% positive on the mipmapping, the RBO itself can't be mipped, but the resulting texture could
+ // have mipmaps generated.
+};
+
+//===============================================================================
+
+struct GLMTexLayoutKey
+{
+ // input values: held const, these are the hash key for the form map
+ GLenum m_texGLTarget; // flavor of texture: GL_TEXTURE_2D, GL_TEXTURE_3D, GLTEXTURE_CUBE_MAP
+ D3DFORMAT m_texFormat; // D3D texel format
+ unsigned long m_texFlags; // mipped, autogen mips, render target, ... ?
+ unsigned long m_texSamples; // zero for a plain tex, 2/4/6/8 for "MSAA tex" (RBO backed)
+ int m_xSize,m_ySize,m_zSize; // size of base mip
+};
+
+bool LessFunc_GLMTexLayoutKey( const GLMTexLayoutKey &a, const GLMTexLayoutKey &b );
+
+#define GLM_TEX_MAX_MIPS 14
+#define GLM_TEX_MAX_FACES 6
+#define GLM_TEX_MAX_SLICES (GLM_TEX_MAX_MIPS * GLM_TEX_MAX_FACES)
+
+#pragma warning( push )
+#pragma warning( disable : 4200 )
+
+struct GLMTexLayout
+{
+ char *m_layoutSummary; // for debug visibility
+
+ // const inputs used for hashing
+ GLMTexLayoutKey m_key;
+
+ // refcount
+ int m_refCount;
+
+ // derived values:
+ GLMTexFormatDesc *m_format; // format specific info
+ int m_mipCount; // derived by starying at base size and working down towards 1x1
+ int m_faceCount; // 1 for 2d/3d, 6 for cubemap
+ int m_sliceCount; // product of faces and mips
+ int m_storageTotalSize; // size of storage slab required
+
+ // slice array
+ GLMTexLayoutSlice m_slices[0]; // dynamically allocated 2-d array [faces][mips]
+};
+
+#pragma warning( pop )
+
+class CGLMTexLayoutTable
+{
+public:
+ CGLMTexLayoutTable();
+
+ GLMTexLayout *NewLayoutRef( GLMTexLayoutKey *pDesiredKey ); // pass in a pointer to layout key - receive ptr to completed layout
+ void DelLayoutRef( GLMTexLayout *layout ); // pass in pointer to completed layout. refcount is dropped.
+
+ void DumpStats( void );
+protected:
+ CUtlMap< GLMTexLayoutKey, GLMTexLayout* > m_layoutMap;
+};
+
+//===============================================================================
+
+// a sampler specifies desired state for drawing on a given sampler index
+// this is the combination of a texture choice and a set of sampler parameters
+// see http://msdn.microsoft.com/en-us/library/bb172602(VS.85).aspx
+
+struct GLMTexLockParams
+{
+ // input params which identify the slice of interest
+ CGLMTex *m_tex;
+ int m_face;
+ int m_mip;
+
+ // identifies the region of the slice
+ GLMRegion m_region;
+
+ // tells GLM to force re-read of the texels back from GL
+ // i.e. "I know I stepped on those texels with a draw or blit - the GLM copy is stale"
+ bool m_readback;
+};
+
+struct GLMTexLockDesc
+{
+ GLMTexLockParams m_req; // form of the lock request
+
+ bool m_active; // set true at lock time. cleared at unlock time.
+
+ int m_sliceIndex; // which slice in the layout
+ int m_sliceBaseOffset; // where is that in the texture data
+ int m_sliceRegionOffset; // offset to the start (lowest address corner) of the region requested
+};
+
+//===============================================================================
+
+#define GLM_SAMPLER_COUNT 16
+
+typedef CBitVec<GLM_SAMPLER_COUNT> CTexBindMask;
+
+enum EGLMTexSliceFlag
+{
+ kSliceValid = 0x01, // slice has been teximage'd in whole at least once - set to 0 initially
+ kSliceStorageValid = 0x02, // if backing store is available, this slice's data is a valid copy - set to 0 initially
+ kSliceLocked = 0x04, // are one or more locks outstanding on this slice
+ kSliceFullyDirty = 0x08, // does the slice need to be fully downloaded at unlock time (disregard dirty rects)
+};
+
+//===============================================================================
+
+#define GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS (2)
+#define GLM_PACKED_SAMPLER_PARAMS_MIN_FILTER_BITS (2)
+#define GLM_PACKED_SAMPLER_PARAMS_MAG_FILTER_BITS (2)
+#define GLM_PACKED_SAMPLER_PARAMS_MIP_FILTER_BITS (2)
+#define GLM_PACKED_SAMPLER_PARAMS_MIN_LOD_BITS (4)
+#define GLM_PACKED_SAMPLER_PARAMS_MAX_ANISO_BITS (5)
+#define GLM_PACKED_SAMPLER_PARAMS_COMPARE_MODE_BITS (1)
+#define GLM_PACKED_SAMPLER_PARAMS_SRGB_BITS (1)
+
+struct GLMTexPackedSamplingParams
+{
+ uint32 m_addressU : GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS;
+ uint32 m_addressV : GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS;
+ uint32 m_addressW : GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS;
+
+ uint32 m_minFilter : GLM_PACKED_SAMPLER_PARAMS_MIN_FILTER_BITS;
+ uint32 m_magFilter : GLM_PACKED_SAMPLER_PARAMS_MAG_FILTER_BITS;
+ uint32 m_mipFilter : GLM_PACKED_SAMPLER_PARAMS_MIP_FILTER_BITS;
+
+ uint32 m_minLOD : GLM_PACKED_SAMPLER_PARAMS_MIN_LOD_BITS;
+ uint32 m_maxAniso : GLM_PACKED_SAMPLER_PARAMS_MAX_ANISO_BITS;
+ uint32 m_compareMode : GLM_PACKED_SAMPLER_PARAMS_COMPARE_MODE_BITS;
+ uint32 m_srgb : GLM_PACKED_SAMPLER_PARAMS_SRGB_BITS;
+ uint32 m_isValid : 1;
+};
+
+struct GLMTexSamplingParams
+{
+ union
+ {
+ GLMTexPackedSamplingParams m_packed;
+ uint32 m_bits;
+ };
+
+ uint32 m_borderColor;
+
+ FORCEINLINE bool operator== (const GLMTexSamplingParams& rhs ) const
+ {
+ return ( m_bits == rhs.m_bits ) && ( m_borderColor == rhs.m_borderColor );
+ }
+
+ FORCEINLINE void SetToDefaults()
+ {
+ m_bits = 0;
+ m_borderColor = 0;
+ m_packed.m_addressU = D3DTADDRESS_WRAP;
+ m_packed.m_addressV = D3DTADDRESS_WRAP;
+ m_packed.m_addressW = D3DTADDRESS_WRAP;
+ m_packed.m_minFilter = D3DTEXF_POINT;
+ m_packed.m_magFilter = D3DTEXF_POINT;
+ m_packed.m_mipFilter = D3DTEXF_NONE;
+ m_packed.m_maxAniso = 1;
+ m_packed.m_isValid = true;
+ }
+
+ FORCEINLINE void SetToSamplerObject( GLuint nSamplerObject ) const
+ {
+ static const GLenum dxtogl_addressMode[] = { GL_REPEAT, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, (GLenum)-1 };
+ static const GLenum dxtogl_magFilter[4] = { GL_NEAREST, GL_NEAREST, GL_LINEAR, GL_LINEAR };
+ static const GLenum dxtogl_minFilter[4][4] = // indexed by _D3DTEXTUREFILTERTYPE on both axes: [row is min filter][col is mip filter].
+ {
+ /* min = D3DTEXF_NONE */ { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, (GLenum)-1 }, // D3DTEXF_NONE we just treat like POINT
+ /* min = D3DTEXF_POINT */ { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, (GLenum)-1 },
+ /* min = D3DTEXF_LINEAR */ { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR, (GLenum)-1 },
+ /* min = D3DTEXF_ANISOTROPIC */ { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR, (GLenum)-1 }, // no diff from prior row, set maxAniso to effect the sampling
+ };
+
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_WRAP_S, dxtogl_addressMode[m_packed.m_addressU] );
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_WRAP_T, dxtogl_addressMode[m_packed.m_addressV] );
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_WRAP_R, dxtogl_addressMode[m_packed.m_addressW] );
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_MIN_FILTER, dxtogl_minFilter[m_packed.m_minFilter][m_packed.m_mipFilter] );
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_MAG_FILTER, dxtogl_magFilter[m_packed.m_magFilter] );
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_packed.m_maxAniso );
+
+ float flBorderColor[4] = { 0, 0, 0, 0 };
+ if ( m_borderColor )
+ {
+ flBorderColor[0] = ((m_borderColor >> 16) & 0xFF) * (1.0f/255.0f); //R
+ flBorderColor[1] = ((m_borderColor >> 8) & 0xFF) * (1.0f/255.0f); //G
+ flBorderColor[2] = ((m_borderColor ) & 0xFF) * (1.0f/255.0f); //B
+ flBorderColor[3] = ((m_borderColor >> 24) & 0xFF) * (1.0f/255.0f); //A
+ }
+ gGL->glSamplerParameterfv( nSamplerObject, GL_TEXTURE_BORDER_COLOR, flBorderColor ); // <-- this crashes ATI's driver, remark it out
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_MIN_LOD, m_packed.m_minLOD );
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_COMPARE_MODE_ARB, m_packed.m_compareMode ? GL_COMPARE_R_TO_TEXTURE_ARB : GL_NONE );
+ if ( m_packed.m_compareMode )
+ {
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL );
+ }
+ if ( gGL->m_bHave_GL_EXT_texture_sRGB_decode )
+ {
+ gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_SRGB_DECODE_EXT, m_packed.m_srgb ? GL_DECODE_EXT : GL_SKIP_DECODE_EXT );
+ }
+ }
+
+ inline void DeltaSetToTarget( GLenum target, const GLMTexSamplingParams &curState )
+ {
+ static const GLenum dxtogl_addressMode[] = { GL_REPEAT, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, (GLenum)-1 };
+ static const GLenum dxtogl_magFilter[4] = { GL_NEAREST, GL_NEAREST, GL_LINEAR, GL_LINEAR };
+ static const GLenum dxtogl_minFilter[4][4] = // indexed by _D3DTEXTUREFILTERTYPE on both axes: [row is min filter][col is mip filter].
+ {
+ /* min = D3DTEXF_NONE */ { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, (GLenum)-1 }, // D3DTEXF_NONE we just treat like POINT
+ /* min = D3DTEXF_POINT */ { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, (GLenum)-1 },
+ /* min = D3DTEXF_LINEAR */ { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR, (GLenum)-1 },
+ /* min = D3DTEXF_ANISOTROPIC */ { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR, (GLenum)-1 }, // no diff from prior row, set maxAniso to effect the sampling
+ };
+
+ if ( m_packed.m_addressU != curState.m_packed.m_addressU )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_WRAP_S, dxtogl_addressMode[m_packed.m_addressU] );
+ }
+
+ if ( m_packed.m_addressV != curState.m_packed.m_addressV )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_WRAP_T, dxtogl_addressMode[m_packed.m_addressV] );
+ }
+
+ if ( m_packed.m_addressW != curState.m_packed.m_addressW )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_WRAP_R, dxtogl_addressMode[m_packed.m_addressW] );
+ }
+
+ if ( ( m_packed.m_minFilter != curState.m_packed.m_minFilter ) ||
+ ( m_packed.m_magFilter != curState.m_packed.m_magFilter ) ||
+ ( m_packed.m_mipFilter != curState.m_packed.m_mipFilter ) ||
+ ( m_packed.m_maxAniso != curState.m_packed.m_maxAniso ) )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_MIN_FILTER, dxtogl_minFilter[m_packed.m_minFilter][m_packed.m_mipFilter] );
+ gGL->glTexParameteri( target, GL_TEXTURE_MAG_FILTER, dxtogl_magFilter[m_packed.m_magFilter] );
+ gGL->glTexParameteri( target, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_packed.m_maxAniso );
+ }
+
+ if ( m_borderColor != curState.m_borderColor )
+ {
+ float flBorderColor[4] = { 0, 0, 0, 0 };
+ if ( m_borderColor )
+ {
+ flBorderColor[0] = ((m_borderColor >> 16) & 0xFF) * (1.0f/255.0f); //R
+ flBorderColor[1] = ((m_borderColor >> 8) & 0xFF) * (1.0f/255.0f); //G
+ flBorderColor[2] = ((m_borderColor ) & 0xFF) * (1.0f/255.0f); //B
+ flBorderColor[3] = ((m_borderColor >> 24) & 0xFF) * (1.0f/255.0f); //A
+ }
+
+ gGL->glTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, flBorderColor ); // <-- this crashes ATI's driver, remark it out
+ }
+
+ if ( m_packed.m_minLOD != curState.m_packed.m_minLOD )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_MIN_LOD, m_packed.m_minLOD );
+ }
+
+ if ( m_packed.m_compareMode != curState.m_packed.m_compareMode )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_COMPARE_MODE_ARB, m_packed.m_compareMode ? GL_COMPARE_R_TO_TEXTURE_ARB : GL_NONE );
+ if ( m_packed.m_compareMode )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL );
+ }
+ }
+
+ if ( ( gGL->m_bHave_GL_EXT_texture_sRGB_decode ) && ( m_packed.m_srgb != curState.m_packed.m_srgb ) )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_SRGB_DECODE_EXT, m_packed.m_srgb ? GL_DECODE_EXT : GL_SKIP_DECODE_EXT );
+ }
+ }
+
+ inline void SetToTargetTexture( GLenum target )
+ {
+ static const GLenum dxtogl_addressMode[] = { GL_REPEAT, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, (GLenum)-1 };
+ static const GLenum dxtogl_magFilter[4] = { GL_NEAREST, GL_NEAREST, GL_LINEAR, GL_LINEAR };
+ static const GLenum dxtogl_minFilter[4][4] = // indexed by _D3DTEXTUREFILTERTYPE on both axes: [row is min filter][col is mip filter].
+ {
+ /* min = D3DTEXF_NONE */ { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, (GLenum)-1 }, // D3DTEXF_NONE we just treat like POINT
+ /* min = D3DTEXF_POINT */ { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, (GLenum)-1 },
+ /* min = D3DTEXF_LINEAR */ { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR, (GLenum)-1 },
+ /* min = D3DTEXF_ANISOTROPIC */ { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR, (GLenum)-1 }, // no diff from prior row, set maxAniso to effect the sampling
+ };
+
+ gGL->glTexParameteri( target, GL_TEXTURE_WRAP_S, dxtogl_addressMode[m_packed.m_addressU] );
+ gGL->glTexParameteri( target, GL_TEXTURE_WRAP_T, dxtogl_addressMode[m_packed.m_addressV] );
+ gGL->glTexParameteri( target, GL_TEXTURE_WRAP_R, dxtogl_addressMode[m_packed.m_addressW] );
+ gGL->glTexParameteri( target, GL_TEXTURE_MIN_FILTER, dxtogl_minFilter[m_packed.m_minFilter][m_packed.m_mipFilter] );
+ gGL->glTexParameteri( target, GL_TEXTURE_MAG_FILTER, dxtogl_magFilter[m_packed.m_magFilter] );
+ gGL->glTexParameteri( target, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_packed.m_maxAniso );
+
+ float flBorderColor[4] = { 0, 0, 0, 0 };
+ if ( m_borderColor )
+ {
+ flBorderColor[0] = ((m_borderColor >> 16) & 0xFF) * (1.0f/255.0f); //R
+ flBorderColor[1] = ((m_borderColor >> 8) & 0xFF) * (1.0f/255.0f); //G
+ flBorderColor[2] = ((m_borderColor ) & 0xFF) * (1.0f/255.0f); //B
+ flBorderColor[3] = ((m_borderColor >> 24) & 0xFF) * (1.0f/255.0f); //A
+ }
+ gGL->glTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, flBorderColor ); // <-- this crashes ATI's driver, remark it out
+ gGL->glTexParameteri( target, GL_TEXTURE_MIN_LOD, m_packed.m_minLOD );
+ gGL->glTexParameteri( target, GL_TEXTURE_COMPARE_MODE_ARB, m_packed.m_compareMode ? GL_COMPARE_R_TO_TEXTURE_ARB : GL_NONE );
+ if ( m_packed.m_compareMode )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL );
+ }
+ if ( gGL->m_bHave_GL_EXT_texture_sRGB_decode )
+ {
+ gGL->glTexParameteri( target, GL_TEXTURE_SRGB_DECODE_EXT, m_packed.m_srgb ? GL_DECODE_EXT : GL_SKIP_DECODE_EXT );
+ }
+ }
+};
+
+//===============================================================================
+
+class CGLMTex
+{
+
+public:
+
+ void Lock( GLMTexLockParams *params, char** addressOut, int* yStrideOut, int *zStrideOut );
+ void Unlock( GLMTexLockParams *params );
+
+protected:
+ friend class GLMContext; // only GLMContext can make CGLMTex objects
+ friend class GLMTester;
+ friend class CGLMFBO;
+
+ friend struct IDirect3DDevice9;
+ friend struct IDirect3DBaseTexture9;
+ friend struct IDirect3DTexture9;
+ friend struct IDirect3DSurface9;
+ friend struct IDirect3DCubeTexture9;
+ friend struct IDirect3DVolumeTexture9;
+
+ CGLMTex( GLMContext *ctx, GLMTexLayout *layout, const char *debugLabel = NULL );
+ ~CGLMTex( );
+
+ int CalcSliceIndex( int face, int mip );
+ void CalcTexelDataOffsetAndStrides( int sliceIndex, int x, int y, int z, int *offsetOut, int *yStrideOut, int *zStrideOut );
+
+ void ReadTexels( GLMTexLockDesc *desc, bool readWholeSlice=true );
+ void WriteTexels( GLMTexLockDesc *desc, bool writeWholeSlice=true, bool noDataWrite=false );
+ // last param lets us send NULL data ptr (only legal with uncompressed formats, beware)
+ // this helps out ResetSRGB.
+
+ bool IsRBODirty() const;
+ void ForceRBONonDirty();
+ void ForceRBODirty();
+
+ void AllocBacking();
+ void ReleaseBacking();
+
+ // re-specify texture format to match desired sRGB form
+ // noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's
+
+ GLuint m_texName; // name of this texture in the context
+ GLenum m_texGLTarget;
+ uint m_nSamplerType; // SAMPLER_2D, etc.
+ GLMTexSamplingParams m_SamplingParams;
+ GLMTexLayout *m_layout; // layout of texture (shared across all tex with same layout)
+
+ uint m_nLastResolvedBatchCounter;
+
+ int m_minActiveMip;//index of lowest mip that has been written. used to drive setting of GL_TEXTURE_MAX_LEVEL.
+ int m_maxActiveMip;//index of highest mip that has been written. used to drive setting of GL_TEXTURE_MAX_LEVEL.
+ int m_mipCount;
+
+ GLMContext *m_ctx; // link back to parent context
+
+ CGLMFBO *m_pBlitSrcFBO;
+ CGLMFBO *m_pBlitDstFBO;
+
+ GLuint m_rboName; // name of MSAA RBO backing the tex if MSAA enabled (or zero)
+
+ int m_rtAttachCount; // how many RT's have this texture attached somewhere
+
+ char *m_pBacking; // backing storage if available
+
+ int m_lockCount; // lock reqs are stored in the GLMContext for tracking
+
+ CUtlVector<unsigned char> m_sliceFlags;
+
+ char *m_debugLabel; // strdup() of debugLabel passed in, or NULL
+
+ bool m_texClientStorage; // was CS selected for texture
+ bool m_texPreloaded; // has it been kicked into VRAM with GLMContext::PreloadTex yet
+
+#if GLMDEBUG
+ CGLMTex *m_pPrevTex;
+ CGLMTex *m_pNextTex;
+#endif
+};
+
+#endif
diff --git a/mp/src/public/togl/linuxwin/dxabstract.h b/mp/src/public/togl/linuxwin/dxabstract.h new file mode 100644 index 00000000..ab5940e5 --- /dev/null +++ b/mp/src/public/togl/linuxwin/dxabstract.h @@ -0,0 +1,1412 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// dxabstract.h
+//
+//==================================================================================================
+#ifndef DXABSTRACT_H
+#define DXABSTRACT_H
+
+#ifdef DX_TO_GL_ABSTRACTION
+
+#include "togl/rendermechanism.h"
+
+#include "tier0/platform.h"
+#include "tier0/dbg.h"
+#include "tier1/utlmap.h"
+
+// turn this on to get refcount logging from IUnknown
+#define IUNKNOWN_ALLOC_SPEW 0
+#define IUNKNOWN_ALLOC_SPEW_MARK_ALL 0
+
+TOGL_INTERFACE void toglGetClientRect( VD3DHWND hWnd, RECT *destRect );
+
+struct TOGL_CLASS IUnknown
+{
+ int m_refcount[2];
+ bool m_mark;
+
+ IUnknown()
+ {
+ m_refcount[0] = 1;
+ m_refcount[1] = 0;
+ m_mark = (IUNKNOWN_ALLOC_SPEW_MARK_ALL != 0); // either all are marked, or only the ones that have SetMark(true) called on them
+
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IUnew (%08x) refc -> (%d,%d) ",this,m_refcount[0],m_refcount[1]));
+ }
+ #endif
+ };
+
+ virtual ~IUnknown()
+ {
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IUdel (%08x) ",this ));
+ }
+ #endif
+ };
+
+ void AddRef( int which=0, char *comment = NULL )
+ {
+ Assert( which >= 0 );
+ Assert( which < 2 );
+ m_refcount[which]++;
+
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IUAddRef (%08x,%d) refc -> (%d,%d) [%s]",this,which,m_refcount[0],m_refcount[1],comment?comment:"...")) ;
+ if (!comment)
+ {
+ GLMPRINTF(("")) ; // place to hang a breakpoint
+ }
+ }
+ #endif
+ };
+
+ ULONG __stdcall Release( int which=0, char *comment = NULL )
+ {
+ Assert( which >= 0 );
+ Assert( which < 2 );
+
+ //int oldrefcs[2] = { m_refcount[0], m_refcount[1] };
+ bool deleting = false;
+
+ m_refcount[which]--;
+ if ( (!m_refcount[0]) && (!m_refcount[1]) )
+ {
+ deleting = true;
+ }
+
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IURelease (%08x,%d) refc -> (%d,%d) [%s] %s",this,which,m_refcount[0],m_refcount[1],comment?comment:"...",deleting?"->DELETING":""));
+ if (!comment)
+ {
+ GLMPRINTF(("")) ; // place to hang a breakpoint
+ }
+ }
+ #endif
+
+ if (deleting)
+ {
+ if (m_mark)
+ {
+ GLMPRINTF(("")) ; // place to hang a breakpoint
+ }
+ delete this;
+ return 0;
+ }
+ else
+ {
+ return m_refcount[0];
+ }
+ };
+
+ void SetMark( bool markValue, char *comment=NULL )
+ {
+ #if IUNKNOWN_ALLOC_SPEW
+ if (!m_mark && markValue) // leading edge detect
+ {
+ // print the same thing that the constructor would have printed if it had been marked from the beginning
+ // i.e. it's anticipated that callers asking for marking will do so right at create time
+ GLMPRINTF(("-A- IUSetMark (%08x) refc -> (%d,%d) (%s) ",this,m_refcount[0],m_refcount[1],comment?comment:"..."));
+ }
+ #endif
+
+ m_mark = markValue;
+ }
+};
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// INTERFACES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+struct TOGL_CLASS IDirect3DResource9 : public IUnknown
+{
+ IDirect3DDevice9 *m_device; // parent device
+ D3DRESOURCETYPE m_restype;
+
+ DWORD SetPriority(DWORD PriorityNew);
+};
+
+struct TOGL_CLASS IDirect3DBaseTexture9 : public IDirect3DResource9 // "A Texture.."
+{
+ D3DSURFACE_DESC m_descZero; // desc of top level.
+ CGLMTex *m_tex; // a CGLMTex can represent all forms of tex
+ int m_srgbFlipCount;
+
+ virtual ~IDirect3DBaseTexture9();
+ D3DRESOURCETYPE TOGLMETHODCALLTYPE GetType();
+ DWORD TOGLMETHODCALLTYPE GetLevelCount();
+ HRESULT TOGLMETHODCALLTYPE GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DTexture9 : public IDirect3DBaseTexture9 // "Texture 2D"
+{
+ IDirect3DSurface9 *m_surfZero; // surf of top level.
+ virtual ~IDirect3DTexture9();
+ HRESULT TOGLMETHODCALLTYPE LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
+ HRESULT TOGLMETHODCALLTYPE UnlockRect(UINT Level);
+ HRESULT TOGLMETHODCALLTYPE GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel);
+};
+
+struct TOGL_CLASS IDirect3DCubeTexture9 : public IDirect3DBaseTexture9 // "Texture Cube Map"
+{
+ IDirect3DSurface9 *m_surfZero[6]; // surfs of top level.
+ virtual ~IDirect3DCubeTexture9();
+ HRESULT TOGLMETHODCALLTYPE GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface);
+ HRESULT TOGLMETHODCALLTYPE GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DVolumeTexture9 : public IDirect3DBaseTexture9 // "Texture 3D"
+{
+ IDirect3DSurface9 *m_surfZero; // surf of top level.
+ D3DVOLUME_DESC m_volDescZero; // volume desc top level
+ virtual ~IDirect3DVolumeTexture9();
+ HRESULT TOGLMETHODCALLTYPE LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags);
+ HRESULT TOGLMETHODCALLTYPE UnlockBox(UINT Level);
+ HRESULT TOGLMETHODCALLTYPE GetLevelDesc( UINT level, D3DVOLUME_DESC *pDesc );
+};
+
+
+// for the moment, a "D3D surface" is modeled as a GLM tex, a face, and a mip.
+// no Create method, these are filled in by the various create surface methods.
+
+struct TOGL_CLASS IDirect3DSurface9 : public IDirect3DResource9
+{
+ virtual ~IDirect3DSurface9();
+ HRESULT TOGLMETHODCALLTYPE LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
+ HRESULT TOGLMETHODCALLTYPE UnlockRect();
+ HRESULT TOGLMETHODCALLTYPE GetDesc(D3DSURFACE_DESC *pDesc);
+
+ D3DSURFACE_DESC m_desc;
+ CGLMTex *m_tex;
+ int m_face;
+ int m_mip;
+};
+
+struct TOGL_CLASS IDirect3D9 : public IUnknown
+{
+ virtual ~IDirect3D9();
+
+ UINT TOGLMETHODCALLTYPE GetAdapterCount();
+
+ HRESULT TOGLMETHODCALLTYPE GetDeviceCaps (UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps);
+ HRESULT TOGLMETHODCALLTYPE GetAdapterIdentifier (UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier);
+ HRESULT TOGLMETHODCALLTYPE CheckDeviceFormat (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat);
+ UINT TOGLMETHODCALLTYPE GetAdapterModeCount (UINT Adapter,D3DFORMAT Format);
+ HRESULT TOGLMETHODCALLTYPE EnumAdapterModes (UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode);
+ HRESULT TOGLMETHODCALLTYPE CheckDeviceType (UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed);
+ HRESULT TOGLMETHODCALLTYPE GetAdapterDisplayMode (UINT Adapter,D3DDISPLAYMODE* pMode);
+ HRESULT TOGLMETHODCALLTYPE CheckDepthStencilMatch (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
+ HRESULT TOGLMETHODCALLTYPE CheckDeviceMultiSampleType (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels);
+
+ HRESULT TOGLMETHODCALLTYPE CreateDevice (UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface);
+};
+
+struct TOGL_CLASS IDirect3DVertexDeclaration9 : public IUnknown
+{
+ IDirect3DDevice9 *m_device;
+ uint m_elemCount;
+ D3DVERTEXELEMENT9_GL m_elements[ MAX_D3DVERTEXELEMENTS ];
+
+ uint8 m_VertexAttribDescToStreamIndex[256];
+
+ virtual ~IDirect3DVertexDeclaration9();
+};
+
+struct TOGL_CLASS IDirect3DQuery9 : public IDirect3DResource9 //was IUnknown
+{
+ D3DQUERYTYPE m_type; // D3DQUERYTYPE_OCCLUSION or D3DQUERYTYPE_EVENT
+ GLMContext *m_ctx;
+ CGLMQuery *m_query;
+
+ uint m_nIssueStartThreadID, m_nIssueEndThreadID;
+ uint m_nIssueStartDrawCallIndex, m_nIssueEndDrawCallIndex;
+ uint m_nIssueStartFrameIndex, m_nIssueEndFrameIndex;
+ uint m_nIssueStartQueryCreationCounter, m_nIssueEndQueryCreationCounter;
+
+ virtual ~IDirect3DQuery9();
+
+ HRESULT Issue(DWORD dwIssueFlags);
+ HRESULT GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags);
+};
+
+struct TOGL_CLASS IDirect3DVertexBuffer9 : public IDirect3DResource9 //was IUnknown
+{
+ GLMContext *m_ctx;
+ CGLMBuffer *m_vtxBuffer;
+ D3DVERTEXBUFFER_DESC m_vtxDesc; // to satisfy GetDesc
+
+ virtual ~IDirect3DVertexBuffer9();
+ HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
+ HRESULT Unlock();
+ void UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
+};
+
+struct TOGL_CLASS IDirect3DIndexBuffer9 : public IDirect3DResource9 //was IUnknown
+{
+ GLMContext *m_ctx;
+ CGLMBuffer *m_idxBuffer;
+ D3DINDEXBUFFER_DESC m_idxDesc; // to satisfy GetDesc
+
+ virtual ~IDirect3DIndexBuffer9();
+
+ HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
+ HRESULT Unlock();
+ void UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
+
+ HRESULT GetDesc(D3DINDEXBUFFER_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DPixelShader9 : public IDirect3DResource9 //was IUnknown
+{
+ CGLMProgram *m_pixProgram;
+ uint m_pixHighWater; // count of active constant slots referenced by shader.
+ uint m_pixSamplerMask; // (1<<n) mask of samplers referemnced by this pixel shader
+ // this can help FlushSamplers avoid SRGB flipping on textures not being referenced...
+ uint m_pixSamplerTypes; // SAMPLER_TYPE_2D, etc.
+
+ virtual ~IDirect3DPixelShader9();
+};
+
+struct TOGL_CLASS IDirect3DVertexShader9 : public IDirect3DResource9 //was IUnknown
+{
+ CGLMProgram *m_vtxProgram;
+ uint m_vtxHighWater; // count of active constant slots referenced by shader.
+ uint m_vtxHighWaterBone;
+ unsigned char m_vtxAttribMap[16]; // high nibble is usage, low nibble is usageindex, array position is attrib number
+ uint m_maxVertexAttrs;
+
+ virtual ~IDirect3DVertexShader9();
+};
+
+#ifdef _MSC_VER
+ typedef class TOGL_CLASS CUtlMemory<D3DMATRIX> CD3DMATRIXAllocator;
+ typedef class TOGL_CLASS CUtlVector<D3DMATRIX, CD3DMATRIXAllocator> CD3DMATRIXStack;
+#else
+ typedef class CUtlMemory<D3DMATRIX> CD3DMATRIXAllocator;
+ typedef class CUtlVector<D3DMATRIX, CD3DMATRIXAllocator> CD3DMATRIXStack;
+#endif
+
+struct TOGL_CLASS ID3DXMatrixStack //: public IUnknown
+{
+ int m_refcount[2];
+ bool m_mark;
+ CD3DMATRIXStack m_stack;
+ int m_stackTop; // top of stack is at the highest index, this is that index. push increases, pop decreases.
+
+ ID3DXMatrixStack();
+ void AddRef( int which=0, char *comment = NULL );
+ ULONG Release( int which=0, char *comment = NULL );
+
+ HRESULT Create( void );
+
+ D3DXMATRIX* GetTop();
+ void Push();
+ void Pop();
+ void LoadIdentity();
+ void LoadMatrix( const D3DXMATRIX *pMat );
+ void MultMatrix( const D3DXMATRIX *pMat );
+ void MultMatrixLocal( const D3DXMATRIX *pMat );
+ HRESULT ScaleLocal(FLOAT x, FLOAT y, FLOAT z);
+
+ // Left multiply the current matrix with the computed rotation
+ // matrix, counterclockwise about the given axis with the given angle.
+ // (rotation is about the local origin of the object)
+ HRESULT RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle);
+
+ // Left multiply the current matrix with the computed translation
+ // matrix. (transformation is about the local origin of the object)
+ HRESULT TranslateLocal(FLOAT x, FLOAT y, FLOAT z);
+};
+
+typedef ID3DXMatrixStack* LPD3DXMATRIXSTACK;
+
+struct RenderTargetState_t
+{
+ void clear() { V_memset( this, 0, sizeof( *this ) ); }
+
+ CGLMTex *m_pRenderTargets[4];
+ CGLMTex *m_pDepthStencil;
+
+ inline bool RefersTo( CGLMTex * pSurf ) const
+ {
+ for ( uint i = 0; i < 4; i++ )
+ if ( m_pRenderTargets[i] == pSurf )
+ return true;
+
+ if ( m_pDepthStencil == pSurf )
+ return true;
+
+ return false;
+ }
+
+ static inline bool LessFunc( const RenderTargetState_t &lhs, const RenderTargetState_t &rhs )
+ {
+ COMPILE_TIME_ASSERT( sizeof( lhs.m_pRenderTargets[0] ) == sizeof( uint32 ) );
+ uint64 lhs0 = reinterpret_cast<const uint64 *>(lhs.m_pRenderTargets)[0];
+ uint64 rhs0 = reinterpret_cast<const uint64 *>(rhs.m_pRenderTargets)[0];
+ if ( lhs0 < rhs0 )
+ return true;
+ else if ( lhs0 == rhs0 )
+ {
+ uint64 lhs1 = reinterpret_cast<const uint64 *>(lhs.m_pRenderTargets)[1];
+ uint64 rhs1 = reinterpret_cast<const uint64 *>(rhs.m_pRenderTargets)[1];
+ if ( lhs1 < rhs1 )
+ return true;
+ else if ( lhs1 == rhs1 )
+ {
+ return lhs.m_pDepthStencil < rhs.m_pDepthStencil;
+ }
+ }
+ return false;
+ }
+
+ inline bool operator < ( const RenderTargetState_t &rhs ) const
+ {
+ return LessFunc( *this, rhs );
+ }
+};
+
+typedef CUtlMap< RenderTargetState_t, CGLMFBO *> CGLMFBOMap;
+
+class simple_bitmap;
+
+struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
+{
+ friend class GLMContext;
+ friend struct IDirect3DBaseTexture9;
+ friend struct IDirect3DTexture9;
+ friend struct IDirect3DCubeTexture9;
+ friend struct IDirect3DVolumeTexture9;
+ friend struct IDirect3DSurface9;
+ friend struct IDirect3DVertexBuffer9;
+ friend struct IDirect3DIndexBuffer9;
+ friend struct IDirect3DPixelShader9;
+ friend struct IDirect3DVertexShader9;
+ friend struct IDirect3DQuery9;
+ friend struct IDirect3DVertexDeclaration9;
+
+ IDirect3DDevice9();
+ virtual ~IDirect3DDevice9();
+
+ // Create call invoked from IDirect3D9
+ HRESULT TOGLMETHODCALLTYPE Create( IDirect3DDevice9Params *params );
+
+ //
+ // Basics
+ //
+ HRESULT TOGLMETHODCALLTYPE Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
+ HRESULT TOGLMETHODCALLTYPE SetViewport(CONST D3DVIEWPORT9* pViewport);
+ HRESULT TOGLMETHODCALLTYPE BeginScene();
+ HRESULT TOGLMETHODCALLTYPE Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
+ HRESULT TOGLMETHODCALLTYPE EndScene();
+ HRESULT TOGLMETHODCALLTYPE Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,VD3DHWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
+
+ // textures
+ HRESULT TOGLMETHODCALLTYPE CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+ HRESULT TOGLMETHODCALLTYPE CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+ HRESULT TOGLMETHODCALLTYPE CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture);
+ HRESULT TOGLMETHODCALLTYPE SetTextureNonInline(DWORD Stage,IDirect3DBaseTexture9* pTexture);
+
+ HRESULT TOGLMETHODCALLTYPE GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture);
+
+ // render targets, color and depthstencil, surfaces, blit
+ HRESULT TOGLMETHODCALLTYPE CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+ HRESULT TOGLMETHODCALLTYPE SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget);
+ HRESULT TOGLMETHODCALLTYPE GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget);
+
+ HRESULT TOGLMETHODCALLTYPE CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
+
+ HRESULT TOGLMETHODCALLTYPE CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
+ HRESULT TOGLMETHODCALLTYPE SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);
+ HRESULT TOGLMETHODCALLTYPE GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);
+
+ HRESULT TOGLMETHODCALLTYPE GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface); // ? is anyone using this ?
+ HRESULT TOGLMETHODCALLTYPE GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface);
+ HRESULT TOGLMETHODCALLTYPE StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter);
+
+ // pixel shaders
+ HRESULT TOGLMETHODCALLTYPE CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader, const char *pShaderName, char *debugLabel = NULL, const uint32 *pCentroidMask = NULL );
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetPixelShader(IDirect3DPixelShader9* pShader);
+ HRESULT TOGLMETHODCALLTYPE SetPixelShaderNonInline(IDirect3DPixelShader9* pShader);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+ HRESULT TOGLMETHODCALLTYPE SetPixelShaderConstantFNonInline(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+
+ HRESULT TOGLMETHODCALLTYPE SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
+ HRESULT TOGLMETHODCALLTYPE SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+
+ // vertex shaders
+ HRESULT TOGLMETHODCALLTYPE CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetVertexShader(IDirect3DVertexShader9* pShader);
+ HRESULT TOGLMETHODCALLTYPE SetVertexShaderNonInline(IDirect3DVertexShader9* pShader);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+ HRESULT TOGLMETHODCALLTYPE SetVertexShaderConstantFNonInline(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
+ HRESULT TOGLMETHODCALLTYPE SetVertexShaderConstantBNonInline(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+ HRESULT TOGLMETHODCALLTYPE SetVertexShaderConstantINonInline(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+
+ // POSIX only - preheating for a specific vertex/pixel shader pair - trigger GLSL link inside GLM
+ HRESULT TOGLMETHODCALLTYPE LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );
+ HRESULT TOGLMETHODCALLTYPE QueryShaderPair( int index, GLMShaderPairInfo *infoOut );
+
+ // vertex buffers
+ HRESULT TOGLMETHODCALLTYPE CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);
+ HRESULT TOGLMETHODCALLTYPE SetVertexDeclarationNonInline(IDirect3DVertexDeclaration9* pDecl);
+
+ HRESULT TOGLMETHODCALLTYPE SetFVF(DWORD FVF); // we might not be using these ?
+ HRESULT TOGLMETHODCALLTYPE GetFVF(DWORD* pFVF);
+
+ HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,VD3DHANDLE* pSharedHandle);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);
+ HRESULT SetStreamSourceNonInline(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);
+
+ // index buffers
+ HRESULT TOGLMETHODCALLTYPE CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,VD3DHANDLE* pSharedHandle);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetIndices(IDirect3DIndexBuffer9* pIndexData);
+ HRESULT TOGLMETHODCALLTYPE SetIndicesNonInline(IDirect3DIndexBuffer9* pIndexData);
+
+ // State management.
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetRenderStateInline(D3DRENDERSTATETYPE State,DWORD Value);
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetRenderStateConstInline(D3DRENDERSTATETYPE State,DWORD Value);
+ HRESULT TOGLMETHODCALLTYPE SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);
+
+ FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);
+ HRESULT TOGLMETHODCALLTYPE SetSamplerStateNonInline(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);
+
+ FORCEINLINE void TOGLMETHODCALLTYPE SetSamplerStates(DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter );
+ void TOGLMETHODCALLTYPE SetSamplerStatesNonInline(DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter );
+
+ // Draw.
+ HRESULT TOGLMETHODCALLTYPE DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
+ HRESULT TOGLMETHODCALLTYPE DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);
+ HRESULT TOGLMETHODCALLTYPE DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
+
+ // misc
+ BOOL TOGLMETHODCALLTYPE ShowCursor(BOOL bShow);
+ HRESULT TOGLMETHODCALLTYPE ValidateDevice(DWORD* pNumPasses);
+ HRESULT TOGLMETHODCALLTYPE SetMaterial(CONST D3DMATERIAL9* pMaterial);
+ HRESULT TOGLMETHODCALLTYPE LightEnable(DWORD Index,BOOL Enable);
+ HRESULT TOGLMETHODCALLTYPE SetScissorRect(CONST RECT* pRect);
+ HRESULT TOGLMETHODCALLTYPE CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery);
+ HRESULT TOGLMETHODCALLTYPE GetDeviceCaps(D3DCAPS9* pCaps);
+ HRESULT TOGLMETHODCALLTYPE TestCooperativeLevel();
+ HRESULT TOGLMETHODCALLTYPE EvictManagedResources();
+ HRESULT TOGLMETHODCALLTYPE SetLight(DWORD Index,CONST D3DLIGHT9*);
+ void TOGLMETHODCALLTYPE SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);
+
+ void TOGLMETHODCALLTYPE SaveGLState();
+ void TOGLMETHODCALLTYPE RestoreGLState();
+
+ // Talk to JasonM about this one. It's tricky in GL.
+ HRESULT TOGLMETHODCALLTYPE SetClipPlane(DWORD Index,CONST float* pPlane);
+
+ //
+ //
+ // **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+ //
+ //
+ HRESULT TOGLMETHODCALLTYPE SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
+ HRESULT TOGLMETHODCALLTYPE SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);
+
+ void TOGLMETHODCALLTYPE AcquireThreadOwnership( );
+ void TOGLMETHODCALLTYPE ReleaseThreadOwnership( );
+ inline DWORD TOGLMETHODCALLTYPE GetCurrentOwnerThreadId() const { return m_ctx->m_nCurOwnerThreadId; }
+
+ FORCEINLINE void TOGLMETHODCALLTYPE SetMaxUsedVertexShaderConstantsHint( uint nMaxReg );
+ void TOGLMETHODCALLTYPE SetMaxUsedVertexShaderConstantsHintNonInline( uint nMaxReg );
+
+ void DumpStatsToConsole( const CCommand *pArgs );
+
+#if GLMDEBUG
+ void DumpTextures( const CCommand *pArgs );
+#endif
+
+private:
+ IDirect3DDevice9( const IDirect3DDevice9& );
+ IDirect3DDevice9& operator= ( const IDirect3DDevice9& );
+
+ // Flushing changes to GL
+ void FlushClipPlaneEquation();
+ void InitStates();
+ void FullFlushStates();
+ void UpdateBoundFBO();
+ void ResetFBOMap();
+ void ScrubFBOMap( CGLMTex *pTex );
+
+ // response to retired objects (when refcount goes to zero and they self-delete..)
+ void ReleasedVertexDeclaration( IDirect3DVertexDeclaration9 *pDecl );
+ void ReleasedTexture( IDirect3DBaseTexture9 *baseTex ); // called from texture destructor - need to scrub samplers
+ void ReleasedCGLMTex( CGLMTex *pTex );
+ void ReleasedSurface( IDirect3DSurface9 *surface ); // called from any surface destructor - need to scrub RT table if an RT
+ void ReleasedPixelShader( IDirect3DPixelShader9 *pixelShader ); // called from IDirect3DPixelShader9 destructor
+ void ReleasedVertexShader( IDirect3DVertexShader9 *vertexShader ); // called from IDirect3DVertexShader9 destructor
+ void ReleasedVertexBuffer( IDirect3DVertexBuffer9 *vertexBuffer ); // called from IDirect3DVertexBuffer9 destructor
+ void ReleasedIndexBuffer( IDirect3DIndexBuffer9 *indexBuffer ); // called from IDirect3DIndexBuffer9 destructor
+ void ReleasedQuery( IDirect3DQuery9 *query ); // called from IDirect3DQuery9 destructor
+
+ // Member variables
+
+ DWORD m_nValidMarker;
+
+ IDirect3DDevice9Params m_params; // mirror of the creation inputs
+
+ // D3D flavor stuff
+ IDirect3DSurface9 *m_pRenderTargets[4];
+ IDirect3DSurface9 *m_pDepthStencil;
+
+ IDirect3DSurface9 *m_pDefaultColorSurface; // default color surface.
+ IDirect3DSurface9 *m_pDefaultDepthStencilSurface; // queried by GetDepthStencilSurface.
+
+ IDirect3DVertexDeclaration9 *m_pVertDecl; // Set by SetVertexDeclaration...
+ D3DStreamDesc m_streams[ D3D_MAX_STREAMS ]; // Set by SetStreamSource..
+ CGLMBuffer *m_vtx_buffers[ D3D_MAX_STREAMS ];
+ CGLMBuffer *m_pDummy_vtx_buffer;
+ D3DIndexDesc m_indices; // Set by SetIndices..
+
+ IDirect3DVertexShader9 *m_vertexShader; // Set by SetVertexShader...
+ IDirect3DPixelShader9 *m_pixelShader; // Set by SetPixelShader...
+
+ IDirect3DBaseTexture9 *m_textures[16]; // set by SetTexture... NULL if stage inactive
+ D3DSamplerDesc m_samplers[16]; // set by SetSamplerState..
+ // GLM flavor stuff
+ GLMContext *m_ctx;
+ CGLMFBOMap *m_pFBOs;
+ bool m_bFBODirty;
+
+ struct ObjectStats_t
+ {
+ int m_nTotalFBOs;
+ int m_nTotalVertexShaders;
+ int m_nTotalPixelShaders;
+ int m_nTotalVertexDecls;
+ int m_nTotalIndexBuffers;
+ int m_nTotalVertexBuffers;
+ int m_nTotalRenderTargets;
+ int m_nTotalTextures;
+ int m_nTotalSurfaces;
+ int m_nTotalQueries;
+
+ void clear() { V_memset( this, 0, sizeof(* this ) ); }
+
+ ObjectStats_t &operator -= ( const ObjectStats_t &rhs )
+ {
+ m_nTotalFBOs -= rhs.m_nTotalFBOs;
+ m_nTotalVertexShaders -= rhs.m_nTotalVertexShaders;
+ m_nTotalPixelShaders -= rhs.m_nTotalPixelShaders;
+ m_nTotalVertexDecls -= rhs.m_nTotalVertexDecls;
+ m_nTotalIndexBuffers -= rhs.m_nTotalIndexBuffers;
+ m_nTotalVertexBuffers -= rhs.m_nTotalVertexBuffers;
+ m_nTotalRenderTargets -= rhs.m_nTotalRenderTargets;
+ m_nTotalTextures -= rhs.m_nTotalTextures;
+ m_nTotalSurfaces -= rhs.m_nTotalSurfaces;
+ m_nTotalQueries -= m_nTotalQueries;
+ return *this;
+ }
+ };
+ ObjectStats_t m_ObjectStats;
+ ObjectStats_t m_PrevObjectStats;
+ void PrintObjectStats( const ObjectStats_t &stats );
+
+ // GL state
+ struct
+ {
+ // render state buckets
+ GLAlphaTestEnable_t m_AlphaTestEnable;
+ GLAlphaTestFunc_t m_AlphaTestFunc;
+
+ GLAlphaToCoverageEnable_t m_AlphaToCoverageEnable;
+
+ GLDepthTestEnable_t m_DepthTestEnable;
+ GLDepthMask_t m_DepthMask;
+ GLDepthFunc_t m_DepthFunc;
+
+ GLClipPlaneEnable_t m_ClipPlaneEnable[kGLMUserClipPlanes];
+ GLClipPlaneEquation_t m_ClipPlaneEquation[kGLMUserClipPlanes];
+
+ GLColorMaskSingle_t m_ColorMaskSingle;
+ GLColorMaskMultiple_t m_ColorMaskMultiple;
+
+ GLCullFaceEnable_t m_CullFaceEnable;
+ GLCullFrontFace_t m_CullFrontFace;
+ GLPolygonMode_t m_PolygonMode;
+ GLDepthBias_t m_DepthBias;
+ GLScissorEnable_t m_ScissorEnable;
+ GLScissorBox_t m_ScissorBox;
+ GLViewportBox_t m_ViewportBox;
+ GLViewportDepthRange_t m_ViewportDepthRange;
+
+ GLBlendEnable_t m_BlendEnable;
+ GLBlendFactor_t m_BlendFactor;
+ GLBlendEquation_t m_BlendEquation;
+ GLBlendColor_t m_BlendColor;
+ GLBlendEnableSRGB_t m_BlendEnableSRGB;
+
+ GLStencilTestEnable_t m_StencilTestEnable;
+ GLStencilFunc_t m_StencilFunc;
+ GLStencilOp_t m_StencilOp;
+ GLStencilWriteMask_t m_StencilWriteMask;
+
+ GLClearColor_t m_ClearColor;
+ GLClearDepth_t m_ClearDepth;
+ GLClearStencil_t m_ClearStencil;
+
+ bool m_FogEnable; // not really pushed to GL, just latched here
+
+ // samplers
+ GLMTexSamplingParams m_samplers[ 16 ];
+ } gl;
+
+#if GL_BATCH_PERF_ANALYSIS
+ simple_bitmap *m_pBatch_vis_bitmap;
+ uint m_nBatchVisY;
+ uint m_nBatchVisFrameIndex, m_nBatchVisFileIdx;
+ uint m_nNumProgramChanges;
+
+ uint m_nTotalD3DCalls;
+ double m_flTotalD3DTime;
+ uint m_nTotalGLCalls;
+ double m_flTotalGLTime;
+ uint m_nTotalPrims;
+
+ uint m_nOverallProgramChanges;
+ uint m_nOverallDraws;
+ uint m_nOverallPrims;
+ uint m_nOverallD3DCalls;
+ double m_flOverallD3DTime;
+ uint m_nOverallGLCalls;
+ double m_flOverallGLTime;
+
+ double m_flOverallPresentTime;
+ double m_flOverallPresentTimeSquared;
+ double m_flOverallSwapWindowTime;
+ double m_flOverallSwapWindowTimeSquared;
+ uint m_nOverallPresents;
+#endif
+};
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetSamplerState( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value )
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetSamplerStateNonInline( Sampler, Type, Value );
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ Assert( Sampler < 16 );
+
+ m_ctx->SetSamplerDirty( Sampler );
+
+ switch( Type )
+ {
+ case D3DSAMP_ADDRESSU:
+ m_ctx->SetSamplerAddressU( Sampler, Value );
+ break;
+ case D3DSAMP_ADDRESSV:
+ m_ctx->SetSamplerAddressV( Sampler, Value );
+ break;
+ case D3DSAMP_ADDRESSW:
+ m_ctx->SetSamplerAddressW( Sampler, Value );
+ break;
+ case D3DSAMP_BORDERCOLOR:
+ m_ctx->SetSamplerBorderColor( Sampler, Value );
+ break;
+ case D3DSAMP_MAGFILTER:
+ m_ctx->SetSamplerMagFilter( Sampler, Value );
+ break;
+ case D3DSAMP_MIPFILTER:
+ m_ctx->SetSamplerMipFilter( Sampler, Value );
+ break;
+ case D3DSAMP_MINFILTER:
+ m_ctx->SetSamplerMinFilter( Sampler, Value );
+ break;
+ case D3DSAMP_MIPMAPLODBIAS:
+ m_ctx->SetSamplerMipMapLODBias( Sampler, Value );
+ break;
+ case D3DSAMP_MAXMIPLEVEL:
+ m_ctx->SetSamplerMaxMipLevel( Sampler, Value);
+ break;
+ case D3DSAMP_MAXANISOTROPY:
+ m_ctx->SetSamplerMaxAnisotropy( Sampler, Value);
+ break;
+ case D3DSAMP_SRGBTEXTURE:
+ m_samplers[ Sampler ].m_srgb = Value;
+ m_ctx->SetSamplerSRGBTexture(Sampler, Value);
+ break;
+ case D3DSAMP_SHADOWFILTER:
+ m_ctx->SetShadowFilter(Sampler, Value);
+ break;
+
+ default: DXABSTRACT_BREAK_ON_ERROR(); break;
+ }
+ return S_OK;
+#endif
+}
+
+FORCEINLINE void TOGLMETHODCALLTYPE IDirect3DDevice9::SetSamplerStates(
+ DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW,
+ DWORD MinFilter, DWORD MagFilter, DWORD MipFilter )
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ SetSamplerStatesNonInline( Sampler, AddressU, AddressV, AddressW, MinFilter, MagFilter, MipFilter );
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ Assert( Sampler < 16);
+
+ m_ctx->SetSamplerDirty( Sampler );
+
+ m_ctx->SetSamplerStates( Sampler, AddressU, AddressV, AddressW, MinFilter, MagFilter, MipFilter );
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetTextureNonInline( Stage, pTexture );
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_textures[Stage] = pTexture;
+ m_ctx->SetSamplerTex( Stage, pTexture ? pTexture->m_tex : NULL );
+ return S_OK;
+#endif
+}
+
+inline GLenum D3DCompareFuncToGL( DWORD function )
+{
+ switch ( function )
+ {
+ case D3DCMP_NEVER : return GL_NEVER; // Always fail the test.
+ case D3DCMP_LESS : return GL_LESS; // Accept the new pixel if its value is less than the value of the current pixel.
+ case D3DCMP_EQUAL : return GL_EQUAL; // Accept the new pixel if its value equals the value of the current pixel.
+ case D3DCMP_LESSEQUAL : return GL_LEQUAL; // Accept the new pixel if its value is less than or equal to the value of the current pixel. **
+ case D3DCMP_GREATER : return GL_GREATER; // Accept the new pixel if its value is greater than the value of the current pixel.
+ case D3DCMP_NOTEQUAL : return GL_NOTEQUAL; // Accept the new pixel if its value does not equal the value of the current pixel.
+ case D3DCMP_GREATEREQUAL: return GL_GEQUAL; // Accept the new pixel if its value is greater than or equal to the value of the current pixel.
+ case D3DCMP_ALWAYS : return GL_ALWAYS; // Always pass the test.
+ default : DXABSTRACT_BREAK_ON_ERROR(); return 0xFFFFFFFF;
+ }
+}
+
+FORCEINLINE GLenum D3DBlendOperationToGL( DWORD operation )
+{
+ switch (operation)
+ {
+ case D3DBLENDOP_ADD : return GL_FUNC_ADD; // The result is the destination added to the source. Result = Source + Destination
+
+ /* not covered by dxabstract.h..
+ case D3DBLENDOP_SUBTRACT : return GL_FUNC_SUBTRACT; // The result is the destination subtracted from to the source. Result = Source - Destination
+ case D3DBLENDOP_REVSUBTRACT : return GL_FUNC_REVERSE_SUBTRACT; // The result is the source subtracted from the destination. Result = Destination - Source
+ case D3DBLENDOP_MIN : return GL_MIN; // The result is the minimum of the source and destination. Result = MIN(Source, Destination)
+ case D3DBLENDOP_MAX : return GL_MAX; // The result is the maximum of the source and destination. Result = MAX(Source, Destination)
+ */
+ default:
+ DXABSTRACT_BREAK_ON_ERROR();
+ return 0xFFFFFFFF;
+ break;
+ }
+}
+
+FORCEINLINE GLenum D3DBlendFactorToGL( DWORD equation )
+{
+ switch (equation)
+ {
+ case D3DBLEND_ZERO : return GL_ZERO; // Blend factor is (0, 0, 0, 0).
+ case D3DBLEND_ONE : return GL_ONE; // Blend factor is (1, 1, 1, 1).
+ case D3DBLEND_SRCCOLOR : return GL_SRC_COLOR; // Blend factor is (Rs, Gs, Bs, As).
+ case D3DBLEND_INVSRCCOLOR : return GL_ONE_MINUS_SRC_COLOR; // Blend factor is (1 - Rs, 1 - Gs, 1 - Bs, 1 - As).
+ case D3DBLEND_SRCALPHA : return GL_SRC_ALPHA; // Blend factor is (As, As, As, As).
+ case D3DBLEND_INVSRCALPHA : return GL_ONE_MINUS_SRC_ALPHA; // Blend factor is ( 1 - As, 1 - As, 1 - As, 1 - As).
+ case D3DBLEND_DESTALPHA : return GL_DST_ALPHA; // Blend factor is (Ad Ad Ad Ad).
+ case D3DBLEND_INVDESTALPHA : return GL_ONE_MINUS_DST_ALPHA; // Blend factor is (1 - Ad 1 - Ad 1 - Ad 1 - Ad).
+ case D3DBLEND_DESTCOLOR : return GL_DST_COLOR; // Blend factor is (Rd, Gd, Bd, Ad).
+ case D3DBLEND_INVDESTCOLOR : return GL_ONE_MINUS_DST_COLOR; // Blend factor is (1 - Rd, 1 - Gd, 1 - Bd, 1 - Ad).
+ case D3DBLEND_SRCALPHASAT : return GL_SRC_ALPHA_SATURATE; // Blend factor is (f, f, f, 1); where f = min(As, 1 - Ad).
+
+ /*
+ // these are weird.... break if we hit them
+ case D3DBLEND_BOTHSRCALPHA : Assert(0); return GL_ZERO; // Obsolete. Starting with DirectX 6, you can achieve the same effect by setting the source and destination blend factors to D3DBLEND_SRCALPHA and D3DBLEND_INVSRCALPHA in separate calls.
+ case D3DBLEND_BOTHINVSRCALPHA: Assert(0); return GL_ZERO; // Source blend factor is (1 - As, 1 - As, 1 - As, 1 - As), and destination blend factor is (As, As, As, As); the destination blend selection is overridden. This blend mode is supported only for the D3DRS_SRCBLEND render state.
+ case D3DBLEND_BLENDFACTOR : Assert(0); return GL_ZERO; // Constant color blending factor used by the frame-buffer blender. This blend mode is supported only if D3DPBLENDCAPS_BLENDFACTOR is set in the SrcBlendCaps or DestBlendCaps members of D3DCAPS9.
+
+ dxabstract.h has not heard of these, so let them hit the debugger if they come through
+ case D3DBLEND_INVBLENDFACTOR: //Inverted constant color-blending factor used by the frame-buffer blender. This blend mode is supported only if the D3DPBLENDCAPS_BLENDFACTOR bit is set in the SrcBlendCaps or DestBlendCaps members of D3DCAPS9.
+ case D3DBLEND_SRCCOLOR2: // Blend factor is (PSOutColor[1]r, PSOutColor[1]g, PSOutColor[1]b, not used). This flag is available in Direct3D 9Ex only.
+ case D3DBLEND_INVSRCCOLOR2: // Blend factor is (1 - PSOutColor[1]r, 1 - PSOutColor[1]g, 1 - PSOutColor[1]b, not used)). This flag is available in Direct3D 9Ex only.
+ */
+ default:
+ DXABSTRACT_BREAK_ON_ERROR();
+ return 0xFFFFFFFF;
+ break;
+ }
+}
+
+
+FORCEINLINE GLenum D3DStencilOpToGL( DWORD operation )
+{
+ switch( operation )
+ {
+ case D3DSTENCILOP_KEEP : return GL_KEEP;
+ case D3DSTENCILOP_ZERO : return GL_ZERO;
+ case D3DSTENCILOP_REPLACE : return GL_REPLACE;
+ case D3DSTENCILOP_INCRSAT : return GL_INCR;
+ case D3DSTENCILOP_DECRSAT : return GL_DECR;
+ case D3DSTENCILOP_INVERT : return GL_INVERT;
+ case D3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
+ case D3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
+ default : DXABSTRACT_BREAK_ON_ERROR(); return 0xFFFFFFFF;
+ }
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetRenderStateInline( D3DRENDERSTATETYPE State, DWORD Value )
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetRenderState( State, Value );
+#else
+ TOGL_NULL_DEVICE_CHECK;
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+
+ switch (State)
+ {
+ case D3DRS_ZENABLE: // kGLDepthTestEnable
+ {
+ gl.m_DepthTestEnable.enable = Value;
+ m_ctx->WriteDepthTestEnable( &gl.m_DepthTestEnable );
+ break;
+ }
+ case D3DRS_ZWRITEENABLE: // kGLDepthMask
+ {
+ gl.m_DepthMask.mask = Value;
+ m_ctx->WriteDepthMask( &gl.m_DepthMask );
+ break;
+ }
+ case D3DRS_ZFUNC:
+ {
+ // kGLDepthFunc
+ GLenum func = D3DCompareFuncToGL( Value );
+ gl.m_DepthFunc.func = func;
+ m_ctx->WriteDepthFunc( &gl.m_DepthFunc );
+ break;
+ }
+ case D3DRS_COLORWRITEENABLE: // kGLColorMaskSingle
+ {
+ gl.m_ColorMaskSingle.r = ((Value & D3DCOLORWRITEENABLE_RED) != 0) ? 0xFF : 0x00;
+ gl.m_ColorMaskSingle.g = ((Value & D3DCOLORWRITEENABLE_GREEN)!= 0) ? 0xFF : 0x00;
+ gl.m_ColorMaskSingle.b = ((Value & D3DCOLORWRITEENABLE_BLUE) != 0) ? 0xFF : 0x00;
+ gl.m_ColorMaskSingle.a = ((Value & D3DCOLORWRITEENABLE_ALPHA)!= 0) ? 0xFF : 0x00;
+ m_ctx->WriteColorMaskSingle( &gl.m_ColorMaskSingle );
+ break;
+ }
+ case D3DRS_CULLMODE: // kGLCullFaceEnable / kGLCullFrontFace
+ {
+ switch (Value)
+ {
+ case D3DCULL_NONE:
+ {
+ gl.m_CullFaceEnable.enable = false;
+ gl.m_CullFrontFace.value = GL_CCW; //doesn't matter
+
+ m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
+ m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
+ break;
+ }
+
+ case D3DCULL_CW:
+ {
+ gl.m_CullFaceEnable.enable = true;
+ gl.m_CullFrontFace.value = GL_CW; //origGL_CCW;
+
+ m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
+ m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
+ break;
+ }
+ case D3DCULL_CCW:
+ {
+ gl.m_CullFaceEnable.enable = true;
+ gl.m_CullFrontFace.value = GL_CCW; //origGL_CW;
+
+ m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
+ m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
+ break;
+ }
+ default:
+ {
+ DXABSTRACT_BREAK_ON_ERROR();
+ break;
+ }
+ }
+ break;
+ }
+ //-------------------------------------------------------------------------------------------- alphablend stuff
+ case D3DRS_ALPHABLENDENABLE: // kGLBlendEnable
+ {
+ gl.m_BlendEnable.enable = Value;
+ m_ctx->WriteBlendEnable( &gl.m_BlendEnable );
+ break;
+ }
+ case D3DRS_BLENDOP: // kGLBlendEquation // D3D blend-op ==> GL blend equation
+ {
+ GLenum equation = D3DBlendOperationToGL( Value );
+ gl.m_BlendEquation.equation = equation;
+ m_ctx->WriteBlendEquation( &gl.m_BlendEquation );
+ break;
+ }
+ case D3DRS_SRCBLEND: // kGLBlendFactor // D3D blend-factor ==> GL blend factor
+ case D3DRS_DESTBLEND: // kGLBlendFactor
+ {
+ GLenum factor = D3DBlendFactorToGL( Value );
+
+ if (State==D3DRS_SRCBLEND)
+ {
+ gl.m_BlendFactor.srcfactor = factor;
+ }
+ else
+ {
+ gl.m_BlendFactor.dstfactor = factor;
+ }
+ m_ctx->WriteBlendFactor( &gl.m_BlendFactor );
+ break;
+ }
+ case D3DRS_SRGBWRITEENABLE: // kGLBlendEnableSRGB
+ {
+ gl.m_BlendEnableSRGB.enable = Value;
+ m_ctx->WriteBlendEnableSRGB( &gl.m_BlendEnableSRGB );
+ break;
+ }
+ //-------------------------------------------------------------------------------------------- alphatest stuff
+ case D3DRS_ALPHATESTENABLE:
+ {
+ gl.m_AlphaTestEnable.enable = Value;
+ m_ctx->WriteAlphaTestEnable( &gl.m_AlphaTestEnable );
+ break;
+ }
+ case D3DRS_ALPHAREF:
+ {
+ gl.m_AlphaTestFunc.ref = Value / 255.0f;
+ m_ctx->WriteAlphaTestFunc( &gl.m_AlphaTestFunc );
+ break;
+ }
+ case D3DRS_ALPHAFUNC:
+ {
+ GLenum func = D3DCompareFuncToGL( Value );;
+ gl.m_AlphaTestFunc.func = func;
+ m_ctx->WriteAlphaTestFunc( &gl.m_AlphaTestFunc );
+ break;
+ }
+ //-------------------------------------------------------------------------------------------- stencil stuff
+ case D3DRS_STENCILENABLE: // GLStencilTestEnable_t
+ {
+ gl.m_StencilTestEnable.enable = Value;
+ m_ctx->WriteStencilTestEnable( &gl.m_StencilTestEnable );
+ break;
+ }
+ case D3DRS_STENCILFAIL: // GLStencilOp_t "what do you do if stencil test fails"
+ {
+ GLenum stencilop = D3DStencilOpToGL( Value );
+ gl.m_StencilOp.sfail = stencilop;
+
+ m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
+ m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
+ break;
+ }
+ case D3DRS_STENCILZFAIL: // GLStencilOp_t "what do you do if stencil test passes *but* depth test fails, if depth test happened"
+ {
+ GLenum stencilop = D3DStencilOpToGL( Value );
+ gl.m_StencilOp.dpfail = stencilop;
+
+ m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
+ m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
+ break;
+ }
+ case D3DRS_STENCILPASS: // GLStencilOp_t "what do you do if stencil test and depth test both pass"
+ {
+ GLenum stencilop = D3DStencilOpToGL( Value );
+ gl.m_StencilOp.dppass = stencilop;
+
+ m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
+ m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
+ break;
+ }
+ case D3DRS_STENCILFUNC: // GLStencilFunc_t
+ {
+ GLenum stencilfunc = D3DCompareFuncToGL( Value );
+ gl.m_StencilFunc.frontfunc = gl.m_StencilFunc.backfunc = stencilfunc;
+
+ m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
+ break;
+ }
+ case D3DRS_STENCILREF: // GLStencilFunc_t
+ {
+ gl.m_StencilFunc.ref = Value;
+ m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
+ break;
+ }
+ case D3DRS_STENCILMASK: // GLStencilFunc_t
+ {
+ gl.m_StencilFunc.mask = Value;
+ m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
+ break;
+ }
+ case D3DRS_STENCILWRITEMASK: // GLStencilWriteMask_t
+ {
+ gl.m_StencilWriteMask.mask = Value;
+ m_ctx->WriteStencilWriteMask( &gl.m_StencilWriteMask );
+ break;
+ }
+ case D3DRS_FOGENABLE: // none of these are implemented yet... erk
+ {
+ gl.m_FogEnable = (Value != 0);
+ GLMPRINTF(("-D- fogenable = %d",Value ));
+ break;
+ }
+ case D3DRS_SCISSORTESTENABLE: // kGLScissorEnable
+ {
+ gl.m_ScissorEnable.enable = Value;
+ m_ctx->WriteScissorEnable( &gl.m_ScissorEnable );
+ break;
+ }
+ case D3DRS_DEPTHBIAS: // kGLDepthBias
+ {
+ // the value in the dword is actually a float
+ float fvalue = *(float*)&Value;
+ gl.m_DepthBias.units = fvalue;
+
+ m_ctx->WriteDepthBias( &gl.m_DepthBias );
+ break;
+ }
+ // good ref on these: http://aras-p.info/blog/2008/06/12/depth-bias-and-the-power-of-deceiving-yourself/
+ case D3DRS_SLOPESCALEDEPTHBIAS:
+ {
+ // the value in the dword is actually a float
+ float fvalue = *(float*)&Value;
+ gl.m_DepthBias.factor = fvalue;
+
+ m_ctx->WriteDepthBias( &gl.m_DepthBias );
+ break;
+ }
+ // Alpha to coverage
+ case D3DRS_ADAPTIVETESS_Y:
+ {
+ gl.m_AlphaToCoverageEnable.enable = Value;
+ m_ctx->WriteAlphaToCoverageEnable( &gl.m_AlphaToCoverageEnable );
+ break;
+ }
+ case D3DRS_CLIPPLANEENABLE: // kGLClipPlaneEnable
+ {
+ // d3d packs all the enables into one word.
+ // we break that out so we don't do N glEnable calls to sync -
+ // GLM is tracking one unique enable per plane.
+ for( int i=0; i<kGLMUserClipPlanes; i++)
+ {
+ gl.m_ClipPlaneEnable[i].enable = (Value & (1<<i)) != 0;
+ }
+
+ for( int x=0; x<kGLMUserClipPlanes; x++)
+ m_ctx->WriteClipPlaneEnable( &gl.m_ClipPlaneEnable[x], x );
+ break;
+ }
+ //-------------------------------------------------------------------------------------------- polygon/fill mode
+ case D3DRS_FILLMODE:
+ {
+ GLuint mode = 0;
+ switch(Value)
+ {
+ case D3DFILL_POINT: mode = GL_POINT; break;
+ case D3DFILL_WIREFRAME: mode = GL_LINE; break;
+ case D3DFILL_SOLID: mode = GL_FILL; break;
+ default: DXABSTRACT_BREAK_ON_ERROR(); break;
+ }
+ gl.m_PolygonMode.values[0] = gl.m_PolygonMode.values[1] = mode;
+ m_ctx->WritePolygonMode( &gl.m_PolygonMode );
+ break;
+ }
+ }
+
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetRenderStateConstInline( D3DRENDERSTATETYPE State, DWORD Value )
+{
+ // State is a compile time constant - luckily no need to do anything special to get the compiler to optimize this case.
+ return SetRenderStateInline( State, Value );
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetIndices(IDirect3DIndexBuffer9* pIndexData)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetIndicesNonInline( pIndexData );
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ // just latch it.
+ m_indices.m_idxBuffer = pIndexData;
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetStreamSourceNonInline( StreamNumber, pStreamData, OffsetInBytes, Stride );
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ Assert( StreamNumber < D3D_MAX_STREAMS );
+ Assert( ( Stride & 3 ) == 0 ); // we support non-DWORD aligned strides, but on some drivers (like AMD's) perf goes off a cliff
+
+ // perfectly legal to see a vertex buffer of NULL get passed in here.
+ // so we need an array to track these.
+ // OK, we are being given the stride, we don't need to calc it..
+
+ GLMPRINTF(("-X- IDirect3DDevice9::SetStreamSource setting stream #%d to D3D buf %p (GL name %d); offset %d, stride %d", StreamNumber, pStreamData, (pStreamData) ? pStreamData->m_vtxBuffer->m_name: -1, OffsetInBytes, Stride));
+
+ if ( !pStreamData )
+ {
+ OffsetInBytes = 0;
+ Stride = 0;
+
+ m_vtx_buffers[ StreamNumber ] = m_pDummy_vtx_buffer;
+ }
+ else
+ {
+ // We do not support strides of 0
+ Assert( Stride > 0 );
+ m_vtx_buffers[ StreamNumber ] = pStreamData->m_vtxBuffer;
+ }
+
+ m_streams[ StreamNumber ].m_vtxBuffer = pStreamData;
+ m_streams[ StreamNumber ].m_offset = OffsetInBytes;
+ m_streams[ StreamNumber ].m_stride = Stride;
+
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount) // groups of 4 floats!
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetVertexShaderConstantFNonInline( StartRegister, pConstantData, Vector4fCount );
+#else
+ TOGL_NULL_DEVICE_CHECK;
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetProgramParametersF( kGLMVertexProgram, StartRegister, (float *)pConstantData, Vector4fCount );
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetVertexShaderConstantBNonInline( StartRegister, pConstantData, BoolCount );
+#else
+ TOGL_NULL_DEVICE_CHECK;
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetProgramParametersB( kGLMVertexProgram, StartRegister, (int *)pConstantData, BoolCount );
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT IDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount) // groups of 4 ints!
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetVertexShaderConstantINonInline( StartRegister, pConstantData, Vector4iCount );
+#else
+ TOGL_NULL_DEVICE_CHECK;
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetProgramParametersI( kGLMVertexProgram, StartRegister, (int *)pConstantData, Vector4iCount );
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetPixelShaderConstantFNonInline(StartRegister, pConstantData, Vector4fCount);
+#else
+ TOGL_NULL_DEVICE_CHECK;
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetProgramParametersF( kGLMFragmentProgram, StartRegister, (float *)pConstantData, Vector4fCount );
+ return S_OK;
+#endif
+}
+
+HRESULT IDirect3DDevice9::SetVertexShader(IDirect3DVertexShader9* pShader)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetVertexShaderNonInline(pShader);
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetVertexProgram( pShader ? pShader->m_vtxProgram : NULL );
+ m_vertexShader = pShader;
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetPixelShader(IDirect3DPixelShader9* pShader)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetPixelShaderNonInline(pShader);
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetFragmentProgram( pShader ? pShader->m_pixProgram : NULL );
+ m_pixelShader = pShader;
+ return S_OK;
+#endif
+}
+
+FORCEINLINE HRESULT IDirect3DDevice9::SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl)
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetVertexDeclarationNonInline(pDecl);
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_pVertDecl = pDecl;
+ return S_OK;
+#endif
+}
+
+FORCEINLINE void IDirect3DDevice9::SetMaxUsedVertexShaderConstantsHint( uint nMaxReg )
+{
+#if GLMDEBUG || GL_BATCH_PERF_ANALYSIS
+ return SetMaxUsedVertexShaderConstantsHintNonInline( nMaxReg );
+#else
+ Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+ m_ctx->SetMaxUsedVertexShaderConstantsHint( nMaxReg );
+#endif
+}
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// D3DX
+// ------------------------------------------------------------------------------------------------------------------------------ //
+struct ID3DXInclude
+{
+ virtual HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes);
+ virtual HRESULT Close(LPCVOID pData);
+};
+typedef ID3DXInclude* LPD3DXINCLUDE;
+
+
+struct TOGL_CLASS ID3DXBuffer : public IUnknown
+{
+ void* GetBufferPointer();
+ DWORD GetBufferSize();
+};
+
+typedef ID3DXBuffer* LPD3DXBUFFER;
+
+class ID3DXConstantTable : public IUnknown
+{
+};
+typedef ID3DXConstantTable* LPD3DXCONSTANTTABLE;
+
+TOGL_INTERFACE const char* D3DXGetPixelShaderProfile( IDirect3DDevice9 *pDevice );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );
+TOGL_INTERFACE D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE HRESULT D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack);
+TOGL_INTERFACE void D3DXMatrixIdentity( D3DXMATRIX * );
+
+TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ pOut->x = pV1->x - pV2->x;
+ pOut->y = pV1->y - pV2->y;
+ pOut->z = pV1->z - pV2->z;
+ return pOut;
+}
+
+TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Cross( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ D3DXVECTOR3 v;
+
+ v.x = pV1->y * pV2->z - pV1->z * pV2->y;
+ v.y = pV1->z * pV2->x - pV1->x * pV2->z;
+ v.z = pV1->x * pV2->y - pV1->y * pV2->x;
+
+ *pOut = v;
+ return pOut;
+}
+
+TOGL_INTERFACE D3DXINLINE FLOAT D3DXVec3Dot( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
+}
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP);
+
+TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM );
+
+
+TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );
+
+// Build an ortho projection matrix. (right-handed)
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf );
+
+// Transform a plane by a matrix. The vector (a,b,c) must be normal.
+// M should be the inverse transpose of the transformation desired.
+TOGL_INTERFACE D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE IDirect3D9 *Direct3DCreate9(UINT SDKVersion);
+
+TOGL_INTERFACE void D3DPERF_SetOptions( DWORD dwOptions );
+
+TOGL_INTERFACE HRESULT D3DXCompileShader(
+ LPCSTR pSrcData,
+ UINT SrcDataLen,
+ CONST D3DXMACRO* pDefines,
+ LPD3DXINCLUDE pInclude,
+ LPCSTR pFunctionName,
+ LPCSTR pProfile,
+ DWORD Flags,
+ LPD3DXBUFFER* ppShader,
+ LPD3DXBUFFER* ppErrorMsgs,
+ LPD3DXCONSTANTTABLE* ppConstantTable);
+
+// fake D3D usage constant for SRGB tex creation
+#define D3DUSAGE_TEXTURE_SRGB (0x80000000L)
+
+#else
+
+ //USE_ACTUAL_DX
+ #ifndef WIN32
+ #error sorry man
+ #endif
+
+ #ifdef _X360
+ #include "d3d9.h"
+ #include "d3dx9.h"
+ #else
+ #include <windows.h>
+ #include "../../dx9sdk/include/d3d9.h"
+ #include "../../dx9sdk/include/d3dx9.h"
+ #endif
+ typedef HWND VD3DHWND;
+
+#endif // DX_TO_GL_ABSTRACTION
+
+#endif // DXABSTRACT_H
diff --git a/mp/src/public/togl/linuxwin/dxabstract_types.h b/mp/src/public/togl/linuxwin/dxabstract_types.h new file mode 100644 index 00000000..c021ca78 --- /dev/null +++ b/mp/src/public/togl/linuxwin/dxabstract_types.h @@ -0,0 +1,1712 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// dxabstract_types.h
+//
+//==================================================================================================
+#ifndef DXABSTRACT_TYPES_H
+#define DXABSTRACT_TYPES_H
+
+#pragma once
+
+#if GL_BATCH_PERF_ANALYSIS
+ class simple_bitmap;
+#endif
+
+struct IUnknown;
+struct IDirect3D9;
+struct IDirect3DDevice9;
+struct IDirect3DResource9;
+struct IDirect3DBaseTexture9;
+struct IDirect3DTexture9;
+struct IDirect3DCubeTexture9;
+struct IDirect3DVolumeTexture9;
+struct IDirect3DSurface9;
+struct IDirect3DVertexDeclaration9;
+struct IDirect3DQuery9;
+struct IDirect3DVertexBuffer9;
+struct IDirect3DIndexBuffer9;
+struct IDirect3DPixelShader9;
+struct IDirect3DVertexShader9;
+struct IDirect3DDevice9Params;
+
+class GLMContext;
+struct GLMRect;
+struct GLMShaderPairInfo;
+class CGLMBuffer;
+class CGLMQuery;
+class CGLMTex;
+class CGLMProgram;
+class CGLMFBO;
+
+#ifdef TOGL_DLL_EXPORT
+ #define TOGL_INTERFACE DLL_EXPORT
+ #define TOGL_OVERLOAD DLL_GLOBAL_EXPORT
+ #define TOGL_CLASS DLL_CLASS_EXPORT
+ #define TOGL_GLOBAL DLL_GLOBAL_EXPORT
+#else
+ #define TOGL_INTERFACE DLL_IMPORT
+ #define TOGL_OVERLOAD DLL_GLOBAL_IMPORT
+ #define TOGL_CLASS DLL_CLASS_IMPORT
+ #define TOGL_GLOBAL DLL_GLOBAL_IMPORT
+#endif
+
+#ifdef OSX
+#error "Do not use this header's types on OSX until togo is ported to Mac!"
+#endif
+
+#define TOGLMETHODCALLTYPE __stdcall
+//#define TOGLMETHODCALLTYPE
+
+#define DXABSTRACT_BREAK_ON_ERROR() DebuggerBreak()
+
+typedef void* VD3DHWND;
+typedef void* VD3DHANDLE;
+
+#define MAKEFOURCC(ch0, ch1, ch2, ch3) ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
+
+//
+//
+// Stuff that would be in windows.h
+//
+//
+#if !defined(_WINNT_)
+
+ typedef int INT;
+ typedef unsigned long ULONG;
+ typedef long LONG;
+ typedef float FLOAT;
+ typedef unsigned int DWORD;
+ typedef unsigned short WORD;
+ typedef long long LONGLONG;
+ typedef unsigned int UINT;
+ typedef long HRESULT;
+ typedef unsigned char BYTE;
+ #define CONST const
+
+ #if defined(POSIX)
+ typedef size_t ULONG_PTR;
+ #else
+ typedef unsigned long ULONG_PTR;
+ #endif
+
+ typedef ULONG_PTR SIZE_T;
+
+ typedef const char* LPCSTR;
+ typedef char* LPSTR;
+ typedef DWORD* LPDWORD;
+
+ #define ZeroMemory RtlZeroMemory
+ #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
+
+ typedef union _LARGE_INTEGER
+ {
+ struct
+ {
+ DWORD LowPart;
+ LONG HighPart;
+ };
+ struct
+ {
+ DWORD LowPart;
+ LONG HighPart;
+ } u;
+ LONGLONG QuadPart;
+ } LARGE_INTEGER;
+
+ typedef struct _GUID
+ {
+ bool operator==( const struct _GUID &other ) const;
+
+ unsigned long Data1;
+ unsigned short Data2;
+ unsigned short Data3;
+ unsigned char Data4[ 8 ];
+ } GUID;
+
+ typedef struct _RECT
+ {
+ int left;
+ int top;
+ int right;
+ int bottom;
+ } RECT;
+
+ typedef struct tagPOINT
+ {
+ LONG x;
+ LONG y;
+ } POINT, *PPOINT, *LPPOINT;
+
+ typedef struct _MEMORYSTATUS
+ {
+ DWORD dwLength;
+ SIZE_T dwTotalPhys;
+ } MEMORYSTATUS, *LPMEMORYSTATUS;
+
+ typedef DWORD COLORREF;
+ #define RGB(r,g,b) ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)))
+
+ #define MAKE_HRESULT(sev,fac,code) ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
+
+ #define S_FALSE ((HRESULT)0x00000001L)
+ #define S_OK 0
+ #define E_FAIL ((HRESULT)0x80004005L)
+ #define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
+
+ #define FAILED(hr) ((HRESULT)(hr) < 0)
+ #define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
+
+ struct RGNDATA
+ {
+ };
+
+ typedef const void* LPCVOID;
+#endif
+
+//-----------------------------------------------------------------------------
+
+typedef enum _D3DFORMAT D3DFORMAT;
+
+#define D3DSI_OPCODE_MASK 0x0000FFFF
+#define D3DSP_TEXTURETYPE_MASK 0x78000000
+
+#define D3DUSAGE_AUTOGENMIPMAP 0x00000400L
+#define D3DSP_DCL_USAGE_MASK 0x0000000f
+
+#define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000
+#define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16
+
+
+/* Flags to construct D3DRS_COLORWRITEENABLE */
+#define D3DCOLORWRITEENABLE_RED (1L<<0)
+#define D3DCOLORWRITEENABLE_GREEN (1L<<1)
+#define D3DCOLORWRITEENABLE_BLUE (1L<<2)
+#define D3DCOLORWRITEENABLE_ALPHA (1L<<3)
+
+#define D3DSGR_NO_CALIBRATION 0x00000000L
+
+#define D3DXINLINE inline
+
+#define D3D_SDK_VERSION 32
+
+#define _FACD3D 0x876
+#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
+
+#define D3DERR_NOTFOUND MAKE_D3DHRESULT(2150)
+#define D3DERR_DEVICELOST MAKE_D3DHRESULT(2152)
+#define D3DERR_NOTAVAILABLE MAKE_D3DHRESULT(2154)
+#define D3DERR_DEVICENOTRESET MAKE_D3DHRESULT(2153)
+#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156)
+#define D3DERR_DRIVERINTERNALERROR MAKE_D3DHRESULT(2087)
+#define D3DERR_OUTOFVIDEOMEMORY MAKE_D3DHRESULT(380)
+#define D3D_OK S_OK
+
+#define D3DPRESENT_RATE_DEFAULT 0x00000000
+
+//
+// DevCaps
+//
+// we need to see who in Source land is interested in these values, as dxabstract is currently reporting zero for the whole Caps word
+#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010L /* Device can use execute buffers from system memory */
+#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */
+#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x00000080L /* Device can use TL buffers from video memory */
+#define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x00000100L /* Device can texture from system memory */
+#define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x00000200L /* Device can texture from device memory */
+#define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x00000400L /* Device can draw TLVERTEX primitives */
+#define D3DDEVCAPS_CANRENDERAFTERFLIP 0x00000800L /* Device can render without waiting for flip to complete */
+#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */
+#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000L /* Device is texturing from separate memory pools */
+#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
+#define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x00020000L /* Device supports a Tex Blt from system memory to non-local vidmem */
+#define D3DDEVCAPS_HWRASTERIZATION 0x00080000L /* Device has HW acceleration for rasterization */
+#define D3DDEVCAPS_PUREDEVICE 0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
+#define D3DDEVCAPS_QUINTICRTPATCHES 0x00200000L /* Device supports quintic Beziers and BSplines */
+#define D3DDEVCAPS_RTPATCHHANDLEZERO 0x00800000L /* Indicates that RT Patches may be drawn efficiently using handle 0 */
+#define D3DDEVCAPS_NPATCHES 0x01000000L /* Device supports N-Patches */
+
+//
+// PrimitiveMiscCaps
+//
+#define D3DPMISCCAPS_MASKZ 0x00000002L
+#define D3DPMISCCAPS_CULLNONE 0x00000010L
+#define D3DPMISCCAPS_CULLCW 0x00000020L
+#define D3DPMISCCAPS_CULLCCW 0x00000040L
+#define D3DPMISCCAPS_COLORWRITEENABLE 0x00000080L
+#define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS 0x00000100L /* Device correctly clips scaled points to clip planes */
+#define D3DPMISCCAPS_CLIPTLVERTS 0x00000200L /* device will clip post-transformed vertex primitives */
+#define D3DPMISCCAPS_TSSARGTEMP 0x00000400L /* device supports D3DTA_TEMP for temporary register */
+#define D3DPMISCCAPS_BLENDOP 0x00000800L /* device supports D3DRS_BLENDOP */
+#define D3DPMISCCAPS_NULLREFERENCE 0x00001000L /* Reference Device that doesnt render */
+#define D3DPMISCCAPS_PERSTAGECONSTANT 0x00008000L /* Device supports per-stage constants */
+#define D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS 0x00040000L /* Device supports different bit depths for MRT */
+#define D3DPMISCCAPS_FOGVERTEXCLAMPED 0x00100000L /* Device clamps fog blend factor per vertex */
+
+// Flags field for Issue
+#define D3DISSUE_END (1 << 0) // Tells the runtime to issue the end of a query, changing it's state to "non-signaled".
+#define D3DISSUE_BEGIN (1 << 1) // Tells the runtime to issue the beginng of a query.
+
+
+#define D3DPRESENT_INTERVAL_ONE 0x00000001L
+#define D3DPRESENT_INTERVAL_IMMEDIATE 0x80000000L
+
+/*
+ * Options for clearing
+ */
+#define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */
+#define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */
+#define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */
+
+
+#define D3DENUM_WHQL_LEVEL 0x00000002L
+
+
+
+
+#define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV 0x00200000L /* Device does not support projected bump env lookup operation
+ in programmable and fixed function pixel shaders */
+#define D3DDEVCAPS2_STREAMOFFSET 0x00000001L /* Device supports offsets in streams. Must be set by DX9 drivers */
+
+#define D3DDEVCAPS_PUREDEVICE 0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
+
+#define D3DCREATE_PUREDEVICE 0x00000010L
+#define D3DCREATE_SOFTWARE_VERTEXPROCESSING 0x00000020L
+#define D3DCREATE_HARDWARE_VERTEXPROCESSING 0x00000040L
+#define D3DCREATE_FPU_PRESERVE 0x00000002L
+#define D3DPRASTERCAPS_FOGRANGE 0x00010000L
+#define D3DPRASTERCAPS_FOGTABLE 0x00000100L
+#define D3DPRASTERCAPS_FOGVERTEX 0x00000080L
+#define D3DPRASTERCAPS_WFOG 0x00100000L
+#define D3DPRASTERCAPS_ZFOG 0x00200000L
+#define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000L
+#define D3DPRASTERCAPS_WBUFFER 0x00040000L
+#define D3DPRASTERCAPS_ZTEST 0x00000010L
+
+//
+// Caps2
+//
+#define D3DCAPS2_CANCALIBRATEGAMMA 0x00100000L
+#define D3DPRASTERCAPS_SCISSORTEST 0x01000000L
+#define D3DPTEXTURECAPS_MIPCUBEMAP 0x00010000L /* Device can do mipmapped cube maps */
+#define D3DPTEXTURECAPS_ALPHA 0x00000004L /* Alpha in texture pixels is supported */
+#define D3DPTEXTURECAPS_SQUAREONLY 0x00000020L /* Only square textures are supported */
+#define D3DCREATE_MULTITHREADED 0x00000004L
+#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
+#define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400L
+#define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000L
+#define D3DPTEXTURECAPS_CUBEMAP 0x00000800L /* Device can do cubemap textures */
+#define D3DPTEXTURECAPS_POW2 0x00000002L /* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. */
+#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL 0x00000100L
+#define D3DPTEXTURECAPS_PROJECTED 0x00000400L /* Device can do D3DTTFF_PROJECTED */
+#define D3DTEXOPCAPS_ADD 0x00000040L
+#define D3DTEXOPCAPS_MODULATE2X 0x00000010L
+#define D3DPRASTERCAPS_DEPTHBIAS 0x04000000L
+#define D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS 0x02000000L
+#define D3DVTXPCAPS_TEXGEN_SPHEREMAP 0x00000100L /* device supports D3DTSS_TCI_SPHEREMAP */
+#define D3DCAPS2_DYNAMICTEXTURES 0x20000000L
+
+// The following usages are valid only for querying CheckDeviceFormat
+#define D3DUSAGE_QUERY_SRGBREAD (0x00010000L)
+#define D3DUSAGE_QUERY_FILTER (0x00020000L)
+#define D3DUSAGE_QUERY_SRGBWRITE (0x00040000L)
+#define D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING (0x00080000L)
+#define D3DUSAGE_QUERY_VERTEXTEXTURE (0x00100000L)
+
+/* Usages for Vertex/Index buffers */
+#define D3DUSAGE_WRITEONLY (0x00000008L)
+#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L)
+#define D3DUSAGE_DONOTCLIP (0x00000020L)
+#define D3DUSAGE_POINTS (0x00000040L)
+#define D3DUSAGE_RTPATCHES (0x00000080L)
+#define D3DUSAGE_NPATCHES (0x00000100L)
+
+
+// Flags field for GetData
+#define D3DGETDATA_FLUSH (1 << 0) // Tells the runtime to flush if the query is outstanding.
+
+#define D3DFVF_XYZ 0x002
+
+
+#define D3DTA_SELECTMASK 0x0000000f // mask for arg selector
+#define D3DTA_DIFFUSE 0x00000000 // select diffuse color (read only)
+#define D3DTA_CURRENT 0x00000001 // select stage destination register (read/write)
+#define D3DTA_TEXTURE 0x00000002 // select texture color (read only)
+#define D3DTA_TFACTOR 0x00000003 // select D3DRS_TEXTUREFACTOR (read only)
+#define D3DTA_SPECULAR 0x00000004 // select specular color (read only)
+#define D3DTA_TEMP 0x00000005 // select temporary register color (read/write)
+#define D3DTA_CONSTANT 0x00000006 // select texture stage constant
+#define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x (read modifier)
+#define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components (read modifier)
+
+
+#define D3DUSAGE_RENDERTARGET (0x00000001L)
+#define D3DUSAGE_QUERY_VERTEXTEXTURE (0x00100000L)
+#define D3DUSAGE_QUERY_FILTER (0x00020000L)
+#define D3DUSAGE_DEPTHSTENCIL (0x00000002L)
+#define D3DUSAGE_WRITEONLY (0x00000008L)
+#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L)
+#define D3DUSAGE_DYNAMIC (0x00000200L)
+
+#define D3DSI_INSTLENGTH_MASK 0x0F000000
+#define D3DSI_INSTLENGTH_SHIFT 24
+#define D3DSP_TEXTURETYPE_SHIFT 27
+#define D3DSP_REGTYPE_SHIFT 28
+#define D3DSP_REGTYPE_SHIFT2 8
+#define D3DSP_REGTYPE_MASK 0x70000000
+#define D3DSP_REGTYPE_MASK2 0x00001800
+
+#define D3DSP_REGNUM_MASK 0x000007FF
+
+#define D3DSP_DSTMOD_SHIFT 20
+#define D3DSP_DSTMOD_MASK 0x00F00000
+#define D3DSPDM_MSAMPCENTROID (4<<D3DSP_DSTMOD_SHIFT) // Relevant to multisampling only:
+ // When the pixel center is not covered, sample
+ // attribute or compute gradients/LOD
+ // using multisample "centroid" location.
+ // "Centroid" is some location within the covered
+ // region of the pixel.
+
+#define D3DXSHADER_DEBUG (1 << 0)
+#define D3DXSHADER_AVOID_FLOW_CONTROL (1 << 9)
+
+
+#define D3DLOCK_READONLY 0x00000010L
+#define D3DLOCK_DISCARD 0x00002000L
+#define D3DLOCK_NOOVERWRITE 0x00001000L
+#define D3DLOCK_NOSYSLOCK 0x00000800L
+
+#define D3DLOCK_NO_DIRTY_UPDATE 0x00008000L
+
+
+#define D3DDMAPSAMPLER 256
+#define D3DVERTEXTEXTURESAMPLER0 (D3DDMAPSAMPLER+1)
+#define D3DSP_SRCMOD_SHIFT 24
+
+
+#define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
+#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
+#define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b)
+
+// maps floating point channels (0.f to 1.f range) to D3DCOLOR
+#define D3DCOLOR_COLORVALUE(r,g,b,a) \
+ D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f))
+
+#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
+
+#define D3DSP_DCL_USAGEINDEX_SHIFT 16
+#define D3DSP_DCL_USAGEINDEX_MASK 0x000f0000
+
+// Bit masks for destination parameter modifiers
+#define D3DSPDM_NONE (0<<D3DSP_DSTMOD_SHIFT) // nop
+#define D3DSPDM_SATURATE (1<<D3DSP_DSTMOD_SHIFT) // clamp to 0. to 1. range
+#define D3DSPDM_PARTIALPRECISION (2<<D3DSP_DSTMOD_SHIFT) // Partial precision hint
+#define D3DSPDM_MSAMPCENTROID (4<<D3DSP_DSTMOD_SHIFT) // Relevant to multisampling only:
+ // When the pixel center is not covered, sample
+ // attribute or compute gradients/LOD
+ // using multisample "centroid" location.
+ // "Centroid" is some location within the covered
+ // region of the pixel.
+
+// Value when there is no swizzle (X is taken from X, Y is taken from Y,
+// Z is taken from Z, W is taken from W
+//
+#define D3DVS_NOSWIZZLE (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z | D3DVS_W_W)
+
+// extract major/minor from version cap
+#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
+#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
+
+#define D3DSHADER_ADDRESSMODE_SHIFT 13
+#define D3DSHADER_ADDRESSMODE_MASK (1 << D3DSHADER_ADDRESSMODE_SHIFT)
+
+#define D3DPS_END() 0x0000FFFF
+
+// ps_2_0 texld controls
+#define D3DSI_TEXLD_PROJECT (0x01 << D3DSP_OPCODESPECIFICCONTROL_SHIFT)
+#define D3DSI_TEXLD_BIAS (0x02 << D3DSP_OPCODESPECIFICCONTROL_SHIFT)
+
+
+// destination parameter write mask
+#define D3DSP_WRITEMASK_0 0x00010000 // Component 0 (X;Red)
+#define D3DSP_WRITEMASK_1 0x00020000 // Component 1 (Y;Green)
+#define D3DSP_WRITEMASK_2 0x00040000 // Component 2 (Z;Blue)
+#define D3DSP_WRITEMASK_3 0x00080000 // Component 3 (W;Alpha)
+#define D3DSP_WRITEMASK_ALL 0x000F0000 // All Components
+
+#define D3DVS_SWIZZLE_SHIFT 16
+#define D3DVS_SWIZZLE_MASK 0x00FF0000
+
+// The following bits define where to take component X from:
+
+#define D3DVS_X_X (0 << D3DVS_SWIZZLE_SHIFT)
+#define D3DVS_X_Y (1 << D3DVS_SWIZZLE_SHIFT)
+#define D3DVS_X_Z (2 << D3DVS_SWIZZLE_SHIFT)
+#define D3DVS_X_W (3 << D3DVS_SWIZZLE_SHIFT)
+
+// The following bits define where to take component Y from:
+
+#define D3DVS_Y_X (0 << (D3DVS_SWIZZLE_SHIFT + 2))
+#define D3DVS_Y_Y (1 << (D3DVS_SWIZZLE_SHIFT + 2))
+#define D3DVS_Y_Z (2 << (D3DVS_SWIZZLE_SHIFT + 2))
+#define D3DVS_Y_W (3 << (D3DVS_SWIZZLE_SHIFT + 2))
+
+// The following bits define where to take component Z from:
+
+#define D3DVS_Z_X (0 << (D3DVS_SWIZZLE_SHIFT + 4))
+#define D3DVS_Z_Y (1 << (D3DVS_SWIZZLE_SHIFT + 4))
+#define D3DVS_Z_Z (2 << (D3DVS_SWIZZLE_SHIFT + 4))
+#define D3DVS_Z_W (3 << (D3DVS_SWIZZLE_SHIFT + 4))
+
+// The following bits define where to take component W from:
+
+#define D3DVS_W_X (0 << (D3DVS_SWIZZLE_SHIFT + 6))
+#define D3DVS_W_Y (1 << (D3DVS_SWIZZLE_SHIFT + 6))
+#define D3DVS_W_Z (2 << (D3DVS_SWIZZLE_SHIFT + 6))
+#define D3DVS_W_W (3 << (D3DVS_SWIZZLE_SHIFT + 6))
+
+// source parameter modifiers
+#define D3DSP_SRCMOD_SHIFT 24
+#define D3DSP_SRCMOD_MASK 0x0F000000
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// ENUMS
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE
+{
+ D3DSPSM_NONE = 0<<D3DSP_SRCMOD_SHIFT, // nop
+ D3DSPSM_NEG = 1<<D3DSP_SRCMOD_SHIFT, // negate
+ D3DSPSM_BIAS = 2<<D3DSP_SRCMOD_SHIFT, // bias
+ D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate
+ D3DSPSM_SIGN = 4<<D3DSP_SRCMOD_SHIFT, // sign
+ D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate
+ D3DSPSM_COMP = 6<<D3DSP_SRCMOD_SHIFT, // complement
+ D3DSPSM_X2 = 7<<D3DSP_SRCMOD_SHIFT, // *2
+ D3DSPSM_X2NEG = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate
+ D3DSPSM_DZ = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z component
+ D3DSPSM_DW = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w component
+ D3DSPSM_ABS = 11<<D3DSP_SRCMOD_SHIFT, // abs()
+ D3DSPSM_ABSNEG = 12<<D3DSP_SRCMOD_SHIFT, // -abs()
+ D3DSPSM_NOT = 13<<D3DSP_SRCMOD_SHIFT, // for predicate register: "!p0"
+ D3DSPSM_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSHADER_PARAM_SRCMOD_TYPE;
+
+
+typedef enum _D3DSAMPLER_TEXTURE_TYPE
+{
+ D3DSTT_UNKNOWN = 0<<D3DSP_TEXTURETYPE_SHIFT, // uninitialized value
+ D3DSTT_2D = 2<<D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for declaring a 2-D texture)
+ D3DSTT_CUBE = 3<<D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for declaring a cube texture)
+ D3DSTT_VOLUME = 4<<D3DSP_TEXTURETYPE_SHIFT, // dcl_volume s# (for declaring a volume texture)
+ D3DSTT_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSAMPLER_TEXTURE_TYPE;
+
+typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE
+{
+ D3DSIO_NOP = 0,
+ D3DSIO_MOV ,
+ D3DSIO_ADD ,
+ D3DSIO_SUB ,
+ D3DSIO_MAD ,
+ D3DSIO_MUL ,
+ D3DSIO_RCP ,
+ D3DSIO_RSQ ,
+ D3DSIO_DP3 ,
+ D3DSIO_DP4 ,
+ D3DSIO_MIN , //10
+ D3DSIO_MAX ,
+ D3DSIO_SLT ,
+ D3DSIO_SGE ,
+ D3DSIO_EXP ,
+ D3DSIO_LOG ,
+ D3DSIO_LIT ,
+ D3DSIO_DST ,
+ D3DSIO_LRP ,
+ D3DSIO_FRC ,
+ D3DSIO_M4x4 , //20
+ D3DSIO_M4x3 ,
+ D3DSIO_M3x4 ,
+ D3DSIO_M3x3 ,
+ D3DSIO_M3x2 ,
+ D3DSIO_CALL ,
+ D3DSIO_CALLNZ ,
+ D3DSIO_LOOP ,
+ D3DSIO_RET ,
+ D3DSIO_ENDLOOP ,
+ D3DSIO_LABEL , //30
+ D3DSIO_DCL ,
+ D3DSIO_POW ,
+ D3DSIO_CRS ,
+ D3DSIO_SGN ,
+ D3DSIO_ABS ,
+ D3DSIO_NRM ,
+ D3DSIO_SINCOS ,
+ D3DSIO_REP ,
+ D3DSIO_ENDREP ,
+ D3DSIO_IF , //40
+ D3DSIO_IFC ,
+ D3DSIO_ELSE ,
+ D3DSIO_ENDIF ,
+ D3DSIO_BREAK ,
+ D3DSIO_BREAKC ,
+ D3DSIO_MOVA ,
+ D3DSIO_DEFB ,
+ D3DSIO_DEFI ,
+
+ D3DSIO_TEXCOORD = 64,
+ D3DSIO_TEXKILL ,
+ D3DSIO_TEX ,
+ D3DSIO_TEXBEM ,
+ D3DSIO_TEXBEML ,
+ D3DSIO_TEXREG2AR ,
+ D3DSIO_TEXREG2GB ,
+ D3DSIO_TEXM3x2PAD ,
+ D3DSIO_TEXM3x2TEX ,
+ D3DSIO_TEXM3x3PAD ,
+ D3DSIO_TEXM3x3TEX ,
+ D3DSIO_RESERVED0 ,
+ D3DSIO_TEXM3x3SPEC ,
+ D3DSIO_TEXM3x3VSPEC ,
+ D3DSIO_EXPP ,
+ D3DSIO_LOGP ,
+ D3DSIO_CND ,
+ D3DSIO_DEF ,
+ D3DSIO_TEXREG2RGB ,
+ D3DSIO_TEXDP3TEX ,
+ D3DSIO_TEXM3x2DEPTH ,
+ D3DSIO_TEXDP3 ,
+ D3DSIO_TEXM3x3 ,
+ D3DSIO_TEXDEPTH ,
+ D3DSIO_CMP ,
+ D3DSIO_BEM ,
+ D3DSIO_DP2ADD ,
+ D3DSIO_DSX ,
+ D3DSIO_DSY ,
+ D3DSIO_TEXLDD ,
+ D3DSIO_SETP ,
+ D3DSIO_TEXLDL ,
+ D3DSIO_BREAKP ,
+
+ D3DSIO_PHASE = 0xFFFD,
+ D3DSIO_COMMENT = 0xFFFE,
+ D3DSIO_END = 0xFFFF,
+
+ D3DSIO_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSHADER_INSTRUCTION_OPCODE_TYPE;
+
+typedef enum _D3DVS_RASTOUT_OFFSETS
+{
+ D3DSRO_POSITION = 0,
+ D3DSRO_FOG,
+ D3DSRO_POINT_SIZE,
+ D3DSRO_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DVS_RASTOUT_OFFSETS;
+
+/* SwapEffects */
+typedef enum _D3DSWAPEFFECT
+{
+ D3DSWAPEFFECT_DISCARD = 1,
+ D3DSWAPEFFECT_COPY = 3,
+
+ D3DSWAPEFFECT_FORCE_DWORD = 0x7fffffff
+} D3DSWAPEFFECT;
+
+typedef enum _D3DRESOURCETYPE
+{
+ D3DRTYPE_SURFACE = 1,
+ D3DRTYPE_TEXTURE = 3,
+ D3DRTYPE_VOLUMETEXTURE = 4,
+ D3DRTYPE_CUBETEXTURE = 5,
+ D3DRTYPE_VERTEXBUFFER = 6,
+ D3DRTYPE_INDEXBUFFER = 7,
+
+ D3DRTYPE_FORCE_DWORD = 0x7fffffff
+} D3DRESOURCETYPE;
+
+typedef enum _D3DDEVTYPE
+{
+ D3DDEVTYPE_HAL = 1,
+ D3DDEVTYPE_REF = 2,
+
+ D3DDEVTYPE_NULLREF = 4,
+
+ D3DDEVTYPE_FORCE_DWORD = 0x7fffffff
+} D3DDEVTYPE;
+
+typedef enum _D3DSTENCILOP
+{
+ D3DSTENCILOP_KEEP = 1,
+ D3DSTENCILOP_ZERO = 2,
+ D3DSTENCILOP_REPLACE = 3,
+ D3DSTENCILOP_INCRSAT = 4,
+ D3DSTENCILOP_DECRSAT = 5,
+ D3DSTENCILOP_INVERT = 6,
+ D3DSTENCILOP_INCR = 7,
+ D3DSTENCILOP_DECR = 8,
+ D3DSTENCILOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DSTENCILOP;
+
+typedef enum _D3DPATCHEDGESTYLE
+{
+ D3DPATCHEDGE_DISCRETE = 0,
+ D3DPATCHEDGE_CONTINUOUS = 1,
+ D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff,
+} D3DPATCHEDGESTYLE;
+
+
+/* Debug monitor tokens (DEBUG only)
+
+ Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as
+ passing a token to the debug monitor. For example, if, after passing
+ D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
+ are passed in, the enabled/disabled state of the debug
+ monitor will still persist.
+
+ The debug monitor defaults to enabled.
+
+ Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
+*/
+typedef enum _D3DDEBUGMONITORTOKENS
+{
+ D3DDMT_ENABLE = 0, // enable debug monitor
+} D3DDEBUGMONITORTOKENS;
+
+typedef enum _D3DDEGREETYPE
+{
+ D3DDEGREE_LINEAR = 1,
+ D3DDEGREE_QUADRATIC = 2,
+ D3DDEGREE_CUBIC = 3,
+ D3DDEGREE_FORCE_DWORD = 0x7fffffff,
+} D3DDEGREETYPE;
+
+typedef enum _D3DBLENDOP
+{
+ D3DBLENDOP_ADD = 1,
+ D3DBLENDOP_SUBTRACT = 2,
+ D3DBLENDOP_REVSUBTRACT = 3,
+ D3DBLENDOP_MIN = 4,
+ D3DBLENDOP_MAX = 5,
+ D3DBLENDOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DBLENDOP;
+
+typedef enum _D3DMULTISAMPLE_TYPE
+{
+ D3DMULTISAMPLE_NONE = 0,
+ D3DMULTISAMPLE_NONMASKABLE = 1,
+ D3DMULTISAMPLE_2_SAMPLES = 2,
+ D3DMULTISAMPLE_3_SAMPLES = 3,
+ D3DMULTISAMPLE_4_SAMPLES = 4,
+ D3DMULTISAMPLE_5_SAMPLES = 5,
+ D3DMULTISAMPLE_6_SAMPLES = 6,
+ D3DMULTISAMPLE_7_SAMPLES = 7,
+ D3DMULTISAMPLE_8_SAMPLES = 8,
+ D3DMULTISAMPLE_9_SAMPLES = 9,
+ D3DMULTISAMPLE_10_SAMPLES = 10,
+ D3DMULTISAMPLE_11_SAMPLES = 11,
+ D3DMULTISAMPLE_12_SAMPLES = 12,
+ D3DMULTISAMPLE_13_SAMPLES = 13,
+ D3DMULTISAMPLE_14_SAMPLES = 14,
+ D3DMULTISAMPLE_15_SAMPLES = 15,
+ D3DMULTISAMPLE_16_SAMPLES = 16,
+
+ D3DMULTISAMPLE_FORCE_DWORD = 0x7fffffff
+} D3DMULTISAMPLE_TYPE;
+
+/* Pool types */
+typedef enum _D3DPOOL
+{
+ D3DPOOL_DEFAULT = 0,
+ D3DPOOL_MANAGED = 1,
+ D3DPOOL_SYSTEMMEM = 2,
+ D3DPOOL_SCRATCH = 3,
+
+ D3DPOOL_FORCE_DWORD = 0x7fffffff
+} D3DPOOL;
+
+typedef enum _D3DQUERYTYPE
+{
+ D3DQUERYTYPE_RESOURCEMANAGER = 5, /* D3DISSUE_END */
+ D3DQUERYTYPE_EVENT = 8, /* D3DISSUE_END */
+ D3DQUERYTYPE_OCCLUSION = 9, /* D3DISSUE_BEGIN, D3DISSUE_END */
+ D3DQUERYTYPE_TIMESTAMP = 10, /* D3DISSUE_END */
+ D3DQUERYTYPE_TIMESTAMPFREQ = 12, /* D3DISSUE_END */
+ D3DQUERYTYPE_INTERFACETIMINGS = 14, /* D3DISSUE_BEGIN, D3DISSUE_END */
+ D3DQUERYTYPE_PIXELTIMINGS = 16, /* D3DISSUE_BEGIN, D3DISSUE_END */
+ D3DQUERYTYPE_CACHEUTILIZATION = 18, /* D3DISSUE_BEGIN, D3DISSUE_END */
+} D3DQUERYTYPE;
+
+typedef enum _D3DRENDERSTATETYPE
+{
+ D3DRS_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */
+ D3DRS_FILLMODE = 8, /* D3DFILLMODE */
+ D3DRS_SHADEMODE = 9, /* D3DSHADEMODE */
+ D3DRS_ZWRITEENABLE = 14, /* TRUE to enable z writes */
+ D3DRS_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */
+ D3DRS_LASTPIXEL = 16, /* TRUE for last-pixel on lines */
+ D3DRS_SRCBLEND = 19, /* D3DBLEND */
+ D3DRS_DESTBLEND = 20, /* D3DBLEND */
+ D3DRS_CULLMODE = 22, /* D3DCULL */
+ D3DRS_ZFUNC = 23, /* D3DCMPFUNC */
+ D3DRS_ALPHAREF = 24, /* D3DFIXED */
+ D3DRS_ALPHAFUNC = 25, /* D3DCMPFUNC */
+ D3DRS_DITHERENABLE = 26, /* TRUE to enable dithering */
+ D3DRS_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */
+ D3DRS_FOGENABLE = 28, /* TRUE to enable fog blending */
+ D3DRS_SPECULARENABLE = 29, /* TRUE to enable specular */
+ D3DRS_FOGCOLOR = 34, /* D3DCOLOR */
+ D3DRS_FOGTABLEMODE = 35, /* D3DFOGMODE */
+ D3DRS_FOGSTART = 36, /* Fog start (for both vertex and pixel fog) */
+ D3DRS_FOGEND = 37, /* Fog end */
+ D3DRS_FOGDENSITY = 38, /* Fog density */
+ D3DRS_RANGEFOGENABLE = 48, /* Enables range-based fog */
+ D3DRS_STENCILENABLE = 52, /* BOOL enable/disable stenciling */
+ D3DRS_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil test fails */
+ D3DRS_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil test passes and Z test fails */
+ D3DRS_STENCILPASS = 55, /* D3DSTENCILOP to do if both stencil and Z tests pass */
+ D3DRS_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
+ D3DRS_STENCILREF = 57, /* Reference value used in stencil test */
+ D3DRS_STENCILMASK = 58, /* Mask value used in stencil test */
+ D3DRS_STENCILWRITEMASK = 59, /* Write mask applied to values written to stencil buffer */
+ D3DRS_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture blend */
+ D3DRS_WRAP0 = 128, /* wrap for 1st texture coord. set */
+ D3DRS_WRAP1 = 129, /* wrap for 2nd texture coord. set */
+ D3DRS_WRAP2 = 130, /* wrap for 3rd texture coord. set */
+ D3DRS_WRAP3 = 131, /* wrap for 4th texture coord. set */
+ D3DRS_WRAP4 = 132, /* wrap for 5th texture coord. set */
+ D3DRS_WRAP5 = 133, /* wrap for 6th texture coord. set */
+ D3DRS_WRAP6 = 134, /* wrap for 7th texture coord. set */
+ D3DRS_WRAP7 = 135, /* wrap for 8th texture coord. set */
+ D3DRS_CLIPPING = 136,
+ D3DRS_LIGHTING = 137,
+ D3DRS_AMBIENT = 139,
+ D3DRS_FOGVERTEXMODE = 140,
+ D3DRS_COLORVERTEX = 141,
+ D3DRS_LOCALVIEWER = 142,
+ D3DRS_NORMALIZENORMALS = 143,
+ D3DRS_DIFFUSEMATERIALSOURCE = 145,
+ D3DRS_SPECULARMATERIALSOURCE = 146,
+ D3DRS_AMBIENTMATERIALSOURCE = 147,
+ D3DRS_EMISSIVEMATERIALSOURCE = 148,
+ D3DRS_VERTEXBLEND = 151,
+ D3DRS_CLIPPLANEENABLE = 152,
+ D3DRS_POINTSIZE = 154, /* float point size */
+ D3DRS_POINTSIZE_MIN = 155, /* float point size min threshold */
+ D3DRS_POINTSPRITEENABLE = 156, /* BOOL point texture coord control */
+ D3DRS_POINTSCALEENABLE = 157, /* BOOL point size scale enable */
+ D3DRS_POINTSCALE_A = 158, /* float point attenuation A value */
+ D3DRS_POINTSCALE_B = 159, /* float point attenuation B value */
+ D3DRS_POINTSCALE_C = 160, /* float point attenuation C value */
+ D3DRS_MULTISAMPLEANTIALIAS = 161, // BOOL - set to do FSAA with multisample buffer
+ D3DRS_MULTISAMPLEMASK = 162, // DWORD - per-sample enable/disable
+ D3DRS_PATCHEDGESTYLE = 163, // Sets whether patch edges will use float style tessellation
+ D3DRS_DEBUGMONITORTOKEN = 165, // DEBUG ONLY - token to debug monitor
+ D3DRS_POINTSIZE_MAX = 166, /* float point size max threshold */
+ D3DRS_INDEXEDVERTEXBLENDENABLE = 167,
+ D3DRS_COLORWRITEENABLE = 168, // per-channel write enable
+ D3DRS_TWEENFACTOR = 170, // float tween factor
+ D3DRS_BLENDOP = 171, // D3DBLENDOP setting
+ D3DRS_POSITIONDEGREE = 172, // NPatch position interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
+ D3DRS_NORMALDEGREE = 173, // NPatch normal interpolation degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
+ D3DRS_SCISSORTESTENABLE = 174,
+ D3DRS_SLOPESCALEDEPTHBIAS = 175,
+ D3DRS_ANTIALIASEDLINEENABLE = 176,
+ D3DRS_MINTESSELLATIONLEVEL = 178,
+ D3DRS_MAXTESSELLATIONLEVEL = 179,
+ D3DRS_ADAPTIVETESS_X = 180,
+ D3DRS_ADAPTIVETESS_Y = 181,
+ D3DRS_ADAPTIVETESS_Z = 182,
+ D3DRS_ADAPTIVETESS_W = 183,
+ D3DRS_ENABLEADAPTIVETESSELLATION = 184,
+ D3DRS_TWOSIDEDSTENCILMODE = 185, /* BOOL enable/disable 2 sided stenciling */
+ D3DRS_CCW_STENCILFAIL = 186, /* D3DSTENCILOP to do if ccw stencil test fails */
+ D3DRS_CCW_STENCILZFAIL = 187, /* D3DSTENCILOP to do if ccw stencil test passes and Z test fails */
+ D3DRS_CCW_STENCILPASS = 188, /* D3DSTENCILOP to do if both ccw stencil and Z tests pass */
+ D3DRS_CCW_STENCILFUNC = 189, /* D3DCMPFUNC fn. ccw Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
+ D3DRS_COLORWRITEENABLE1 = 190, /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
+ D3DRS_COLORWRITEENABLE2 = 191, /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
+ D3DRS_COLORWRITEENABLE3 = 192, /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
+ D3DRS_BLENDFACTOR = 193, /* D3DCOLOR used for a constant blend factor during alpha blending for devices that support D3DPBLENDCAPS_BLENDFACTOR */
+ D3DRS_SRGBWRITEENABLE = 194, /* Enable rendertarget writes to be DE-linearized to SRGB (for formats that expose D3DUSAGE_QUERY_SRGBWRITE) */
+ D3DRS_DEPTHBIAS = 195,
+ D3DRS_WRAP8 = 198, /* Additional wrap states for vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD */
+ D3DRS_WRAP9 = 199,
+ D3DRS_WRAP10 = 200,
+ D3DRS_WRAP11 = 201,
+ D3DRS_WRAP12 = 202,
+ D3DRS_WRAP13 = 203,
+ D3DRS_WRAP14 = 204,
+ D3DRS_WRAP15 = 205,
+ D3DRS_SEPARATEALPHABLENDENABLE = 206, /* TRUE to enable a separate blending function for the alpha channel */
+ D3DRS_SRCBLENDALPHA = 207, /* SRC blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
+ D3DRS_DESTBLENDALPHA = 208, /* DST blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
+ D3DRS_BLENDOPALPHA = 209, /* Blending operation for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
+
+
+ D3DRS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DRENDERSTATETYPE;
+
+typedef enum _D3DCULL
+{
+ D3DCULL_NONE = 1,
+ D3DCULL_CW = 2,
+ D3DCULL_CCW = 3,
+ D3DCULL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DCULL;
+
+typedef enum _D3DTEXTUREFILTERTYPE
+{
+ D3DTEXF_NONE = 0, // filtering disabled (valid for mip filter only)
+ D3DTEXF_POINT = 1, // nearest
+ D3DTEXF_LINEAR = 2, // linear interpolation
+ D3DTEXF_ANISOTROPIC = 3, // anisotropic
+ D3DTEXF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DTEXTUREFILTERTYPE;
+
+typedef enum _D3DBACKBUFFER_TYPE
+{
+ D3DBACKBUFFER_TYPE_MONO = 0,
+
+ D3DBACKBUFFER_TYPE_FORCE_DWORD = 0x7fffffff
+} D3DBACKBUFFER_TYPE;
+
+#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
+#define D3DTS_WORLD D3DTS_WORLDMATRIX(0)
+#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
+#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
+#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)
+
+typedef enum _D3DCMPFUNC
+{
+ D3DCMP_NEVER = 1,
+ D3DCMP_LESS = 2,
+ D3DCMP_EQUAL = 3,
+ D3DCMP_LESSEQUAL = 4,
+ D3DCMP_GREATER = 5,
+ D3DCMP_NOTEQUAL = 6,
+ D3DCMP_GREATEREQUAL = 7,
+ D3DCMP_ALWAYS = 8,
+ D3DCMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DCMPFUNC;
+
+typedef enum _D3DZBUFFERTYPE
+{
+ D3DZB_FALSE = 0,
+ D3DZB_TRUE = 1, // Z buffering
+ D3DZB_USEW = 2, // W buffering
+ D3DZB_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DZBUFFERTYPE;
+
+typedef enum _D3DFILLMODE
+{
+ D3DFILL_POINT = 1,
+ D3DFILL_WIREFRAME = 2,
+ D3DFILL_SOLID = 3,
+ D3DFILL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DFILLMODE;
+
+typedef enum _D3DBLEND
+{
+ D3DBLEND_ZERO = 1,
+ D3DBLEND_ONE = 2,
+ D3DBLEND_SRCCOLOR = 3,
+ D3DBLEND_INVSRCCOLOR = 4,
+ D3DBLEND_SRCALPHA = 5,
+ D3DBLEND_INVSRCALPHA = 6,
+ D3DBLEND_DESTALPHA = 7,
+ D3DBLEND_INVDESTALPHA = 8,
+ D3DBLEND_DESTCOLOR = 9,
+ D3DBLEND_INVDESTCOLOR = 10,
+ D3DBLEND_SRCALPHASAT = 11,
+ D3DBLEND_BOTHSRCALPHA = 12,
+ D3DBLEND_BOTHINVSRCALPHA = 13,
+ D3DBLEND_BLENDFACTOR = 14, /* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on */
+ D3DBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DBLEND;
+
+// Values for material source
+typedef enum _D3DMATERIALCOLORSOURCE
+{
+ D3DMCS_MATERIAL = 0, // Color from material is used
+ D3DMCS_COLOR1 = 1, // Diffuse vertex color is used
+ D3DMCS_COLOR2 = 2, // Specular vertex color is used
+ D3DMCS_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DMATERIALCOLORSOURCE;
+
+typedef enum _D3DCUBEMAP_FACES
+{
+ D3DCUBEMAP_FACE_POSITIVE_Z = 4,
+
+ D3DCUBEMAP_FACE_FORCE_DWORD = 0x7fffffff
+} D3DCUBEMAP_FACES;
+
+typedef enum _D3DTEXTURETRANSFORMFLAGS
+{
+ D3DTTFF_DISABLE = 0, // texture coordinates are passed directly
+ D3DTTFF_COUNT3 = 3, // rasterizer should expect 3-D texture coords
+ D3DTTFF_PROJECTED = 256, // texcoords to be divided by COUNTth element
+ D3DTTFF_FORCE_DWORD = 0x7fffffff,
+} D3DTEXTURETRANSFORMFLAGS;
+
+typedef enum _D3DTEXTUREADDRESS
+{
+ D3DTADDRESS_WRAP = 0,
+ D3DTADDRESS_CLAMP = 1,
+ D3DTADDRESS_BORDER = 2,
+ D3DTADDRESS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTUREADDRESS;
+
+typedef enum _D3DSHADEMODE
+{
+ D3DSHADE_FLAT = 1,
+ D3DSHADE_GOURAUD = 2,
+ D3DSHADE_PHONG = 3,
+ D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DSHADEMODE;
+
+typedef enum _D3DFOGMODE
+{
+ D3DFOG_NONE = 0,
+ D3DFOG_LINEAR = 3,
+ D3DFOG_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DFOGMODE;
+
+typedef struct _D3DRECT
+{
+ LONG x1;
+ LONG y1;
+ LONG x2;
+ LONG y2;
+} D3DRECT;
+
+typedef enum _D3DSHADER_PARAM_REGISTER_TYPE
+{
+ D3DSPR_TEMP = 0, // Temporary Register File
+ D3DSPR_INPUT = 1, // Input Register File
+ D3DSPR_CONST = 2, // Constant Register File
+ D3DSPR_ADDR = 3, // Address Register (VS)
+ D3DSPR_TEXTURE = 3, // Texture Register File (PS)
+ D3DSPR_RASTOUT = 4, // Rasterizer Register File
+ D3DSPR_ATTROUT = 5, // Attribute Output Register File
+ D3DSPR_TEXCRDOUT = 6, // Texture Coordinate Output Register File
+ D3DSPR_OUTPUT = 6, // Output register file for VS3.0+
+ D3DSPR_CONSTINT = 7, // Constant Integer Vector Register File
+ D3DSPR_COLOROUT = 8, // Color Output Register File
+ D3DSPR_DEPTHOUT = 9, // Depth Output Register File
+ D3DSPR_SAMPLER = 10, // Sampler State Register File
+ D3DSPR_CONST2 = 11, // Constant Register File 2048 - 4095
+ D3DSPR_CONST3 = 12, // Constant Register File 4096 - 6143
+ D3DSPR_CONST4 = 13, // Constant Register File 6144 - 8191
+ D3DSPR_CONSTBOOL = 14, // Constant Boolean register file
+ D3DSPR_LOOP = 15, // Loop counter register file
+ D3DSPR_TEMPFLOAT16 = 16, // 16-bit float temp register file
+ D3DSPR_MISCTYPE = 17, // Miscellaneous (single) registers.
+ D3DSPR_LABEL = 18, // Label
+ D3DSPR_PREDICATE = 19, // Predicate register
+ D3DSPR_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSHADER_PARAM_REGISTER_TYPE;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
+#endif
+
+typedef struct _D3DMATRIX
+{
+ union
+ {
+ struct
+ {
+ float _11, _12, _13, _14;
+ float _21, _22, _23, _24;
+ float _31, _32, _33, _34;
+ float _41, _42, _43, _44;
+ };
+ float m[4][4];
+ };
+} D3DMATRIX;
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+typedef struct _D3DVERTEXBUFFER_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+ UINT Size;
+
+ DWORD FVF;
+
+} D3DVERTEXBUFFER_DESC;
+
+class TOGL_CLASS D3DXMATRIX : public D3DMATRIX
+{
+public:
+ D3DXMATRIX operator*( const D3DXMATRIX &o ) const;
+ operator FLOAT* ();
+ float& operator()( int row, int column );
+ const float& operator()( int row, int column ) const;
+};
+
+typedef DWORD D3DCOLOR;
+
+typedef enum _D3DSAMPLERSTATETYPE
+{
+ D3DSAMP_ADDRESSU = 1, /* D3DTEXTUREADDRESS for U coordinate */
+ D3DSAMP_ADDRESSV = 2, /* D3DTEXTUREADDRESS for V coordinate */
+ D3DSAMP_ADDRESSW = 3, /* D3DTEXTUREADDRESS for W coordinate */
+ D3DSAMP_BORDERCOLOR = 4, /* D3DCOLOR */
+ D3DSAMP_MAGFILTER = 5, /* D3DTEXTUREFILTER filter to use for magnification */
+ D3DSAMP_MINFILTER = 6, /* D3DTEXTUREFILTER filter to use for minification */
+ D3DSAMP_MIPFILTER = 7, /* D3DTEXTUREFILTER filter to use between mipmaps during minification */
+ D3DSAMP_MIPMAPLODBIAS = 8, /* float Mipmap LOD bias */
+ D3DSAMP_MAXMIPLEVEL = 9, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */
+ D3DSAMP_MAXANISOTROPY = 10, /* DWORD maximum anisotropy */
+ D3DSAMP_SRGBTEXTURE = 11, /* Default = 0 (which means Gamma 1.0,
+ no correction required.) else correct for
+ Gamma = 2.2 */
+ D3DSAMP_SHADOWFILTER = 12, /* Tells the sampler that it should be doing shadow compares */
+ D3DSAMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DSAMPLERSTATETYPE;
+
+typedef enum _D3DDECLTYPE
+{
+ D3DDECLTYPE_FLOAT1 = 0, // 1D float expanded to (value, 0., 0., 1.)
+ D3DDECLTYPE_FLOAT2 = 1, // 2D float expanded to (value, value, 0., 1.)
+ D3DDECLTYPE_FLOAT3 = 2, // 3D float expanded to (value, value, value, 1.)
+ D3DDECLTYPE_FLOAT4 = 3, // 4D float
+ D3DDECLTYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. range
+ // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
+ D3DDECLTYPE_UBYTE4 = 5, // 4D unsigned byte
+ D3DDECLTYPE_SHORT2 = 6, // 2D signed short expanded to (value, value, 0., 1.)
+ D3DDECLTYPE_SHORT4 = 7, // 4D signed short
+
+// The following types are valid only with vertex shaders >= 2.0
+
+
+ D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to 255.0
+ D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
+ D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
+ D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
+ D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
+ D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
+ D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
+ D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
+ D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values
+ D3DDECLTYPE_UNUSED = 17, // When the type field in a decl is unused.
+} D3DDECLTYPE;
+
+typedef enum _D3DDECLMETHOD
+{
+ D3DDECLMETHOD_DEFAULT = 0,
+ D3DDECLMETHOD_PARTIALU,
+ D3DDECLMETHOD_PARTIALV,
+ D3DDECLMETHOD_CROSSUV, // Normal
+ D3DDECLMETHOD_UV,
+ D3DDECLMETHOD_LOOKUP, // Lookup a displacement map
+ D3DDECLMETHOD_LOOKUPPRESAMPLED, // Lookup a pre-sampled displacement map
+} D3DDECLMETHOD;
+
+typedef enum _D3DDECLUSAGE
+{
+ D3DDECLUSAGE_POSITION = 0,
+ D3DDECLUSAGE_BLENDWEIGHT = 1,
+ D3DDECLUSAGE_BLENDINDICES = 2,
+ D3DDECLUSAGE_NORMAL = 3,
+ D3DDECLUSAGE_PSIZE = 4,
+ D3DDECLUSAGE_TEXCOORD = 5,
+ D3DDECLUSAGE_TANGENT = 6,
+ D3DDECLUSAGE_BINORMAL = 7,
+ D3DDECLUSAGE_TESSFACTOR = 8,
+ D3DDECLUSAGE_PLUGH = 9, // mystery value
+ D3DDECLUSAGE_COLOR = 10,
+ D3DDECLUSAGE_FOG = 11,
+ D3DDECLUSAGE_DEPTH = 12,
+ D3DDECLUSAGE_SAMPLE = 13,
+} D3DDECLUSAGE;
+
+typedef enum _D3DPRIMITIVETYPE
+{
+ D3DPT_POINTLIST = 1,
+ D3DPT_LINELIST = 2,
+ D3DPT_TRIANGLELIST = 4,
+ D3DPT_TRIANGLESTRIP = 5,
+ D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DPRIMITIVETYPE;
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// STRUCTURES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+typedef struct TOGL_CLASS D3DXPLANE
+{
+ float& operator[]( int i );
+ bool operator==( const D3DXPLANE &o );
+ bool operator!=( const D3DXPLANE &o );
+ operator float*();
+ operator const float*() const;
+
+ float a, b, c, d;
+} D3DXPLANE;
+
+typedef enum _D3DVERTEXBLENDFLAGS
+{
+ D3DVBF_DISABLE = 0, // Disable vertex blending
+ D3DVBF_1WEIGHTS = 1, // 2 matrix blending
+ D3DVBF_2WEIGHTS = 2, // 3 matrix blending
+ D3DVBF_3WEIGHTS = 3, // 4 matrix blending
+ D3DVBF_TWEENING = 255, // blending using D3DRS_TWEENFACTOR
+ D3DVBF_0WEIGHTS = 256, // one matrix is used with weight 1.0
+ D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DVERTEXBLENDFLAGS;
+
+typedef struct _D3DINDEXBUFFER_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+ UINT Size;
+} D3DINDEXBUFFER_DESC;
+
+typedef struct _D3DVERTEXELEMENT9
+{
+ WORD Stream; // Stream index
+ WORD Offset; // Offset in the stream in bytes
+ BYTE Type; // Data type
+ BYTE Method; // Processing method
+ BYTE Usage; // Semantics
+ BYTE UsageIndex; // Semantic index
+} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;
+
+
+#define MAX_DEVICE_IDENTIFIER_STRING 512
+typedef struct _D3DADAPTER_IDENTIFIER9
+{
+ char Driver[MAX_DEVICE_IDENTIFIER_STRING];
+ char Description[MAX_DEVICE_IDENTIFIER_STRING];
+ char DeviceName[32]; /* Device name for GDI (ex. \\.\DISPLAY1) */
+
+ LARGE_INTEGER DriverVersion; /* Defined for 32 bit components */
+
+ DWORD VendorId;
+ DWORD DeviceId;
+ DWORD SubSysId;
+ DWORD Revision;
+ DWORD VideoMemory;
+
+} D3DADAPTER_IDENTIFIER9;
+
+typedef struct _D3DCOLORVALUE
+{
+ float r;
+ float g;
+ float b;
+ float a;
+} D3DCOLORVALUE;
+
+typedef struct _D3DMATERIAL9
+{
+ D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */
+ D3DCOLORVALUE Ambient; /* Ambient color RGB */
+ D3DCOLORVALUE Specular; /* Specular 'shininess' */
+ D3DCOLORVALUE Emissive; /* Emissive color RGB */
+ float Power; /* Sharpness if specular highlight */
+} D3DMATERIAL9;
+
+typedef struct _D3DVOLUME_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+
+ UINT Width;
+ UINT Height;
+ UINT Depth;
+} D3DVOLUME_DESC;
+
+typedef struct _D3DVIEWPORT9
+{
+ DWORD X;
+ DWORD Y; /* Viewport Top left */
+ DWORD Width;
+ DWORD Height; /* Viewport Dimensions */
+ float MinZ; /* Min/max of clip Volume */
+ float MaxZ;
+} D3DVIEWPORT9;
+
+typedef struct _D3DPSHADERCAPS2_0
+{
+ DWORD Caps;
+ INT DynamicFlowControlDepth;
+ INT NumTemps;
+ INT StaticFlowControlDepth;
+ INT NumInstructionSlots;
+} D3DPSHADERCAPS2_0;
+
+typedef struct _D3DCAPS9
+{
+ /* Device Info */
+ D3DDEVTYPE DeviceType;
+
+ /* Caps from DX7 Draw */
+ DWORD Caps;
+ DWORD Caps2;
+
+ /* Cursor Caps */
+ DWORD CursorCaps;
+
+ /* 3D Device Caps */
+ DWORD DevCaps;
+
+ DWORD PrimitiveMiscCaps;
+ DWORD RasterCaps;
+ DWORD TextureCaps;
+ DWORD TextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9's
+
+ DWORD MaxTextureWidth, MaxTextureHeight;
+ DWORD MaxVolumeExtent;
+
+ DWORD MaxTextureAspectRatio;
+ DWORD MaxAnisotropy;
+
+ DWORD TextureOpCaps;
+ DWORD MaxTextureBlendStages;
+ DWORD MaxSimultaneousTextures;
+
+ DWORD VertexProcessingCaps;
+ DWORD MaxActiveLights;
+ DWORD MaxUserClipPlanes;
+ DWORD MaxVertexBlendMatrices;
+ DWORD MaxVertexBlendMatrixIndex;
+
+ DWORD MaxPrimitiveCount; // max number of primitives per DrawPrimitive call
+ DWORD MaxStreams;
+
+ DWORD VertexShaderVersion;
+ DWORD MaxVertexShaderConst; // number of vertex shader constant registers
+
+ DWORD PixelShaderVersion;
+
+ // Here are the DX9 specific ones
+ DWORD DevCaps2;
+ D3DPSHADERCAPS2_0 PS20Caps;
+
+ DWORD NumSimultaneousRTs; // Will be at least 1
+ DWORD MaxVertexShader30InstructionSlots;
+ DWORD MaxPixelShader30InstructionSlots;
+
+ // only on Posix/GL
+ DWORD FakeSRGBWrite; // 1 for parts which can't support SRGB writes due to driver issues - 0 for others
+ DWORD MixedSizeTargets; // 1 for parts which can mix attachment sizes (RT's color vs depth)
+ DWORD CanDoSRGBReadFromRTs; // 0 when we're on Leopard, 1 when on Snow Leopard
+} D3DCAPS9;
+
+typedef struct _D3DDISPLAYMODE
+{
+ UINT Width;
+ UINT Height;
+ UINT RefreshRate;
+ D3DFORMAT Format;
+} D3DDISPLAYMODE;
+
+typedef struct _D3DGAMMARAMP
+{
+ WORD red [256];
+ WORD green[256];
+ WORD blue [256];
+} D3DGAMMARAMP;
+
+
+/* Resize Optional Parameters */
+typedef struct _D3DPRESENT_PARAMETERS_
+{
+ UINT BackBufferWidth;
+ UINT BackBufferHeight;
+ D3DFORMAT BackBufferFormat;
+ UINT BackBufferCount;
+
+ D3DMULTISAMPLE_TYPE MultiSampleType;
+ DWORD MultiSampleQuality;
+
+ D3DSWAPEFFECT SwapEffect;
+ VD3DHWND hDeviceWindow;
+ BOOL Windowed;
+ BOOL EnableAutoDepthStencil;
+ D3DFORMAT AutoDepthStencilFormat;
+ DWORD Flags;
+
+ /* FullScreen_RefreshRateInHz must be zero for Windowed mode */
+ UINT FullScreen_RefreshRateInHz;
+ UINT PresentationInterval;
+} D3DPRESENT_PARAMETERS;
+
+typedef struct _D3DDEVICE_CREATION_PARAMETERS
+{
+ UINT AdapterOrdinal;
+ D3DDEVTYPE DeviceType;
+ VD3DHWND hFocusWindow;
+ DWORD BehaviorFlags;
+} D3DDEVICE_CREATION_PARAMETERS;
+
+/* Structures for LockBox */
+typedef struct _D3DBOX
+{
+ UINT Left;
+ UINT Top;
+ UINT Right;
+ UINT Bottom;
+ UINT Front;
+ UINT Back;
+} D3DBOX;
+
+typedef struct _D3DLOCKED_BOX
+{
+ INT RowPitch;
+ INT SlicePitch;
+ void* pBits;
+} D3DLOCKED_BOX;
+
+typedef struct _D3DSURFACE_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+
+ D3DMULTISAMPLE_TYPE MultiSampleType;
+ DWORD MultiSampleQuality;
+ UINT Width;
+ UINT Height;
+} D3DSURFACE_DESC;
+
+
+typedef struct _D3DLOCKED_RECT
+{
+ INT Pitch;
+ void* pBits;
+} D3DLOCKED_RECT;
+
+
+typedef struct _D3DRASTER_STATUS
+{
+ BOOL InVBlank;
+ UINT ScanLine;
+} D3DRASTER_STATUS;
+
+typedef enum _D3DLIGHTTYPE
+{
+ D3DLIGHT_POINT = 1,
+ D3DLIGHT_SPOT = 2,
+ D3DLIGHT_DIRECTIONAL = 3,
+ D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DLIGHTTYPE;
+
+typedef struct TOGL_CLASS _D3DVECTOR
+{
+ float x;
+ float y;
+ float z;
+} D3DVECTOR;
+
+class TOGL_CLASS D3DXVECTOR2
+{
+public:
+ operator FLOAT* ();
+ operator CONST FLOAT* () const;
+
+ float x,y;
+};
+
+class TOGL_CLASS D3DXVECTOR3 : public D3DVECTOR
+{
+public:
+ D3DXVECTOR3() {}
+ D3DXVECTOR3( float a, float b, float c );
+ operator FLOAT* ();
+ operator CONST FLOAT* () const;
+};
+
+typedef enum _D3DXINCLUDE_TYPE
+{
+ D3DXINC_LOCAL,
+
+ // force 32-bit size enum
+ D3DXINC_FORCE_DWORD = 0x7fffffff
+
+} D3DXINCLUDE_TYPE;
+
+typedef struct _D3DLIGHT9
+{
+ D3DLIGHTTYPE Type; /* Type of light source */
+ D3DCOLORVALUE Diffuse; /* Diffuse color of light */
+ D3DCOLORVALUE Specular; /* Specular color of light */
+ D3DCOLORVALUE Ambient; /* Ambient color of light */
+ D3DVECTOR Position; /* Position in world space */
+ D3DVECTOR Direction; /* Direction in world space */
+ float Range; /* Cutoff range */
+ float Falloff; /* Falloff */
+ float Attenuation0; /* Constant attenuation */
+ float Attenuation1; /* Linear attenuation */
+ float Attenuation2; /* Quadratic attenuation */
+ float Theta; /* Inner angle of spotlight cone */
+ float Phi; /* Outer angle of spotlight cone */
+} D3DLIGHT9;
+
+class TOGL_CLASS D3DXVECTOR4
+{
+public:
+ D3DXVECTOR4() {}
+ D3DXVECTOR4( float a, float b, float c, float d );
+
+ float x,y,z,w;
+};
+
+//----------------------------------------------------------------------------
+// D3DXMACRO:
+// ----------
+// Preprocessor macro definition. The application pass in a NULL-terminated
+// array of this structure to various D3DX APIs. This enables the application
+// to #define tokens at runtime, before the file is parsed.
+//----------------------------------------------------------------------------
+
+typedef struct _D3DXMACRO
+{
+ LPCSTR Name;
+ LPCSTR Definition;
+
+} D3DXMACRO, *LPD3DXMACRO;
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+//
+// Also look for any functions marked with "**** FIXED FUNCTION STUFF"
+//
+// It's only laying around here so we don't have to chop up the shader system a lot to strip out the fixed function code paths.
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+typedef enum _D3DTRANSFORMSTATETYPE
+{
+ D3DTS_VIEW = 2,
+ D3DTS_PROJECTION = 3,
+ D3DTS_TEXTURE0 = 16,
+ D3DTS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DTRANSFORMSTATETYPE;
+
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+typedef enum _D3DTEXTUREOP
+{
+ // Control
+ D3DTOP_DISABLE = 1, // disables stage
+ D3DTOP_SELECTARG1 = 2, // the default
+ D3DTOP_SELECTARG2 = 3,
+
+ // Modulate
+ D3DTOP_MODULATE = 4, // multiply args together
+ D3DTOP_MODULATE2X = 5, // multiply and 1 bit
+ D3DTOP_MODULATE4X = 6, // multiply and 2 bits
+
+ // Add
+ D3DTOP_ADD = 7, // add arguments together
+ D3DTOP_ADDSIGNED = 8, // add with -0.5 bias
+ D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit
+ D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation
+ D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product
+ // Arg1 + Arg2 - Arg1*Arg2
+ // = Arg1 + (1-Arg1)*Arg2
+
+ // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
+ D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha
+ D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha
+ D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRS_TEXTUREFACTOR
+
+ // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
+ D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha
+ D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color
+
+ // Specular mapping
+ D3DTOP_PREMODULATE = 17, // modulate with next texture before use
+ D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB
+ // COLOROP only
+ D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A
+ // COLOROP only
+ D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB
+ // COLOROP only
+ D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A
+ // COLOROP only
+
+ // Bump mapping
+ D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation
+ D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel
+
+ // This can do either diffuse or specular bump mapping with correct input.
+ // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B)
+ // where each component has been scaled and offset to make it signed.
+ // The result is replicated into all four (including alpha) channels.
+ // This is a valid COLOROP only.
+ D3DTOP_DOTPRODUCT3 = 24,
+
+ // Triadic ops
+ D3DTOP_MULTIPLYADD = 25, // Arg0 + Arg1*Arg2
+ D3DTOP_LERP = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2
+
+ D3DTOP_FORCE_DWORD = 0x7fffffff,
+} D3DTEXTUREOP;
+
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+typedef enum _D3DTEXTURESTAGESTATETYPE
+{
+ D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */
+ D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */
+ D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */
+ D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */
+ D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */
+ D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */
+ D3DTSS_BUMPENVMAT00 = 7, /* float (bump mapping matrix) */
+ D3DTSS_BUMPENVMAT01 = 8, /* float (bump mapping matrix) */
+ D3DTSS_BUMPENVMAT10 = 9, /* float (bump mapping matrix) */
+ D3DTSS_BUMPENVMAT11 = 10, /* float (bump mapping matrix) */
+ D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */
+ D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */
+ D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */
+ D3DTSS_COLORARG0 = 26, /* D3DTA_* third arg for triadic ops */
+ D3DTSS_RESULTARG = 28, /* D3DTA_* arg for result (CURRENT or TEMP) */
+
+
+ D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTURESTAGESTATETYPE;
+
+//===========================================================================//
+
+enum GLMVertexAttributeIndex
+{
+ kGLMGenericAttr00 = 0,
+ kGLMGenericAttr01,
+ kGLMGenericAttr02,
+ kGLMGenericAttr03,
+ kGLMGenericAttr04,
+ kGLMGenericAttr05,
+ kGLMGenericAttr06,
+ kGLMGenericAttr07,
+ kGLMGenericAttr08,
+ kGLMGenericAttr09,
+ kGLMGenericAttr10,
+ kGLMGenericAttr11,
+ kGLMGenericAttr12,
+ kGLMGenericAttr13,
+ kGLMGenericAttr14,
+ kGLMGenericAttr15,
+
+ kGLMVertexAttributeIndexMax // ideally < 32
+};
+
+struct GLMVertexAttributeDesc // all the info you need to do vertex setup for one attribute
+{
+ CGLMBuffer *m_pBuffer; // NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired
+ GLuint m_nCompCount; // comp count of the attribute (1-4)
+ GLenum m_datatype; // data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)
+ GLuint m_stride;
+ GLuint m_offset; // net offset to attribute 'zero' within the buffer.
+ GLuint m_streamOffset; // net offset to attribute 'zero' within the buffer.
+ GLboolean m_normalized; // apply to any fixed point data that needs normalizing, esp color bytes
+
+ inline uint GetDataTypeSizeInBytes() const
+ {
+ switch ( m_datatype )
+ {
+ case GL_BYTE:
+ case GL_UNSIGNED_BYTE:
+ return 1;
+ case GL_SHORT:
+ case GL_UNSIGNED_SHORT:
+ case GL_HALF_FLOAT:
+ return 2;
+ case GL_INT:
+ case GL_FLOAT:
+ return 4;
+ default:
+ Assert( 0 );
+ break;
+ }
+ return 0;
+ }
+
+ inline uint GetTotalAttributeSizeInBytes() const { Assert( m_nCompCount ); return m_nCompCount * GetDataTypeSizeInBytes(); }
+
+ // may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer
+ // simpler alternative is to do shoot-down inside the vertex/index buffer free calls.
+ // I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..
+
+//#define EQ(fff) ( (src.fff) == (fff) )
+ // test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..
+ //inline bool operator== ( const GLMVertexAttributeDesc& src ) const { return EQ( m_pBuffer ) && EQ( m_offset ) && EQ( m_stride ) && EQ( m_datatype ) && EQ( m_normalized ) && EQ( m_nCompCount ); }
+//#undef EQ
+
+ uint m_bufferRevision; // only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event
+};
+
+#define MAX_D3DVERTEXELEMENTS 16
+
+struct D3DVERTEXELEMENT9_GL
+{
+ // fields right out of the original decl element (copied)
+ D3DVERTEXELEMENT9 m_dxdecl; // d3d info
+ // WORD Stream; // Stream index
+ // WORD Offset; // Offset in the stream in bytes
+ // BYTE Type; // Data type
+ // BYTE Method; // Processing method
+ // BYTE Usage; // Semantics
+ // BYTE UsageIndex; // Semantic index
+
+ GLMVertexAttributeDesc m_gldecl;
+ // CGLMBuffer *m_buffer; // late-dropped from selected stream desc (left NULL, will replace with stream source buffer at sync time)
+ // GLuint m_datasize; // component count (1,2,3,4) of the attrib
+ // GLenum m_datatype; // data type of the attribute (GL_FLOAT et al)
+ // GLuint m_stride; // late-dropped from stream desc
+ // GLuint m_offset; // net offset to attribute 'zero' within the stream data. Add the stream offset before passing to GL.
+ // GLuint m_normalized; // net offset to attribute 'zero' within the stream data. Add the stream offset before passing to GL.
+};
+
+struct IDirect3DDevice9Params
+{
+ UINT m_adapter;
+ D3DDEVTYPE m_deviceType;
+ VD3DHWND m_focusWindow;
+ DWORD m_behaviorFlags;
+ D3DPRESENT_PARAMETERS m_presentationParameters;
+};
+
+#define D3D_MAX_STREAMS 4
+struct D3DStreamDesc
+{
+ IDirect3DVertexBuffer9 *m_vtxBuffer;
+ uint m_offset;
+ uint m_stride;
+};
+
+struct D3DIndexDesc
+{
+ IDirect3DIndexBuffer9 *m_idxBuffer;
+};
+
+// we latch sampler values until draw time and then convert them all to GL form
+// note these are similar in name to the fields of a GLMTexSamplingParams but contents are not
+// particularly in the texture filtering area
+
+struct D3DSamplerDesc
+{
+ DWORD m_srgb; // D3DSAMP_SRGBTEXTURE 0 = no SRGB sampling
+};
+
+// Tracking and naming sampler dimensions
+#define SAMPLER_TYPE_2D 0
+#define SAMPLER_TYPE_CUBE 1
+#define SAMPLER_TYPE_3D 2
+#define SAMPLER_TYPE_UNUSED 3
+
+#endif // DXABSTRACT_TYPES_H
diff --git a/mp/src/public/togl/linuxwin/glbase.h b/mp/src/public/togl/linuxwin/glbase.h new file mode 100644 index 00000000..445d3665 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glbase.h @@ -0,0 +1,104 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glbase.h
+//
+//===============================================================================
+
+#ifndef GLBASE_H
+#define GLBASE_H
+
+#ifdef DX_TO_GL_ABSTRACTION
+
+#undef HAVE_GL_ARB_SYNC
+
+#ifndef OSX
+ #define HAVE_GL_ARB_SYNC 1
+#endif
+
+#ifdef OSX
+ #include <OpenGL/OpenGL.h>
+ #include <OpenGL/gl.h>
+ #include <OpenGL/glext.h>
+ #include <OpenGL/CGLTypes.h>
+ #include <OpenGL/CGLRenderers.h>
+ #include <OpenGL/CGLCurrent.h>
+ #include <OpenGL/CGLProfiler.h>
+ #include <ApplicationServices/ApplicationServices.h>
+#elif defined(DX_TO_GL_ABSTRACTION)
+ #include <GL/gl.h>
+ #include <GL/glext.h>
+#else
+ #error
+#endif
+
+#ifdef DX_TO_GL_ABSTRACTION
+ #ifndef WIN32
+ #define Debugger DebuggerBreak
+ #endif
+ #undef CurrentTime
+
+ // prevent some conflicts in SDL headers...
+ #undef M_PI
+ #include <stdint.h>
+ #ifndef _STDINT_H_
+ #define _STDINT_H_ 1
+ #endif
+#endif
+
+//===============================================================================
+// glue to call out to Obj-C land (these are in glmgrcocoa.mm)
+#ifdef OSX
+ bool NewNSGLContext( unsigned long *attribs, PseudoNSGLContextPtr nsglShareCtx, PseudoNSGLContextPtr *nsglCtxOut, CGLContextObj *cglCtxOut );
+ CGLContextObj GetCGLContextFromNSGL( PseudoNSGLContextPtr nsglCtx );
+ void DelNSGLContext( PseudoNSGLContextPtr nsglCtx );
+#endif
+
+// Set TOGL_SUPPORT_NULL_DEVICE to 1 to support the NULL ref device
+#define TOGL_SUPPORT_NULL_DEVICE 0
+
+#if TOGL_SUPPORT_NULL_DEVICE
+ #define TOGL_NULL_DEVICE_CHECK if( m_params.m_deviceType == D3DDEVTYPE_NULLREF ) return S_OK;
+ #define TOGL_NULL_DEVICE_CHECK_RET_VOID if( m_params.m_deviceType == D3DDEVTYPE_NULLREF ) return;
+#else
+ #define TOGL_NULL_DEVICE_CHECK
+ #define TOGL_NULL_DEVICE_CHECK_RET_VOID
+#endif
+
+// GL_ENABLE_INDEX_VERIFICATION enables index range verification on all dynamic IB/VB's (obviously slow)
+#define GL_ENABLE_INDEX_VERIFICATION 0
+
+// GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION (currently win32 only) - If 1, VirtualAlloc/VirtualProtect is used to detect cases where the app locks a buffer, copies the ptr away, unlocks, then tries to later write to the buffer.
+#define GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION 0
+
+#define GL_BATCH_TELEMETRY_ZONES 0
+
+// GL_BATCH_PERF_ANALYSIS - Enables gl_batch_vis, and various per-batch telemetry statistics messages.
+#define GL_BATCH_PERF_ANALYSIS 0
+#define GL_BATCH_PERF_ANALYSIS_WRITE_PNGS 0
+
+// GL_TELEMETRY_ZONES - Causes every single OpenGL call to generate a telemetry event
+#define GL_TELEMETRY_ZONES 0
+
+// GL_DUMP_ALL_API_CALLS - Causes a debug message to be printed for every API call if s_bDumpCalls bool is set to 1
+#define GL_DUMP_ALL_API_CALLS 0
+
+// Must also enable PIX_ENABLE to use GL_TELEMETRY_GPU_ZONES.
+#define GL_TELEMETRY_GPU_ZONES 0
+
+// Records global # of OpenGL calls/total cycles spent inside GL
+#define GL_TRACK_API_TIME GL_BATCH_PERF_ANALYSIS
+
+#define GL_USE_EXECUTE_HELPER_FOR_ALL_API_CALLS ( GL_TELEMETRY_ZONES || GL_TRACK_API_TIME || GL_DUMP_ALL_API_CALLS )
+
+#if GL_BATCH_PERF_ANALYSIS
+ #define GL_BATCH_PERF(...) __VA_ARGS__
+#else
+ #define GL_BATCH_PERF(...)
+#endif
+
+#define kGLMUserClipPlanes 2
+#define kGLMScratchFBOCount 4
+
+#endif // DX_TO_GL_ABSTRACTION
+
+#endif // GLBASE_H
diff --git a/mp/src/public/togl/linuxwin/glentrypoints.h b/mp/src/public/togl/linuxwin/glentrypoints.h new file mode 100644 index 00000000..d1347175 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glentrypoints.h @@ -0,0 +1,378 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glentrypoints.h
+//
+//===============================================================================
+
+#ifndef GLENTRYPOINTS_H
+#define GLENTRYPOINTS_H
+
+#pragma once
+
+#ifdef DX_TO_GL_ABSTRACTION
+
+#include "tier0/platform.h"
+#include "tier0/dynfunction.h"
+#include "tier0/vprof_telemetry.h"
+#include "interface.h"
+
+#include "togl/rendermechanism.h"
+
+void *VoidFnPtrLookup_GlMgr(const char *fn, bool &okay, const bool bRequired, void *fallback=NULL);
+
+#if GL_USE_EXECUTE_HELPER_FOR_ALL_API_CALLS
+class CGLExecuteHelperBase
+{
+public:
+ inline void StartCall(const char *pName);
+ inline void StopCall(const char *pName);
+#if GL_TRACK_API_TIME
+ TmU64 m_nStartTime;
+#endif
+};
+
+template < class FunctionType, typename Result >
+class CGLExecuteHelper : public CGLExecuteHelperBase
+{
+public:
+ inline CGLExecuteHelper(FunctionType pFn, const char *pName ) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(); StopCall(pName); }
+ template<typename A> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a); StopCall(pName); }
+ template<typename A, typename B> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b); StopCall(pName); }
+ template<typename A, typename B, typename C> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h, i); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h, i, j); StopCall(pName); }
+
+ inline operator Result() const { return m_Result; }
+ inline operator char*() const { return (char*)m_Result; }
+
+ FunctionType m_pFn;
+
+ Result m_Result;
+};
+
+template < class FunctionType>
+class CGLExecuteHelper<FunctionType, void> : public CGLExecuteHelperBase
+{
+public:
+ inline CGLExecuteHelper(FunctionType pFn, const char *pName ) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(); StopCall(pName); }
+ template<typename A> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a); StopCall(pName); }
+ template<typename A, typename B> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b); StopCall(pName); }
+ template<typename A, typename B, typename C> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h, i); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h, i, j); StopCall(pName); }
+
+ FunctionType m_pFn;
+};
+#endif
+
+template < class FunctionType, typename Result >
+class CDynamicFunctionOpenGLBase
+{
+public:
+ // Construct with a NULL function pointer. You must manually call
+ // Lookup() before you can call a dynamic function through this interface.
+ CDynamicFunctionOpenGLBase() : m_pFn(NULL) {}
+
+ // Construct and do a lookup right away. You will need to make sure that
+ // the lookup actually succeeded, as the gl library might have failed to load
+ // or (fn) might not exist in it.
+ CDynamicFunctionOpenGLBase(const char *fn, FunctionType fallback=NULL) : m_pFn(NULL)
+ {
+ Lookup(fn, fallback);
+ }
+
+ // Construct and do a lookup right away. See comments in Lookup() about what (okay) does.
+ CDynamicFunctionOpenGLBase(const char *fn, bool &okay, FunctionType fallback=NULL) : m_pFn(NULL)
+ {
+ Lookup(fn, okay, fallback);
+ }
+
+ // Load library if necessary, look up symbol. Returns true and sets
+ // m_pFn on successful lookup, returns false otherwise. If the
+ // function pointer is already looked up, this return true immediately.
+ // Use Reset() first if you want to look up the symbol again.
+ // This function will return false immediately unless (okay) is true.
+ // This allows you to chain lookups like this:
+ // bool okay = true;
+ // x.Lookup(lib, "x", okay);
+ // y.Lookup(lib, "y", okay);
+ // z.Lookup(lib, "z", okay);
+ // if (okay) { printf("All functions were loaded successfully!\n"); }
+ // If you supply a fallback, it'll be used if the lookup fails (and if
+ // non-NULL, means this will always return (okay)).
+ bool Lookup(const char *fn, bool &okay, FunctionType fallback=NULL)
+ {
+ if (!okay)
+ return false;
+ else if (this->m_pFn == NULL)
+ {
+ this->m_pFn = (FunctionType) VoidFnPtrLookup_GlMgr(fn, okay, false, (void *) fallback);
+ this->SetFuncName( fn );
+ }
+ okay = m_pFn != NULL;
+ return okay;
+ }
+
+ // Load library if necessary, look up symbol. Returns true and sets
+ // m_pFn on successful lookup, returns false otherwise. If the
+ // function pointer is already looked up, this return true immediately.
+ // Use Reset() first if you want to look up the symbol again.
+ // This function will return false immediately unless (okay) is true.
+ // If you supply a fallback, it'll be used if the lookup fails (and if
+ // non-NULL, means this will always return true).
+ bool Lookup(const char *fn, FunctionType fallback=NULL)
+ {
+ bool okay = true;
+ return Lookup(fn, okay, fallback);
+ }
+
+ // Invalidates the current lookup. Makes the function pointer NULL. You
+ // will need to call Lookup() before you can call a dynamic function
+ // through this interface again.
+ void Reset() { m_pFn = NULL; }
+
+ // Force this to be a specific function pointer.
+ void Force(FunctionType ptr) { m_pFn = ptr; }
+
+ // Retrieve the actual function pointer.
+ FunctionType Pointer() const { return m_pFn; }
+
+#if GL_USE_EXECUTE_HELPER_FOR_ALL_API_CALLS
+ #if GL_TELEMETRY_ZONES || GL_DUMP_ALL_API_CALLS
+ #define GL_FUNC_NAME m_szName
+ #else
+ #define GL_FUNC_NAME ""
+ #endif
+
+ inline CGLExecuteHelper<FunctionType, Result> operator() () const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME ); }
+
+ template<typename T>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a); }
+
+ template<typename T, typename U>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b); }
+
+ template<typename T, typename U, typename V>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c ) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c); }
+
+ template<typename T, typename U, typename V, typename W>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d); }
+
+ template<typename T, typename U, typename V, typename W, typename X>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A, typename B>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h, B i) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h, i); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A, typename B, typename C>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h, B i, C j) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h, i, j); }
+#else
+ operator FunctionType() const { return m_pFn; }
+#endif
+
+ // Can be used to verify that we have an actual function looked up and
+ // ready to call: if (!MyDynFunc) { printf("Function not found!\n"); }
+ operator bool () const { return m_pFn != NULL; }
+ bool operator !() const { return m_pFn == NULL; }
+
+protected:
+ FunctionType m_pFn;
+
+#if GL_TELEMETRY_ZONES || GL_DUMP_ALL_API_CALLS
+ char m_szName[32];
+ inline void SetFuncName(const char *pFn) { V_strncpy( m_szName, pFn, sizeof( m_szName ) ); }
+#else
+ inline void SetFuncName(const char *pFn) { (void)pFn; }
+#endif
+};
+
+// This works a lot like CDynamicFunctionMustInit, but we use SDL_GL_GetProcAddress().
+template < const bool bRequired, class FunctionType, typename Result >
+class CDynamicFunctionOpenGL : public CDynamicFunctionOpenGLBase< FunctionType, Result >
+{
+private: // forbid default constructor.
+ CDynamicFunctionOpenGL() {}
+
+public:
+ CDynamicFunctionOpenGL(const char *fn, FunctionType fallback=NULL)
+ {
+ bool okay = true;
+ Lookup(fn, okay, fallback);
+ this->SetFuncName( fn );
+ }
+
+ CDynamicFunctionOpenGL(const char *fn, bool &okay, FunctionType fallback=NULL)
+ {
+ Lookup(fn, okay, fallback);
+ this->SetFuncName( fn );
+ }
+
+ // Please note this is not virtual.
+ // !!! FIXME: we might want to fall back and try "EXT" or "ARB" versions in some case.
+ bool Lookup(const char *fn, bool &okay, FunctionType fallback=NULL)
+ {
+ if (this->m_pFn == NULL)
+ {
+ this->m_pFn = (FunctionType) VoidFnPtrLookup_GlMgr(fn, okay, bRequired, (void *) fallback);
+ this->SetFuncName( fn );
+ }
+ return okay;
+ }
+};
+
+enum GLDriverStrings_t
+{
+ cGLVendorString,
+ cGLRendererString,
+ cGLVersionString,
+ cGLExtensionsString,
+
+ cGLTotalDriverStrings
+};
+
+enum GLDriverProvider_t
+{
+ cGLDriverProviderUnknown,
+ cGLDriverProviderNVIDIA,
+ cGLDriverProviderAMD,
+ cGLDriverProviderIntel,
+ cGLDriverProviderIntelOpenSource,
+ cGLDriverProviderApple,
+
+ cGLTotalDriverProviders
+};
+
+// This provides all the entry points for a given OpenGL context.
+// ENTRY POINTS ARE ONLY VALID FOR THE CONTEXT THAT WAS CURRENT WHEN
+// YOU LOOKED THEM UP. 99% of the time, this is not a problem, but
+// that 1% is really hard to track down. Always access the GL
+// through this class!
+class COpenGLEntryPoints
+{
+ COpenGLEntryPoints( const COpenGLEntryPoints & );
+ COpenGLEntryPoints &operator= ( const COpenGLEntryPoints & );
+
+public:
+ // The GL context you are looking up entry points for must be current when you construct this object!
+ COpenGLEntryPoints();
+ ~COpenGLEntryPoints();
+
+ void ClearEntryPoints();
+
+ uint64 m_nTotalGLCycles, m_nTotalGLCalls;
+
+ int m_nOpenGLVersionMajor; // if GL_VERSION is 2.1.0, this will be set to 2.
+ int m_nOpenGLVersionMinor; // if GL_VERSION is 2.1.0, this will be set to 1.
+ int m_nOpenGLVersionPatch; // if GL_VERSION is 2.1.0, this will be set to 0.
+ bool m_bHave_OpenGL;
+
+ char *m_pGLDriverStrings[cGLTotalDriverStrings];
+ GLDriverProvider_t m_nDriverProvider;
+
+ #define GL_EXT(x,glmajor,glminor) bool m_bHave_##x;
+ #define GL_FUNC(ext,req,ret,fn,arg,call) CDynamicFunctionOpenGL< req, ret (APIENTRY *) arg, ret > fn;
+ #define GL_FUNC_VOID(ext,req,fn,arg,call) CDynamicFunctionOpenGL< req, void (APIENTRY *) arg, void > fn;
+ #include "togl/glfuncs.inl"
+ #undef GL_FUNC_VOID
+ #undef GL_FUNC
+ #undef GL_EXT
+
+ bool HasSwapTearExtension() const
+ {
+#ifdef _WIN32
+ return m_bHave_WGL_EXT_swap_control_tear;
+#else
+ return m_bHave_GLX_EXT_swap_control_tear;
+#endif
+ }
+};
+
+// This will be set to the current OpenGL context's entry points.
+extern COpenGLEntryPoints *gGL;
+typedef void * (*GL_GetProcAddressCallbackFunc_t)(const char *, bool &, const bool, void *);
+
+#ifdef TOGL_DLL_EXPORT
+ DLL_EXPORT COpenGLEntryPoints *ToGLConnectLibraries( CreateInterfaceFn factory );
+ DLL_EXPORT void ToGLDisconnectLibraries();
+ DLL_EXPORT COpenGLEntryPoints *GetOpenGLEntryPoints(GL_GetProcAddressCallbackFunc_t callback);
+ DLL_EXPORT void ClearOpenGLEntryPoints();
+#else
+ DLL_IMPORT COpenGLEntryPoints *ToGLConnectLibraries( CreateInterfaceFn factory );
+ DLL_IMPORT void ToGLDisconnectLibraries();
+ DLL_IMPORT COpenGLEntryPoints *GetOpenGLEntryPoints(GL_GetProcAddressCallbackFunc_t callback);
+ DLL_IMPORT void ClearOpenGLEntryPoints();
+#endif
+
+#if GL_USE_EXECUTE_HELPER_FOR_ALL_API_CALLS
+inline void CGLExecuteHelperBase::StartCall(const char *pName)
+{
+ (void)pName;
+
+#if GL_TELEMETRY_ZONES
+ tmEnter( TELEMETRY_LEVEL3, TMZF_NONE, pName );
+#endif
+
+#if GL_TRACK_API_TIME
+ m_nStartTime = tmFastTime();
+#endif
+
+#if GL_DUMP_ALL_API_CALLS
+ static bool s_bDumpCalls;
+ if ( s_bDumpCalls )
+ {
+ char buf[128];
+ buf[0] = 'G';
+ buf[1] = 'L';
+ buf[2] = ':';
+ size_t l = strlen( pName );
+ memcpy( buf + 3, pName, l );
+ buf[3 + l] = '\n';
+ buf[4 + l] = '\0';
+ Plat_DebugString( buf );
+ }
+#endif
+}
+
+inline void CGLExecuteHelperBase::StopCall(const char *pName)
+{
+#if GL_TRACK_API_TIME
+ uint64 nTotalCycles = tmFastTime() - m_nStartTime;
+#endif
+
+#if GL_TELEMETRY_ZONES
+ tmLeave( TELEMETRY_LEVEL3 );
+#endif
+
+#if GL_TRACK_API_TIME
+ //double flMilliseconds = g_Telemetry.flRDTSCToMilliSeconds * nTotalCycles;
+ if (gGL)
+ {
+ gGL->m_nTotalGLCycles += nTotalCycles;
+ gGL->m_nTotalGLCalls++;
+ }
+#endif
+}
+#endif
+
+#endif // DX_TO_GL_ABSTRACTION
+
+#endif // GLENTRYPOINTS_H
diff --git a/mp/src/public/togl/linuxwin/glfuncs.h b/mp/src/public/togl/linuxwin/glfuncs.h new file mode 100644 index 00000000..3ef3772c --- /dev/null +++ b/mp/src/public/togl/linuxwin/glfuncs.h @@ -0,0 +1,236 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+// !!! FIXME: Some of these aren't base OpenGL...pick out the extensions.
+// !!! FIXME: Also, look up these -1, -1 versions numbers.
+GL_FUNC(OpenGL,true,GLenum,glGetError,(void),())
+GL_FUNC_VOID(OpenGL,true,glActiveTexture,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glAlphaFunc,(GLenum a,GLclampf b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glAttachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBegin,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glBindAttribLocationARB,(GLhandleARB a,GLuint b,const GLcharARB *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glBindBufferARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindProgramARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindTexture,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBlendColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glBlendEquation,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glBlendFunc,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBufferDataARB,(GLenum a,GLsizeiptrARB b,const GLvoid *c,GLenum d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glClear,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glClearColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glClearDepth,(GLclampd a),(a))
+GL_FUNC_VOID(OpenGL,true,glClearStencil,(GLint a),(a))
+GL_FUNC_VOID(OpenGL,true,glClipPlane,(GLenum a,const GLdouble *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glColorMask,(GLboolean a,GLboolean b,GLboolean c,GLboolean d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glCompileShaderARB,(GLhandleARB a),(a))
+GL_FUNC_VOID(OpenGL,true,glCompressedTexImage2D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLint f,GLsizei g,const GLvoid *h),(a,b,c,d,e,f,g,h))
+GL_FUNC_VOID(OpenGL,true,glCompressedTexImage3D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLsizei h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC(OpenGL,true,GLhandleARB,glCreateProgramObjectARB,(void),())
+GL_FUNC(OpenGL,true,GLhandleARB,glCreateShaderObjectARB,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteBuffersARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteObjectARB,(GLhandleARB a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteProgramsARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteQueriesARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteShader,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteTextures,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDepthFunc,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDepthMask,(GLboolean a),(a))
+GL_FUNC_VOID(OpenGL,true,glDepthRange,(GLclampd a,GLclampd b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDetachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDisable,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDisableVertexAttribArray,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawArrays,(GLenum a,GLint b,GLsizei c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glDrawBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawRangeElements,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glDrawRangeElementsBaseVertex,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f, GLenum g),(a,b,c,d,e,f,g))
+GL_FUNC_VOID(OpenGL,true,glEnable,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glEnableVertexAttribArray,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glEnd,(void),())
+GL_FUNC_VOID(OpenGL,true,glFinish,(void),())
+GL_FUNC_VOID(OpenGL,true,glFlush,(void),())
+GL_FUNC_VOID(OpenGL,true,glFrontFace,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glGenBuffersARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenProgramsARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenQueriesARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenTextures,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetBooleanv,(GLenum a,GLboolean *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetCompressedTexImage,(GLenum a,GLint b,GLvoid *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGetDoublev,(GLenum a,GLdouble *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetFloatv,(GLenum a,GLfloat *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetInfoLogARB,(GLhandleARB a,GLsizei b,GLsizei *c,GLcharARB *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glGetIntegerv,(GLenum a,GLint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetObjectParameterivARB,(GLhandleARB a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGetProgramivARB,(GLenum a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC(OpenGL,true,const GLubyte *,glGetString,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glGetTexImage,(GLenum a,GLint b,GLenum c,GLenum d,GLvoid *e),(a,b,c,d,e))
+GL_FUNC(OpenGL,true,GLint,glGetUniformLocationARB,(GLhandleARB a,const GLcharARB *b),(a,b))
+GL_FUNC(OpenGL,true,GLboolean,glIsEnabled,(GLenum a),(a))
+GL_FUNC(OpenGL,true,GLboolean,glIsTexture,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glLinkProgramARB,(GLhandleARB a),(a))
+GL_FUNC(OpenGL,true,GLvoid*,glMapBufferARB,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glOrtho,(GLdouble a,GLdouble b,GLdouble c,GLdouble d,GLdouble e,GLdouble f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glPixelStorei,(GLenum a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPolygonMode,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPolygonOffset,(GLfloat a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPopAttrib,(void),())
+GL_FUNC_VOID(OpenGL,true,glProgramStringARB,(GLenum a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glPushAttrib,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glReadBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glScissor,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glShaderSourceARB,(GLhandleARB a,GLsizei b,const GLcharARB **c,const GLint *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glStencilFunc,(GLenum a,GLint b,GLuint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glStencilMask,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glStencilOp,(GLenum a,GLenum b,GLenum c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexCoord2f,(GLfloat a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glTexImage2D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLint f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC_VOID(OpenGL,true,glTexImage3D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLenum h,GLenum i,const GLvoid *j),(a,b,c,d,e,f,g,h,i,j))
+GL_FUNC_VOID(OpenGL,true,glTexParameterfv,(GLenum a,GLenum b,const GLfloat *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexParameteri,(GLenum a,GLenum b,GLint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexSubImage2D,(GLenum a,GLint b,GLint c,GLint d,GLsizei e,GLsizei f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC_VOID(OpenGL,true,glUniform1f,(GLint a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform1i,(GLint a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform1iARB,(GLint a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform4fv,(GLint a,GLsizei b,const GLfloat *c),(a,b,c))
+GL_FUNC(OpenGL,true,GLboolean,glUnmapBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glUseProgram,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glVertex3f,(GLfloat a,GLfloat b,GLfloat c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glVertexAttribPointer,(GLuint a,GLint b,GLenum c,GLboolean d,GLsizei e,const GLvoid *f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glViewport,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glEnableClientState,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDisableClientState,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glClientActiveTexture,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glVertexPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glTexCoordPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glProgramEnvParameters4fvEXT,(GLenum a,GLuint b,GLsizei c,const GLfloat *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glColor4sv,(const GLshort *a),(a))
+GL_FUNC_VOID(OpenGL,true,glStencilOpSeparate,(GLenum a,GLenum b,GLenum c,GLenum d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glStencilFuncSeparate,(GLenum a,GLenum b,GLint c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glGetTexLevelParameteriv,(GLenum a,GLint b,GLenum c,GLint *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glColor4f,(GLfloat a,GLfloat b,GLfloat c,GLfloat d),(a,b,c,d))
+GL_EXT(GL_EXT_framebuffer_object,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindFramebufferEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindRenderbufferEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC(GL_EXT_framebuffer_object,false,GLenum,glCheckFramebufferStatusEXT,(GLenum a),(a))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteRenderbuffersEXT,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferRenderbufferEXT,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture2DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture3DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenFramebuffersEXT,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenRenderbuffersEXT,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteFramebuffersEXT,(GLsizei a,const GLuint *b),(a,b))
+GL_EXT(GL_EXT_framebuffer_blit,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_blit,false,glBlitFramebufferEXT,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
+GL_EXT(GL_EXT_framebuffer_multisample,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_multisample,false,glRenderbufferStorageMultisampleEXT,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
+GL_EXT(GL_APPLE_fence,-1,-1)
+GL_FUNC(GL_APPLE_fence,false,GLboolean,glTestFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glSetFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glFinishFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glDeleteFencesAPPLE,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_APPLE_fence,false,glGenFencesAPPLE,(GLsizei a,GLuint *b),(a,b))
+GL_EXT(GL_NV_fence,-1,-1)
+GL_FUNC(GL_NV_fence,false,GLboolean,glTestFenceNV,(GLuint a),(a))
+GL_FUNC_VOID(GL_NV_fence,false,glSetFenceNV,(GLuint a,GLenum b),(a,b))
+GL_FUNC_VOID(GL_NV_fence,false,glFinishFenceNV,(GLuint a),(a))
+GL_FUNC_VOID(GL_NV_fence,false,glDeleteFencesNV,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_NV_fence,false,glGenFencesNV,(GLsizei a,GLuint *b),(a,b))
+GL_EXT(GL_ARB_sync,3,2)
+#ifdef HAVE_GL_ARB_SYNC
+GL_FUNC_VOID(GL_ARB_sync,false,glGetSynciv,(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e),(a,b,c,d,e))
+GL_FUNC(GL_ARB_sync,false,GLenum,glClientWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_sync,false,glWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_sync,false,glDeleteSync,(GLsync a),(a))
+GL_FUNC(GL_ARB_sync,false,GLsync,glFenceSync,(GLenum a, GLbitfield b),(a,b))
+#endif
+GL_EXT(GL_EXT_draw_buffers2,-1,-1)
+GL_FUNC_VOID(GL_EXT_draw_buffers2,true,glColorMaskIndexedEXT,(GLuint a,GLboolean b,GLboolean c,GLboolean d,GLboolean e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,true,glEnableIndexedEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,true,glDisableIndexedEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,true,glGetBooleanIndexedvEXT,(GLenum a,GLuint b,GLboolean *c),(a,b,c))
+GL_EXT(GL_EXT_bindable_uniform,-1,-1)
+GL_FUNC_VOID(GL_EXT_bindable_uniform,false,glUniformBufferEXT,(GLuint a,GLint b,GLuint c),(a,b,c))
+GL_FUNC(GL_EXT_bindable_uniform,false,int,glGetUniformBufferSizeEXT,(GLenum a, GLenum b),(a,b))
+GL_FUNC(GL_EXT_bindable_uniform,false,GLintptr,glGetUniformOffsetEXT,(GLenum a, GLenum b),(a,b))
+GL_EXT(GL_APPLE_flush_buffer_range,-1,-1)
+GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glBufferParameteriAPPLE,(GLenum a,GLenum b,GLint c),(a,b,c))
+GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glFlushMappedBufferRangeAPPLE,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
+GL_EXT(GL_ARB_map_buffer_range,-1,-1)
+GL_FUNC(GL_ARB_map_buffer_range,false,void*,glMapBufferRange,(GLenum a,GLintptr b,GLsizeiptr c,GLbitfield d),(a,b,c,d))
+GL_FUNC_VOID(GL_ARB_map_buffer_range,false,glFlushMappedBufferRange,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
+GL_EXT(GL_ARB_vertex_buffer_object,-1,-1)
+GL_FUNC_VOID(GL_ARB_vertex_buffer_object,true,glBufferSubData,(GLenum a,GLintptr b,GLsizeiptr c,const GLvoid *d),(a,b,c,d))
+GL_EXT(GL_ARB_occlusion_query,-1,-1)
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glBeginQueryARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glEndQueryARB,(GLenum a),(a))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectivARB,(GLuint a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectuivARB,(GLuint a,GLenum b,GLuint *c),(a,b,c))
+GL_EXT(GL_APPLE_texture_range,-1,-1)
+GL_FUNC_VOID(GL_APPLE_texture_range,false,glTextureRangeAPPLE,(GLenum a,GLsizei b,void *c),(a,b,c))
+GL_FUNC_VOID(GL_APPLE_texture_range,false,glGetTexParameterPointervAPPLE,(GLenum a,GLenum b,void* *c),(a,b,c))
+GL_EXT(GL_APPLE_client_storage,-1,-1)
+GL_EXT(GL_ARB_uniform_buffer,-1,-1)
+GL_EXT(GL_ARB_vertex_array_bgra,-1,-1)
+GL_EXT(GL_EXT_vertex_array_bgra,-1,-1)
+GL_EXT(GL_ARB_framebuffer_object,3,0)
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindFramebuffer,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindRenderbuffer,(GLenum a,GLuint b),(a,b))
+GL_FUNC(GL_ARB_framebuffer_object,false,GLenum,glCheckFramebufferStatus,(GLenum a),(a))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteRenderbuffers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferRenderbuffer,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture2D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture3D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenFramebuffers,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenRenderbuffers,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteFramebuffers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBlitFramebuffer,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glRenderbufferStorageMultisample,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
+GL_EXT(GL_GREMEDY_string_marker,-1,-1)
+GL_FUNC_VOID(GL_GREMEDY_string_marker,false,glStringMarkerGREMEDY,(GLsizei a,const void *b),(a,b))
+GL_EXT(GL_ARB_debug_output,-1,-1)
+GL_FUNC_VOID(GL_ARB_debug_output,false,glDebugMessageCallbackARB,(void (APIENTRY *a)(GLenum, GLenum , GLuint , GLenum , GLsizei , const GLchar* , GLvoid*) ,void* b),(a,b))
+GL_FUNC_VOID(GL_ARB_debug_output,false,glDebugMessageControlARB,(GLenum a, GLenum b, GLenum c, GLsizei d, const GLuint* e, GLboolean f),(a,b,c,d,e,f))
+GL_EXT(GL_EXT_direct_state_access,-1,-1)
+GL_FUNC_VOID(GL_EXT_direct_state_access,false,glBindMultiTextureEXT,(GLenum a,GLuint b, GLuint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGenSamplers,(GLuint a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteSamplers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindSampler,(GLuint a, GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glSamplerParameteri,(GLuint a, GLenum b, GLint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glSamplerParameterf,(GLuint a, GLenum b, GLfloat c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glSamplerParameterfv,(GLuint a, GLenum b, const GLfloat *c),(a,b,c))
+GL_EXT(GL_NV_bindless_texture,-1,-1)
+GL_FUNC(GL_NV_bindless_texture, false, GLuint64, glGetTextureHandleNV, (GLuint texture), (texture))
+GL_FUNC(GL_NV_bindless_texture, false, GLuint64, glGetTextureSamplerHandleNV, (GLuint texture, GLuint sampler), (texture, sampler))
+GL_FUNC_VOID(GL_NV_bindless_texture, false, glMakeTextureHandleResidentNV, (GLuint64 handle), (handle))
+GL_FUNC_VOID(GL_NV_bindless_texture, false, glMakeTextureHandleNonResidentNV, (GLuint64 handle), (handle))
+GL_FUNC_VOID(GL_NV_bindless_texture, false, glUniformHandleui64NV, (GLint location, GLuint64 value), (location, value))
+GL_FUNC_VOID(GL_NV_bindless_texture, false, glUniformHandleui64vNV, (int location, GLsizei count, const GLuint64 *value), (location count, value))
+GL_FUNC_VOID(GL_NV_bindless_texture, false, glProgramUniformHandleui64NV, (GLuint program, GLint location, GLuint64 value), (program, location, value))
+GL_FUNC_VOID(GL_NV_bindless_texture, false, glProgramUniformHandleui64vNV, (GLuint program, GLint location, GLsizei count, const GLuint64 *values), (program, location, count, values))
+GL_FUNC(GL_NV_bindless_texture, false, GLboolean, glIsTextureHandleResidentNV, (GLuint64 handle), (handle))
+GL_FUNC_VOID(OpenGL,true,glGenQueries,(GLsizei n, GLuint *ids), (n, ids))
+GL_FUNC_VOID(OpenGL,true,glDeleteQueries,(GLsizei n, const GLuint *ids),(n, ids))
+GL_FUNC_VOID(OpenGL,true,glBeginQuery,(GLenum target, GLuint id), (target, id))
+GL_FUNC_VOID(OpenGL,true,glEndQuery,(GLenum target), (target))
+GL_FUNC_VOID(OpenGL,true,glQueryCounter,(GLuint id, GLenum target), (id, target))
+GL_FUNC_VOID(OpenGL,true,glGetQueryObjectiv,(GLuint id, GLenum pname, GLint *params), (id, pname, params))
+GL_FUNC_VOID(OpenGL,true,glGetQueryObjectui64v,(GLuint id, GLenum pname, GLuint64 *params), (id, pname, params))
+GL_FUNC_VOID(OpenGL,true,glCopyBufferSubData,(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size),(readtarget, writetarget, readoffset, writeoffset, size))
+GL_EXT(GL_AMD_pinned_memory,-1,-1)
+GL_EXT(GL_EXT_framebuffer_multisample_blit_scaled,-1,-1)
+GL_FUNC_VOID(OpenGL,true,glGenVertexArrays,(GLsizei n, GLuint *arrays),(n, arrays))
+GL_FUNC_VOID(OpenGL,true,glDeleteVertexArrays,(GLsizei n, GLuint *arrays),(n, arrays))
+GL_FUNC_VOID(OpenGL,true,glBindVertexArray,(GLuint a),(a))
+GL_EXT(GL_EXT_texture_sRGB_decode,-1,-1)
+GL_FUNC_VOID(OpenGL,true,glPushClientAttrib,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glPopClientAttrib,(void),())
+GL_EXT(GL_NVX_gpu_memory_info,-1,-1)
+GL_EXT(GL_ATI_meminfo,-1,-1)
+GL_EXT(GL_EXT_texture_compression_s3tc,-1,-1)
+GL_EXT(GL_EXT_texture_compression_dxt1,-1,-1)
+GL_EXT(GL_ANGLE_texture_compression_dxt3,-1,-1)
+GL_EXT(GL_ANGLE_texture_compression_dxt5,-1,-1)
+
+// This one is an OS extension. We'll add a little helper function to look for it.
+#ifdef _WIN32
+ GL_EXT(WGL_EXT_swap_control_tear,-1,-1)
+#else
+ GL_EXT(GLX_EXT_swap_control_tear,-1,-1)
+#endif
diff --git a/mp/src/public/togl/linuxwin/glmdebug.h b/mp/src/public/togl/linuxwin/glmdebug.h new file mode 100644 index 00000000..80df86f1 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glmdebug.h @@ -0,0 +1,160 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef GLMDEBUG_H
+#define GLMDEBUG_H
+
+#include "tier0/platform.h"
+
+// include this anywhere you need to be able to compile-out code related specifically to GLM debugging.
+
+// we expect DEBUG to be driven by the build system so you can include this header anywhere.
+// when we come out, GLMDEBUG will be defined to a value - 0, 1, or 2
+// 0 means no GLM debugging is possible
+// 1 means it's possible and resulted from being a debug build
+// 2 means it's possible and resulted from being manually forced on for a release build
+
+#ifdef POSIX
+ #ifndef GLMDEBUG
+ #ifdef DEBUG
+ #define GLMDEBUG 1 // normally 1 here, testing
+ #else
+ // #define GLMDEBUG 2 // don't check this in enabled..
+ #endif
+
+ #ifndef GLMDEBUG
+ #define GLMDEBUG 0
+ #endif
+ #endif
+#else
+ #ifndef GLMDEBUG
+ #define GLMDEBUG 0
+ #endif
+#endif
+
+
+//===============================================================================
+// debug channels
+
+enum EGLMDebugChannel
+{
+ ePrintf,
+ eDebugger,
+ eGLProfiler
+};
+
+#if GLMDEBUG
+ // make all these prototypes disappear in non GLMDEBUG
+ void GLMDebugInitialize( bool forceReinit=false );
+
+ bool GLMDetectOGLP( void );
+ bool GLMDetectGDB( void );
+ uint GLMDetectAvailableChannels( void );
+
+ uint GLMDebugChannelMask( uint *newValue = NULL );
+ // note that GDB and OGLP can both come and go during run - forceCheck will allow that to be detected.
+ // mask returned is in form of 1<<n, n from EGLMDebugChannel
+#endif
+
+//===============================================================================
+// debug message flavors
+
+enum EGLMDebugFlavor
+{
+ eAllFlavors, // 0
+ eDebugDump, // 1 debug dump flavor -D-
+ eTenure, // 2 code tenures > <
+ eComment, // 3 one off messages ---
+ eMatrixData, // 4 matrix data -M-
+ eShaderData, // 5 shader data (params) -S-
+ eFrameBufData, // 6 FBO data (attachments) -F-
+ eDXStuff, // 7 dxabstract spew -X-
+ eAllocations, // 8 tracking allocs and frees -A-
+ eSlowness, // 9 slow things happening (srgb flips..) -Z-
+ eDefaultFlavor, // not specified (no marker)
+ eFlavorCount
+};
+uint GLMDebugFlavorMask( uint *newValue = NULL );
+
+// make all these prototypes disappear in non GLMDEBUG
+#if GLMDEBUG
+ // these are unconditional outputs, they don't interrogate the string
+ void GLMStringOut( const char *string );
+ void GLMStringOutIndented( const char *string, int indentColumns );
+
+ #ifdef TOGL_DLL_EXPORT
+ // these will look at the string to guess its flavor: <, >, ---, -M-, -S-
+ DLL_EXPORT void GLMPrintfVA( const char *fmt, va_list vargs );
+ DLL_EXPORT void GLMPrintf( const char *fmt, ... );
+ #else
+ DLL_IMPORT void GLMPrintfVA( const char *fmt, va_list vargs );
+ DLL_IMPORT void GLMPrintf( const char *fmt, ... );
+ #endif
+
+ // these take an explicit flavor with a default value
+ void GLMPrintStr( const char *str, EGLMDebugFlavor flavor = eDefaultFlavor );
+
+ #define GLMPRINTTEXT_NUMBEREDLINES 0x80000000
+ void GLMPrintText( const char *str, EGLMDebugFlavor flavor = eDefaultFlavor, uint options=0 ); // indent each newline
+
+ int GLMIncIndent( int indentDelta );
+ int GLMGetIndent( void );
+ void GLMSetIndent( int indent );
+
+#endif
+
+// helpful macro if you are in a position to call GLM functions directly (i.e. you live in materialsystem / shaderapidx9)
+#if GLMDEBUG
+ #define GLMPRINTF(args) GLMPrintf args
+ #define GLMPRINTSTR(args) GLMPrintStr args
+ #define GLMPRINTTEXT(args) GLMPrintText args
+#else
+ #define GLMPRINTF(args)
+ #define GLMPRINTSTR(args)
+ #define GLMPRINTTEXT(args)
+#endif
+
+
+//===============================================================================
+// knob twiddling
+#ifdef TOGL_DLL_EXPORT
+ DLL_EXPORT float GLMKnob( char *knobname, float *setvalue ); // Pass NULL to not-set the knob value
+ DLL_EXPORT float GLMKnobToggle( char *knobname );
+#else
+ DLL_IMPORT float GLMKnob( char *knobname, float *setvalue ); // Pass NULL to not-set the knob value
+ DLL_IMPORT float GLMKnobToggle( char *knobname );
+#endif
+
+//===============================================================================
+// other stuff
+
+#if GLMDEBUG
+void GLMTriggerDebuggerBreak();
+inline void GLMDebugger( void )
+{
+ if (GLMDebugChannelMask() & (1<<eDebugger))
+ {
+#ifdef OSX
+ asm {int 3 };
+#else
+ DebuggerBreak();
+#endif
+ }
+
+ if (GLMDebugChannelMask() & (1<<eGLProfiler))
+ {
+ GLMTriggerDebuggerBreak();
+ }
+}
+#else
+ #define GLMDebugger() do { } while(0)
+#endif
+
+// helpers for CGLSetOption - no op if no profiler
+void GLMProfilerClearTrace( void );
+void GLMProfilerEnableTrace( bool enable );
+
+// helpers for CGLSetParameter - no op if no profiler
+void GLMProfilerDumpState( void );
+
+void CheckGLError( int line );
+
+#endif // GLMDEBUG_H
diff --git a/mp/src/public/togl/linuxwin/glmdisplay.h b/mp/src/public/togl/linuxwin/glmdisplay.h new file mode 100644 index 00000000..6e83f8b8 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glmdisplay.h @@ -0,0 +1,176 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmdisplay.h
+// display related stuff - used by both GLMgr and the CocoaMgr
+//
+//===============================================================================
+
+#ifndef GLMDISPLAY_H
+#define GLMDISPLAY_H
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#include <OpenGL/CGLTypes.h>
+#include <OpenGL/CGLRenderers.h>
+#include <OpenGL/CGLCurrent.h>
+#include <ApplicationServices/ApplicationServices.h>
+#elif defined(DX_TO_GL_ABSTRACTION)
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include "tier0/platform.h"
+#else
+#error
+#endif
+
+typedef void _PseudoNSGLContext; // aka NSOpenGLContext
+typedef _PseudoNSGLContext *PseudoNSGLContextPtr;
+
+struct GLMDisplayModeInfoFields
+{
+ uint m_modePixelWidth;
+ uint m_modePixelHeight;
+ uint m_modeRefreshHz;
+ // are we even going to talk about bit depth... not yet
+};
+
+struct GLMDisplayInfoFields
+{
+#ifdef OSX
+ CGDirectDisplayID m_cgDisplayID;
+ CGOpenGLDisplayMask m_glDisplayMask; // result of CGDisplayIDToOpenGLDisplayMask on the cg_displayID.
+#endif
+ uint m_displayPixelWidth;
+ uint m_displayPixelHeight;
+};
+
+struct GLMRendererInfoFields
+{
+ /*properties of interest and their desired values.
+
+ kCGLRPFullScreen = 54, true
+ kCGLRPAccelerated = 73, true
+ kCGLRPWindow = 80, true
+
+ kCGLRPRendererID = 70, informational
+ kCGLRPDisplayMask = 84, informational
+ kCGLRPBufferModes = 100, informational
+ kCGLRPColorModes = 103, informational
+ kCGLRPAccumModes = 104, informational
+ kCGLRPDepthModes = 105, informational
+ kCGLRPStencilModes = 106, informational
+ kCGLRPMaxAuxBuffers = 107, informational
+ kCGLRPMaxSampleBuffers = 108, informational
+ kCGLRPMaxSamples = 109, informational
+ kCGLRPSampleModes = 110, informational
+ kCGLRPSampleAlpha = 111, informational
+ kCGLRPVideoMemory = 120, informational
+ kCGLRPTextureMemory = 121, informational
+ kCGLRPRendererCount = 128 number of renderers in the CGLRendererInfoObj under examination
+
+ kCGLRPOffScreen = 53, D/C
+ kCGLRPRobust = 75, FALSE or D/C - aka we're asking for no-fallback
+ kCGLRPBackingStore = 76, D/C
+ kCGLRPMPSafe = 78, D/C
+ kCGLRPMultiScreen = 81, D/C
+ kCGLRPCompliant = 83, D/C
+ */
+
+
+ //--------------------------- info we have from CGL renderer queries, IOKit, Gestalt
+ //--------------------------- these are set up in the displayDB by CocoaMgr
+ GLint m_fullscreen;
+ GLint m_accelerated;
+ GLint m_windowed;
+
+ GLint m_rendererID;
+ GLint m_displayMask;
+ GLint m_bufferModes;
+ GLint m_colorModes;
+ GLint m_accumModes;
+ GLint m_depthModes;
+ GLint m_stencilModes;
+
+ GLint m_maxAuxBuffers;
+ GLint m_maxSampleBuffers;
+ GLint m_maxSamples;
+ GLint m_sampleModes;
+ GLint m_sampleAlpha;
+
+ GLint m_vidMemory;
+ GLint m_texMemory;
+
+ uint m_pciVendorID;
+ uint m_pciDeviceID;
+ char m_pciModelString[64];
+ char m_driverInfoString[64];
+
+ //--------------------------- OS version related - set up by CocoaMgr
+
+ // OS version found
+ uint m_osComboVersion; // 0x00XXYYZZ : XX major, YY minor, ZZ minor minor : 10.6.3 --> 0x000A0603. 10.5.8 --> 0x000A0508.
+
+ //--------------------------- shorthands - also set up by CocoaMgr - driven by vendorid / deviceid
+
+ bool m_ati;
+ bool m_atiR5xx;
+ bool m_atiR6xx;
+ bool m_atiR7xx;
+ bool m_atiR8xx;
+ bool m_atiNewer;
+
+ bool m_intel;
+ bool m_intel95x;
+ bool m_intel3100;
+ bool m_intelNewer;
+
+ bool m_nv;
+ bool m_nvG7x;
+ bool m_nvG8x;
+ bool m_nvNewer;
+
+ //--------------------------- context query results - left blank in the display DB - but valid in a GLMContext (call ctx->Caps() to get a const ref)
+
+ // booleans
+ bool m_hasGammaWrites; // aka glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT) / glEnable(GL_FRAMEBUFFER_SRGB_EXT)
+ bool m_hasMixedAttachmentSizes; // aka ARB_fbo in 10.6.3 - test for min OS vers, then exported ext string
+ bool m_hasBGRA; // aka GL_BGRA vertex attribs in 10.6.3 - - test for min OS vers, then exported ext string
+ bool m_hasNewFullscreenMode; // aka 10.6.x "big window" fullscreen mode
+ bool m_hasNativeClipVertexMode; // aka GLSL gl_ClipVertex does not fall back to SW- OS version and folklore-based
+ bool m_hasOcclusionQuery; // occlusion query: do you speak it ?!
+ bool m_hasFramebufferBlit; // framebuffer blit: know what I'm sayin?!
+ bool m_hasPerfPackage1; // means new MTGL, fast OQ, fast uniform upload, NV can resolve flipped (late summer 2010 post 10.6.4 update)
+
+ // counts
+ int m_maxAniso; // aniso limit - context query
+
+ // other exts
+ bool m_hasBindableUniforms;
+ int m_maxVertexBindableUniforms;
+ int m_maxFragmentBindableUniforms;
+ int m_maxBindableUniformSize;
+
+ bool m_hasUniformBuffers;
+
+ // runtime options that aren't negotiable once set
+ bool m_hasDualShaders; // must supply CLI arg "-glmdualshaders" or we go GLSL only
+
+ //--------------------------- " can'ts " - specific problems that need to be worked around
+
+ bool m_cantBlitReliably; // Intel chipsets have problems blitting sRGB sometimes
+ bool m_cantAttachSRGB; // NV G8x on 10.5.8 can't have srgb tex on FBO color - separate issue from hasGammaWrites
+ bool m_cantResolveFlipped; // happens on NV in 10.6.4 and prior - console variable "gl_can_resolve_flipped" can overrule
+ bool m_cantResolveScaled; // happens everywhere per GL spec but may be relaxed some day - console variable "gl_can_resolve_scaled" can overrule
+ bool m_costlyGammaFlips; // this means that sRGB sampling state affects shader code gen, resulting in state-dependent code regen
+
+
+ //--------------------------- " bads " - known bad drivers
+ bool m_badDriver1064NV; // this is the bad NVIDIA driver on 10.6.4 - stutter, tex corruption, black screen issues
+};
+
+
+
+#endif
diff --git a/mp/src/public/togl/linuxwin/glmdisplaydb.h b/mp/src/public/togl/linuxwin/glmdisplaydb.h new file mode 100644 index 00000000..7f78f910 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glmdisplaydb.h @@ -0,0 +1,92 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef GLMDISPLAYDB_H
+#define GLMDISPLAYDB_H
+
+#include "tier1/utlvector.h"
+
+//===============================================================================
+// modes, displays, and renderers
+//===============================================================================
+
+// GLMDisplayModeInfoFields is in glmdisplay.h
+
+class GLMDisplayMode
+{
+public:
+ GLMDisplayModeInfoFields m_info;
+
+ GLMDisplayMode( uint width, uint height, uint refreshHz );
+ GLMDisplayMode() { };
+ ~GLMDisplayMode( void );
+
+ void Init( uint width, uint height, uint refreshHz );
+ void Dump( int which );
+};
+
+//===============================================================================
+
+// GLMDisplayInfoFields is in glmdisplay.h
+
+class GLMDisplayInfo
+{
+public:
+ GLMDisplayInfoFields m_info;
+ CUtlVector< GLMDisplayMode* > *m_modes; // starts out NULL, set by PopulateModes
+
+ GLMDisplayInfo( void );
+ ~GLMDisplayInfo( void );
+
+ void PopulateModes( void );
+
+ void Dump( int which );
+};
+
+//===============================================================================
+
+// GLMRendererInfoFields is in glmdisplay.h
+
+class GLMRendererInfo
+{
+public:
+ GLMRendererInfoFields m_info;
+ GLMDisplayInfo *m_display;
+
+ GLMRendererInfo ();
+ ~GLMRendererInfo ( void );
+
+ void Init( GLMRendererInfoFields *info );
+ void PopulateDisplays();
+ void Dump( int which );
+};
+
+//===============================================================================
+
+class GLMDisplayDB
+{
+public:
+ GLMRendererInfo m_renderer;
+
+ GLMDisplayDB ( void );
+ ~GLMDisplayDB ( void );
+
+ virtual void PopulateRenderers( void );
+ virtual void PopulateFakeAdapters( uint realRendererIndex ); // fake adapters = one real adapter times however many displays are on it
+ virtual void Populate( void );
+
+ // The info-get functions return false on success.
+ virtual int GetFakeAdapterCount( void );
+ virtual bool GetFakeAdapterInfo( int fakeAdapterIndex, int *rendererOut, int *displayOut, GLMRendererInfoFields *rendererInfoOut, GLMDisplayInfoFields *displayInfoOut );
+
+ virtual int GetRendererCount( void );
+ virtual bool GetRendererInfo( int rendererIndex, GLMRendererInfoFields *infoOut );
+
+ virtual int GetDisplayCount( int rendererIndex );
+ virtual bool GetDisplayInfo( int rendererIndex, int displayIndex, GLMDisplayInfoFields *infoOut );
+
+ virtual int GetModeCount( int rendererIndex, int displayIndex );
+ virtual bool GetModeInfo( int rendererIndex, int displayIndex, int modeIndex, GLMDisplayModeInfoFields *infoOut );
+
+ virtual void Dump( void );
+};
+
+#endif // GLMDISPLAYDB_H
diff --git a/mp/src/public/togl/linuxwin/glmgr.h b/mp/src/public/togl/linuxwin/glmgr.h new file mode 100644 index 00000000..cc828636 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glmgr.h @@ -0,0 +1,2259 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmgr.h
+// singleton class, common basis for managing GL contexts
+// responsible for tracking adapters and contexts
+//
+//===============================================================================
+
+#ifndef GLMGR_H
+#define GLMGR_H
+
+#pragma once
+
+#include "glbase.h"
+#include "glentrypoints.h"
+#include "glmdebug.h"
+#include "glmdisplay.h"
+#include "glmgrext.h"
+#include "glmgrbasics.h"
+#include "cglmtex.h"
+#include "cglmfbo.h"
+#include "cglmprogram.h"
+#include "cglmbuffer.h"
+#include "cglmquery.h"
+
+#include "tier0/vprof_telemetry.h"
+#include "materialsystem/IShader.h"
+#include "dxabstract_types.h"
+#include "tier0/icommandline.h"
+
+//===============================================================================
+
+#define GLM_OPENGL_VENDOR_ID 1
+#define GLM_OPENGL_DEFAULT_DEVICE_ID 1
+#define GLM_OPENGL_LOW_PERF_DEVICE_ID 2
+
+extern void GLMDebugPrintf( const char *pMsg, ... );
+
+extern uint g_nTotalDrawsOrClears, g_nTotalVBLockBytes, g_nTotalIBLockBytes;
+
+#if GL_TELEMETRY_GPU_ZONES
+struct TelemetryGPUStats_t
+{
+ uint m_nTotalBufferLocksAndUnlocks;
+ uint m_nTotalTexLocksAndUnlocks;
+ uint m_nTotalBlit2;
+ uint m_nTotalResolveTex;
+ uint m_nTotalPresent;
+
+ inline void Clear() { memset( this, 0, sizeof( *this ) ); }
+ inline uint GetTotal() const { return m_nTotalBufferLocksAndUnlocks + m_nTotalTexLocksAndUnlocks + m_nTotalBlit2 + m_nTotalResolveTex + m_nTotalPresent; }
+};
+extern TelemetryGPUStats_t g_TelemetryGPUStats;
+#endif
+
+struct GLMRect;
+typedef void *PseudoGLContextPtr;
+
+// parrot the D3D present parameters, more or less... "adapter" translates into "active display index" per the m_activeDisplayCount below.
+class GLMDisplayParams
+{
+ public:
+
+ // presumption, these indices are in sync with the current display DB that GLMgr has handy
+ //int m_rendererIndex; // index of renderer (-1 if root context)
+ //int m_displayIndex; // index of display in renderer - for FS
+ //int m_modeIndex; // index of mode in display - for FS
+
+ void *m_focusWindow; // (VD3DHWND aka WindowRef) - what window does this context display into
+
+ bool m_fsEnable; // fullscreen on or not
+ bool m_vsyncEnable; // vsync on or not
+
+ // height and width have to match the display mode info if full screen.
+
+ uint m_backBufferWidth; // pixel width (aka screen h-resolution if full screen)
+ uint m_backBufferHeight; // pixel height (aka screen v-resolution if full screen)
+ D3DFORMAT m_backBufferFormat; // pixel format
+ uint m_multiSampleCount; // 0 means no MSAA, 2 means 2x MSAA, etc
+ // uint m_multiSampleQuality; // no MSAA quality control yet
+
+ bool m_enableAutoDepthStencil; // generally set to 'TRUE' per CShaderDeviceDx8::SetPresentParameters
+ D3DFORMAT m_autoDepthStencilFormat;
+
+ uint m_fsRefreshHz; // if full screen, this refresh rate (likely 0 for LCD's)
+
+ //uint m_rootRendererID; // only used if m_rendererIndex is -1.
+ //uint m_rootDisplayMask; // only used if m_rendererIndex is -1.
+
+ bool m_mtgl; // enable multi threaded GL driver
+};
+
+//===============================================================================
+
+class GLMgr
+{
+public:
+
+ //===========================================================================
+ // class methods - singleton
+ static void NewGLMgr( void ); // instantiate singleton..
+ static GLMgr *aGLMgr( void ); // return singleton..
+ static void DelGLMgr( void ); // tear down singleton..
+
+ //===========================================================================
+ // plain methods
+
+ #if 0 // turned all these off while new approach is coded
+ void RefreshDisplayDB( void ); // blow away old display DB, make a new one
+ GLMDisplayDB *GetDisplayDB( void ); // get a ptr to the one GLMgr keeps. only valid til next refresh.
+
+ // eligible renderers will be ranked by desirability starting at index 0 within the db
+ // within each renderer, eligible displays will be ranked some kind of desirability (area? dist from menu bar?)
+ // within each display, eligible modes will be ranked by descending areas
+
+ // calls supplying indices are implicitly making reference to the current DB
+ bool CaptureDisplay( int rendIndex, int displayIndex, bool captureAll ); // capture one display or all displays
+ void ReleaseDisplays( void ); // release all captures
+
+ int GetDisplayMode( int rendIndex, int displayIndex ); // retrieve current display res (returns modeIndex)
+ void SetDisplayMode( GLMDisplayParams *params ); // set the display res (only useful for FS)
+ #endif
+
+ GLMContext *NewContext( IDirect3DDevice9 *pDevice, GLMDisplayParams *params ); // this will have to change
+ void DelContext( GLMContext *context );
+
+ // with usage of CGLMacro.h we could dispense with the "current context" thing
+ // and just declare a member variable of GLMContext, allowing each glXXX call to be routed directly
+ // to the correct context
+ void SetCurrentContext( GLMContext *context ); // make current in calling thread only
+ GLMContext *GetCurrentContext( void );
+
+protected:
+ friend class GLMContext;
+
+ GLMgr();
+ ~GLMgr();
+};
+
+
+//===========================================================================//
+
+// helper function to do enable or disable in one step
+FORCEINLINE void glSetEnable( GLenum which, bool enable )
+{
+ if (enable)
+ gGL->glEnable(which);
+ else
+ gGL->glDisable(which);
+}
+
+// helper function for int vs enum clarity
+FORCEINLINE void glGetEnumv( GLenum which, GLenum *dst )
+{
+ gGL->glGetIntegerv( which, (int*)dst );
+}
+
+//===========================================================================//
+//
+// types to support the GLMContext
+//
+//===========================================================================//
+
+// Each state set/get path we are providing caching for, needs its own struct and a comparison operator.
+// we also provide an enum of how many such types there are, handy for building dirty masks etc.
+
+// shorthand macros
+#define EQ(fff) ( (src.fff) == (fff) )
+
+//rasterizer
+struct GLAlphaTestEnable_t { GLint enable; inline bool operator==(const GLAlphaTestEnable_t& src) const { return EQ(enable); } };
+struct GLAlphaTestFunc_t { GLenum func; GLclampf ref; inline bool operator==(const GLAlphaTestFunc_t& src) const { return EQ(func) && EQ(ref); } };
+struct GLCullFaceEnable_t { GLint enable; inline bool operator==(const GLCullFaceEnable_t& src) const { return EQ(enable); } };
+struct GLCullFrontFace_t { GLenum value; inline bool operator==(const GLCullFrontFace_t& src) const { return EQ(value); } };
+struct GLPolygonMode_t { GLenum values[2]; inline bool operator==(const GLPolygonMode_t& src) const { return EQ(values[0]) && EQ(values[1]); } };
+struct GLDepthBias_t { GLfloat factor; GLfloat units; inline bool operator==(const GLDepthBias_t& src) const { return EQ(factor) && EQ(units); } };
+struct GLScissorEnable_t { GLint enable; inline bool operator==(const GLScissorEnable_t& src) const { return EQ(enable); } };
+struct GLScissorBox_t { GLint x,y; GLsizei width, height; inline bool operator==(const GLScissorBox_t& src) const { return EQ(x) && EQ(y) && EQ(width) && EQ(height); } };
+struct GLAlphaToCoverageEnable_t{ GLint enable; inline bool operator==(const GLAlphaToCoverageEnable_t& src) const { return EQ(enable); } };
+struct GLViewportBox_t { GLint x,y; GLsizei width, height; uint widthheight; inline bool operator==(const GLViewportBox_t& src) const { return EQ(x) && EQ(y) && EQ(width) && EQ(height); } };
+struct GLViewportDepthRange_t { GLdouble flNear,flFar; inline bool operator==(const GLViewportDepthRange_t& src) const { return EQ(flNear) && EQ(flFar); } };
+struct GLClipPlaneEnable_t { GLint enable; inline bool operator==(const GLClipPlaneEnable_t& src) const { return EQ(enable); } };
+struct GLClipPlaneEquation_t { GLfloat x,y,z,w; inline bool operator==(const GLClipPlaneEquation_t& src) const { return EQ(x) && EQ(y) && EQ(z) && EQ(w); } };
+
+//blend
+struct GLColorMaskSingle_t { char r,g,b,a; inline bool operator==(const GLColorMaskSingle_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLColorMaskMultiple_t { char r,g,b,a; inline bool operator==(const GLColorMaskMultiple_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLBlendEnable_t { GLint enable; inline bool operator==(const GLBlendEnable_t& src) const { return EQ(enable); } };
+struct GLBlendFactor_t { GLenum srcfactor,dstfactor; inline bool operator==(const GLBlendFactor_t& src) const { return EQ(srcfactor) && EQ(dstfactor); } };
+struct GLBlendEquation_t { GLenum equation; inline bool operator==(const GLBlendEquation_t& src) const { return EQ(equation); } };
+struct GLBlendColor_t { GLfloat r,g,b,a; inline bool operator==(const GLBlendColor_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLBlendEnableSRGB_t { GLint enable; inline bool operator==(const GLBlendEnableSRGB_t& src) const { return EQ(enable); } };
+
+//depth
+struct GLDepthTestEnable_t { GLint enable; inline bool operator==(const GLDepthTestEnable_t& src) const { return EQ(enable); } };
+struct GLDepthFunc_t { GLenum func; inline bool operator==(const GLDepthFunc_t& src) const { return EQ(func); } };
+struct GLDepthMask_t { char mask; inline bool operator==(const GLDepthMask_t& src) const { return EQ(mask); } };
+
+//stencil
+struct GLStencilTestEnable_t { GLint enable; inline bool operator==(const GLStencilTestEnable_t& src) const { return EQ(enable); } };
+struct GLStencilFunc_t { GLenum frontfunc, backfunc; GLint ref; GLuint mask; inline bool operator==(const GLStencilFunc_t& src) const { return EQ(frontfunc) && EQ(backfunc) && EQ(ref) && EQ(mask); } };
+struct GLStencilOp_t { GLenum sfail; GLenum dpfail; GLenum dppass; inline bool operator==(const GLStencilOp_t& src) const { return EQ(sfail) && EQ(dpfail) && EQ(dppass); } };
+struct GLStencilWriteMask_t { GLint mask; inline bool operator==(const GLStencilWriteMask_t& src) const { return EQ(mask); } };
+
+//clearing
+struct GLClearColor_t { GLfloat r,g,b,a; inline bool operator==(const GLClearColor_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLClearDepth_t { GLdouble d; inline bool operator==(const GLClearDepth_t& src) const { return EQ(d); } };
+struct GLClearStencil_t { GLint s; inline bool operator==(const GLClearStencil_t& src) const { return EQ(s); } };
+
+#undef EQ
+
+enum EGLMStateBlockType
+{
+ kGLAlphaTestEnable,
+ kGLAlphaTestFunc,
+
+ kGLCullFaceEnable,
+ kGLCullFrontFace,
+
+ kGLPolygonMode,
+
+ kGLDepthBias,
+
+ kGLScissorEnable,
+ kGLScissorBox,
+
+ kGLViewportBox,
+ kGLViewportDepthRange,
+
+ kGLClipPlaneEnable,
+ kGLClipPlaneEquation,
+
+ kGLColorMaskSingle,
+ kGLColorMaskMultiple,
+
+ kGLBlendEnable,
+ kGLBlendFactor,
+ kGLBlendEquation,
+ kGLBlendColor,
+ kGLBlendEnableSRGB,
+
+ kGLDepthTestEnable,
+ kGLDepthFunc,
+ kGLDepthMask,
+
+ kGLStencilTestEnable,
+ kGLStencilFunc,
+ kGLStencilOp,
+ kGLStencilWriteMask,
+
+ kGLClearColor,
+ kGLClearDepth,
+ kGLClearStencil,
+
+ kGLAlphaToCoverageEnable,
+
+ kGLMStateBlockLimit
+};
+
+//===========================================================================//
+
+// templated functions representing GL R/W bottlenecks
+// one set of set/get/getdefault is instantiated for each of the GL*** types above.
+
+// use these from the non array state objects
+template<typename T> void GLContextSet( T *src );
+template<typename T> void GLContextGet( T *dst );
+template<typename T> void GLContextGetDefault( T *dst );
+
+// use these from the array state objects
+template<typename T> void GLContextSetIndexed( T *src, int index );
+template<typename T> void GLContextGetIndexed( T *dst, int index );
+template<typename T> void GLContextGetDefaultIndexed( T *dst, int index );
+
+//===============================================================================
+// template specializations for each type of state
+
+// --- GLAlphaTestEnable ---
+FORCEINLINE void GLContextSet( GLAlphaTestEnable_t *src )
+{
+ glSetEnable( GL_ALPHA_TEST, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLAlphaTestEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_ALPHA_TEST );
+}
+
+FORCEINLINE void GLContextGetDefault( GLAlphaTestEnable_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+// --- GLAlphaTestFunc ---
+FORCEINLINE void GLContextSet( GLAlphaTestFunc_t *src )
+{
+ gGL->glAlphaFunc( src->func, src->ref );
+}
+
+FORCEINLINE void GLContextGet( GLAlphaTestFunc_t *dst )
+{
+ glGetEnumv( GL_ALPHA_TEST_FUNC, &dst->func );
+ gGL->glGetFloatv( GL_ALPHA_TEST_REF, &dst->ref );
+}
+
+FORCEINLINE void GLContextGetDefault( GLAlphaTestFunc_t *dst )
+{
+ dst->func = GL_ALWAYS;
+ dst->ref = 0.0f;
+}
+
+// --- GLAlphaToCoverageEnable ---
+FORCEINLINE void GLContextSet( GLAlphaToCoverageEnable_t *src )
+{
+ glSetEnable( GL_SAMPLE_ALPHA_TO_COVERAGE_ARB, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLAlphaToCoverageEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_SAMPLE_ALPHA_TO_COVERAGE_ARB );
+}
+
+FORCEINLINE void GLContextGetDefault( GLAlphaToCoverageEnable_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+// --- GLCullFaceEnable ---
+FORCEINLINE void GLContextSet( GLCullFaceEnable_t *src )
+{
+ glSetEnable( GL_CULL_FACE, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLCullFaceEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_CULL_FACE );
+}
+
+FORCEINLINE void GLContextGetDefault( GLCullFaceEnable_t *dst )
+{
+ dst->enable = GL_TRUE;
+}
+
+
+// --- GLCullFrontFace ---
+FORCEINLINE void GLContextSet( GLCullFrontFace_t *src )
+{
+ gGL->glFrontFace( src->value ); // legal values are GL_CW or GL_CCW
+}
+
+FORCEINLINE void GLContextGet( GLCullFrontFace_t *dst )
+{
+ glGetEnumv( GL_FRONT_FACE, &dst->value );
+}
+
+FORCEINLINE void GLContextGetDefault( GLCullFrontFace_t *dst )
+{
+ dst->value = GL_CCW;
+}
+
+
+// --- GLPolygonMode ---
+FORCEINLINE void GLContextSet( GLPolygonMode_t *src )
+{
+ gGL->glPolygonMode( GL_FRONT, src->values[0] );
+ gGL->glPolygonMode( GL_BACK, src->values[1] );
+}
+
+FORCEINLINE void GLContextGet( GLPolygonMode_t *dst )
+{
+ glGetEnumv( GL_POLYGON_MODE, &dst->values[0] );
+
+}
+
+FORCEINLINE void GLContextGetDefault( GLPolygonMode_t *dst )
+{
+ dst->values[0] = dst->values[1] = GL_FILL;
+}
+
+
+// --- GLDepthBias ---
+// note the implicit enable / disable.
+// if you set non zero values, it is enabled, otherwise not.
+FORCEINLINE void GLContextSet( GLDepthBias_t *src )
+{
+ bool enable = (src->factor != 0.0f) || (src->units != 0.0f);
+
+ glSetEnable( GL_POLYGON_OFFSET_FILL, enable );
+ gGL->glPolygonOffset( src->factor, src->units );
+}
+
+FORCEINLINE void GLContextGet( GLDepthBias_t *dst )
+{
+ gGL->glGetFloatv ( GL_POLYGON_OFFSET_FACTOR, &dst->factor );
+ gGL->glGetFloatv ( GL_POLYGON_OFFSET_UNITS, &dst->units );
+}
+
+FORCEINLINE void GLContextGetDefault( GLDepthBias_t *dst )
+{
+ dst->factor = 0.0;
+ dst->units = 0.0;
+}
+
+
+// --- GLScissorEnable ---
+FORCEINLINE void GLContextSet( GLScissorEnable_t *src )
+{
+ glSetEnable( GL_SCISSOR_TEST, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLScissorEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_SCISSOR_TEST );
+}
+
+FORCEINLINE void GLContextGetDefault( GLScissorEnable_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+
+// --- GLScissorBox ---
+FORCEINLINE void GLContextSet( GLScissorBox_t *src )
+{
+ gGL->glScissor ( src->x, src->y, src->width, src->height );
+}
+
+FORCEINLINE void GLContextGet( GLScissorBox_t *dst )
+{
+ gGL->glGetIntegerv ( GL_SCISSOR_BOX, &dst->x );
+}
+
+FORCEINLINE void GLContextGetDefault( GLScissorBox_t *dst )
+{
+ // hmmmm, good question? we can't really know a good answer so we pick a silly one
+ // and the client better come back with a better answer later.
+ dst->x = dst->y = 0;
+ dst->width = dst->height = 16;
+}
+
+
+// --- GLViewportBox ---
+
+FORCEINLINE void GLContextSet( GLViewportBox_t *src )
+{
+ Assert( src->width == (int)( src->widthheight & 0xFFFF ) );
+ Assert( src->height == (int)( src->widthheight >> 16 ) );
+ gGL->glViewport (src->x, src->y, src->width, src->height );
+}
+
+FORCEINLINE void GLContextGet( GLViewportBox_t *dst )
+{
+ gGL->glGetIntegerv ( GL_VIEWPORT, &dst->x );
+ dst->widthheight = dst->width | ( dst->height << 16 );
+}
+
+FORCEINLINE void GLContextGetDefault( GLViewportBox_t *dst )
+{
+ // as with the scissor box, we don't know yet, so pick a silly one and change it later
+ dst->x = dst->y = 0;
+ dst->width = dst->height = 16;
+ dst->widthheight = dst->width | ( dst->height << 16 );
+}
+
+
+// --- GLViewportDepthRange ---
+FORCEINLINE void GLContextSet( GLViewportDepthRange_t *src )
+{
+ gGL->glDepthRange ( src->flNear, src->flFar );
+}
+
+FORCEINLINE void GLContextGet( GLViewportDepthRange_t *dst )
+{
+ gGL->glGetDoublev ( GL_DEPTH_RANGE, &dst->flNear );
+}
+
+FORCEINLINE void GLContextGetDefault( GLViewportDepthRange_t *dst )
+{
+ dst->flNear = 0.0;
+ dst->flFar = 1.0;
+}
+
+// --- GLClipPlaneEnable ---
+FORCEINLINE void GLContextSetIndexed( GLClipPlaneEnable_t *src, int index )
+{
+#if GLMDEBUG
+ if (CommandLine()->FindParm("-caps_noclipplanes"))
+ {
+ if (GLMKnob("caps-key",NULL) > 0.0)
+ {
+ // caps ON means NO clipping
+ src->enable = false;
+ }
+ }
+#endif
+ glSetEnable( GL_CLIP_PLANE0 + index, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGetIndexed( GLClipPlaneEnable_t *dst, int index )
+{
+ dst->enable = gGL->glIsEnabled( GL_CLIP_PLANE0 + index );
+}
+
+FORCEINLINE void GLContextGetDefaultIndexed( GLClipPlaneEnable_t *dst, int index )
+{
+ dst->enable = 0;
+}
+
+
+
+// --- GLClipPlaneEquation ---
+FORCEINLINE void GLContextSetIndexed( GLClipPlaneEquation_t *src, int index )
+{
+ // shove into glGlipPlane
+ GLdouble coeffs[4] = { src->x, src->y, src->z, src->w };
+
+ gGL->glClipPlane( GL_CLIP_PLANE0 + index, coeffs );
+}
+
+FORCEINLINE void GLContextGetIndexed( GLClipPlaneEquation_t *dst, int index )
+{
+ DebuggerBreak(); // do this later
+ // glClipPlane( GL_CLIP_PLANE0 + index, coeffs );
+ // GLdouble coeffs[4] = { src->x, src->y, src->z, src->w };
+}
+
+FORCEINLINE void GLContextGetDefaultIndexed( GLClipPlaneEquation_t *dst, int index )
+{
+ dst->x = 1.0;
+ dst->y = 0.0;
+ dst->z = 0.0;
+ dst->w = 0.0;
+}
+
+
+// --- GLColorMaskSingle ---
+FORCEINLINE void GLContextSet( GLColorMaskSingle_t *src )
+{
+ gGL->glColorMask( src->r, src->g, src->b, src->a );
+}
+
+FORCEINLINE void GLContextGet( GLColorMaskSingle_t *dst )
+{
+ gGL->glGetBooleanv( GL_COLOR_WRITEMASK, (GLboolean*)&dst->r);
+}
+
+FORCEINLINE void GLContextGetDefault( GLColorMaskSingle_t *dst )
+{
+ dst->r = dst->g = dst->b = dst->a = 1;
+}
+
+
+// --- GLColorMaskMultiple ---
+FORCEINLINE void GLContextSetIndexed( GLColorMaskMultiple_t *src, int index )
+{
+ gGL->glColorMaskIndexedEXT ( index, src->r, src->g, src->b, src->a );
+}
+
+FORCEINLINE void GLContextGetIndexed( GLColorMaskMultiple_t *dst, int index )
+{
+ gGL->glGetBooleanIndexedvEXT ( GL_COLOR_WRITEMASK, index, (GLboolean*)&dst->r );
+}
+
+FORCEINLINE void GLContextGetDefaultIndexed( GLColorMaskMultiple_t *dst, int index )
+{
+ dst->r = dst->g = dst->b = dst->a = 1;
+}
+
+
+// --- GLBlendEnable ---
+FORCEINLINE void GLContextSet( GLBlendEnable_t *src )
+{
+ glSetEnable( GL_BLEND, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLBlendEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_BLEND );
+}
+
+FORCEINLINE void GLContextGetDefault( GLBlendEnable_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+
+// --- GLBlendFactor ---
+FORCEINLINE void GLContextSet( GLBlendFactor_t *src )
+{
+ gGL->glBlendFunc ( src->srcfactor, src->dstfactor );
+}
+
+FORCEINLINE void GLContextGet( GLBlendFactor_t *dst )
+{
+ glGetEnumv ( GL_BLEND_SRC, &dst->srcfactor );
+ glGetEnumv ( GL_BLEND_DST, &dst->dstfactor );
+}
+
+FORCEINLINE void GLContextGetDefault( GLBlendFactor_t *dst )
+{
+ dst->srcfactor = GL_ONE;
+ dst->dstfactor = GL_ZERO;
+}
+
+
+// --- GLBlendEquation ---
+FORCEINLINE void GLContextSet( GLBlendEquation_t *src )
+{
+ gGL->glBlendEquation ( src->equation );
+}
+
+FORCEINLINE void GLContextGet( GLBlendEquation_t *dst )
+{
+ glGetEnumv ( GL_BLEND_EQUATION, &dst->equation );
+}
+
+FORCEINLINE void GLContextGetDefault( GLBlendEquation_t *dst )
+{
+ dst->equation = GL_FUNC_ADD;
+}
+
+
+// --- GLBlendColor ---
+FORCEINLINE void GLContextSet( GLBlendColor_t *src )
+{
+ gGL->glBlendColor ( src->r, src->g, src->b, src->a );
+}
+
+FORCEINLINE void GLContextGet( GLBlendColor_t *dst )
+{
+ gGL->glGetFloatv ( GL_BLEND_COLOR, &dst->r );
+}
+
+FORCEINLINE void GLContextGetDefault( GLBlendColor_t *dst )
+{
+ //solid white
+ dst->r = dst->g = dst->b = dst->a = 1.0;
+}
+
+
+// --- GLBlendEnableSRGB ---
+
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+
+FORCEINLINE void GLContextSet( GLBlendEnableSRGB_t *src )
+{
+#if GLMDEBUG
+ // just check in debug... this is too expensive to look at on MTGL
+ if (src->enable)
+ {
+ GLboolean srgb_capable = false;
+ gGL->glGetBooleanv( GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, &srgb_capable);
+
+ if (src->enable && !srgb_capable)
+ {
+ GLMPRINTF(("-Z- srgb-state-set FBO conflict: attempt to enable SRGB on non SRGB capable FBO config"));
+ }
+ }
+#endif
+ // this query is not useful unless you have the ARB_framebuffer_srgb ext.
+ //GLint encoding = 0;
+ //pfnglGetFramebufferAttachmentParameteriv( GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &encoding );
+
+ glSetEnable( GL_FRAMEBUFFER_SRGB_EXT, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLBlendEnableSRGB_t *dst )
+{
+ //dst->enable = glIsEnabled( GL_FRAMEBUFFER_SRGB_EXT );
+ dst->enable = true; // wtf ?
+}
+
+FORCEINLINE void GLContextGetDefault( GLBlendEnableSRGB_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+
+// --- GLDepthTestEnable ---
+FORCEINLINE void GLContextSet( GLDepthTestEnable_t *src )
+{
+ glSetEnable( GL_DEPTH_TEST, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLDepthTestEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_DEPTH_TEST );
+}
+
+FORCEINLINE void GLContextGetDefault( GLDepthTestEnable_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+
+// --- GLDepthFunc ---
+FORCEINLINE void GLContextSet( GLDepthFunc_t *src )
+{
+ gGL->glDepthFunc ( src->func );
+}
+
+FORCEINLINE void GLContextGet( GLDepthFunc_t *dst )
+{
+ glGetEnumv ( GL_DEPTH_FUNC, &dst->func );
+}
+
+FORCEINLINE void GLContextGetDefault( GLDepthFunc_t *dst )
+{
+ dst->func = GL_GEQUAL;
+}
+
+
+// --- GLDepthMask ---
+FORCEINLINE void GLContextSet( GLDepthMask_t *src )
+{
+ gGL->glDepthMask ( src->mask );
+}
+
+FORCEINLINE void GLContextGet( GLDepthMask_t *dst )
+{
+ gGL->glGetBooleanv ( GL_DEPTH_WRITEMASK, (GLboolean*)&dst->mask );
+}
+
+FORCEINLINE void GLContextGetDefault( GLDepthMask_t *dst )
+{
+ dst->mask = GL_TRUE;
+}
+
+
+// --- GLStencilTestEnable ---
+FORCEINLINE void GLContextSet( GLStencilTestEnable_t *src )
+{
+ glSetEnable( GL_STENCIL_TEST, src->enable != 0 );
+}
+
+FORCEINLINE void GLContextGet( GLStencilTestEnable_t *dst )
+{
+ dst->enable = gGL->glIsEnabled( GL_STENCIL_TEST );
+}
+
+FORCEINLINE void GLContextGetDefault( GLStencilTestEnable_t *dst )
+{
+ dst->enable = GL_FALSE;
+}
+
+
+// --- GLStencilFunc ---
+FORCEINLINE void GLContextSet( GLStencilFunc_t *src )
+{
+ if (src->frontfunc == src->backfunc)
+ gGL->glStencilFuncSeparate( GL_FRONT_AND_BACK, src->frontfunc, src->ref, src->mask);
+ else
+ {
+ gGL->glStencilFuncSeparate( GL_FRONT, src->frontfunc, src->ref, src->mask);
+ gGL->glStencilFuncSeparate( GL_BACK, src->backfunc, src->ref, src->mask);
+ }
+}
+
+FORCEINLINE void GLContextGet( GLStencilFunc_t *dst )
+{
+ glGetEnumv ( GL_STENCIL_FUNC, &dst->frontfunc );
+ glGetEnumv ( GL_STENCIL_BACK_FUNC, &dst->backfunc );
+ gGL->glGetIntegerv ( GL_STENCIL_REF, &dst->ref );
+ gGL->glGetIntegerv ( GL_STENCIL_VALUE_MASK, (GLint*)&dst->mask );
+}
+
+FORCEINLINE void GLContextGetDefault( GLStencilFunc_t *dst )
+{
+ dst->frontfunc = GL_ALWAYS;
+ dst->backfunc = GL_ALWAYS;
+ dst->ref = 0;
+ dst->mask = 0xFFFFFFFF;
+}
+
+
+// --- GLStencilOp --- indexed 0=front, 1=back
+
+FORCEINLINE void GLContextSetIndexed( GLStencilOp_t *src, int index )
+{
+ GLenum face = (index==0) ? GL_FRONT : GL_BACK;
+ gGL->glStencilOpSeparate( face, src->sfail, src->dpfail, src->dppass );
+}
+
+FORCEINLINE void GLContextGetIndexed( GLStencilOp_t *dst, int index )
+{
+ glGetEnumv ( (index==0) ? GL_STENCIL_FAIL : GL_STENCIL_BACK_FAIL, &dst->sfail );
+ glGetEnumv ( (index==0) ? GL_STENCIL_PASS_DEPTH_FAIL : GL_STENCIL_BACK_PASS_DEPTH_FAIL, &dst->dpfail );
+ glGetEnumv ( (index==0) ? GL_STENCIL_PASS_DEPTH_PASS : GL_STENCIL_BACK_PASS_DEPTH_PASS, &dst->dppass );
+}
+
+FORCEINLINE void GLContextGetDefaultIndexed( GLStencilOp_t *dst, int index )
+{
+ dst->sfail = dst->dpfail = dst->dppass = GL_KEEP;
+}
+
+
+// --- GLStencilWriteMask ---
+FORCEINLINE void GLContextSet( GLStencilWriteMask_t *src )
+{
+ gGL->glStencilMask( src->mask );
+}
+
+FORCEINLINE void GLContextGet( GLStencilWriteMask_t *dst )
+{
+ gGL->glGetIntegerv ( GL_STENCIL_WRITEMASK, &dst->mask );
+}
+
+FORCEINLINE void GLContextGetDefault( GLStencilWriteMask_t *dst )
+{
+ dst->mask = 0xFFFFFFFF;
+}
+
+
+// --- GLClearColor ---
+FORCEINLINE void GLContextSet( GLClearColor_t *src )
+{
+ gGL->glClearColor( src->r, src->g, src->b, src->a );
+}
+
+FORCEINLINE void GLContextGet( GLClearColor_t *dst )
+{
+ gGL->glGetFloatv ( GL_COLOR_CLEAR_VALUE, &dst->r );
+}
+
+FORCEINLINE void GLContextGetDefault( GLClearColor_t *dst )
+{
+ dst->r = dst->g = dst->b = 0.5;
+ dst->a = 1.0;
+}
+
+
+// --- GLClearDepth ---
+FORCEINLINE void GLContextSet( GLClearDepth_t *src )
+{
+ gGL->glClearDepth ( src->d );
+}
+
+FORCEINLINE void GLContextGet( GLClearDepth_t *dst )
+{
+ gGL->glGetDoublev ( GL_DEPTH_CLEAR_VALUE, &dst->d );
+}
+
+FORCEINLINE void GLContextGetDefault( GLClearDepth_t *dst )
+{
+ dst->d = 1.0;
+}
+
+
+// --- GLClearStencil ---
+FORCEINLINE void GLContextSet( GLClearStencil_t *src )
+{
+ gGL->glClearStencil( src->s );
+}
+
+FORCEINLINE void GLContextGet( GLClearStencil_t *dst )
+{
+ gGL->glGetIntegerv ( GL_STENCIL_CLEAR_VALUE, &dst->s );
+}
+
+FORCEINLINE void GLContextGetDefault( GLClearStencil_t *dst )
+{
+ dst->s = 0;
+}
+
+//===========================================================================//
+
+// caching state object template. One of these is instantiated in the context per unique struct type above
+template<typename T> class GLState
+{
+ public:
+ inline GLState()
+ {
+ memset( &data, 0, sizeof(data) );
+ Default();
+ }
+
+ FORCEINLINE void Flush()
+ {
+ // immediately blast out the state - it makes no sense to delta it or do anything fancy because shaderapi, dxabstract, and OpenGL itself does this for us (and OpenGL calls with multithreaded drivers are very cheap)
+ GLContextSet( &data );
+ }
+
+ // write: client src into cache
+ // common case is both false. dirty is calculated, context write is deferred.
+ FORCEINLINE void Write( const T *src )
+ {
+ data = *src;
+ Flush();
+ }
+
+ // default: write default value to cache, optionally write through
+ inline void Default( bool noDefer=false )
+ {
+ GLContextGetDefault( &data ); // read default values directly to our cache copy
+ Flush();
+ }
+
+ // read: sel = 0 for cache, 1 for context
+ inline void Read( T *dst, int sel )
+ {
+ if (sel==0)
+ *dst = data;
+ else
+ GLContextGet( dst );
+ }
+
+ // check: verify that context equals cache, return true if mismatched or if illegal values seen
+ inline bool Check ( void )
+ {
+ T temp;
+ bool result;
+
+ GLContextGet( &temp );
+ result = !(temp == data);
+ return result;
+ }
+
+ FORCEINLINE const T &GetData() const { return data; }
+
+ protected:
+ T data;
+};
+
+// caching state object template - with multiple values behind it that are indexed
+template<typename T, int COUNT> class GLStateArray
+{
+ public:
+ inline GLStateArray()
+ {
+ memset( &data, 0, sizeof(data) );
+ Default();
+ }
+
+ // write cache->context if dirty or forced.
+ FORCEINLINE void FlushIndex( int index )
+ {
+ // immediately blast out the state - it makes no sense to delta it or do anything fancy because shaderapi, dxabstract, and OpenGL itself does this for us (and OpenGL calls with multithreaded drivers are very cheap)
+ GLContextSetIndexed( &data[index], index );
+ };
+
+ // write: client src into cache
+ // common case is both false. dirty is calculated, context write is deferred.
+ FORCEINLINE void WriteIndex( T *src, int index )
+ {
+ data[index] = *src;
+ FlushIndex( index ); // dirty becomes false
+ };
+
+ // write all slots in the array
+ FORCEINLINE void Flush()
+ {
+ for( int i=0; i < COUNT; i++)
+ {
+ FlushIndex( i );
+ }
+ }
+
+ // default: write default value to cache, optionally write through
+ inline void DefaultIndex( int index )
+ {
+ GLContextGetDefaultIndexed( &data[index], index ); // read default values directly to our cache copy
+ Flush();
+ };
+
+ inline void Default( void )
+ {
+ for( int i=0; i<COUNT; i++)
+ {
+ DefaultIndex( i );
+ }
+ }
+
+ // read: sel = 0 for cache, 1 for context
+ inline void ReadIndex( T *dst, int index, int sel )
+ {
+ if (sel==0)
+ *dst = data[index];
+ else
+ GLContextGetIndexed( dst, index );
+ };
+
+ // check: verify that context equals cache, return true if mismatched or if illegal values seen
+ inline bool CheckIndex( int index )
+ {
+ T temp;
+ bool result;
+
+ GLContextGetIndexed( &temp, index );
+ result = !(temp == data[index]);
+
+ return result;
+ };
+
+ inline bool Check( void )
+ {
+ //T temp;
+ bool result = false;
+
+ for( int i=0; i<COUNT; i++)
+ {
+ result |= CheckIndex( i );
+ }
+
+ return result;
+ };
+
+ protected:
+ T data[COUNT];
+};
+
+
+//===========================================================================//
+
+
+
+struct GLMTexSampler
+{
+ CGLMTex *m_pBoundTex; // tex which is actually bound now
+ GLMTexSamplingParams m_samp; // current 2D sampler state
+};
+
+// GLMContext will maintain one of these structures inside the context to represent the current state.
+// Client can supply a new one when it wants to change the setup.
+//FIXME GLMContext can do the work to migrate from old setup to new setup as efficiently as possible (but it doesn't yet)
+
+struct GLMVertexSetup
+{
+ uint m_attrMask; // which attrs are enabled (1<<n) mask where n is a GLMVertexAttributeIndex.
+
+ GLMVertexAttributeDesc m_attrs[ kGLMVertexAttributeIndexMax ];
+
+ // copied in from dxabstract, not strictly needed for operation, helps debugging
+ unsigned char m_vtxAttribMap[16];
+
+ /* high nibble is usage per _D3DDECLUSAGE
+ typedef enum _D3DDECLUSAGE
+ {
+ D3DDECLUSAGE_POSITION = 0,
+ D3DDECLUSAGE_BLENDWEIGHT = 1,
+ D3DDECLUSAGE_BLENDINDICES = 2,
+ D3DDECLUSAGE_NORMAL = 3,
+ D3DDECLUSAGE_PSIZE = 4,
+ D3DDECLUSAGE_TEXCOORD = 5,
+ D3DDECLUSAGE_TANGENT = 6,
+ D3DDECLUSAGE_BINORMAL = 7,
+ D3DDECLUSAGE_TESSFACTOR = 8,
+ D3DDECLUSAGE_PLUGH = 9, // mystery value
+ D3DDECLUSAGE_COLOR = 10,
+ D3DDECLUSAGE_FOG = 11,
+ D3DDECLUSAGE_DEPTH = 12,
+ D3DDECLUSAGE_SAMPLE = 13,
+ } D3DDECLUSAGE;
+
+ low nibble is usageindex (i.e. POSITION0, POSITION1, etc)
+ array position is attrib number.
+ */
+};
+
+//===========================================================================//
+
+//FIXME magic numbers here
+
+#define kGLMProgramParamFloat4Limit 256
+#define kGLMProgramParamBoolLimit 16
+#define kGLMProgramParamInt4Limit 16
+
+#define kGLMVertexProgramParamFloat4Limit 256
+#define kGLMFragmentProgramParamFloat4Limit 32
+
+struct GLMProgramParamsF
+{
+ float m_values[kGLMProgramParamFloat4Limit][4]; // float4's 256 of them
+
+ int m_firstDirtySlotNonBone;
+ int m_dirtySlotHighWaterNonBone; // index of slot past highest dirty non-bone register (assume 0 for base of range)
+
+ int m_dirtySlotHighWaterBone; // index of slot past highest dirty bone register (0=first bone reg, which is DXABSTRACT_VS_FIRST_BONE_SLOT)
+};
+
+struct GLMProgramParamsB
+{
+ int m_values[kGLMProgramParamBoolLimit]; // bools, 4 of them
+ uint m_dirtySlotCount;
+};
+
+struct GLMProgramParamsI
+{
+ int m_values[kGLMProgramParamInt4Limit][4]; // int4s, 16 of them
+ uint m_dirtySlotCount;
+};
+
+enum EGLMParamWriteMode
+{
+ eParamWriteAllSlots, // glUniform4fv of the maximum size (not recommended if shader is down-sizing the decl)
+ eParamWriteShaderSlots, // glUniform4fv of the active slot count ("highwater")
+ eParamWriteShaderSlotsOptional, // glUniform4fv of the active slot count ("highwater") - but only if at least one has been written - it's optional
+ eParamWriteDirtySlotRange // glUniform4fv of the 0-N range where N is highest dirty slot
+};
+
+enum EGLMAttribWriteMode
+{
+ eAttribWriteAll,
+ eAttribWriteDirty
+};
+
+//===========================================================================//
+
+#if GLMDEBUG
+enum EGLMDebugCallSite
+{
+ eBeginFrame, // inside begin frame func - frame number has been inc'd, batch number should be -1
+ eClear, // inside clear func
+ eDrawElements, // inside repeat loop, prior to draw call - batch numberhas been inc'd
+ eEndFrame, // end frame
+ ePresent // before showing pixels
+};
+
+// caller should zero one of these out and fill in the m_caller before invoking the hook
+struct GLMDebugHookInfo
+{
+ // info from the caller to the debug hook
+ EGLMDebugCallSite m_caller;
+
+
+ // state the hook uses to keep track of progress within a single run of the caller
+ int m_iteration; // which call to the hook is this. if it's zero, it precedes any action in the caller.
+
+
+ // bools used to communicate between caller and hook
+ bool m_loop; // hook tells caller to loop around again (don't exit)
+ bool m_holding; // current mood of hook, are we holding on this batch (i.e. rerun)
+
+ // specific info for a draw call
+ GLenum m_drawMode;
+ GLuint m_drawStart;
+ GLuint m_drawEnd;
+ GLsizei m_drawCount;
+ GLenum m_drawType;
+ const GLvoid *m_drawIndices;
+};
+#endif
+
+//===========================================================================//
+
+class CFlushDrawStatesStats
+{
+public:
+ CFlushDrawStatesStats()
+ {
+ Clear();
+ }
+
+ void Clear()
+ {
+ memset(this, 0, sizeof(*this));
+ }
+
+ uint m_nTotalBatchFlushes;
+ uint m_nTotalProgramPairChanges;
+
+ uint m_nNumChangedSamplers;
+ uint m_nNumSamplingParamsChanged;
+ uint m_nIndexBufferChanged;
+ uint m_nVertexBufferChanged;
+
+ uint m_nFirstVSConstant;
+ uint m_nNumVSConstants;
+ uint m_nNumVSBoneConstants;
+ uint m_nFirstPSConstant;
+ uint m_nNumPSConstants;
+ uint m_nNewPS;
+ uint m_nNewVS;
+};
+
+//===========================================================================//
+
+#ifndef GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD
+#define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD 0x9160
+#endif
+
+#define GLMGR_PINNED_MEMORY_BUFFER_SIZE ( 6 * 1024 * 1024 )
+
+class CPinnedMemoryBuffer
+{
+ CPinnedMemoryBuffer( const CPinnedMemoryBuffer & );
+ CPinnedMemoryBuffer & operator= ( const CPinnedMemoryBuffer & );
+
+public:
+ CPinnedMemoryBuffer() : m_pRawBuf( NULL ), m_pBuf( NULL ), m_nSize( 0 ), m_nOfs( 0 ), m_nBufferObj( 0 ), m_nSyncObj( 0 )
+ {
+ }
+
+ ~CPinnedMemoryBuffer()
+ {
+ Deinit();
+ }
+
+ bool Init( uint nSize )
+ {
+ Deinit();
+
+ // Guarantee 64KB alignment
+ m_pRawBuf = malloc( nSize + 65535 );
+ m_pBuf = reinterpret_cast<void *>((reinterpret_cast<uint64>(m_pRawBuf) + 65535) & (~65535));
+ m_nSize = nSize;
+ m_nOfs = 0;
+
+ gGL->glGenBuffersARB( 1, &m_nBufferObj );
+ gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_nBufferObj );
+
+ gGL->glBufferDataARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_nSize, m_pBuf, GL_STREAM_COPY );
+
+ return true;
+ }
+
+ void Deinit()
+ {
+ if ( !m_pRawBuf )
+ return;
+
+ BlockUntilNotBusy();
+
+ gGL->glBindBufferARB(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_nBufferObj );
+
+ gGL->glBufferDataARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0, (void*)NULL, GL_STREAM_COPY );
+
+ gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0 );
+
+ gGL->glDeleteBuffersARB( 1, &m_nBufferObj );
+ m_nBufferObj = 0;
+
+ free( m_pRawBuf );
+ m_pRawBuf = NULL;
+ m_pBuf = NULL;
+
+ m_nSize = 0;
+ m_nOfs = 0;
+ }
+
+ inline uint GetSize() const { return m_nSize; }
+ inline uint GetOfs() const { return m_nOfs; }
+ inline uint GetBytesRemaining() const { return m_nSize - m_nOfs; }
+ inline void *GetPtr() const { return m_pBuf; }
+ inline GLuint GetHandle() const { return m_nBufferObj; }
+
+ void InsertFence()
+ {
+ if ( m_nSyncObj )
+ {
+ gGL->glDeleteSync( m_nSyncObj );
+ }
+
+ m_nSyncObj = gGL->glFenceSync( GL_SYNC_GPU_COMMANDS_COMPLETE, 0 );
+ }
+
+ void BlockUntilNotBusy()
+ {
+ if ( m_nSyncObj )
+ {
+ gGL->glClientWaitSync( m_nSyncObj, GL_SYNC_FLUSH_COMMANDS_BIT, 3000000000000ULL );
+
+ gGL->glDeleteSync( m_nSyncObj );
+
+ m_nSyncObj = 0;
+ }
+ m_nOfs = 0;
+ }
+
+ void Append( uint nSize )
+ {
+ m_nOfs += nSize;
+ Assert( m_nOfs <= m_nSize );
+ }
+
+private:
+ void *m_pRawBuf;
+ void *m_pBuf;
+ uint m_nSize;
+ uint m_nOfs;
+
+ GLuint m_nBufferObj;
+
+ GLsync m_nSyncObj;
+};
+
+//===========================================================================//
+
+class GLMContext
+{
+ public:
+ // set/check current context (perq for many other calls)
+ void MakeCurrent( bool bRenderThread = false );
+ void ReleaseCurrent( bool bRenderThread = false );
+
+ // CheckCurrent has been removed (it no longer compiled on Linux). To minimize churn I'm leaving
+ // the inline NOP version.
+ // DO NOT change this to non-inlined. It's called all over the place from very hot codepaths.
+ FORCEINLINE void CheckCurrent( void ) { }
+
+ void PopulateCaps( void ); // fill out later portions of renderer info record which need context queries
+ void DumpCaps( void ); // printf all the caps info (you can call this in release too)
+ const GLMRendererInfoFields& Caps( void ); // peek at the caps record
+
+ // state cache/mirror
+ void SetDefaultStates( void );
+ void ForceFlushStates();
+
+ void VerifyStates( void );
+
+ // textures
+ // Lock and Unlock reqs go directly to the tex object
+ CGLMTex *NewTex( GLMTexLayoutKey *key, const char *debugLabel=NULL );
+ void DelTex( CGLMTex *tex );
+
+ // options for Blit (replacement for ResolveTex and BlitTex)
+ // pass NULL for dstTex if you want to target GL_BACK with the blit. You get y-flip with that, don't change the dstrect yourself.
+ void Blit2( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter );
+
+ // tex blit (via FBO blit)
+ void BlitTex( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter, bool useBlitFB = true );
+
+ // MSAA resolve - we do this in GLMContext because it has to do a bunch of FBO/blit gymnastics
+ void ResolveTex( CGLMTex *tex, bool forceDirty=false );
+
+ // texture pre-load (residency forcing) - normally done one-time but you can force it
+ void PreloadTex( CGLMTex *tex, bool force=false );
+
+ // samplers
+ FORCEINLINE void SetSamplerTex( int sampler, CGLMTex *tex );
+
+ FORCEINLINE void SetSamplerDirty( int sampler );
+ FORCEINLINE void SetSamplerMinFilter( int sampler, GLenum Value );
+ FORCEINLINE void SetSamplerMagFilter( int sampler, GLenum Value );
+ FORCEINLINE void SetSamplerMipFilter( int sampler, GLenum Value );
+ FORCEINLINE void SetSamplerAddressU( int sampler, GLenum Value );
+ FORCEINLINE void SetSamplerAddressV( int sampler, GLenum Value );
+ FORCEINLINE void SetSamplerAddressW( int sampler, GLenum Value );
+ FORCEINLINE void SetSamplerStates( int sampler, GLenum AddressU, GLenum AddressV, GLenum AddressW, GLenum minFilter, GLenum magFilter, GLenum mipFilter );
+ FORCEINLINE void SetSamplerBorderColor( int sampler, DWORD Value );
+ FORCEINLINE void SetSamplerMipMapLODBias( int sampler, DWORD Value );
+ FORCEINLINE void SetSamplerMaxMipLevel( int sampler, DWORD Value );
+ FORCEINLINE void SetSamplerMaxAnisotropy( int sampler, DWORD Value );
+ FORCEINLINE void SetSamplerSRGBTexture( int sampler, DWORD Value );
+ FORCEINLINE void SetShadowFilter( int sampler, DWORD Value );
+
+ // render targets (FBO's)
+ CGLMFBO *NewFBO( void );
+ void DelFBO( CGLMFBO *fbo );
+
+ // programs
+ CGLMProgram *NewProgram( EGLMProgramType type, char *progString, const char *pShaderName );
+ void DelProgram( CGLMProgram *pProg );
+ void NullProgram( void ); // de-ac all shader state
+
+ FORCEINLINE void SetVertexProgram( CGLMProgram *pProg );
+ FORCEINLINE void SetFragmentProgram( CGLMProgram *pProg );
+ FORCEINLINE void SetProgram( EGLMProgramType nProgType, CGLMProgram *pProg ) { m_drawingProgram[nProgType] = pProg; m_bDirtyPrograms = true; }
+
+ void SetDrawingLang( EGLMProgramLang lang, bool immediate=false ); // choose ARB or GLSL. immediate=false defers lang change to top of frame
+
+ void LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp ); // ensure this combo has been linked and is in the GLSL pair cache
+ void ClearShaderPairCache( void ); // call this to shoot down all the linked pairs
+ void QueryShaderPair( int index, GLMShaderPairInfo *infoOut ); // this lets you query the shader pair cache for saving its state
+
+ // buffers
+ // Lock and Unlock reqs go directly to the buffer object
+ CGLMBuffer *NewBuffer( EGLMBufferType type, uint size, uint options );
+ void DelBuffer( CGLMBuffer *buff );
+
+ FORCEINLINE void SetIndexBuffer( CGLMBuffer *buff ) { BindIndexBufferToCtx( buff ); }
+
+ // FIXME: Remove this, it's no longer used
+ FORCEINLINE void SetVertexAttributes( GLMVertexSetup *setup )
+ {
+ // we now just latch the vert setup and then execute on it at flushdrawstatestime if shaders are enabled.
+ if ( setup )
+ {
+ m_drawVertexSetup = *setup;
+ }
+ else
+ {
+ memset( &m_drawVertexSetup, 0, sizeof( m_drawVertexSetup ) );
+ }
+ }
+
+ // note, no API is exposed for setting a single attribute source.
+ // come prepared with a complete block of attributes to use.
+
+ // Queries
+ CGLMQuery *NewQuery( GLMQueryParams *params );
+ void DelQuery( CGLMQuery *query );
+
+ // "slot" means a vec4-sized thing
+ // these write into .env parameter space
+ FORCEINLINE void SetProgramParametersF( EGLMProgramType type, uint baseSlot, float *slotData, uint slotCount );
+ FORCEINLINE void SetProgramParametersB( EGLMProgramType type, uint baseSlot, int *slotData, uint boolCount ); // take "BOOL" aka int
+ FORCEINLINE void SetProgramParametersI( EGLMProgramType type, uint baseSlot, int *slotData, uint slotCount ); // take int4s
+
+ // state sync
+ // If lazyUnbinding is true, unbound samplers will not actually be unbound to the GL device.
+ FORCEINLINE void FlushDrawStates( uint nStartIndex, uint nEndIndex, uint nBaseVertex ); // pushes all drawing state - samplers, tex, programs, etc.
+ void FlushDrawStatesNoShaders();
+
+ // drawing
+ FORCEINLINE void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf );
+ void DrawRangeElementsNonInline( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf );
+
+ void CheckNative( void );
+
+ // clearing
+ void Clear( bool color, unsigned long colorValue, bool depth, float depthValue, bool stencil, unsigned int stencilValue, GLScissorBox_t *rect = NULL );
+
+ // display
+ //void SetVSyncEnable( bool vsyncOn );
+ //void SetFullScreen( bool fsOn, int screenIndex ); // will be latched for next BeginFrame
+ //void ActivateFullScreen( bool fsOn, int screenIndex ); // will be called by BeginFrame
+ bool SetDisplayParams( GLMDisplayParams *params ); // either the first time setup, or a change to new setup
+
+ void Present( CGLMTex *tex ); // somewhat hardwired for the time being
+
+ // Called when IDirect3DDevice9::Reset() is called.
+ void Reset();
+
+ // writers for the state block inputs
+
+ FORCEINLINE void WriteAlphaTestEnable( GLAlphaTestEnable_t *src ) { m_AlphaTestEnable.Write( src ); }
+ FORCEINLINE void WriteAlphaTestFunc( GLAlphaTestFunc_t *src ) { m_AlphaTestFunc.Write( src ); }
+ FORCEINLINE void WriteAlphaToCoverageEnable( GLAlphaToCoverageEnable_t *src ) { m_AlphaToCoverageEnable.Write( src ); }
+ FORCEINLINE void WriteCullFaceEnable( GLCullFaceEnable_t *src ) { m_CullFaceEnable.Write( src ); }
+ FORCEINLINE void WriteCullFrontFace( GLCullFrontFace_t *src ) { m_CullFrontFace.Write( src ); }
+ FORCEINLINE void WritePolygonMode( GLPolygonMode_t *src ) { m_PolygonMode.Write( src ); }
+ FORCEINLINE void WriteDepthBias( GLDepthBias_t *src ) { m_DepthBias.Write( src ); }
+ FORCEINLINE void WriteClipPlaneEnable( GLClipPlaneEnable_t *src, int which ) { m_ClipPlaneEnable.WriteIndex( src, which ); }
+ FORCEINLINE void WriteClipPlaneEquation( GLClipPlaneEquation_t *src, int which ) { m_ClipPlaneEquation.WriteIndex( src, which ); }
+ FORCEINLINE void WriteScissorEnable( GLScissorEnable_t *src ) { m_ScissorEnable.Write( src ); }
+ FORCEINLINE void WriteScissorBox( GLScissorBox_t *src ) { m_ScissorBox.Write( src ); }
+ FORCEINLINE void WriteViewportBox( GLViewportBox_t *src ) { m_ViewportBox.Write( src ); }
+ FORCEINLINE void WriteViewportDepthRange( GLViewportDepthRange_t *src ) { m_ViewportDepthRange.Write( src ); }
+ FORCEINLINE void WriteColorMaskSingle( GLColorMaskSingle_t *src ) { m_ColorMaskSingle.Write( src ); }
+ FORCEINLINE void WriteColorMaskMultiple( GLColorMaskMultiple_t *src, int which ) { m_ColorMaskMultiple.WriteIndex( src, which ); }
+ FORCEINLINE void WriteBlendEnable( GLBlendEnable_t *src ) { m_BlendEnable.Write( src ); }
+ FORCEINLINE void WriteBlendFactor( GLBlendFactor_t *src ) { m_BlendFactor.Write( src ); }
+ FORCEINLINE void WriteBlendEquation( GLBlendEquation_t *src ) { m_BlendEquation.Write( src ); }
+ FORCEINLINE void WriteBlendColor( GLBlendColor_t *src ) { m_BlendColor.Write( src ); }
+
+ FORCEINLINE void WriteBlendEnableSRGB( GLBlendEnableSRGB_t *src )
+ {
+ if (m_caps.m_hasGammaWrites) // only if caps allow do we actually push it through to the extension
+ {
+ m_BlendEnableSRGB.Write( src );
+ }
+ else
+ {
+ m_FakeBlendEnableSRGB = src->enable != 0;
+ }
+ // note however that we're still tracking what this mode should be, so FlushDrawStates can look at it and adjust the pixel shader
+ // if fake SRGB mode is in place (m_caps.m_hasGammaWrites is false)
+ }
+
+ FORCEINLINE void WriteDepthTestEnable( GLDepthTestEnable_t *src ) { m_DepthTestEnable.Write( src ); }
+ FORCEINLINE void WriteDepthFunc( GLDepthFunc_t *src ) { m_DepthFunc.Write( src ); }
+ FORCEINLINE void WriteDepthMask( GLDepthMask_t *src ) { m_DepthMask.Write( src ); }
+ FORCEINLINE void WriteStencilTestEnable( GLStencilTestEnable_t *src ) { m_StencilTestEnable.Write( src ); }
+ FORCEINLINE void WriteStencilFunc( GLStencilFunc_t *src ) { m_StencilFunc.Write( src ); }
+ FORCEINLINE void WriteStencilOp( GLStencilOp_t *src, int which ) { m_StencilOp.WriteIndex( src, which ); }
+ FORCEINLINE void WriteStencilWriteMask( GLStencilWriteMask_t *src ) { m_StencilWriteMask.Write( src ); }
+ FORCEINLINE void WriteClearColor( GLClearColor_t *src ) { m_ClearColor.Write( src ); }
+ FORCEINLINE void WriteClearDepth( GLClearDepth_t *src ) { m_ClearDepth.Write( src ); }
+ FORCEINLINE void WriteClearStencil( GLClearStencil_t *src ) { m_ClearStencil.Write( src ); }
+
+ // debug stuff
+ void BeginFrame( void );
+ void EndFrame( void );
+
+ // new interactive debug stuff
+#if GLMDEBUG
+ void DebugDump( GLMDebugHookInfo *info, uint options, uint vertDumpMode );
+ void DebugHook( GLMDebugHookInfo *info );
+ void DebugPresent( void );
+ void DebugClear( void );
+#endif
+
+ FORCEINLINE void SetMaxUsedVertexShaderConstantsHint( uint nMaxConstants );
+
+ FORCEINLINE DWORD GetCurrentOwnerThreadId() const { return m_nCurOwnerThreadId; }
+
+ protected:
+ friend class GLMgr; // only GLMgr can make GLMContext objects
+ friend class GLMRendererInfo; // only GLMgr can make GLMContext objects
+ friend class CGLMTex; // tex needs to be able to do binds
+ friend class CGLMFBO; // fbo needs to be able to do binds
+ friend class CGLMProgram;
+ friend class CGLMShaderPair;
+ friend class CGLMShaderPairCache;
+ friend class CGLMBuffer;
+ friend class CGLMBufferSpanManager;
+ friend class GLMTester; // tester class needs access back into GLMContext
+
+ friend struct IDirect3D9;
+ friend struct IDirect3DDevice9;
+ friend struct IDirect3DQuery9;
+
+ // methods------------------------------------------
+
+ // old GLMContext( GLint displayMask, GLint rendererID, PseudoNSGLContextPtr nsglShareCtx );
+ GLMContext( IDirect3DDevice9 *pDevice, GLMDisplayParams *params );
+ ~GLMContext();
+
+ FORCEINLINE GLuint FindSamplerObject( const GLMTexSamplingParams &desiredParams );
+
+ FORCEINLINE void SetBufAndVertexAttribPointer( uint nIndex, GLuint nGLName, GLuint stride, GLuint datatype, GLboolean normalized, GLuint nCompCount, const void *pBuf, uint nRevision )
+ {
+ VertexAttribs_t &curAttribs = m_boundVertexAttribs[nIndex];
+ if ( nGLName != m_nBoundGLBuffer[kGLMVertexBuffer] )
+ {
+ m_nBoundGLBuffer[kGLMVertexBuffer] = nGLName;
+ gGL->glBindBufferARB( GL_ARRAY_BUFFER_ARB, nGLName );
+ }
+ else if ( ( curAttribs.m_pPtr == pBuf ) &&
+ ( curAttribs.m_revision == nRevision ) &&
+ ( curAttribs.m_stride == stride ) &&
+ ( curAttribs.m_datatype == datatype ) &&
+ ( curAttribs.m_normalized == normalized ) &&
+ ( curAttribs.m_nCompCount == nCompCount ) )
+ {
+ return;
+ }
+
+ curAttribs.m_nCompCount = nCompCount;
+ curAttribs.m_datatype = datatype;
+ curAttribs.m_normalized = normalized;
+ curAttribs.m_stride = stride;
+ curAttribs.m_pPtr = pBuf;
+ curAttribs.m_revision = nRevision;
+
+ gGL->glVertexAttribPointer( nIndex, nCompCount, datatype, normalized, stride, pBuf );
+ }
+
+ struct CurAttribs_t
+ {
+ uint m_nTotalBufferRevision;
+ IDirect3DVertexDeclaration9 *m_pVertDecl;
+ D3DStreamDesc m_streams[ D3D_MAX_STREAMS ];
+ uint64 m_vtxAttribMap[2];
+ };
+
+ CurAttribs_t m_CurAttribs;
+
+ FORCEINLINE void ClearCurAttribs()
+ {
+ m_CurAttribs.m_nTotalBufferRevision = 0;
+ m_CurAttribs.m_pVertDecl = NULL;
+ memset( m_CurAttribs.m_streams, 0, sizeof( m_CurAttribs.m_streams ) );
+ m_CurAttribs.m_vtxAttribMap[0] = 0xBBBBBBBBBBBBBBBBULL;
+ m_CurAttribs.m_vtxAttribMap[1] = 0xBBBBBBBBBBBBBBBBULL;
+ }
+
+ FORCEINLINE void ReleasedShader() { NullProgram(); }
+
+ // textures
+ FORCEINLINE void SelectTMU( int tmu )
+ {
+ if ( tmu != m_activeTexture )
+ {
+ gGL->glActiveTexture( GL_TEXTURE0 + tmu );
+ m_activeTexture = tmu;
+ }
+ }
+
+ void BindTexToTMU( CGLMTex *tex, int tmu );
+
+ // render targets / FBO's
+ void BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint = GL_FRAMEBUFFER_EXT ); // you can also choose GL_READ_FRAMEBUFFER_EXT / GL_DRAW_FRAMEBUFFER_EXT
+
+ // buffers
+ FORCEINLINE void BindGLBufferToCtx( GLenum nGLBufType, GLuint nGLName, bool bForce = false )
+ {
+ Assert( ( nGLBufType == GL_ARRAY_BUFFER_ARB ) || ( nGLBufType == GL_ELEMENT_ARRAY_BUFFER_ARB ) );
+
+ const uint nIndex = ( nGLBufType == GL_ARRAY_BUFFER_ARB ) ? kGLMVertexBuffer : kGLMIndexBuffer;
+ if ( ( bForce ) || ( m_nBoundGLBuffer[nIndex] != nGLName ) )
+ {
+ m_nBoundGLBuffer[nIndex] = nGLName;
+ gGL->glBindBufferARB( nGLBufType, nGLName );
+ }
+ }
+
+ void BindBufferToCtx( EGLMBufferType type, CGLMBuffer *buff, bool force = false ); // does not twiddle any enables.
+
+ FORCEINLINE void BindIndexBufferToCtx( CGLMBuffer *buff );
+ FORCEINLINE void BindVertexBufferToCtx( CGLMBuffer *buff );
+
+ CPinnedMemoryBuffer *GetCurPinnedMemoryBuffer( ) { return &m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer]; }
+
+ // members------------------------------------------
+
+ // context
+ DWORD m_nCurOwnerThreadId;
+ uint m_nThreadOwnershipReleaseCounter;
+
+ bool m_bUseSamplerObjects;
+ bool m_bPreferMapBufferRange;
+
+ IDirect3DDevice9 *m_pDevice;
+ GLMRendererInfoFields m_caps;
+
+ bool m_displayParamsValid; // is there a param block copied in yet
+ GLMDisplayParams m_displayParams; // last known display config, either via constructor, or by SetDisplayParams...
+
+#ifdef OSX
+ CGLPixelFormatAttribute m_pixelFormatAttribs[100]; // more than enough
+ PseudoNSGLContextPtr m_nsctx;
+ CGLContextObj m_ctx;
+#elif defined( USE_SDL )
+ int m_pixelFormatAttribs[100]; // more than enough
+ PseudoNSGLContextPtr m_nsctx;
+ void * m_ctx;
+#endif
+ bool m_oneCtxEnable; // true if we use the window's context directly instead of making a second one shared against it
+
+ bool m_bUseBoneUniformBuffers; // if true, we use two uniform buffers for vertex shader constants vs. one
+
+ // texture form table
+ CGLMTexLayoutTable *m_texLayoutTable;
+
+ // context state mirrors
+
+ GLState<GLAlphaTestEnable_t> m_AlphaTestEnable;
+
+ GLState<GLAlphaTestFunc_t> m_AlphaTestFunc;
+
+ GLState<GLCullFaceEnable_t> m_CullFaceEnable;
+ GLState<GLCullFrontFace_t> m_CullFrontFace;
+ GLState<GLPolygonMode_t> m_PolygonMode;
+
+ GLState<GLDepthBias_t> m_DepthBias;
+
+ GLStateArray<GLClipPlaneEnable_t,kGLMUserClipPlanes> m_ClipPlaneEnable;
+ GLStateArray<GLClipPlaneEquation_t,kGLMUserClipPlanes> m_ClipPlaneEquation; // dxabstract puts them directly into param slot 253(0) and 254(1)
+
+ GLState<GLScissorEnable_t> m_ScissorEnable;
+ GLState<GLScissorBox_t> m_ScissorBox;
+
+ GLState<GLAlphaToCoverageEnable_t> m_AlphaToCoverageEnable;
+
+ GLState<GLViewportBox_t> m_ViewportBox;
+ GLState<GLViewportDepthRange_t> m_ViewportDepthRange;
+
+ GLState<GLColorMaskSingle_t> m_ColorMaskSingle;
+ GLStateArray<GLColorMaskMultiple_t,8> m_ColorMaskMultiple; // need an official constant for the color buffers limit
+
+ GLState<GLBlendEnable_t> m_BlendEnable;
+ GLState<GLBlendFactor_t> m_BlendFactor;
+ GLState<GLBlendEquation_t> m_BlendEquation;
+ GLState<GLBlendColor_t> m_BlendColor;
+ GLState<GLBlendEnableSRGB_t> m_BlendEnableSRGB; // write to this one to transmit intent to write SRGB encoded pixels to drawing FB
+ bool m_FakeBlendEnableSRGB; // writes to above will be shunted here if fake SRGB is in effect.
+
+ GLState<GLDepthTestEnable_t> m_DepthTestEnable;
+ GLState<GLDepthFunc_t> m_DepthFunc;
+ GLState<GLDepthMask_t> m_DepthMask;
+
+ GLState<GLStencilTestEnable_t> m_StencilTestEnable; // global stencil test enable
+ GLState<GLStencilFunc_t> m_StencilFunc; // holds front and back stencil funcs
+ GLStateArray<GLStencilOp_t,2> m_StencilOp; // indexed: 0=front 1=back
+ GLState<GLStencilWriteMask_t> m_StencilWriteMask;
+
+ GLState<GLClearColor_t> m_ClearColor;
+ GLState<GLClearDepth_t> m_ClearDepth;
+ GLState<GLClearStencil_t> m_ClearStencil;
+
+ // texture bindings and sampler setup
+ int m_activeTexture; // mirror for glActiveTexture
+ GLMTexSampler m_samplers[GLM_SAMPLER_COUNT];
+
+ uint8 m_nDirtySamplerFlags[GLM_SAMPLER_COUNT]; // 0 if the sampler is dirty, 1 if not
+ uint32 m_nNumDirtySamplers; // # of unique dirty sampler indices in m_nDirtySamplers
+ uint8 m_nDirtySamplers[GLM_SAMPLER_COUNT + 1]; // dirty sampler indices
+
+ void MarkAllSamplersDirty();
+
+ struct SamplerHashEntry
+ {
+ GLuint m_samplerObject;
+ GLMTexSamplingParams m_params;
+ };
+
+ enum
+ {
+ cSamplerObjectHashBits = 9, cSamplerObjectHashSize = 1 << cSamplerObjectHashBits
+ };
+ SamplerHashEntry m_samplerObjectHash[cSamplerObjectHashSize];
+ uint m_nSamplerObjectHashNumEntries;
+
+ // texture lock tracking - CGLMTex objects share usage of this
+ CUtlVector< GLMTexLockDesc > m_texLocks;
+
+ // render target binding - check before draw
+ // similar to tex sampler mechanism, we track "bound" from "chosen for drawing" separately,
+ // so binding for creation/setup need not disrupt any notion of what will be used at draw time
+
+ CGLMFBO *m_boundDrawFBO; // FBO on GL_DRAW_FRAMEBUFFER bind point
+ CGLMFBO *m_boundReadFBO; // FBO on GL_READ_FRAMEBUFFER bind point
+ // ^ both are set if you bind to GL_FRAMEBUFFER_EXT
+
+ CGLMFBO *m_drawingFBO; // what FBO should be bound at draw time (to both read/draw bp's).
+
+ CGLMFBO *m_blitReadFBO;
+ CGLMFBO *m_blitDrawFBO; // scratch FBO's for framebuffer blit
+
+ CGLMFBO *m_scratchFBO[ kGLMScratchFBOCount ]; // general purpose FBO's for internal use
+
+ CUtlVector< CGLMFBO* > m_fboTable; // each live FBO goes in the table
+
+ // program bindings
+ EGLMProgramLang m_drawingLangAtFrameStart; // selector for start of frame (spills into m_drawingLang)
+ EGLMProgramLang m_drawingLang; // selector for which language we desire to draw with on the next batch
+ CGLMProgram *m_drawingProgram[ kGLMNumProgramTypes ];
+ bool m_bDirtyPrograms;
+
+ GLMProgramParamsF m_programParamsF[ kGLMNumProgramTypes ];
+ GLMProgramParamsB m_programParamsB[ kGLMNumProgramTypes ]; // two banks, but only the vertex one is used
+ GLMProgramParamsI m_programParamsI[ kGLMNumProgramTypes ]; // two banks, but only the vertex one is used
+ EGLMParamWriteMode m_paramWriteMode;
+
+ CGLMProgram *m_pNullFragmentProgram; // write opaque black. Activate when caller asks for null FP
+
+ CGLMProgram *m_preloadTexVertexProgram; // programs to help preload textures (dummies)
+ CGLMProgram *m_preload2DTexFragmentProgram;
+ CGLMProgram *m_preload3DTexFragmentProgram;
+ CGLMProgram *m_preloadCubeTexFragmentProgram;
+
+ CGLMShaderPairCache *m_pairCache; // GLSL only
+ CGLMShaderPair *m_pBoundPair; // GLSL only
+
+ FORCEINLINE void NewLinkedProgram() { ClearCurAttribs(); }
+
+ //uint m_boundPairRevision; // GLSL only
+ //GLhandleARB m_boundPairProgram; // GLSL only
+
+ // buffer bindings
+ GLuint m_nBoundGLBuffer[kGLMNumBufferTypes];
+
+ struct VertexAttribs_t
+ {
+ GLuint m_nCompCount;
+ GLenum m_datatype;
+ GLboolean m_normalized;
+ GLuint m_stride;
+ const void *m_pPtr;
+ uint m_revision;
+ };
+
+ VertexAttribs_t m_boundVertexAttribs[ kGLMVertexAttributeIndexMax ]; // tracked per attrib for dupe-set-absorb
+ uint m_lastKnownVertexAttribMask; // tracked for dupe-enable-absorb
+ int m_nNumSetVertexAttributes;
+
+ // FIXME: Remove this, it's no longer used
+ GLMVertexSetup m_drawVertexSetup;
+
+ EGLMAttribWriteMode m_attribWriteMode;
+
+ bool m_slowCheckEnable; // turn this on or no native checking is done ("-glmassertslow" or "-glmsspewslow")
+ bool m_slowAssertEnable; // turn this on to assert on a non-native batch "-glmassertslow"
+ bool m_slowSpewEnable; // turn this on to log non-native batches to stdout "-glmspewslow"
+ bool m_checkglErrorsAfterEveryBatch; // turn this on to check for GL errors after each batch (slow) ("-glcheckerrors")
+
+ // debug font texture
+ CGLMTex *m_debugFontTex; // might be NULL unless you call GenDebugFontTex
+ CGLMBuffer *m_debugFontIndices; // up to 1024 indices (256 chars times 4)
+ CGLMBuffer *m_debugFontVertices; // up to 1024 verts
+
+ // batch/frame debugging support
+ int m_debugFrameIndex; // init to -1. Increment at BeginFrame
+
+ int m_nMaxUsedVertexProgramConstantsHint;
+
+ uint32 m_dwRenderThreadId;
+ volatile bool m_bIsThreading;
+
+ uint m_nCurFrame;
+ uint m_nBatchCounter;
+
+ enum { cNumPinnedMemoryBuffers = 4 };
+ CPinnedMemoryBuffer m_PinnedMemoryBuffers[cNumPinnedMemoryBuffers];
+ uint m_nCurPinnedMemoryBuffer;
+
+ void SaveColorMaskAndSetToDefault();
+ void RestoreSavedColorMask();
+ GLColorMaskSingle_t m_SavedColorMask;
+
+#if GLMDEBUG
+ // interactive (DebugHook) debug support
+
+ // using these you can implement frame advance, batch single step, and batch rewind (let it run til next frame and hold on prev batch #)
+ int m_holdFrameBegin; // -1 if no hold req'd, otherwise # of frame to hold at (at beginframe time)
+ int m_holdFrameEnd; // -1 if no hold req'd, otherwise # of frame to hold at (at endframe time)
+
+ int m_holdBatch,m_holdBatchFrame; // -1 if no hold, else # of batch&frame to hold at (both must be set)
+ // these can be expired/cleared to -1 if the frame passes without a hit
+ // may be desirable to re-pause in that event, as user was expecting a hold to occur
+
+ bool m_debugDelayEnable; // allow sleep delay
+ uint m_debugDelay; // sleep time per hook call in microseconds (for usleep())
+
+ // pre-draw global toggles / options
+ bool m_autoClearColor,m_autoClearDepth,m_autoClearStencil;
+ float m_autoClearColorValues[4];
+
+ // debug knobs
+ int m_selKnobIndex;
+ float m_selKnobMinValue,m_selKnobMaxValue,m_selKnobIncrement;
+#endif
+
+#if GL_BATCH_PERF_ANALYSIS
+ uint m_nTotalVSUniformCalls;
+ uint m_nTotalVSUniformBoneCalls;
+ uint m_nTotalVSUniformsSet;
+ uint m_nTotalVSUniformsBoneSet;
+ uint m_nTotalPSUniformCalls;
+ uint m_nTotalPSUniformsSet;
+
+ CFlushDrawStatesStats m_FlushStats;
+#endif
+};
+
+FORCEINLINE void GLMContext::DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf )
+{
+#if GL_ENABLE_INDEX_VERIFICATION
+ DrawRangeElementsNonInline( mode, start, end, count, type, indices, baseVertex, pIndexBuf );
+#else
+
+#if GLMDEBUG
+ GLM_FUNC;
+#else
+ //tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %d-%d count:%d mode:%d type:%d", __FUNCTION__, start, end, count, mode, type );
+#endif
+
+ ++m_nBatchCounter;
+
+ SetIndexBuffer( pIndexBuf );
+
+ void *indicesActual = (void*)indices;
+
+ if ( pIndexBuf->m_bPseudo )
+ {
+ // you have to pass actual address, not offset
+ indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_pPseudoBuf );
+ }
+
+#if GLMDEBUG
+ bool hasVP = m_drawingProgram[ kGLMVertexProgram ] != NULL;
+ bool hasFP = m_drawingProgram[ kGLMFragmentProgram ] != NULL;
+
+ // init debug hook information
+ GLMDebugHookInfo info;
+ memset( &info, 0, sizeof(info) );
+ info.m_caller = eDrawElements;
+
+ // relay parameters we're operating under
+ info.m_drawMode = mode;
+ info.m_drawStart = start;
+ info.m_drawEnd = end;
+ info.m_drawCount = count;
+ info.m_drawType = type;
+ info.m_drawIndices = indices;
+
+ do
+ {
+ // obey global options re pre-draw clear
+ if ( m_autoClearColor || m_autoClearDepth || m_autoClearStencil )
+ {
+ GLMPRINTF(("-- DrawRangeElements auto clear" ));
+ this->DebugClear();
+ }
+
+ // always sync with editable shader text prior to draw
+#if GLMDEBUG
+ //FIXME disengage this path if context is in GLSL mode..
+ // it will need fixes to get the shader pair re-linked etc if edits happen anyway.
+
+ if (m_drawingProgram[ kGLMVertexProgram ])
+ {
+ m_drawingProgram[ kGLMVertexProgram ]->SyncWithEditable();
+ }
+ else
+ {
+ AssertOnce(!"drawing with no vertex program bound");
+ }
+
+
+ if (m_drawingProgram[ kGLMFragmentProgram ])
+ {
+ m_drawingProgram[ kGLMFragmentProgram ]->SyncWithEditable();
+ }
+ else
+ {
+ AssertOnce(!"drawing with no fragment program bound");
+ }
+#endif
+ // do the drawing
+ if (hasVP && hasFP)
+ {
+ gGL->glDrawRangeElementsBaseVertex( mode, start, end, count, type, indicesActual, baseVertex );
+
+ if ( m_slowCheckEnable )
+ {
+ CheckNative();
+ }
+ }
+ this->DebugHook( &info );
+
+ } while ( info.m_loop );
+#else
+ Assert( m_drawingLang == kGLMGLSL );
+
+ if ( m_pBoundPair )
+ {
+ gGL->glDrawRangeElementsBaseVertex( mode, start, end, count, type, indicesActual, baseVertex );
+
+#if GLMDEBUG
+ if ( m_slowCheckEnable )
+ {
+ CheckNative();
+ }
+#endif
+ }
+#endif
+
+#endif // GL_ENABLE_INDEX_VERIFICATION
+}
+
+FORCEINLINE void GLMContext::SetVertexProgram( CGLMProgram *pProg )
+{
+ m_drawingProgram[kGLMVertexProgram] = pProg;
+ m_bDirtyPrograms = true;
+}
+
+FORCEINLINE void GLMContext::SetFragmentProgram( CGLMProgram *pProg )
+{
+ m_drawingProgram[kGLMFragmentProgram] = pProg ? pProg : m_pNullFragmentProgram;
+ m_bDirtyPrograms = true;
+}
+
+// "slot" means a vec4-sized thing
+// these write into .env parameter space
+FORCEINLINE void GLMContext::SetProgramParametersF( EGLMProgramType type, uint baseSlot, float *slotData, uint slotCount )
+{
+#if GLMDEBUG
+ GLM_FUNC;
+#endif
+
+ Assert( baseSlot < kGLMProgramParamFloat4Limit );
+ Assert( baseSlot+slotCount <= kGLMProgramParamFloat4Limit );
+
+#if GLMDEBUG
+ GLMPRINTF(("-S-GLMContext::SetProgramParametersF %s slots %d - %d: ", (type==kGLMVertexProgram) ? "VS" : "FS", baseSlot, baseSlot + slotCount - 1 ));
+ for( uint i=0; i<slotCount; i++ )
+ {
+ GLMPRINTF(( "-S- %03d: [ %7.4f %7.4f %7.4f %7.4f ]",
+ baseSlot+i,
+ slotData[i*4], slotData[i*4+1], slotData[i*4+2], slotData[i*4+3]
+ ));
+ }
+#endif
+
+ memcpy( &m_programParamsF[type].m_values[baseSlot][0], slotData, (4 * sizeof(float)) * slotCount );
+
+ if ( ( type == kGLMVertexProgram ) && ( m_bUseBoneUniformBuffers ) )
+ {
+ if ( ( baseSlot + slotCount ) > DXABSTRACT_VS_FIRST_BONE_SLOT )
+ {
+ if ( baseSlot < DXABSTRACT_VS_FIRST_BONE_SLOT )
+ {
+ // The register set crosses between the constant buffers - should only happen at startup during init.
+ m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, (int)baseSlot );
+ m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, (int)MIN( baseSlot + slotCount, DXABSTRACT_VS_FIRST_BONE_SLOT ) );
+ baseSlot = DXABSTRACT_VS_FIRST_BONE_SLOT;
+ }
+
+ int nNumActualBones = ( baseSlot + slotCount ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
+ m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone, nNumActualBones );
+ }
+ else
+ {
+ m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, (int)baseSlot );
+ m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, (int)(baseSlot + slotCount) );
+ }
+ }
+ else
+ {
+ m_programParamsF[type].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[type].m_dirtySlotHighWaterNonBone, (int)(baseSlot + slotCount) );
+ m_programParamsF[type].m_firstDirtySlotNonBone = MIN( m_programParamsF[type].m_firstDirtySlotNonBone, (int)baseSlot );
+ }
+}
+
+FORCEINLINE void GLMContext::SetProgramParametersB( EGLMProgramType type, uint baseSlot, int *slotData, uint boolCount )
+{
+#if GLMDEBUG
+ GLM_FUNC;
+#endif
+
+ Assert( m_drawingLang == kGLMGLSL );
+ Assert( type==kGLMVertexProgram );
+
+ Assert( baseSlot < kGLMProgramParamBoolLimit );
+ Assert( baseSlot+boolCount <= kGLMProgramParamBoolLimit );
+
+#if GLMDEBUG
+ GLMPRINTF(("-S-GLMContext::SetProgramParametersB %s bools %d - %d: ", (type==kGLMVertexProgram) ? "VS" : "FS", baseSlot, baseSlot + boolCount - 1 ));
+ for( uint i=0; i<boolCount; i++ )
+ {
+ GLMPRINTF(( "-S- %03d: %d (bool)",
+ baseSlot+i,
+ slotData[i]
+ ));
+ }
+#endif
+
+ memcpy( &m_programParamsB[type].m_values[baseSlot], slotData, sizeof(int) * boolCount );
+
+ if ( (baseSlot+boolCount) > m_programParamsB[type].m_dirtySlotCount)
+ m_programParamsB[type].m_dirtySlotCount = baseSlot+boolCount;
+}
+
+FORCEINLINE void GLMContext::SetProgramParametersI( EGLMProgramType type, uint baseSlot, int *slotData, uint slotCount ) // groups of 4 ints...
+{
+#if GLMDEBUG
+ GLM_FUNC;
+#endif
+
+ Assert( m_drawingLang == kGLMGLSL );
+ Assert( type==kGLMVertexProgram );
+
+ Assert( baseSlot < kGLMProgramParamInt4Limit );
+ Assert( baseSlot+slotCount <= kGLMProgramParamInt4Limit );
+
+#if GLMDEBUG
+ GLMPRINTF(("-S-GLMContext::SetProgramParametersI %s slots %d - %d: ", (type==kGLMVertexProgram) ? "VS" : "FS", baseSlot, baseSlot + slotCount - 1 ));
+ for( uint i=0; i<slotCount; i++ )
+ {
+ GLMPRINTF(( "-S- %03d: %d %d %d %d (int4)",
+ baseSlot+i,
+ slotData[i*4],slotData[i*4+1],slotData[i*4+2],slotData[i*4+3]
+ ));
+ }
+#endif
+
+ memcpy( &m_programParamsI[type].m_values[baseSlot][0], slotData, (4*sizeof(int)) * slotCount );
+
+ if ( (baseSlot + slotCount) > m_programParamsI[type].m_dirtySlotCount)
+ {
+ m_programParamsI[type].m_dirtySlotCount = baseSlot + slotCount;
+ }
+}
+
+FORCEINLINE void GLMContext::SetSamplerDirty( int sampler )
+{
+ Assert( sampler < GLM_SAMPLER_COUNT );
+ m_nDirtySamplers[m_nNumDirtySamplers] = sampler;
+ m_nNumDirtySamplers += m_nDirtySamplerFlags[sampler];
+ m_nDirtySamplerFlags[sampler] = 0;
+}
+
+FORCEINLINE void GLMContext::SetSamplerTex( int sampler, CGLMTex *tex )
+{
+ Assert( sampler < GLM_SAMPLER_COUNT );
+ m_samplers[sampler].m_pBoundTex = tex;
+ if ( tex )
+ {
+ if ( !gGL->m_bHave_GL_EXT_direct_state_access )
+ {
+ if ( sampler != m_activeTexture )
+ {
+ gGL->glActiveTexture( GL_TEXTURE0 + sampler );
+ m_activeTexture = sampler;
+ }
+
+ gGL->glBindTexture( tex->m_texGLTarget, tex->m_texName );
+ }
+ else
+ {
+ gGL->glBindMultiTextureEXT( GL_TEXTURE0 + sampler, tex->m_texGLTarget, tex->m_texName );
+ }
+ }
+
+ if ( !m_bUseSamplerObjects )
+ {
+ SetSamplerDirty( sampler );
+ }
+}
+
+FORCEINLINE void GLMContext::SetSamplerMinFilter( int sampler, GLenum Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MIN_FILTER_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_minFilter = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerMagFilter( int sampler, GLenum Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MAG_FILTER_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_magFilter = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerMipFilter( int sampler, GLenum Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MIP_FILTER_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_mipFilter = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerAddressU( int sampler, GLenum Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS) );
+ m_samplers[sampler].m_samp.m_packed.m_addressU = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerAddressV( int sampler, GLenum Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS) );
+ m_samplers[sampler].m_samp.m_packed.m_addressV = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerAddressW( int sampler, GLenum Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS) );
+ m_samplers[sampler].m_samp.m_packed.m_addressW = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerStates( int sampler, GLenum AddressU, GLenum AddressV, GLenum AddressW, GLenum minFilter, GLenum magFilter, GLenum mipFilter )
+{
+ Assert( AddressU < ( 1 << GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS) );
+ Assert( AddressV < ( 1 << GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS) );
+ Assert( AddressW < ( 1 << GLM_PACKED_SAMPLER_PARAMS_ADDRESS_BITS) );
+ Assert( minFilter < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MIN_FILTER_BITS ) );
+ Assert( magFilter < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MAG_FILTER_BITS ) );
+ Assert( mipFilter < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MIP_FILTER_BITS ) );
+
+ GLMTexSamplingParams ¶ms = m_samplers[sampler].m_samp;
+ params.m_packed.m_addressU = AddressU;
+ params.m_packed.m_addressV = AddressV;
+ params.m_packed.m_addressW = AddressW;
+ params.m_packed.m_minFilter = minFilter;
+ params.m_packed.m_magFilter = magFilter;
+ params.m_packed.m_mipFilter = mipFilter;
+}
+
+FORCEINLINE void GLMContext::SetSamplerBorderColor( int sampler, DWORD Value )
+{
+ m_samplers[sampler].m_samp.m_borderColor = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerMipMapLODBias( int sampler, DWORD Value )
+{
+ // not currently supported
+}
+
+FORCEINLINE void GLMContext::SetSamplerMaxMipLevel( int sampler, DWORD Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MIN_LOD_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_minLOD = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerMaxAnisotropy( int sampler, DWORD Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MAX_ANISO_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_maxAniso = Value;
+}
+
+FORCEINLINE void GLMContext::SetSamplerSRGBTexture( int sampler, DWORD Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_SRGB_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_srgb = Value;
+}
+
+FORCEINLINE void GLMContext::SetShadowFilter( int sampler, DWORD Value )
+{
+ Assert( Value < ( 1 << GLM_PACKED_SAMPLER_PARAMS_COMPARE_MODE_BITS ) );
+ m_samplers[sampler].m_samp.m_packed.m_compareMode = Value;
+}
+
+FORCEINLINE void GLMContext::BindIndexBufferToCtx( CGLMBuffer *buff )
+{
+ GLMPRINTF(( "--- GLMContext::BindIndexBufferToCtx buff %p, GL name %d", buff, (buff) ? buff->m_nHandle : -1 ));
+
+ Assert( !buff || ( buff->m_buffGLTarget == GL_ELEMENT_ARRAY_BUFFER_ARB ) );
+
+ GLuint nGLName = buff ? buff->m_nHandle : 0;
+
+ if ( m_nBoundGLBuffer[ kGLMIndexBuffer] == nGLName )
+ return;
+
+ m_nBoundGLBuffer[ kGLMIndexBuffer] = nGLName;
+ gGL->glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, nGLName );
+}
+
+FORCEINLINE void GLMContext::BindVertexBufferToCtx( CGLMBuffer *buff )
+{
+ GLMPRINTF(( "--- GLMContext::BindVertexBufferToCtx buff %p, GL name %d", buff, (buff) ? buff->m_nHandle : -1 ));
+
+ Assert( !buff || ( buff->m_buffGLTarget == GL_ARRAY_BUFFER_ARB ) );
+
+ GLuint nGLName = buff ? buff->m_nHandle : 0;
+
+ if ( m_nBoundGLBuffer[ kGLMVertexBuffer] == nGLName )
+ return;
+
+ m_nBoundGLBuffer[ kGLMVertexBuffer] = nGLName;
+ gGL->glBindBufferARB( GL_ARRAY_BUFFER_ARB, nGLName );
+}
+
+FORCEINLINE void GLMContext::SetMaxUsedVertexShaderConstantsHint( uint nMaxConstants )
+{
+ static bool bUseMaxVertexShadeConstantHints = !CommandLine()->CheckParm("-disablemaxvertexshaderconstanthints");
+ if ( bUseMaxVertexShadeConstantHints )
+ {
+ m_nMaxUsedVertexProgramConstantsHint = nMaxConstants;
+ }
+}
+
+struct GLMTestParams
+{
+ GLMContext *m_ctx;
+ int *m_testList; // -1 termed
+
+ bool m_glErrToDebugger;
+ bool m_glErrToConsole;
+
+ bool m_intlErrToDebugger;
+ bool m_intlErrToConsole;
+
+ int m_frameCount; // how many frames to test.
+};
+
+class CShowPixelsParams
+{
+public:
+ GLuint m_srcTexName;
+ int m_width,m_height;
+ bool m_vsyncEnable;
+ bool m_fsEnable; // want receiving view to be full screen. for now, just target the main screen. extend later.
+ bool m_useBlit; // use FBO blit - sending context says it is available.
+ bool m_noBlit; // the back buffer has already been populated by the caller (perhaps via direct MSAA resolve from multisampled RT tex)
+ bool m_onlySyncView; // react to full/windowed state change only, do not present bits
+};
+
+#define kMaxCrawlFrames 100
+#define kMaxCrawlText (kMaxCrawlFrames * 256)
+class CStackCrawlParams
+{
+ public:
+ uint m_frameLimit; // input: max frames to retrieve
+ uint m_frameCount; // output: frames found
+ void *m_crawl[kMaxCrawlFrames]; // call site addresses
+ char *m_crawlNames[kMaxCrawlFrames]; // pointers into text following, one per decoded name
+ char m_crawlText[kMaxCrawlText];
+};
+
+#endif // GLMGR_H
diff --git a/mp/src/public/togl/linuxwin/glmgrbasics.h b/mp/src/public/togl/linuxwin/glmgrbasics.h new file mode 100644 index 00000000..1897ebca --- /dev/null +++ b/mp/src/public/togl/linuxwin/glmgrbasics.h @@ -0,0 +1,308 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmgrbasics.h
+// types, common headers, forward declarations, utilities
+//
+//===============================================================================
+
+#ifndef GLMBASICS_H
+#define GLMBASICS_H
+
+#pragma once
+
+#ifdef OSX
+ #include <OpenGL/OpenGL.h>
+ #include <OpenGL/gl.h>
+ #include <OpenGL/glext.h>
+ #include <OpenGL/CGLTypes.h>
+ #include <OpenGL/CGLRenderers.h>
+ #include <OpenGL/CGLCurrent.h>
+ #include <OpenGL/CGLProfiler.h>
+ #include <ApplicationServices/ApplicationServices.h>
+#elif defined(DX_TO_GL_ABSTRACTION)
+ #include <GL/gl.h>
+ #include <GL/glext.h>
+#else
+ #error
+#endif
+
+#include "tier0/platform.h"
+
+#include "bitmap/imageformat.h"
+#include "bitvec.h"
+#include "tier1/checksum_md5.h"
+#include "tier1/utlvector.h"
+#include "tier1/convar.h"
+
+#include <sys/stat.h>
+
+#include "dxabstract_types.h"
+
+struct GLMRect;
+typedef void *PseudoGLContextPtr;
+
+// types
+
+ // 3-d integer box (used for texture lock/unlock etc)
+struct GLMRegion
+{
+ int xmin,xmax;
+ int ymin,ymax;
+ int zmin,zmax;
+};
+
+struct GLMRect // follows GL convention - if coming from the D3D rect you will need to fiddle the Y's
+{
+ int xmin; // left
+ int ymin; // bottom
+ int xmax; // right
+ int ymax; // top
+};
+
+// macros
+
+//#define GLMassert(x) assert(x)
+
+// forward decls
+class GLMgr; // singleton
+class GLMContext; // GL context
+class CGLMContextTester; // testing class
+class CGLMTex;
+class CGLMFBO;
+class CGLMProgram;
+class CGLMBuffer;
+
+
+// utilities
+
+typedef enum
+{
+ // D3D codes
+ eD3D_DEVTYPE,
+ eD3D_FORMAT,
+ eD3D_RTYPE,
+ eD3D_USAGE,
+ eD3D_RSTATE, // render state
+ eD3D_SIO, // D3D shader bytecode
+ eD3D_VTXDECLUSAGE,
+
+ // CGL codes
+ eCGL_RENDID,
+
+ // OpenGL error codes
+ eGL_ERROR,
+
+ // OpenGL enums
+ eGL_ENUM,
+ eGL_RENDERER
+
+} GLMThing_t;
+
+// these will look at the string to guess its flavor: <, >, ---, -M-, -S-
+#ifdef TOGL_DLL_EXPORT
+ DLL_EXPORT const char* GLMDecode( GLMThing_t type, unsigned long value ); // decode a numeric const
+#else
+ DLL_IMPORT const char* GLMDecode( GLMThing_t type, unsigned long value ); // decode a numeric const
+#endif
+
+const char* GLMDecodeMask( GLMThing_t type, unsigned long value ); // decode a bitmask
+
+FORCEINLINE void GLMStop( void ) { DXABSTRACT_BREAK_ON_ERROR(); }
+
+void GLMEnableTrace( bool on );
+
+//===============================================================================
+// output functions
+
+// expose these in release now
+// Mimic PIX events so we can decorate debug spew
+DLL_EXPORT void GLMBeginPIXEvent( const char *str );
+DLL_EXPORT void GLMEndPIXEvent( void );
+
+class CScopedGLMPIXEvent
+{
+ CScopedGLMPIXEvent( const CScopedGLMPIXEvent & );
+ CScopedGLMPIXEvent& operator= ( const CScopedGLMPIXEvent & );
+public:
+ inline CScopedGLMPIXEvent( const char *pName ) { GLMBeginPIXEvent( pName ); }
+ inline ~CScopedGLMPIXEvent() { GLMEndPIXEvent( ); }
+};
+
+#if GLMDEBUG
+
+
+//===============================================================================
+// classes
+
+// helper class making function tracking easier to wire up
+
+class GLMFuncLogger
+{
+ public:
+
+ // simple function log
+ GLMFuncLogger( const char *funcName )
+ {
+ m_funcName = funcName;
+ m_earlyOut = false;
+
+ GLMPrintf( ">%s", m_funcName );
+ };
+
+ // more advanced version lets you pass args (i.e. called parameters or anything else of interest)
+ // no macro for this one, since no easy way to pass through the args as well as the funcname
+ GLMFuncLogger( const char *funcName, char *fmt, ... )
+ {
+ m_funcName = funcName;
+ m_earlyOut = false;
+
+ // this acts like GLMPrintf here
+ // all the indent policy is down in GLMPrintfVA
+ // which means we need to inject a ">" at the front of the format string to make this work... sigh.
+
+ char modifiedFmt[2000];
+ modifiedFmt[0] = '>';
+ strcpy( modifiedFmt+1, fmt );
+
+ va_list vargs;
+ va_start(vargs, fmt);
+ GLMPrintfVA( modifiedFmt, vargs );
+ va_end( vargs );
+ }
+
+ ~GLMFuncLogger( )
+ {
+ if (m_earlyOut)
+ {
+ GLMPrintf( "<%s (early out)", m_funcName );
+ }
+ else
+ {
+ GLMPrintf( "<%s", m_funcName );
+ }
+ };
+
+ void EarlyOut( void )
+ {
+ m_earlyOut = true;
+ };
+
+ const char *m_funcName; // set at construction time
+ bool m_earlyOut;
+};
+
+// handy macro to go with the function tracking class
+#define GLM_FUNC GLMFuncLogger _logger_ ( __FUNCTION__ )
+#else
+#define GLM_FUNC tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ )
+#endif
+
+
+// class to keep an in-memory mirror of a file which may be getting edited during run
+class CGLMFileMirror
+{
+public:
+ CGLMFileMirror( char *fullpath ); // just associates mirror with file. if file exists it will be read.
+ //if non existent it will be created with size zero
+ ~CGLMFileMirror( );
+
+ bool HasData( void ); // see if data avail
+ void GetData( char **dataPtr, uint *dataSizePtr ); // read it out
+ void SetData( char *data, uint dataSize ); // put data in (and write it to disk)
+ bool PollForChanges( void ); // check disk copy. If different, read it back in and return true.
+
+ void UpdateStatInfo( void ); // make sure stat info is current for our file
+ void ReadFile( void );
+ void WriteFile( void );
+
+ void OpenInEditor( bool foreground=false ); // pass TRUE if you would like the editor to pop to foreground
+
+ /// how about a "wait for change" method..
+
+ char *m_path; // fullpath to file
+ bool m_exists;
+ struct stat m_stat; // stat results for the file (last time checked)
+
+ char *m_data; // content of file
+ uint m_size; // length of content
+
+};
+
+// class based on the file mirror, that makes it easy to edit them outside the app.
+
+// it receives an initial block of text from the engine, and hashes it. ("orig")
+// it munges it by duplicating all the text after the "!!" line, and appending it in commented form. ("munged")
+// a mirror file is activated, using a filename based on the hash from the orig text.
+// if there is already content on disk matching that filename, use that content *unless* the 'blitz' parameter is set.
+// (i.e. engine is instructing this subsystem to wipe out any old/modified variants of the text)
+
+
+class CGLMEditableTextItem
+{
+public:
+ CGLMEditableTextItem( char *text, uint size, bool forceOverwrite, char *prefix, char *suffix = NULL ); // create a text blob from text source, optional filename suffix
+ ~CGLMEditableTextItem( );
+
+ bool HasData( void );
+ bool PollForChanges( void ); // return true if stale i.e. you need to get a new edition
+ void GetCurrentText( char **textOut, uint *sizeOut ); // query for read access to the active blob (could be the original, could be external edited copy)
+ void OpenInEditor( bool foreground=false ); // call user attention to this text
+
+ // internal methods
+ void GenHashOfOrigText( void );
+ void GenBaseNameAndFullPath( char *prefix, char *suffix );
+ void GenMungedText( bool fromMirror );
+
+ // members
+ // orig
+ uint m_origSize;
+ char *m_origText; // what was submitted
+ unsigned char m_origDigest[MD5_DIGEST_LENGTH]; // digest of what was submitted
+
+ // munged
+ uint m_mungedSize;
+ char *m_mungedText; // re-processed edition, initial content submission to the file mirror
+
+ // mirror
+ char *m_mirrorBaseName; // generated from the hash of the orig text, plus the label / prefix
+ char *m_mirrorFullPath; // base name
+ CGLMFileMirror *m_mirror; // file mirror itself. holds "official" copy for GetCurrentText to return.
+};
+
+
+// debug font
+extern unsigned char g_glmDebugFontMap[16384];
+
+// class for cracking multi-part text blobs
+// sections are demarcated by beginning-of-line markers submitted in a table by the caller
+
+struct GLMTextSection
+{
+ int m_markerIndex; // based on table of markers passed in to constructor
+ uint m_textOffset; // where is the text - offset
+ int m_textLength; // how big is the section
+};
+
+class CGLMTextSectioner
+{
+public:
+ CGLMTextSectioner( char *text, int textSize, const char **markers ); // constructor finds all the sections
+ ~CGLMTextSectioner( );
+
+ int Count( void ); // how many sections found
+ void GetSection( int index, uint *offsetOut, uint *lengthOut, int *markerIndexOut );
+ // find section, size, what marker
+ // note that more than one section can be marked similarly.
+ // so policy isn't made here, you walk the sections and decide what to do if there are dupes.
+
+ //members
+
+ //section table
+ CUtlVector< GLMTextSection > m_sectionTable;
+};
+
+void GLMGPUTimestampManagerInit();
+void GLMGPUTimestampManagerDeinit();
+void GLMGPUTimestampManagerTick();
+
+#endif // GLMBASICS_H
diff --git a/mp/src/public/togl/linuxwin/glmgrext.h b/mp/src/public/togl/linuxwin/glmgrext.h new file mode 100644 index 00000000..810d4055 --- /dev/null +++ b/mp/src/public/togl/linuxwin/glmgrext.h @@ -0,0 +1,93 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmgrext.h
+// helper file for extension testing and runtime importing of entry points
+//
+//===============================================================================
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#elif defined(DX_TO_GL_ABSTRACTION)
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+#ifndef GL_EXT_framebuffer_sRGB
+ #define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9
+ #define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA
+#endif
+
+#ifndef ARB_texture_rg
+ #define GL_COMPRESSED_RED 0x8225
+ #define GL_COMPRESSED_RG 0x8226
+ #define GL_RG 0x8227
+ #define GL_RG_INTEGER 0x8228
+ #define GL_R8 0x8229
+ #define GL_R16 0x822A
+ #define GL_RG8 0x822B
+ #define GL_RG16 0x822C
+ #define GL_R16F 0x822D
+ #define GL_R32F 0x822E
+ #define GL_RG16F 0x822F
+ #define GL_RG32F 0x8230
+ #define GL_R8I 0x8231
+ #define GL_R8UI 0x8232
+ #define GL_R16I 0x8233
+ #define GL_R16UI 0x8234
+ #define GL_R32I 0x8235
+ #define GL_R32UI 0x8236
+ #define GL_RG8I 0x8237
+ #define GL_RG8UI 0x8238
+ #define GL_RG16I 0x8239
+ #define GL_RG16UI 0x823A
+ #define GL_RG32I 0x823B
+ #define GL_RG32UI 0x823C
+#endif
+
+#ifndef GL_EXT_bindable_uniform
+ #define GL_UNIFORM_BUFFER_EXT 0x8DEE
+#endif
+
+// unpublished extension enums (thus the "X")
+
+// from EXT_framebuffer_multisample_blit_scaled..
+#define XGL_SCALED_RESOLVE_FASTEST_EXT 0x90BA
+#define XGL_SCALED_RESOLVE_NICEST_EXT 0x90BB
+
+#ifndef GL_TEXTURE_MINIMIZE_STORAGE_APPLE
+#define GL_TEXTURE_MINIMIZE_STORAGE_APPLE 0x85B6
+#endif
+
+#ifndef GL_ALL_COMPLETED_NV
+#define GL_ALL_COMPLETED_NV 0x84F2
+#endif
+
+#ifndef GL_MAP_READ_BIT
+#define GL_MAP_READ_BIT 0x0001
+#endif
+
+#ifndef GL_MAP_WRITE_BIT
+#define GL_MAP_WRITE_BIT 0x0002
+#endif
+
+#ifndef GL_MAP_INVALIDATE_RANGE_BIT
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#endif
+
+#ifndef GL_MAP_INVALIDATE_BUFFER_BIT
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#endif
+
+#ifndef GL_MAP_FLUSH_EXPLICIT_BIT
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#endif
+
+#ifndef GL_MAP_UNSYNCHRONIZED_BIT
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#endif
+
diff --git a/mp/src/public/togl/osx/cglmbuffer.h b/mp/src/public/togl/osx/cglmbuffer.h new file mode 100644 index 00000000..0e40f474 --- /dev/null +++ b/mp/src/public/togl/osx/cglmbuffer.h @@ -0,0 +1,99 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmprogram.h
+// GLMgr buffers (index / vertex)
+// ... maybe add PBO later as well
+//===============================================================================
+
+#ifndef CGLMBUFFER_H
+#define CGLMBUFFER_H
+
+#pragma once
+
+// ext links
+
+// http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+//#ifndef GL_DEPTH_STENCIL_ATTACHMENT_EXT
+// #define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+//#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+
+enum EGLMBufferType
+{
+ kGLMVertexBuffer,
+ kGLMIndexBuffer,
+ kGLMUniformBuffer, // for bindable uniform
+ kGLMPixelBuffer, // for PBO
+
+ kGLMNumBufferTypes
+};
+
+ // pass this in "options" to constructor to make a dynamic buffer
+#define GLMBufferOptionDynamic 0x00000001
+
+struct GLMBuffLockParams
+{
+ uint m_offset;
+ uint m_size;
+ bool m_nonblocking;
+ bool m_discard;
+};
+
+class CGLMBuffer
+{
+
+public:
+ void Lock( GLMBuffLockParams *params, char **addressOut );
+ void Unlock( void );
+
+//protected:
+ friend class GLMContext; // only GLMContext can make CGLMBuffer objects
+ friend class GLMTester;
+ friend class IDirect3D9;
+ friend class IDirect3DDevice9;
+
+ CGLMBuffer ( GLMContext *ctx, EGLMBufferType type, uint size, uint options );
+ ~CGLMBuffer ( );
+
+ void SetModes ( bool asyncMap, bool explicitFlush, bool force = false );
+ void FlushRange ( uint offset, uint size );
+
+ GLMContext *m_ctx; // link back to parent context
+ EGLMBufferType m_type;
+ uint m_size;
+ GLenum m_buffGLTarget; // GL_ARRAY_BUFFER_ARB / GL_ELEMENT_BUFFER_ARB
+ GLuint m_name; // name of this program in the context
+ uint m_revision; // bump anytime the size changes or buffer is orphaned
+ bool m_enableAsyncMap; // mirror of the buffer state
+ bool m_enableExplicitFlush; // mirror of the buffer state
+
+ bool m_bound; // true if bound to context
+ bool m_mapped; // is it currently mapped
+ uint m_dirtyMinOffset; // when equal, range is empty
+ uint m_dirtyMaxOffset;
+
+ float *m_lastMappedAddress;
+
+ // --------------------- pseudo-VBO support below here (explicitly for dynamic index buffers)
+ bool m_pseudo; // true if the m_name is 0, and the backing is plain RAM
+
+ // in pseudo mode, there is just one RAM buffer that acts as the backing.
+ // expectation is that this mode would only be used for dynamic indices.
+ // since indices have to be consumed (copied to command stream) prior to return from a drawing call,
+ // there's no need to do any fencing or multibuffering. orphaning in particular becomes a no-op.
+
+ char *m_pseudoBuf; // storage for pseudo buffer
+};
+
+
+#endif
\ No newline at end of file diff --git a/mp/src/public/togl/osx/cglmfbo.h b/mp/src/public/togl/osx/cglmfbo.h new file mode 100644 index 00000000..ab889af2 --- /dev/null +++ b/mp/src/public/togl/osx/cglmfbo.h @@ -0,0 +1,91 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmfbo.h
+// GLMgr FBO's (render targets)
+//
+//===============================================================================
+
+#ifndef CGLMFBO_H
+#define CGLMFBO_H
+
+#pragma once
+
+#include "togl/rendermechanism.h"
+
+// good FBO references / recaps
+// http://www.songho.ca/opengl/gl_fbo.html
+// http://www.gamedev.net/reference/articles/article2331.asp
+
+// ext links
+
+// http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt
+// http://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+#ifndef GL_DEPTH_STENCIL_ATTACHMENT_EXT
+ #define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+
+// implicitly 16 maximum color attachments possible
+enum EGLMFBOAttachment {
+ kAttColor0, kAttColor1, kAttColor2, kAttColor3,
+ kAttColor4, kAttColor5, kAttColor6, kAttColor7,
+ kAttColor8, kAttColor9, kAttColor10, kAttColor11,
+ kAttColor12, kAttColor13, kAttColor14, kAttColor15,
+ kAttDepth, kAttStencil, kAttDepthStencil,
+ kAttCount
+};
+
+struct GLMFBOTexAttachParams
+{
+ CGLMTex *m_tex;
+ int m_face; // keep zero if not cube map
+ int m_mip; // keep zero if notmip mapped
+ int m_zslice; // keep zero if not a 3D tex
+};
+
+class CGLMFBO
+{
+
+public:
+
+protected:
+ friend class GLMContext; // only GLMContext can make CGLMFBO objects
+ friend class GLMTester;
+ friend class CGLMTex;
+
+ friend class IDirect3D9;
+ friend class IDirect3DDevice9;
+
+ CGLMFBO( GLMContext *ctx );
+ ~CGLMFBO( );
+
+ void TexAttach( GLMFBOTexAttachParams *params, EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
+ void TexDetach( EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
+ // you can also pass GL_READ_FRAMEBUFFER_EXT or GL_DRAW_FRAMEBUFFER_EXT to selectively bind the receiving FBO to one or the other.
+
+ void TexScrub( CGLMTex *tex );
+ // search and destroy any attachment for the named texture
+
+ bool IsReady( void ); // aka FBO completeness check - ready to draw
+
+ GLMContext *m_ctx; // link back to parent context
+
+ GLuint m_name; // name of this FBO in the context
+
+ GLMFBOTexAttachParams m_attach[ kAttCount ]; // indexed by EGLMFBOAttachment
+
+ int m_sizeX,m_sizeY;
+};
+
+
+#endif
diff --git a/mp/src/public/togl/osx/cglmprogram.h b/mp/src/public/togl/osx/cglmprogram.h new file mode 100644 index 00000000..8d702c42 --- /dev/null +++ b/mp/src/public/togl/osx/cglmprogram.h @@ -0,0 +1,291 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmprogram.h
+// GLMgr programs (ARBVP/ARBfp)
+//
+//===============================================================================
+
+#ifndef CGLMPROGRAM_H
+#define CGLMPROGRAM_H
+
+#include <sys/stat.h>
+
+#pragma once
+
+// good ARB program references
+// http://petewarden.com/notes/archives/2005/05/fragment_progra_2.html
+// http://petewarden.com/notes/archives/2005/06/fragment_progra_3.html
+
+// ext links
+
+// http://www.opengl.org/registry/specs/ARB/vertex_program.txt
+// http://www.opengl.org/registry/specs/ARB/fragment_program.txt
+// http://www.opengl.org/registry/specs/EXT/gpu_program_parameters.txt
+
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+//#ifndef GL_DEPTH_STENCIL_ATTACHMENT_EXT
+// #define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+//#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class CGLMShaderPair;
+class CGLMShaderPairCache;
+
+// CGLMProgram can contain two flavors of the same program, one in assembler, one in GLSL.
+// these flavors are pretty different in terms of the API's that are used to activate them -
+// for example, assembler programs can just get bound to the context, whereas GLSL programs
+// have to be linked. To some extent we try to hide that detail inside GLM.
+
+// for now, make CGLMProgram a container, it does not set policy or hold a preference as to which
+// flavor you want to use. GLMContext has to handle that.
+
+enum EGLMProgramType
+{
+ kGLMVertexProgram,
+ kGLMFragmentProgram,
+
+ kGLMNumProgramTypes
+};
+
+enum EGLMProgramLang
+{
+ kGLMARB,
+ kGLMGLSL,
+
+ kGLMNumProgramLangs
+};
+
+struct GLMShaderDesc
+{
+ union
+ {
+ GLuint arb; // ARB program object name
+ GLhandleARB glsl; // GLSL shader object handle (void*)
+ } m_object;
+
+ // these can change if shader text is edited
+ bool m_textPresent; // is this flavor(lang) of text present in the buffer?
+ int m_textOffset; // where is it
+ int m_textLength; // how big
+
+ bool m_compiled; // has this text been through a compile attempt
+ bool m_valid; // and if so, was the compile successful
+
+ int m_slowMark; // has it been flagged during a non native draw batch before. increment every time it's slow.
+
+ int m_highWater; // vount of vec4's in the major uniform array ("vc" on vs, "pc" on ps)
+ // written by dxabstract.... gross!
+};
+
+GLenum GLMProgTypeToARBEnum( EGLMProgramType type ); // map vert/frag to ARB asm bind target
+GLenum GLMProgTypeToGLSLEnum( EGLMProgramType type ); // map vert/frag to ARB asm bind target
+
+class CGLMProgram
+{
+public:
+ friend class CGLMShaderPairCache;
+ friend class CGLMShaderPair;
+ friend class GLMContext; // only GLMContext can make CGLMProgram objects
+ friend class GLMTester;
+ friend class IDirect3D9;
+ friend class IDirect3DDevice9;
+
+ //===============================
+
+ // constructor is very light, it just makes one empty program object per flavor.
+ CGLMProgram( GLMContext *ctx, EGLMProgramType type );
+ ~CGLMProgram( );
+
+ void SetProgramText ( char *text ); // import text to GLM object - invalidate any prev compiled program
+
+ bool CompileActiveSources ( void ); // compile only the flavors that were provided.
+ bool Compile ( EGLMProgramLang lang );
+ bool CheckValidity ( EGLMProgramLang lang );
+
+ void LogSlow ( EGLMProgramLang lang ); // detailed spew when called for first time; one liner or perhaps silence after that
+
+ void GetLabelIndexCombo ( char *labelOut, int labelOutMaxChars, int *indexOut, int *comboOut );
+ void GetComboIndexNameString ( char *stringOut, int stringOutMaxChars ); // mmmmmmmm-nnnnnnnn-filename
+
+#if GLMDEBUG
+ bool PollForChanges( void ); // check mirror for changes.
+ void ReloadStringFromEditable( void ); // populate m_string from editable item (react to change)
+ bool SyncWithEditable( void );
+#endif
+
+ //===============================
+
+ // common stuff
+
+ GLMContext *m_ctx; // link back to parent context
+
+ EGLMProgramType m_type; // vertex or pixel
+
+ uint m_serial; // serial number for hashing
+
+ char *m_text; // copy of text passed into constructor. Can change if editable shaders is enabled.
+ // note - it can contain multiple flavors, so use CGLMTextSectioner to scan it and locate them
+#if GLMDEBUG
+ CGLMEditableTextItem *m_editable; // editable text item for debugging
+#endif
+
+ GLMShaderDesc m_descs[ kGLMNumProgramLangs ];
+
+ uint m_samplerMask; // (1<<n) mask of sampler active locs, if this is a fragment shader (dxabstract sets this field)
+};
+
+//===============================================================================
+
+struct GLMShaderPairInfo
+{
+ int m_status; // -1 means req'd index was out of bounds (loop stop..) 0 means not present. 1 means present/active.
+
+ char m_vsName[ 128 ];
+ int m_vsStaticIndex;
+ int m_vsDynamicIndex;
+
+ char m_psName[ 128 ];
+ int m_psStaticIndex;
+ int m_psDynamicIndex;
+};
+
+
+class CGLMShaderPair // a container for a linked GLSL shader pair, and metadata obtained post-link
+{
+
+public:
+
+ friend class CGLMProgram;
+ friend class GLMContext;
+ friend class CGLMShaderPairCache;
+
+ //===============================
+
+ // constructor just sets up a GLSL program object and leaves it empty.
+ CGLMShaderPair( GLMContext *ctx );
+ ~CGLMShaderPair( );
+
+ bool SetProgramPair ( CGLMProgram *vp, CGLMProgram *fp );
+ // true result means successful link and query
+
+ bool RefreshProgramPair ( void );
+ // re-link and re-query the uniforms
+
+ //===============================
+
+ // common stuff
+
+ GLMContext *m_ctx; // link back to parent context
+
+ CGLMProgram *m_vertexProg;
+ CGLMProgram *m_fragmentProg;
+
+ GLhandleARB m_program; // linked program object
+
+ // need meta data for attribs / samplers / params
+ // actually we only need it for samplers and params.
+ // attributes are hardwired.
+
+ // vertex stage uniforms
+ GLint m_locVertexParams; // "vc" per dx9asmtogl2 convention
+ GLint m_locVertexInteger0; // "i0"
+ GLint m_locVertexBool0; // "b0"
+ GLint m_locVertexBool1; // "b1"
+ GLint m_locVertexBool2; // "b2"
+ GLint m_locVertexBool3; // "b3"
+
+ // fragment stage uniforms
+ GLint m_locFragmentParams; // "pc" per dx9asmtogl2 convention
+ GLint m_locFragmentFakeSRGBEnable; // "flSRGBWrite" - set to 1.0 to effect sRGB encoding on output
+ float m_fakeSRGBEnableValue; // shadow to avoid redundant sets of the m_locFragmentFakeSRGBEnable uniform
+ // init it to -1.0 at link or relink, so it will trip on any legit incoming value (0.0 or 1.0)
+
+ GLint m_locSamplers[ 16 ]; // "sampler0 ... sampler1..."
+
+ // other stuff
+ bool m_valid; // true on successful link
+ bool m_samplersFixed; // set on first draw (can't write the uniforms until the program is in use, and we don't want to mess with cur program inside cglmprogram)
+ uint m_revision; // if this pair is relinked, bump this number.
+};
+
+//===============================================================================
+
+// N-row, M-way associative cache with LRU per row.
+// still needs some metric dump ability and some parameter tuning.
+// extra credit would be to make an auto-tuner.
+
+struct CGLMPairCacheEntry
+{
+ long long m_lastMark; // a mark of zero means an empty entry
+ CGLMProgram *m_vertexProg;
+ CGLMProgram *m_fragmentProg;
+ uint m_extraKeyBits;
+ CGLMShaderPair *m_pair;
+};
+
+class CGLMShaderPairCache // cache for linked GLSL shader pairs
+{
+
+public:
+
+protected:
+ friend class CGLMShaderPair;
+ friend class CGLMProgram;
+ friend class GLMContext;
+
+ //===============================
+
+ CGLMShaderPairCache( GLMContext *ctx );
+ ~CGLMShaderPairCache( );
+
+ CGLMShaderPair *SelectShaderPair ( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
+ void QueryShaderPair ( int index, GLMShaderPairInfo *infoOut );
+
+ // shoot down linked pairs that use the program in the arg
+ // return true if any had to be skipped due to conflict with currently bound pair
+ bool PurgePairsWithShader( CGLMProgram *prog );
+
+ // purge everything (when would GLM know how to do this ? at context destroy time, but any other times?)
+ // return true if any had to be skipped due to conflict with currently bound pair
+ bool Purge ( void );
+
+ // stats
+ void DumpStats ( void );
+
+ //===============================
+
+ uint HashRowIndex ( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
+ CGLMPairCacheEntry* HashRowPtr ( uint hashRowIndex );
+ void HashRowProbe ( CGLMPairCacheEntry *row, CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int *hitwayOut, int *emptywayOut, int *oldestwayOut );
+ //===============================
+
+ // common stuff
+
+ GLMContext *m_ctx; // link back to parent context
+
+ long long m_mark;
+
+ uint m_rowsLg2;
+ uint m_rows;
+
+ uint m_waysLg2;
+ uint m_ways;
+
+ uint m_entryCount;
+
+ CGLMPairCacheEntry *m_entries; // array[ m_rows ][ m_ways ]
+
+ uint *m_evictions; // array[ m_rows ];
+ uint *m_hits; // array[ m_rows ];
+};
+
+
+#endif
\ No newline at end of file diff --git a/mp/src/public/togl/osx/cglmquery.h b/mp/src/public/togl/osx/cglmquery.h new file mode 100644 index 00000000..1f257ccf --- /dev/null +++ b/mp/src/public/togl/osx/cglmquery.h @@ -0,0 +1,85 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmquery.h
+// GLMgr queries
+//
+//===============================================================================
+
+#ifndef CGLMQUERY_H
+#define CGLMQUERY_H
+
+#pragma once
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class CGLMQuery;
+
+//===============================================================================
+
+enum EGLMQueryType
+{
+ EOcclusion,
+ EFence,
+ EGLMQueryCount
+};
+
+struct GLMQueryParams
+{
+ EGLMQueryType m_type;
+};
+
+class CGLMQuery
+{
+ // leave everything public til it's running
+public:
+ friend class GLMContext; // only GLMContext can make CGLMTex objects
+ friend class IDirect3DDevice9;
+ friend class IDirect3DQuery9;
+
+ GLMContext *m_ctx; // link back to parent context
+ GLMQueryParams m_params; // params created with
+
+ GLuint m_name; // name of the query object per se - could be fence, could be query object ... NOT USED WITH GL_ARB_sync!
+#ifdef HAVE_GL_ARB_SYNC
+ GLsync m_syncobj; // GL_ARB_sync object. NOT USED WITH GL_NV_fence or GL_APPLE_fence!
+#else
+ GLuint m_syncobj;
+#endif
+
+ bool m_started;
+ bool m_stopped;
+ bool m_done;
+
+ bool m_nullQuery; // was gl_nullqueries true at Start time - if so, continue to act like a null query through Stop/IsDone/Complete time
+ // restated - only Start should examine the convar.
+
+ CGLMQuery( GLMContext *ctx, GLMQueryParams *params );
+ ~CGLMQuery( );
+
+ // for an occlusion query:
+ // Start = BeginQuery query-start goes into stream
+ // Stop = EndQuery query-end goes into stream - a fence is also set so we can probe for completion
+ // IsDone = TestFence use the added fence to ask if query-end has passed (i.e. will Complete block?)
+ // Complete = GetQueryObjectuivARB(uint id, enum pname, uint *params) - extract the sample count
+
+ // for a fence query:
+ // Start = SetFence fence goes into command stream
+ // Stop = NOP fences are self finishing - no need to call Stop on a fence
+ // IsDone = TestFence ask if fence passed
+ // Complete = FinishFence
+
+ void Start ( void );
+ void Stop ( void );
+ bool IsDone ( void );
+ void Complete ( uint *result );
+
+ // accessors for the started/stopped state
+ bool IsStarted ( void );
+ bool IsStopped ( void );
+};
+
+
+#endif
diff --git a/mp/src/public/togl/osx/cglmtex.h b/mp/src/public/togl/osx/cglmtex.h new file mode 100644 index 00000000..a48995a0 --- /dev/null +++ b/mp/src/public/togl/osx/cglmtex.h @@ -0,0 +1,273 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// cglmtex.h
+// GLMgr textures
+//
+//===============================================================================
+
+#ifndef CGLMTEX_H
+#define CGLMTEX_H
+
+#pragma once
+
+#include "tier1/utlhash.h"
+#include "tier1/utlmap.h"
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class GLMTester;
+class CGLMTexLayoutTable;
+class CGLMTex;
+class CGLMFBO;
+
+class IDirect3DSurface9;
+
+//===============================================================================
+
+struct GLMTexFormatDesc
+{
+ char *m_formatSummary; // for debug visibility
+
+ D3DFORMAT m_d3dFormat; // what D3D knows it as; see public/bitmap/imageformat.h
+
+ GLenum m_glIntFormat; // GL internal format
+ GLenum m_glIntFormatSRGB; // internal format if SRGB flavor
+ GLenum m_glDataFormat; // GL data format
+ GLenum m_glDataType; // GL data type
+
+ int m_chunkSize; // 1 or 4 - 4 is used for compressed textures
+ int m_bytesPerSquareChunk; // how many bytes for the smallest quantum (m_chunkSize x m_chunkSize)
+ // this description lets us calculate size cleanly without conditional logic for compression
+};
+const GLMTexFormatDesc *GetFormatDesc( D3DFORMAT format );
+
+//===============================================================================
+
+// utility function for generating slabs of texels. mostly for test.
+typedef struct
+{
+ // in
+ D3DFORMAT m_format;
+ void *m_dest; // dest address
+ int m_chunkCount; // square chunk count (single texels or compressed blocks)
+ int m_byteCountLimit; // caller expectation of max number of bytes to write out
+ float r,g,b,a; // color desired
+
+ // out
+ int m_bytesWritten;
+} GLMGenTexelParams;
+
+// return true if successful
+bool GLMGenTexels( GLMGenTexelParams *params );
+
+
+//===============================================================================
+
+struct GLMTexLayoutSlice
+{
+ int m_xSize,m_ySize,m_zSize; //texel dimensions of this slice
+ int m_storageOffset; //where in the storage slab does this slice live
+ int m_storageSize; //how much storage does this slice occupy
+};
+
+enum EGLMTexFlags
+{
+ kGLMTexMipped = 0x01,
+ kGLMTexMippedAuto = 0x02,
+ kGLMTexRenderable = 0x04,
+ kGLMTexIsStencil = 0x08,
+ kGLMTexIsDepth = 0x10,
+ kGLMTexSRGB = 0x20,
+ kGLMTexMultisampled = 0x40, // has an RBO backing it. Cannot combine with Mipped, MippedAuto. One slice maximum, only targeting GL_TEXTURE_2D.
+ // actually not 100% positive on the mipmapping, the RBO itself can't be mipped, but the resulting texture could
+ // have mipmaps generated.
+};
+
+//===============================================================================
+
+struct GLMTexLayoutKey
+{
+ // input values: held const, these are the hash key for the form map
+ GLenum m_texGLTarget; // flavor of texture: GL_TEXTURE_2D, GL_TEXTURE_3D, GLTEXTURE_CUBE_MAP
+ D3DFORMAT m_texFormat; // D3D texel format
+ unsigned long m_texFlags; // mipped, autogen mips, render target, ... ?
+ unsigned long m_texSamples; // zero for a plain tex, 2/4/6/8 for "MSAA tex" (RBO backed)
+ int m_xSize,m_ySize,m_zSize; // size of base mip
+};
+
+bool LessFunc_GLMTexLayoutKey( const GLMTexLayoutKey &a, const GLMTexLayoutKey &b );
+
+#define GLM_TEX_MAX_MIPS 14
+#define GLM_TEX_MAX_FACES 6
+#define GLM_TEX_MAX_SLICES (GLM_TEX_MAX_MIPS * GLM_TEX_MAX_FACES)
+
+struct GLMTexLayout
+{
+ char *m_layoutSummary; // for debug visibility
+
+ // const inputs used for hashing
+ GLMTexLayoutKey m_key;
+
+ // refcount
+ int m_refCount;
+
+ // derived values:
+ GLMTexFormatDesc *m_format; // format specific info
+ int m_mipCount; // derived by starying at base size and working down towards 1x1
+ int m_faceCount; // 1 for 2d/3d, 6 for cubemap
+ int m_sliceCount; // product of faces and mips
+ int m_storageTotalSize; // size of storage slab required
+
+ // slice array
+ GLMTexLayoutSlice m_slices[0]; // dynamically allocated 2-d array [faces][mips]
+};
+
+
+class CGLMTexLayoutTable
+{
+public:
+ CGLMTexLayoutTable();
+
+ GLMTexLayout *NewLayoutRef( GLMTexLayoutKey *key ); // pass in a pointer to layout key - receive ptr to completed layout
+ void DelLayoutRef( GLMTexLayout *layout ); // pass in pointer to completed layout. refcount is dropped.
+
+ void DumpStats( void );
+protected:
+ CUtlMap< GLMTexLayoutKey, GLMTexLayout* > m_layoutMap;
+};
+
+//===============================================================================
+
+// a sampler specifies desired state for drawing on a given sampler index
+// this is the combination of a texture choice and a set of sampler parameters
+// see http://msdn.microsoft.com/en-us/library/bb172602(VS.85).aspx
+
+
+struct GLMTexSamplingParams
+{
+ GLenum m_addressModes[3]; // S, T, R
+ GLfloat m_borderColor[4]; // R,G,B,A
+
+ GLenum m_magFilter;
+ GLenum m_minFilter;
+
+ GLfloat m_mipmapBias;
+ GLint m_minMipLevel;
+ GLint m_maxMipLevel;
+ GLint m_maxAniso;
+ GLenum m_compareMode; // only used for depth and stencil type textures
+ bool m_srgb; // srgb texture read...
+};
+
+struct GLMTexLockParams
+{
+ // input params which identify the slice of interest
+ CGLMTex *m_tex;
+ int m_face;
+ int m_mip;
+
+ // identifies the region of the slice
+ GLMRegion m_region;
+
+ // tells GLM to force re-read of the texels back from GL
+ // i.e. "I know I stepped on those texels with a draw or blit - the GLM copy is stale"
+ bool m_readback;
+};
+
+struct GLMTexLockDesc
+{
+ GLMTexLockParams m_req; // form of the lock request
+
+ bool m_active; // set true at lock time. cleared at unlock time.
+
+ int m_sliceIndex; // which slice in the layout
+ int m_sliceBaseOffset; // where is that in the texture data
+ int m_sliceRegionOffset; // offset to the start (lowest address corner) of the region requested
+};
+
+//===============================================================================
+
+#define GLM_SAMPLER_COUNT 16
+
+typedef CBitVec<GLM_SAMPLER_COUNT> CTexBindMask;
+
+enum EGLMTexSliceFlag
+{
+ kSliceValid = 0x01, // slice has been teximage'd in whole at least once - set to 0 initially
+ kSliceStorageValid = 0x02, // if backing store is available, this slice's data is a valid copy - set to 0 initially
+ kSliceLocked = 0x04, // are one or more locks outstanding on this slice
+ kSliceFullyDirty = 0x08, // does the slice need to be fully downloaded at unlock time (disregard dirty rects)
+};
+
+class CGLMTex
+{
+
+public:
+
+ void Lock( GLMTexLockParams *params, char** addressOut, int* yStrideOut, int *zStrideOut );
+ void Unlock( GLMTexLockParams *params );
+
+protected:
+ friend class GLMContext; // only GLMContext can make CGLMTex objects
+ friend class GLMTester;
+ friend class CGLMFBO;
+
+ friend class IDirect3DDevice9;
+ friend class IDirect3DBaseTexture9;
+ friend class IDirect3DTexture9;
+ friend class IDirect3DSurface9;
+ friend class IDirect3DCubeTexture9;
+ friend class IDirect3DVolumeTexture9;
+
+ CGLMTex( GLMContext *ctx, GLMTexLayout *layout, GLMTexSamplingParams *sampling, char *debugLabel = NULL );
+ ~CGLMTex( );
+
+ int CalcSliceIndex( int face, int mip );
+ void CalcTexelDataOffsetAndStrides( int sliceIndex, int x, int y, int z, int *offsetOut, int *yStrideOut, int *zStrideOut );
+
+ void ApplySamplingParams( GLMTexSamplingParams *params, bool noCheck=FALSE );
+
+ void ReadTexels( GLMTexLockDesc *desc, bool readWholeSlice=true );
+ void WriteTexels( GLMTexLockDesc *desc, bool writeWholeSlice=true, bool noDataWrite=false );
+ // last param lets us send NULL data ptr (only legal with uncompressed formats, beware)
+ // this helps out ResetSRGB.
+
+ void ResetSRGB( bool srgb, bool noDataWrite );
+ // re-specify texture format to match desired sRGB form
+ // noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's
+
+ GLMTexLayout *m_layout; // layout of texture (shared across all tex with same layout)
+ int m_minActiveMip;//index of lowest mip that has been written. used to drive setting of GL_TEXTURE_MAX_LEVEL.
+ int m_maxActiveMip;//index of highest mip that has been written. used to drive setting of GL_TEXTURE_MAX_LEVEL.
+
+ GLMTexSamplingParams m_sampling; // mirror of sampling params currently embodied in the texture
+ // (consult this at draw time, in order to know if changes need to be made)
+
+ GLMContext *m_ctx; // link back to parent context
+
+ GLuint m_texName; // name of this texture in the context
+ bool m_texClientStorage; // was CS selecetd for texture
+ bool m_texPreloaded; // has it been kicked into VRAM with GLMContext::PreloadTex yet
+
+ GLuint m_rboName; // name of MSAA RBO backing the tex if MSAA enabled (or zero)
+ bool m_rboDirty; // has RBO been drawn on - i.e. needs to be blitted back to texture if texture is going to be sampled from
+
+ CTexBindMask m_bindPoints; // true for each place in the parent ctx where currently
+ // bound (indexed via EGLMTexCtxBindingIndex)
+
+ int m_rtAttachCount; // how many RT's have this texture attached somewhere
+
+ char *m_backing; // backing storage if available
+
+ int m_lockCount; // lock reqs are stored in the GLMContext for tracking
+
+ CUtlVector<unsigned char> m_sliceFlags;
+
+ char *m_debugLabel; // strdup() of debugLabel passed in, or NULL
+};
+
+
+#endif
diff --git a/mp/src/public/togl/osx/dxabstract.h b/mp/src/public/togl/osx/dxabstract.h new file mode 100644 index 00000000..682676c7 --- /dev/null +++ b/mp/src/public/togl/osx/dxabstract.h @@ -0,0 +1,804 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//
+//
+//==================================================================================================
+
+#ifndef DXABSTRACT_H
+#define DXABSTRACT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "togl/rendermechanism.h"
+
+#include "materialsystem/ishader.h"
+
+// Uncomment this on Windows if you want to compile the Windows GL version.
+// #undef USE_ACTUAL_DX
+
+#ifdef USE_ACTUAL_DX
+
+#ifndef WIN32
+#error sorry man
+#endif
+#ifdef _X360
+#include "d3d9.h"
+#include "d3dx9.h"
+#else
+#include <windows.h>
+#include "../../dx9sdk/include/d3d9.h"
+#include "../../dx9sdk/include/d3dx9.h"
+#endif
+typedef HWND VD3DHWND;
+
+#else
+
+#ifdef WIN32
+#error Gl on win32?
+#endif
+
+#include "tier0/platform.h"
+
+#ifndef DX_TO_GL_ABSTRACTION
+#define DX_TO_GL_ABSTRACTION
+#endif
+
+#include "bitmap/imageformat.h"
+#include "togl/rendermechanism.h"
+
+#ifdef OSX
+extern "C" void Debugger(void);
+#endif
+
+// turn this on to get refcount logging from IUnknown
+#define IUNKNOWN_ALLOC_SPEW 0
+#define IUNKNOWN_ALLOC_SPEW_MARK_ALL 0
+
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// DEFINES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+typedef void* VD3DHWND;
+typedef void* VD3DHANDLE;
+
+
+TOGL_INTERFACE void toglGetClientRect( VD3DHWND hWnd, RECT *destRect );
+
+struct TOGL_CLASS IUnknown
+{
+ int m_refcount[2];
+ bool m_mark;
+
+ IUnknown( void )
+ {
+ m_refcount[0] = 1;
+ m_refcount[1] = 0;
+ m_mark = (IUNKNOWN_ALLOC_SPEW_MARK_ALL != 0); // either all are marked, or only the ones that have SetMark(true) called on them
+
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IUnew (%08x) refc -> (%d,%d) ",this,m_refcount[0],m_refcount[1]));
+ }
+ #endif
+ };
+
+ virtual ~IUnknown( void )
+ {
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IUdel (%08x) ",this ));
+ }
+ #endif
+ };
+
+ void AddRef( int which=0, char *comment = NULL )
+ {
+ Assert( which >= 0 );
+ Assert( which < 2 );
+ m_refcount[which]++;
+
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IUAddRef (%08x,%d) refc -> (%d,%d) [%s]",this,which,m_refcount[0],m_refcount[1],comment?comment:"...")) ;
+ if (!comment)
+ {
+ GLMPRINTF(("")) ; // place to hang a breakpoint
+ }
+ }
+ #endif
+ };
+
+ ULONG __stdcall Release( int which=0, char *comment = NULL )
+ {
+ Assert( which >= 0 );
+ Assert( which < 2 );
+
+ //int oldrefcs[2] = { m_refcount[0], m_refcount[1] };
+ bool deleting = false;
+
+ m_refcount[which]--;
+ if ( (!m_refcount[0]) && (!m_refcount[1]) )
+ {
+ deleting = true;
+ }
+
+ #if IUNKNOWN_ALLOC_SPEW
+ if (m_mark)
+ {
+ GLMPRINTF(("-A- IURelease (%08x,%d) refc -> (%d,%d) [%s] %s",this,which,m_refcount[0],m_refcount[1],comment?comment:"...",deleting?"->DELETING":""));
+ if (!comment)
+ {
+ GLMPRINTF(("")) ; // place to hang a breakpoint
+ }
+ }
+ #endif
+
+ if (deleting)
+ {
+ if (m_mark)
+ {
+ GLMPRINTF(("")) ; // place to hang a breakpoint
+ }
+ delete this;
+ return 0;
+ }
+ else
+ {
+ return m_refcount[0];
+ }
+ };
+
+ void SetMark( bool markValue, char *comment=NULL )
+ {
+ #if IUNKNOWN_ALLOC_SPEW
+ if (!m_mark && markValue) // leading edge detect
+ {
+ // print the same thing that the constructor would have printed if it had been marked from the beginning
+ // i.e. it's anticipated that callers asking for marking will do so right at create time
+ GLMPRINTF(("-A- IUSetMark (%08x) refc -> (%d,%d) (%s) ",this,m_refcount[0],m_refcount[1],comment?comment:"..."));
+ }
+ #endif
+
+ m_mark = markValue;
+ }
+};
+
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// INTERFACES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+struct TOGL_CLASS IDirect3DResource9 : public IUnknown
+{
+ IDirect3DDevice9 *m_device; // parent device
+ D3DRESOURCETYPE m_restype;
+
+ DWORD SetPriority(DWORD PriorityNew);
+};
+
+struct TOGL_CLASS IDirect3DBaseTexture9 : public IDirect3DResource9 // "A Texture.."
+{
+ D3DSURFACE_DESC m_descZero; // desc of top level.
+ CGLMTex *m_tex; // a CGLMTex can represent all forms of tex
+ int m_srgbFlipCount;
+
+ virtual ~IDirect3DBaseTexture9();
+ D3DRESOURCETYPE GetType();
+ DWORD GetLevelCount();
+ HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DTexture9 : public IDirect3DBaseTexture9 // "Texture 2D"
+{
+ IDirect3DSurface9 *m_surfZero; // surf of top level.
+
+ virtual ~IDirect3DTexture9();
+
+ HRESULT LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
+ HRESULT UnlockRect(UINT Level);
+ HRESULT GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel);
+};
+
+struct TOGL_CLASS IDirect3DCubeTexture9 : public IDirect3DBaseTexture9 // "Texture Cube Map"
+{
+ IDirect3DSurface9 *m_surfZero[6]; // surfs of top level.
+
+ virtual ~IDirect3DCubeTexture9();
+
+ HRESULT GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface);
+ HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DVolumeTexture9 : public IDirect3DBaseTexture9 // "Texture 3D"
+{
+ IDirect3DSurface9 *m_surfZero; // surf of top level.
+ D3DVOLUME_DESC m_volDescZero; // volume desc top level
+
+ virtual ~IDirect3DVolumeTexture9();
+
+ HRESULT LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags);
+ HRESULT UnlockBox(UINT Level);
+ HRESULT GetLevelDesc( UINT level, D3DVOLUME_DESC *pDesc );
+};
+
+
+// for the moment, a "D3D surface" is modeled as a GLM tex, a face, and a mip.
+// no Create method, these are filled in by the various create surface methods.
+
+struct TOGL_CLASS IDirect3DSurface9 : public IDirect3DResource9
+{
+ virtual ~IDirect3DSurface9();
+
+ HRESULT LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
+ HRESULT UnlockRect();
+ HRESULT GetDesc(D3DSURFACE_DESC *pDesc);
+
+ D3DSURFACE_DESC m_desc;
+ CGLMTex *m_tex;
+ int m_face;
+ int m_mip;
+};
+
+
+
+struct TOGL_CLASS IDirect3D9 : public IUnknown
+{
+public:
+ virtual ~IDirect3D9();
+
+ UINT GetAdapterCount(); //cheese: returns 1
+
+ HRESULT GetDeviceCaps (UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps);
+ HRESULT GetAdapterIdentifier (UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier);
+ HRESULT CheckDeviceFormat (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat);
+ UINT GetAdapterModeCount (UINT Adapter,D3DFORMAT Format);
+ HRESULT EnumAdapterModes (UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode);
+ HRESULT CheckDeviceType (UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed);
+ HRESULT GetAdapterDisplayMode (UINT Adapter,D3DDISPLAYMODE* pMode);
+ HRESULT CheckDepthStencilMatch (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
+ HRESULT CheckDeviceMultiSampleType (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels);
+
+ HRESULT CreateDevice (UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface);
+};
+
+struct TOGL_CLASS IDirect3DSwapChain9 : public IUnknown
+{
+};
+
+
+
+ // typedef enum D3DDECLUSAGE
+ // {
+ // D3DDECLUSAGE_POSITION = 0,
+ // D3DDECLUSAGE_BLENDWEIGHT = 1,
+ // D3DDECLUSAGE_BLENDINDICES = 2,
+ // D3DDECLUSAGE_NORMAL = 3,
+ // D3DDECLUSAGE_PSIZE = 4,
+ // D3DDECLUSAGE_TEXCOORD = 5,
+ // D3DDECLUSAGE_TANGENT = 6,
+ // D3DDECLUSAGE_BINORMAL = 7,
+ // D3DDECLUSAGE_TESSFACTOR = 8,
+ // D3DDECLUSAGE_POSITIONT = 9,
+ // D3DDECLUSAGE_COLOR = 10,
+ // D3DDECLUSAGE_FOG = 11,
+ // D3DDECLUSAGE_DEPTH = 12,
+ // D3DDECLUSAGE_SAMPLE = 13,
+ // } D3DDECLUSAGE, *LPD3DDECLUSAGE;
+ // Constants
+ //
+ // D3DDECLUSAGE_POSITION
+ // Position data ranging from (-1,-1) to (1,1). Use D3DDECLUSAGE_POSITION with
+ // a usage index of 0 to specify untransformed position for fixed function
+ // vertex processing and the n-patch tessellator. Use D3DDECLUSAGE_POSITION
+ // with a usage index of 1 to specify untransformed position in the fixed
+ // function vertex shader for vertex tweening.
+ //
+ // D3DDECLUSAGE_BLENDWEIGHT
+ // Blending weight data. Use D3DDECLUSAGE_BLENDWEIGHT with a usage index of 0
+ // to specify the blend weights used in indexed and nonindexed vertex
+ // blending.
+ //
+ // D3DDECLUSAGE_BLENDINDICES
+ // Blending indices data. Use D3DDECLUSAGE_BLENDINDICES with a usage index of
+ // 0 to specify matrix indices for indexed paletted skinning.
+ //
+ // D3DDECLUSAGE_NORMAL
+ // Vertex normal data. Use D3DDECLUSAGE_NORMAL with a usage index of 0 to
+ // specify vertex normals for fixed function vertex processing and the n-patch
+ // tessellator. Use D3DDECLUSAGE_NORMAL with a usage index of 1 to specify
+ // vertex normals for fixed function vertex processing for vertex tweening.
+ //
+ // D3DDECLUSAGE_PSIZE
+ // Point size data. Use D3DDECLUSAGE_PSIZE with a usage index of 0 to specify
+ // the point-size attribute used by the setup engine of the rasterizer to
+ // expand a point into a quad for the point-sprite functionality.
+ //
+ // D3DDECLUSAGE_TEXCOORD
+ // Texture coordinate data. Use D3DDECLUSAGE_TEXCOORD, n to specify texture
+ // coordinates in fixed function vertex processing and in pixel shaders prior
+ // to ps_3_0. These can be used to pass user defined data.
+ //
+ // D3DDECLUSAGE_TANGENT
+ // Vertex tangent data.
+ //
+ // D3DDECLUSAGE_BINORMAL
+ // Vertex binormal data.
+ //
+ // D3DDECLUSAGE_TESSFACTOR
+ // Single positive floating point value. Use D3DDECLUSAGE_TESSFACTOR with a
+ // usage index of 0 to specify a tessellation factor used in the tessellation
+ // unit to control the rate of tessellation. For more information about the
+ // data type, see D3DDECLTYPE_FLOAT1.
+ //
+ // D3DDECLUSAGE_POSITIONT
+ // Vertex data contains transformed position data ranging from (0,0) to
+ // (viewport width, viewport height). Use D3DDECLUSAGE_POSITIONT with a usage
+ // index of 0 to specify transformed position. When a declaration containing
+ // this is set, the pipeline does not perform vertex processing.
+ //
+ // D3DDECLUSAGE_COLOR
+ // Vertex data contains diffuse or specular color. Use D3DDECLUSAGE_COLOR with
+ // a usage index of 0 to specify the diffuse color in the fixed function
+ // vertex shader and pixel shaders prior to ps_3_0. Use D3DDECLUSAGE_COLOR
+ // with a usage index of 1 to specify the specular color in the fixed function
+ // vertex shader and pixel shaders prior to ps_3_0.
+ //
+ // D3DDECLUSAGE_FOG
+ // Vertex data contains fog data. Use D3DDECLUSAGE_FOG with a usage index of 0
+ // to specify a fog blend value used after pixel shading finishes. This
+ // applies to pixel shaders prior to version ps_3_0.
+ //
+ // D3DDECLUSAGE_DEPTH
+ // Vertex data contains depth data.
+ //
+ // D3DDECLUSAGE_SAMPLE
+ // Vertex data contains sampler data. Use D3DDECLUSAGE_SAMPLE with a usage
+ // index of 0 to specify the displacement value to look up. It can be used
+ // only with D3DDECLUSAGE_LOOKUPPRESAMPLED or D3DDECLUSAGE_LOOKUP.
+
+ //note the form of the list terminator..
+
+ // #define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
+ // typedef struct _D3DVERTEXELEMENT9
+ // {
+ // WORD Stream; // Stream index
+ // WORD Offset; // Offset in the stream in bytes
+ // BYTE Type; // Data type
+ // BYTE Method; // Processing method
+ // BYTE Usage; // Semantics
+ // BYTE UsageIndex; // Semantic index
+ // } D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;
+
+#define MAX_D3DVERTEXELEMENTS 16
+
+struct TOGL_CLASS IDirect3DVertexDeclaration9 : public IUnknown
+{
+//public:
+ uint m_elemCount;
+ D3DVERTEXELEMENT9_GL m_elements[ MAX_D3DVERTEXELEMENTS ];
+
+ virtual ~IDirect3DVertexDeclaration9();
+};
+
+struct TOGL_CLASS IDirect3DQuery9 : public IDirect3DResource9 //was IUnknown
+{
+//public:
+ D3DQUERYTYPE m_type; // D3DQUERYTYPE_OCCLUSION or D3DQUERYTYPE_EVENT
+ GLMContext *m_ctx;
+ CGLMQuery *m_query;
+
+ virtual ~IDirect3DQuery9();
+
+ HRESULT Issue(DWORD dwIssueFlags);
+ HRESULT GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags);
+};
+
+struct TOGL_CLASS IDirect3DVertexBuffer9 : public IDirect3DResource9 //was IUnknown
+{
+//public:
+ GLMContext *m_ctx;
+ CGLMBuffer *m_vtxBuffer;
+ D3DVERTEXBUFFER_DESC m_vtxDesc; // to satisfy GetDesc
+
+ virtual ~IDirect3DVertexBuffer9();
+ HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
+ HRESULT Unlock();
+ HRESULT UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
+
+};
+
+struct TOGL_CLASS IDirect3DIndexBuffer9 : public IDirect3DResource9 //was IUnknown
+{
+//public:
+ GLMContext *m_ctx;
+ CGLMBuffer *m_idxBuffer;
+ D3DINDEXBUFFER_DESC m_idxDesc; // to satisfy GetDesc
+
+ virtual ~IDirect3DIndexBuffer9();
+
+ HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
+ HRESULT Unlock();
+ HRESULT UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
+ HRESULT GetDesc(D3DINDEXBUFFER_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DPixelShader9 : public IDirect3DResource9 //was IUnknown
+{
+//public:
+ CGLMProgram *m_pixProgram;
+ uint m_pixHighWater; // count of active constant slots referenced by shader.
+ uint m_pixSamplerMask; // (1<<n) mask of samplers referemnced by this pixel shader
+ // this can help FlushSamplers avoid SRGB flipping on textures not being referenced...
+
+ virtual ~IDirect3DPixelShader9();
+};
+
+struct TOGL_CLASS IDirect3DVertexShader9 : public IDirect3DResource9 //was IUnknown
+{
+//public:
+ CGLMProgram *m_vtxProgram;
+ uint m_vtxHighWater; // count of active constant slots referenced by shader.
+ unsigned char m_vtxAttribMap[16]; // high nibble is usage, low nibble is usageindex, array position is attrib number
+
+ virtual ~IDirect3DVertexShader9();
+
+};
+
+struct TOGL_CLASS ID3DXMatrixStack : public IUnknown
+{
+//public:
+ CUtlVector<D3DMATRIX> m_stack;
+ int m_stackTop; // top of stack is at the highest index, this is that index. push increases, pop decreases.
+
+ HRESULT Create( void );
+
+ D3DXMATRIX* GetTop();
+ void Push();
+ void Pop();
+ void LoadIdentity();
+ void LoadMatrix( const D3DXMATRIX *pMat );
+ void MultMatrix( const D3DXMATRIX *pMat );
+ void MultMatrixLocal( const D3DXMATRIX *pMat );
+ HRESULT ScaleLocal(FLOAT x, FLOAT y, FLOAT z);
+
+ // Left multiply the current matrix with the computed rotation
+ // matrix, counterclockwise about the given axis with the given angle.
+ // (rotation is about the local origin of the object)
+ HRESULT RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle);
+
+ // Left multiply the current matrix with the computed translation
+ // matrix. (transformation is about the local origin of the object)
+ HRESULT TranslateLocal(FLOAT x, FLOAT y, FLOAT z);
+};
+typedef ID3DXMatrixStack* LPD3DXMATRIXSTACK;
+
+struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
+{
+public:
+ // members
+
+ IDirect3DDevice9Params m_params; // mirror of the creation inputs
+
+ // D3D flavor stuff
+ IDirect3DSurface9 *m_rtSurfaces[16]; // current color RT surfaces. [0] is initially == m_defaultColorSurface
+ IDirect3DSurface9 *m_dsSurface; // current DS RT surface. can be changed!
+
+ IDirect3DSurface9 *m_defaultColorSurface; // default color surface.
+ IDirect3DSurface9 *m_defaultDepthStencilSurface; // queried by GetDepthStencilSurface.
+
+ IDirect3DVertexDeclaration9 *m_vertDecl; // Set by SetVertexDeclaration...
+ D3DStreamDesc m_streams[ D3D_MAX_STREAMS ]; // Set by SetStreamSource..
+ D3DIndexDesc m_indices; // Set by SetIndices..
+
+ IDirect3DVertexShader9 *m_vertexShader; // Set by SetVertexShader...
+ IDirect3DPixelShader9 *m_pixelShader; // Set by SetPixelShader...
+
+ IDirect3DBaseTexture9 *m_textures[16]; // set by SetTexture... NULL if stage inactive
+ D3DSamplerDesc m_samplers[16]; // set by SetSamplerState..
+ // GLM flavor stuff
+ GLMContext *m_ctx;
+ CGLMFBO *m_drawableFBO; // this FBO should have all the attachments set to match m_rtSurfaces and m_dsSurface.
+
+ // GL state
+ struct
+ {
+ // render state buckets
+ GLAlphaTestEnable_t m_AlphaTestEnable;
+ GLAlphaTestFunc_t m_AlphaTestFunc;
+
+ GLAlphaToCoverageEnable_t m_AlphaToCoverageEnable;
+
+ GLDepthTestEnable_t m_DepthTestEnable;
+ GLDepthMask_t m_DepthMask;
+ GLDepthFunc_t m_DepthFunc;
+
+ GLClipPlaneEnable_t m_ClipPlaneEnable[kGLMUserClipPlanes];
+ GLClipPlaneEquation_t m_ClipPlaneEquation[kGLMUserClipPlanes];
+
+ GLColorMaskSingle_t m_ColorMaskSingle;
+ GLColorMaskMultiple_t m_ColorMaskMultiple;
+
+ GLCullFaceEnable_t m_CullFaceEnable;
+ GLCullFrontFace_t m_CullFrontFace;
+ GLPolygonMode_t m_PolygonMode;
+ GLDepthBias_t m_DepthBias;
+ GLScissorEnable_t m_ScissorEnable;
+ GLScissorBox_t m_ScissorBox;
+ GLViewportBox_t m_ViewportBox;
+ GLViewportDepthRange_t m_ViewportDepthRange;
+
+ GLBlendEnable_t m_BlendEnable;
+ GLBlendFactor_t m_BlendFactor;
+ GLBlendEquation_t m_BlendEquation;
+ GLBlendColor_t m_BlendColor;
+ GLBlendEnableSRGB_t m_BlendEnableSRGB;
+
+ GLStencilTestEnable_t m_StencilTestEnable;
+ GLStencilFunc_t m_StencilFunc;
+ GLStencilOp_t m_StencilOp;
+ GLStencilWriteMask_t m_StencilWriteMask;
+
+ GLClearColor_t m_ClearColor;
+ GLClearDepth_t m_ClearDepth;
+ GLClearStencil_t m_ClearStencil;
+
+ bool m_FogEnable; // not really pushed to GL, just latched here
+
+ // samplers
+ GLMTexSamplingParams m_samplers[ 16 ];
+
+ // bindings...hmmm...
+
+ // dirty-bits
+ uint m_stateDirtyMask; // covers the state blocks, indexed by 1<<n, n = EGLMStateBlockType
+ uint m_samplerDirtyMask; // covers the samplers, indexed 1<<n, n = sampler index
+ } gl;
+
+ // methods
+
+public:
+ virtual ~IDirect3DDevice9();
+
+ // Create call invoked from IDirect3D9
+ HRESULT Create( IDirect3DDevice9Params *params );
+
+ //
+ // Basics
+ //
+ HRESULT Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
+ HRESULT SetViewport(CONST D3DVIEWPORT9* pViewport);
+ HRESULT GetViewport(D3DVIEWPORT9* pViewport);
+ HRESULT BeginScene();
+ HRESULT Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
+ HRESULT EndScene();
+ HRESULT Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,VD3DHWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
+
+ // textures
+ HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+ HRESULT CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+ HRESULT CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+
+ HRESULT SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture);
+ HRESULT GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture);
+
+ // render targets, color and depthstencil, surfaces, blit
+ HRESULT CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+ HRESULT SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget);
+ HRESULT GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget);
+
+ HRESULT CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
+
+ HRESULT CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
+ HRESULT SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);
+ HRESULT GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);
+
+ HRESULT GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface); // ? is anyone using this ?
+ HRESULT GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface);
+ HRESULT StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter);
+
+ // pixel shaders
+ HRESULT CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
+ HRESULT SetPixelShader(IDirect3DPixelShader9* pShader);
+ HRESULT SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+ HRESULT SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
+ HRESULT SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+
+ // vertex shaders
+ HRESULT CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
+ HRESULT SetVertexShader(IDirect3DVertexShader9* pShader);
+ HRESULT SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+ HRESULT SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
+ HRESULT SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+
+ // POSIX only - preheating for a specific vertex/pixel shader pair - trigger GLSL link inside GLM
+ HRESULT LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );
+ HRESULT QueryShaderPair( int index, GLMShaderPairInfo *infoOut );
+
+ // vertex buffers
+ HRESULT CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl);
+ HRESULT SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);
+
+ HRESULT SetFVF(DWORD FVF); // we might not be using these ?
+ HRESULT GetFVF(DWORD* pFVF);
+
+ HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,VD3DHANDLE* pSharedHandle);
+ HRESULT SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);
+
+ // index buffers
+ HRESULT CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,VD3DHANDLE* pSharedHandle);
+ HRESULT SetIndices(IDirect3DIndexBuffer9* pIndexData);
+
+ // response to retired objects (when refcount goes to zero and they self-delete..)
+ void ReleasedTexture ( IDirect3DBaseTexture9 *baseTex ); // called from texture destructor - need to scrub samplers
+ void ReleasedSurface ( IDirect3DSurface9 *surface ); // called from any surface destructor - need to scrub RT table if an RT
+ void ReleasedPixelShader ( IDirect3DPixelShader9 *pixelShader ); // called from IDirect3DPixelShader9 destructor
+ void ReleasedVertexShader ( IDirect3DVertexShader9 *vertexShader ); // called from IDirect3DVertexShader9 destructor
+ void ReleasedVertexBuffer ( IDirect3DVertexBuffer9 *vertexBuffer ); // called from IDirect3DVertexBuffer9 destructor
+ void ReleasedIndexBuffer ( IDirect3DIndexBuffer9 *indexBuffer ); // called from IDirect3DIndexBuffer9 destructor
+ void ReleasedQuery ( IDirect3DQuery9 *query ); // called from IDirect3DQuery9 destructor
+
+ // State management.
+ HRESULT SetRenderStateInline(D3DRENDERSTATETYPE State,DWORD Value);
+ HRESULT SetRenderStateConstInline(D3DRENDERSTATETYPE State,DWORD Value);
+ HRESULT SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);
+ HRESULT SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);
+
+
+ // Flushing changes to GL
+ HRESULT FlushStates( uint mask );
+ HRESULT FlushSamplers( uint mask ); // push SetRenderState and SetSamplerState changes
+ HRESULT FlushIndexBindings( void ); // push index buffer (set index ptr)
+ HRESULT FlushVertexBindings( uint baseVertexIndex ); // push vertex streams (set attrib ptrs)
+ HRESULT FlushGLM( void );
+
+ // Draw.
+ HRESULT DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
+ HRESULT DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);
+ HRESULT DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
+
+ // misc
+ BOOL ShowCursor(BOOL bShow);
+ HRESULT ValidateDevice(DWORD* pNumPasses);
+ HRESULT SetMaterial(CONST D3DMATERIAL9* pMaterial);
+ HRESULT LightEnable(DWORD Index,BOOL Enable);
+ HRESULT SetScissorRect(CONST RECT* pRect);
+ HRESULT CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery);
+ HRESULT GetDeviceCaps(D3DCAPS9* pCaps);
+ HRESULT TestCooperativeLevel();
+ HRESULT EvictManagedResources();
+ HRESULT SetLight(DWORD Index,CONST D3DLIGHT9*);
+ void SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);
+
+ void SaveGLState();
+ void RestoreGLState();
+
+ // Talk to JasonM about this one. It's tricky in GL.
+ HRESULT SetClipPlane(DWORD Index,CONST float* pPlane);
+
+ //
+ //
+ // **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+ //
+ //
+ HRESULT SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
+ HRESULT SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);
+
+ void AcquireThreadOwnership( );
+ void ReleaseThreadOwnership( );
+ inline DWORD GetCurrentOwnerThreadId() const { return m_ctx->m_nCurOwnerThreadId; }
+
+};
+
+struct ID3DXInclude
+{
+ virtual HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) = 0;
+ virtual HRESULT Close(LPCVOID pData) = 0;
+};
+typedef ID3DXInclude* LPD3DXINCLUDE;
+
+
+struct TOGL_CLASS ID3DXBuffer : public IUnknown
+{
+ void* GetBufferPointer();
+ DWORD GetBufferSize();
+};
+
+typedef ID3DXBuffer* LPD3DXBUFFER;
+
+class TOGL_CLASS ID3DXConstantTable : public IUnknown
+{
+};
+typedef ID3DXConstantTable* LPD3DXCONSTANTTABLE;
+
+
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// D3DX stuff.
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+TOGL_INTERFACE const char* D3DXGetPixelShaderProfile( IDirect3DDevice9 *pDevice );
+
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );
+TOGL_INTERFACE D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE HRESULT D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack);
+TOGL_INTERFACE void D3DXMatrixIdentity( D3DXMATRIX * );
+
+TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ pOut->x = pV1->x - pV2->x;
+ pOut->y = pV1->y - pV2->y;
+ pOut->z = pV1->z - pV2->z;
+ return pOut;
+}
+
+TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Cross( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ D3DXVECTOR3 v;
+
+ v.x = pV1->y * pV2->z - pV1->z * pV2->y;
+ v.y = pV1->z * pV2->x - pV1->x * pV2->z;
+ v.z = pV1->x * pV2->y - pV1->y * pV2->x;
+
+ *pOut = v;
+ return pOut;
+}
+
+TOGL_INTERFACE D3DXINLINE FLOAT D3DXVec3Dot( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
+}
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP);
+
+TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM );
+
+
+TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );
+
+// Build an ortho projection matrix. (right-handed)
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf );
+
+// Transform a plane by a matrix. The vector (a,b,c) must be normal.
+// M should be the inverse transpose of the transformation desired.
+TOGL_INTERFACE D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE IDirect3D9 *Direct3DCreate9(UINT SDKVersion);
+
+TOGL_INTERFACE void D3DPERF_SetOptions( DWORD dwOptions );
+
+TOGL_INTERFACE HRESULT D3DXCompileShader(
+ LPCSTR pSrcData,
+ UINT SrcDataLen,
+ CONST D3DXMACRO* pDefines,
+ LPD3DXINCLUDE pInclude,
+ LPCSTR pFunctionName,
+ LPCSTR pProfile,
+ DWORD Flags,
+ LPD3DXBUFFER* ppShader,
+ LPD3DXBUFFER* ppErrorMsgs,
+ LPD3DXCONSTANTTABLE* ppConstantTable);
+
+
+#endif // USE_ACTUAL_DX
+
+// fake D3D usage constant for SRGB tex creation
+#define D3DUSAGE_TEXTURE_SRGB (0x80000000L)
+
+#endif // DXABSTRACT_H
diff --git a/mp/src/public/togl/osx/dxabstract_types.h b/mp/src/public/togl/osx/dxabstract_types.h new file mode 100644 index 00000000..7df586cd --- /dev/null +++ b/mp/src/public/togl/osx/dxabstract_types.h @@ -0,0 +1,1710 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// dxabstract_types.h
+//
+//==================================================================================================
+#ifndef DXABSTRACT_TYPES_H
+#define DXABSTRACT_TYPES_H
+
+#pragma once
+
+#if GL_BATCH_PERF_ANALYSIS
+ class simple_bitmap;
+#endif
+
+struct IUnknown;
+struct IDirect3D9;
+struct IDirect3DDevice9;
+struct IDirect3DResource9;
+struct IDirect3DBaseTexture9;
+struct IDirect3DTexture9;
+struct IDirect3DCubeTexture9;
+struct IDirect3DVolumeTexture9;
+struct IDirect3DSurface9;
+struct IDirect3DVertexDeclaration9;
+struct IDirect3DQuery9;
+struct IDirect3DVertexBuffer9;
+struct IDirect3DIndexBuffer9;
+struct IDirect3DPixelShader9;
+struct IDirect3DVertexShader9;
+struct IDirect3DDevice9Params;
+
+class GLMContext;
+struct GLMRect;
+struct GLMShaderPairInfo;
+class CGLMBuffer;
+class CGLMQuery;
+class CGLMTex;
+class CGLMProgram;
+class CGLMFBO;
+
+#ifdef TOGL_DLL_EXPORT
+ #define TOGL_INTERFACE DLL_EXPORT
+ #define TOGL_OVERLOAD DLL_GLOBAL_EXPORT
+ #define TOGL_CLASS DLL_CLASS_EXPORT
+ #define TOGL_GLOBAL DLL_GLOBAL_EXPORT
+#else
+ #define TOGL_INTERFACE DLL_IMPORT
+ #define TOGL_OVERLOAD DLL_GLOBAL_IMPORT
+ #define TOGL_CLASS DLL_CLASS_IMPORT
+ #define TOGL_GLOBAL DLL_GLOBAL_IMPORT
+#endif
+
+#define TOGLMETHODCALLTYPE __stdcall
+//#define TOGLMETHODCALLTYPE
+
+#define DXABSTRACT_BREAK_ON_ERROR() DebuggerBreak()
+
+typedef void* VD3DHWND;
+typedef void* VD3DHANDLE;
+
+#define MAKEFOURCC(ch0, ch1, ch2, ch3) ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
+
+//
+//
+// Stuff that would be in windows.h
+//
+//
+#if !defined(_WINNT_)
+
+ typedef int INT;
+ typedef unsigned long ULONG;
+ typedef long LONG;
+ typedef float FLOAT;
+ typedef unsigned short WORD;
+ typedef long long LONGLONG;
+ typedef unsigned int UINT;
+ typedef long HRESULT;
+ typedef unsigned char BYTE;
+ #define CONST const
+
+ #if defined(POSIX)
+ typedef size_t ULONG_PTR;
+ #else
+ typedef unsigned long ULONG_PTR;
+ #endif
+
+ typedef ULONG_PTR SIZE_T;
+
+ typedef const char* LPCSTR;
+ typedef char* LPSTR;
+#ifndef OSX
+ typedef unsigned int DWORD;
+ typedef DWORD* LPDWORD;
+#endif
+
+
+ #define ZeroMemory RtlZeroMemory
+ #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
+
+ typedef union _LARGE_INTEGER
+ {
+ struct
+ {
+ DWORD LowPart;
+ LONG HighPart;
+ };
+ struct
+ {
+ DWORD LowPart;
+ LONG HighPart;
+ } u;
+ LONGLONG QuadPart;
+ } LARGE_INTEGER;
+
+ typedef struct _GUID
+ {
+ bool operator==( const struct _GUID &other ) const;
+
+ unsigned long Data1;
+ unsigned short Data2;
+ unsigned short Data3;
+ unsigned char Data4[ 8 ];
+ } GUID;
+
+ typedef struct _RECT
+ {
+ int left;
+ int top;
+ int right;
+ int bottom;
+ } RECT;
+
+ typedef struct tagPOINT
+ {
+ LONG x;
+ LONG y;
+ } POINT, *PPOINT, *LPPOINT;
+
+ typedef struct _MEMORYSTATUS
+ {
+ DWORD dwLength;
+ SIZE_T dwTotalPhys;
+ } MEMORYSTATUS, *LPMEMORYSTATUS;
+
+ typedef DWORD COLORREF;
+ #define RGB(r,g,b) ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)))
+
+ #define MAKE_HRESULT(sev,fac,code) ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
+
+
+// Mac header files like to define these
+#ifdef S_FALSE
+#undef S_FALSE
+#endif
+#ifdef S_OK
+#undef S_OK
+#endif
+#ifdef E_FAIL
+#undef E_FAIL
+#endif
+#ifdef E_OUTOFMEMORY
+#undef E_OUTOFMEMORY
+#endif
+#ifdef FAILED
+#undef FAILED
+#endif
+#ifdef SUCCEEDED
+#undef SUCCEEDED
+#endif
+
+ #define S_FALSE ((HRESULT)0x00000001L)
+ #define S_OK 0
+ #define E_FAIL ((HRESULT)0x80004005L)
+ #define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
+
+ #define FAILED(hr) ((HRESULT)(hr) < 0)
+ #define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
+
+ struct RGNDATA
+ {
+ };
+
+ typedef const void* LPCVOID;
+#endif
+
+//-----------------------------------------------------------------------------
+
+typedef enum _D3DFORMAT D3DFORMAT;
+
+#define D3DSI_OPCODE_MASK 0x0000FFFF
+#define D3DSP_TEXTURETYPE_MASK 0x78000000
+
+#define D3DUSAGE_AUTOGENMIPMAP 0x00000400L
+#define D3DSP_DCL_USAGE_MASK 0x0000000f
+
+#define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000
+#define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16
+
+
+/* Flags to construct D3DRS_COLORWRITEENABLE */
+#define D3DCOLORWRITEENABLE_RED (1L<<0)
+#define D3DCOLORWRITEENABLE_GREEN (1L<<1)
+#define D3DCOLORWRITEENABLE_BLUE (1L<<2)
+#define D3DCOLORWRITEENABLE_ALPHA (1L<<3)
+
+#define D3DSGR_NO_CALIBRATION 0x00000000L
+
+#define D3DXINLINE inline
+
+#define D3D_SDK_VERSION 32
+
+#define _FACD3D 0x876
+#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
+
+#define D3DERR_NOTFOUND MAKE_D3DHRESULT(2150)
+#define D3DERR_DEVICELOST MAKE_D3DHRESULT(2152)
+#define D3DERR_NOTAVAILABLE MAKE_D3DHRESULT(2154)
+#define D3DERR_DEVICENOTRESET MAKE_D3DHRESULT(2153)
+#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156)
+#define D3DERR_DRIVERINTERNALERROR MAKE_D3DHRESULT(2087)
+#define D3DERR_OUTOFVIDEOMEMORY MAKE_D3DHRESULT(380)
+#define D3D_OK S_OK
+
+#define D3DPRESENT_RATE_DEFAULT 0x00000000
+
+//
+// DevCaps
+//
+// we need to see who in Source land is interested in these values, as dxabstract is currently reporting zero for the whole Caps word
+#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010L /* Device can use execute buffers from system memory */
+#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */
+#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x00000080L /* Device can use TL buffers from video memory */
+#define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x00000100L /* Device can texture from system memory */
+#define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x00000200L /* Device can texture from device memory */
+#define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x00000400L /* Device can draw TLVERTEX primitives */
+#define D3DDEVCAPS_CANRENDERAFTERFLIP 0x00000800L /* Device can render without waiting for flip to complete */
+#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */
+#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000L /* Device is texturing from separate memory pools */
+#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
+#define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x00020000L /* Device supports a Tex Blt from system memory to non-local vidmem */
+#define D3DDEVCAPS_HWRASTERIZATION 0x00080000L /* Device has HW acceleration for rasterization */
+#define D3DDEVCAPS_PUREDEVICE 0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
+#define D3DDEVCAPS_QUINTICRTPATCHES 0x00200000L /* Device supports quintic Beziers and BSplines */
+#define D3DDEVCAPS_RTPATCHHANDLEZERO 0x00800000L /* Indicates that RT Patches may be drawn efficiently using handle 0 */
+#define D3DDEVCAPS_NPATCHES 0x01000000L /* Device supports N-Patches */
+
+//
+// PrimitiveMiscCaps
+//
+#define D3DPMISCCAPS_MASKZ 0x00000002L
+#define D3DPMISCCAPS_CULLNONE 0x00000010L
+#define D3DPMISCCAPS_CULLCW 0x00000020L
+#define D3DPMISCCAPS_CULLCCW 0x00000040L
+#define D3DPMISCCAPS_COLORWRITEENABLE 0x00000080L
+#define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS 0x00000100L /* Device correctly clips scaled points to clip planes */
+#define D3DPMISCCAPS_CLIPTLVERTS 0x00000200L /* device will clip post-transformed vertex primitives */
+#define D3DPMISCCAPS_TSSARGTEMP 0x00000400L /* device supports D3DTA_TEMP for temporary register */
+#define D3DPMISCCAPS_BLENDOP 0x00000800L /* device supports D3DRS_BLENDOP */
+#define D3DPMISCCAPS_NULLREFERENCE 0x00001000L /* Reference Device that doesnt render */
+#define D3DPMISCCAPS_PERSTAGECONSTANT 0x00008000L /* Device supports per-stage constants */
+#define D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS 0x00040000L /* Device supports different bit depths for MRT */
+#define D3DPMISCCAPS_FOGVERTEXCLAMPED 0x00100000L /* Device clamps fog blend factor per vertex */
+
+// Flags field for Issue
+#define D3DISSUE_END (1 << 0) // Tells the runtime to issue the end of a query, changing it's state to "non-signaled".
+#define D3DISSUE_BEGIN (1 << 1) // Tells the runtime to issue the beginng of a query.
+
+
+#define D3DPRESENT_INTERVAL_ONE 0x00000001L
+#define D3DPRESENT_INTERVAL_IMMEDIATE 0x80000000L
+
+/*
+ * Options for clearing
+ */
+#define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */
+#define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */
+#define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */
+
+
+#define D3DENUM_WHQL_LEVEL 0x00000002L
+
+
+
+
+#define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV 0x00200000L /* Device does not support projected bump env lookup operation
+ in programmable and fixed function pixel shaders */
+#define D3DDEVCAPS2_STREAMOFFSET 0x00000001L /* Device supports offsets in streams. Must be set by DX9 drivers */
+
+#define D3DDEVCAPS_PUREDEVICE 0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
+
+#define D3DCREATE_PUREDEVICE 0x00000010L
+#define D3DCREATE_SOFTWARE_VERTEXPROCESSING 0x00000020L
+#define D3DCREATE_HARDWARE_VERTEXPROCESSING 0x00000040L
+#define D3DCREATE_FPU_PRESERVE 0x00000002L
+#define D3DPRASTERCAPS_FOGRANGE 0x00010000L
+#define D3DPRASTERCAPS_FOGTABLE 0x00000100L
+#define D3DPRASTERCAPS_FOGVERTEX 0x00000080L
+#define D3DPRASTERCAPS_WFOG 0x00100000L
+#define D3DPRASTERCAPS_ZFOG 0x00200000L
+#define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000L
+#define D3DPRASTERCAPS_WBUFFER 0x00040000L
+#define D3DPRASTERCAPS_ZTEST 0x00000010L
+
+//
+// Caps2
+//
+#define D3DCAPS2_CANCALIBRATEGAMMA 0x00100000L
+#define D3DPRASTERCAPS_SCISSORTEST 0x01000000L
+#define D3DPTEXTURECAPS_MIPCUBEMAP 0x00010000L /* Device can do mipmapped cube maps */
+#define D3DPTEXTURECAPS_ALPHA 0x00000004L /* Alpha in texture pixels is supported */
+#define D3DPTEXTURECAPS_SQUAREONLY 0x00000020L /* Only square textures are supported */
+#define D3DCREATE_MULTITHREADED 0x00000004L
+#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
+#define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400L
+#define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000L
+#define D3DPTEXTURECAPS_CUBEMAP 0x00000800L /* Device can do cubemap textures */
+#define D3DPTEXTURECAPS_POW2 0x00000002L /* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. */
+#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL 0x00000100L
+#define D3DPTEXTURECAPS_PROJECTED 0x00000400L /* Device can do D3DTTFF_PROJECTED */
+#define D3DTEXOPCAPS_ADD 0x00000040L
+#define D3DTEXOPCAPS_MODULATE2X 0x00000010L
+#define D3DPRASTERCAPS_DEPTHBIAS 0x04000000L
+#define D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS 0x02000000L
+#define D3DVTXPCAPS_TEXGEN_SPHEREMAP 0x00000100L /* device supports D3DTSS_TCI_SPHEREMAP */
+#define D3DCAPS2_DYNAMICTEXTURES 0x20000000L
+
+// The following usages are valid only for querying CheckDeviceFormat
+#define D3DUSAGE_QUERY_SRGBREAD (0x00010000L)
+#define D3DUSAGE_QUERY_FILTER (0x00020000L)
+#define D3DUSAGE_QUERY_SRGBWRITE (0x00040000L)
+#define D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING (0x00080000L)
+#define D3DUSAGE_QUERY_VERTEXTEXTURE (0x00100000L)
+
+/* Usages for Vertex/Index buffers */
+#define D3DUSAGE_WRITEONLY (0x00000008L)
+#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L)
+#define D3DUSAGE_DONOTCLIP (0x00000020L)
+#define D3DUSAGE_POINTS (0x00000040L)
+#define D3DUSAGE_RTPATCHES (0x00000080L)
+#define D3DUSAGE_NPATCHES (0x00000100L)
+
+
+// Flags field for GetData
+#define D3DGETDATA_FLUSH (1 << 0) // Tells the runtime to flush if the query is outstanding.
+
+#define D3DFVF_XYZ 0x002
+
+
+#define D3DTA_SELECTMASK 0x0000000f // mask for arg selector
+#define D3DTA_DIFFUSE 0x00000000 // select diffuse color (read only)
+#define D3DTA_CURRENT 0x00000001 // select stage destination register (read/write)
+#define D3DTA_TEXTURE 0x00000002 // select texture color (read only)
+#define D3DTA_TFACTOR 0x00000003 // select D3DRS_TEXTUREFACTOR (read only)
+#define D3DTA_SPECULAR 0x00000004 // select specular color (read only)
+#define D3DTA_TEMP 0x00000005 // select temporary register color (read/write)
+#define D3DTA_CONSTANT 0x00000006 // select texture stage constant
+#define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x (read modifier)
+#define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components (read modifier)
+
+
+#define D3DUSAGE_RENDERTARGET (0x00000001L)
+#define D3DUSAGE_QUERY_VERTEXTEXTURE (0x00100000L)
+#define D3DUSAGE_QUERY_FILTER (0x00020000L)
+#define D3DUSAGE_DEPTHSTENCIL (0x00000002L)
+#define D3DUSAGE_WRITEONLY (0x00000008L)
+#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L)
+#define D3DUSAGE_DYNAMIC (0x00000200L)
+
+#define D3DSI_INSTLENGTH_MASK 0x0F000000
+#define D3DSI_INSTLENGTH_SHIFT 24
+#define D3DSP_TEXTURETYPE_SHIFT 27
+#define D3DSP_REGTYPE_SHIFT 28
+#define D3DSP_REGTYPE_SHIFT2 8
+#define D3DSP_REGTYPE_MASK 0x70000000
+#define D3DSP_REGTYPE_MASK2 0x00001800
+
+#define D3DSP_REGNUM_MASK 0x000007FF
+
+#define D3DSP_DSTMOD_SHIFT 20
+#define D3DSP_DSTMOD_MASK 0x00F00000
+#define D3DSPDM_MSAMPCENTROID (4<<D3DSP_DSTMOD_SHIFT) // Relevant to multisampling only:
+ // When the pixel center is not covered, sample
+ // attribute or compute gradients/LOD
+ // using multisample "centroid" location.
+ // "Centroid" is some location within the covered
+ // region of the pixel.
+
+#define D3DXSHADER_DEBUG (1 << 0)
+#define D3DXSHADER_AVOID_FLOW_CONTROL (1 << 9)
+
+
+#define D3DLOCK_READONLY 0x00000010L
+#define D3DLOCK_DISCARD 0x00002000L
+#define D3DLOCK_NOOVERWRITE 0x00001000L
+#define D3DLOCK_NOSYSLOCK 0x00000800L
+
+#define D3DLOCK_NO_DIRTY_UPDATE 0x00008000L
+
+
+#define D3DDMAPSAMPLER 256
+#define D3DVERTEXTEXTURESAMPLER0 (D3DDMAPSAMPLER+1)
+#define D3DSP_SRCMOD_SHIFT 24
+
+
+#define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
+#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
+#define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b)
+
+// maps floating point channels (0.f to 1.f range) to D3DCOLOR
+#define D3DCOLOR_COLORVALUE(r,g,b,a) \
+ D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f))
+
+#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
+
+#define D3DSP_DCL_USAGEINDEX_SHIFT 16
+#define D3DSP_DCL_USAGEINDEX_MASK 0x000f0000
+
+// Bit masks for destination parameter modifiers
+#define D3DSPDM_NONE (0<<D3DSP_DSTMOD_SHIFT) // nop
+#define D3DSPDM_SATURATE (1<<D3DSP_DSTMOD_SHIFT) // clamp to 0. to 1. range
+#define D3DSPDM_PARTIALPRECISION (2<<D3DSP_DSTMOD_SHIFT) // Partial precision hint
+#define D3DSPDM_MSAMPCENTROID (4<<D3DSP_DSTMOD_SHIFT) // Relevant to multisampling only:
+ // When the pixel center is not covered, sample
+ // attribute or compute gradients/LOD
+ // using multisample "centroid" location.
+ // "Centroid" is some location within the covered
+ // region of the pixel.
+
+// Value when there is no swizzle (X is taken from X, Y is taken from Y,
+// Z is taken from Z, W is taken from W
+//
+#define D3DVS_NOSWIZZLE (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z | D3DVS_W_W)
+
+// extract major/minor from version cap
+#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
+#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
+
+#define D3DSHADER_ADDRESSMODE_SHIFT 13
+#define D3DSHADER_ADDRESSMODE_MASK (1 << D3DSHADER_ADDRESSMODE_SHIFT)
+
+#define D3DPS_END() 0x0000FFFF
+
+// ps_2_0 texld controls
+#define D3DSI_TEXLD_PROJECT (0x01 << D3DSP_OPCODESPECIFICCONTROL_SHIFT)
+#define D3DSI_TEXLD_BIAS (0x02 << D3DSP_OPCODESPECIFICCONTROL_SHIFT)
+
+
+// destination parameter write mask
+#define D3DSP_WRITEMASK_0 0x00010000 // Component 0 (X;Red)
+#define D3DSP_WRITEMASK_1 0x00020000 // Component 1 (Y;Green)
+#define D3DSP_WRITEMASK_2 0x00040000 // Component 2 (Z;Blue)
+#define D3DSP_WRITEMASK_3 0x00080000 // Component 3 (W;Alpha)
+#define D3DSP_WRITEMASK_ALL 0x000F0000 // All Components
+
+#define D3DVS_SWIZZLE_SHIFT 16
+#define D3DVS_SWIZZLE_MASK 0x00FF0000
+
+// The following bits define where to take component X from:
+
+#define D3DVS_X_X (0 << D3DVS_SWIZZLE_SHIFT)
+#define D3DVS_X_Y (1 << D3DVS_SWIZZLE_SHIFT)
+#define D3DVS_X_Z (2 << D3DVS_SWIZZLE_SHIFT)
+#define D3DVS_X_W (3 << D3DVS_SWIZZLE_SHIFT)
+
+// The following bits define where to take component Y from:
+
+#define D3DVS_Y_X (0 << (D3DVS_SWIZZLE_SHIFT + 2))
+#define D3DVS_Y_Y (1 << (D3DVS_SWIZZLE_SHIFT + 2))
+#define D3DVS_Y_Z (2 << (D3DVS_SWIZZLE_SHIFT + 2))
+#define D3DVS_Y_W (3 << (D3DVS_SWIZZLE_SHIFT + 2))
+
+// The following bits define where to take component Z from:
+
+#define D3DVS_Z_X (0 << (D3DVS_SWIZZLE_SHIFT + 4))
+#define D3DVS_Z_Y (1 << (D3DVS_SWIZZLE_SHIFT + 4))
+#define D3DVS_Z_Z (2 << (D3DVS_SWIZZLE_SHIFT + 4))
+#define D3DVS_Z_W (3 << (D3DVS_SWIZZLE_SHIFT + 4))
+
+// The following bits define where to take component W from:
+
+#define D3DVS_W_X (0 << (D3DVS_SWIZZLE_SHIFT + 6))
+#define D3DVS_W_Y (1 << (D3DVS_SWIZZLE_SHIFT + 6))
+#define D3DVS_W_Z (2 << (D3DVS_SWIZZLE_SHIFT + 6))
+#define D3DVS_W_W (3 << (D3DVS_SWIZZLE_SHIFT + 6))
+
+// source parameter modifiers
+#define D3DSP_SRCMOD_SHIFT 24
+#define D3DSP_SRCMOD_MASK 0x0F000000
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// ENUMS
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE
+{
+ D3DSPSM_NONE = 0<<D3DSP_SRCMOD_SHIFT, // nop
+ D3DSPSM_NEG = 1<<D3DSP_SRCMOD_SHIFT, // negate
+ D3DSPSM_BIAS = 2<<D3DSP_SRCMOD_SHIFT, // bias
+ D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate
+ D3DSPSM_SIGN = 4<<D3DSP_SRCMOD_SHIFT, // sign
+ D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate
+ D3DSPSM_COMP = 6<<D3DSP_SRCMOD_SHIFT, // complement
+ D3DSPSM_X2 = 7<<D3DSP_SRCMOD_SHIFT, // *2
+ D3DSPSM_X2NEG = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate
+ D3DSPSM_DZ = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z component
+ D3DSPSM_DW = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w component
+ D3DSPSM_ABS = 11<<D3DSP_SRCMOD_SHIFT, // abs()
+ D3DSPSM_ABSNEG = 12<<D3DSP_SRCMOD_SHIFT, // -abs()
+ D3DSPSM_NOT = 13<<D3DSP_SRCMOD_SHIFT, // for predicate register: "!p0"
+ D3DSPSM_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSHADER_PARAM_SRCMOD_TYPE;
+
+
+typedef enum _D3DSAMPLER_TEXTURE_TYPE
+{
+ D3DSTT_UNKNOWN = 0<<D3DSP_TEXTURETYPE_SHIFT, // uninitialized value
+ D3DSTT_2D = 2<<D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for declaring a 2-D texture)
+ D3DSTT_CUBE = 3<<D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for declaring a cube texture)
+ D3DSTT_VOLUME = 4<<D3DSP_TEXTURETYPE_SHIFT, // dcl_volume s# (for declaring a volume texture)
+ D3DSTT_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSAMPLER_TEXTURE_TYPE;
+
+typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE
+{
+ D3DSIO_NOP = 0,
+ D3DSIO_MOV ,
+ D3DSIO_ADD ,
+ D3DSIO_SUB ,
+ D3DSIO_MAD ,
+ D3DSIO_MUL ,
+ D3DSIO_RCP ,
+ D3DSIO_RSQ ,
+ D3DSIO_DP3 ,
+ D3DSIO_DP4 ,
+ D3DSIO_MIN , //10
+ D3DSIO_MAX ,
+ D3DSIO_SLT ,
+ D3DSIO_SGE ,
+ D3DSIO_EXP ,
+ D3DSIO_LOG ,
+ D3DSIO_LIT ,
+ D3DSIO_DST ,
+ D3DSIO_LRP ,
+ D3DSIO_FRC ,
+ D3DSIO_M4x4 , //20
+ D3DSIO_M4x3 ,
+ D3DSIO_M3x4 ,
+ D3DSIO_M3x3 ,
+ D3DSIO_M3x2 ,
+ D3DSIO_CALL ,
+ D3DSIO_CALLNZ ,
+ D3DSIO_LOOP ,
+ D3DSIO_RET ,
+ D3DSIO_ENDLOOP ,
+ D3DSIO_LABEL , //30
+ D3DSIO_DCL ,
+ D3DSIO_POW ,
+ D3DSIO_CRS ,
+ D3DSIO_SGN ,
+ D3DSIO_ABS ,
+ D3DSIO_NRM ,
+ D3DSIO_SINCOS ,
+ D3DSIO_REP ,
+ D3DSIO_ENDREP ,
+ D3DSIO_IF , //40
+ D3DSIO_IFC ,
+ D3DSIO_ELSE ,
+ D3DSIO_ENDIF ,
+ D3DSIO_BREAK ,
+ D3DSIO_BREAKC ,
+ D3DSIO_MOVA ,
+ D3DSIO_DEFB ,
+ D3DSIO_DEFI ,
+
+ D3DSIO_TEXCOORD = 64,
+ D3DSIO_TEXKILL ,
+ D3DSIO_TEX ,
+ D3DSIO_TEXBEM ,
+ D3DSIO_TEXBEML ,
+ D3DSIO_TEXREG2AR ,
+ D3DSIO_TEXREG2GB ,
+ D3DSIO_TEXM3x2PAD ,
+ D3DSIO_TEXM3x2TEX ,
+ D3DSIO_TEXM3x3PAD ,
+ D3DSIO_TEXM3x3TEX ,
+ D3DSIO_RESERVED0 ,
+ D3DSIO_TEXM3x3SPEC ,
+ D3DSIO_TEXM3x3VSPEC ,
+ D3DSIO_EXPP ,
+ D3DSIO_LOGP ,
+ D3DSIO_CND ,
+ D3DSIO_DEF ,
+ D3DSIO_TEXREG2RGB ,
+ D3DSIO_TEXDP3TEX ,
+ D3DSIO_TEXM3x2DEPTH ,
+ D3DSIO_TEXDP3 ,
+ D3DSIO_TEXM3x3 ,
+ D3DSIO_TEXDEPTH ,
+ D3DSIO_CMP ,
+ D3DSIO_BEM ,
+ D3DSIO_DP2ADD ,
+ D3DSIO_DSX ,
+ D3DSIO_DSY ,
+ D3DSIO_TEXLDD ,
+ D3DSIO_SETP ,
+ D3DSIO_TEXLDL ,
+ D3DSIO_BREAKP ,
+
+ D3DSIO_PHASE = 0xFFFD,
+ D3DSIO_COMMENT = 0xFFFE,
+ D3DSIO_END = 0xFFFF,
+
+ D3DSIO_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSHADER_INSTRUCTION_OPCODE_TYPE;
+
+typedef enum _D3DVS_RASTOUT_OFFSETS
+{
+ D3DSRO_POSITION = 0,
+ D3DSRO_FOG,
+ D3DSRO_POINT_SIZE,
+ D3DSRO_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DVS_RASTOUT_OFFSETS;
+
+/* SwapEffects */
+typedef enum _D3DSWAPEFFECT
+{
+ D3DSWAPEFFECT_DISCARD = 1,
+ D3DSWAPEFFECT_COPY = 3,
+
+ D3DSWAPEFFECT_FORCE_DWORD = 0x7fffffff
+} D3DSWAPEFFECT;
+
+typedef enum _D3DRESOURCETYPE
+{
+ D3DRTYPE_SURFACE = 1,
+ D3DRTYPE_TEXTURE = 3,
+ D3DRTYPE_VOLUMETEXTURE = 4,
+ D3DRTYPE_CUBETEXTURE = 5,
+ D3DRTYPE_VERTEXBUFFER = 6,
+ D3DRTYPE_INDEXBUFFER = 7,
+
+ D3DRTYPE_FORCE_DWORD = 0x7fffffff
+} D3DRESOURCETYPE;
+
+typedef enum _D3DDEVTYPE
+{
+ D3DDEVTYPE_HAL = 1,
+ D3DDEVTYPE_REF = 2,
+
+ D3DDEVTYPE_NULLREF = 4,
+
+ D3DDEVTYPE_FORCE_DWORD = 0x7fffffff
+} D3DDEVTYPE;
+
+typedef enum _D3DSTENCILOP
+{
+ D3DSTENCILOP_KEEP = 1,
+ D3DSTENCILOP_ZERO = 2,
+ D3DSTENCILOP_REPLACE = 3,
+ D3DSTENCILOP_INCRSAT = 4,
+ D3DSTENCILOP_DECRSAT = 5,
+ D3DSTENCILOP_INVERT = 6,
+ D3DSTENCILOP_INCR = 7,
+ D3DSTENCILOP_DECR = 8,
+ D3DSTENCILOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DSTENCILOP;
+
+typedef enum _D3DPATCHEDGESTYLE
+{
+ D3DPATCHEDGE_DISCRETE = 0,
+ D3DPATCHEDGE_CONTINUOUS = 1,
+ D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff,
+} D3DPATCHEDGESTYLE;
+
+
+/* Debug monitor tokens (DEBUG only)
+
+ Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as
+ passing a token to the debug monitor. For example, if, after passing
+ D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
+ are passed in, the enabled/disabled state of the debug
+ monitor will still persist.
+
+ The debug monitor defaults to enabled.
+
+ Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
+*/
+typedef enum _D3DDEBUGMONITORTOKENS
+{
+ D3DDMT_ENABLE = 0, // enable debug monitor
+} D3DDEBUGMONITORTOKENS;
+
+typedef enum _D3DDEGREETYPE
+{
+ D3DDEGREE_LINEAR = 1,
+ D3DDEGREE_QUADRATIC = 2,
+ D3DDEGREE_CUBIC = 3,
+ D3DDEGREE_FORCE_DWORD = 0x7fffffff,
+} D3DDEGREETYPE;
+
+typedef enum _D3DBLENDOP
+{
+ D3DBLENDOP_ADD = 1,
+ D3DBLENDOP_SUBTRACT = 2,
+ D3DBLENDOP_REVSUBTRACT = 3,
+ D3DBLENDOP_MIN = 4,
+ D3DBLENDOP_MAX = 5,
+ D3DBLENDOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DBLENDOP;
+
+typedef enum _D3DMULTISAMPLE_TYPE
+{
+ D3DMULTISAMPLE_NONE = 0,
+ D3DMULTISAMPLE_NONMASKABLE = 1,
+ D3DMULTISAMPLE_2_SAMPLES = 2,
+ D3DMULTISAMPLE_3_SAMPLES = 3,
+ D3DMULTISAMPLE_4_SAMPLES = 4,
+ D3DMULTISAMPLE_5_SAMPLES = 5,
+ D3DMULTISAMPLE_6_SAMPLES = 6,
+ D3DMULTISAMPLE_7_SAMPLES = 7,
+ D3DMULTISAMPLE_8_SAMPLES = 8,
+ D3DMULTISAMPLE_9_SAMPLES = 9,
+ D3DMULTISAMPLE_10_SAMPLES = 10,
+ D3DMULTISAMPLE_11_SAMPLES = 11,
+ D3DMULTISAMPLE_12_SAMPLES = 12,
+ D3DMULTISAMPLE_13_SAMPLES = 13,
+ D3DMULTISAMPLE_14_SAMPLES = 14,
+ D3DMULTISAMPLE_15_SAMPLES = 15,
+ D3DMULTISAMPLE_16_SAMPLES = 16,
+
+ D3DMULTISAMPLE_FORCE_DWORD = 0x7fffffff
+} D3DMULTISAMPLE_TYPE;
+
+/* Pool types */
+typedef enum _D3DPOOL
+{
+ D3DPOOL_DEFAULT = 0,
+ D3DPOOL_MANAGED = 1,
+ D3DPOOL_SYSTEMMEM = 2,
+ D3DPOOL_SCRATCH = 3,
+
+ D3DPOOL_FORCE_DWORD = 0x7fffffff
+} D3DPOOL;
+
+typedef enum _D3DQUERYTYPE
+{
+ D3DQUERYTYPE_RESOURCEMANAGER = 5, /* D3DISSUE_END */
+ D3DQUERYTYPE_EVENT = 8, /* D3DISSUE_END */
+ D3DQUERYTYPE_OCCLUSION = 9, /* D3DISSUE_BEGIN, D3DISSUE_END */
+ D3DQUERYTYPE_TIMESTAMP = 10, /* D3DISSUE_END */
+ D3DQUERYTYPE_TIMESTAMPFREQ = 12, /* D3DISSUE_END */
+ D3DQUERYTYPE_INTERFACETIMINGS = 14, /* D3DISSUE_BEGIN, D3DISSUE_END */
+ D3DQUERYTYPE_PIXELTIMINGS = 16, /* D3DISSUE_BEGIN, D3DISSUE_END */
+ D3DQUERYTYPE_CACHEUTILIZATION = 18, /* D3DISSUE_BEGIN, D3DISSUE_END */
+} D3DQUERYTYPE;
+
+typedef enum _D3DRENDERSTATETYPE
+{
+ D3DRS_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */
+ D3DRS_FILLMODE = 8, /* D3DFILLMODE */
+ D3DRS_SHADEMODE = 9, /* D3DSHADEMODE */
+ D3DRS_ZWRITEENABLE = 14, /* TRUE to enable z writes */
+ D3DRS_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */
+ D3DRS_LASTPIXEL = 16, /* TRUE for last-pixel on lines */
+ D3DRS_SRCBLEND = 19, /* D3DBLEND */
+ D3DRS_DESTBLEND = 20, /* D3DBLEND */
+ D3DRS_CULLMODE = 22, /* D3DCULL */
+ D3DRS_ZFUNC = 23, /* D3DCMPFUNC */
+ D3DRS_ALPHAREF = 24, /* D3DFIXED */
+ D3DRS_ALPHAFUNC = 25, /* D3DCMPFUNC */
+ D3DRS_DITHERENABLE = 26, /* TRUE to enable dithering */
+ D3DRS_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */
+ D3DRS_FOGENABLE = 28, /* TRUE to enable fog blending */
+ D3DRS_SPECULARENABLE = 29, /* TRUE to enable specular */
+ D3DRS_FOGCOLOR = 34, /* D3DCOLOR */
+ D3DRS_FOGTABLEMODE = 35, /* D3DFOGMODE */
+ D3DRS_FOGSTART = 36, /* Fog start (for both vertex and pixel fog) */
+ D3DRS_FOGEND = 37, /* Fog end */
+ D3DRS_FOGDENSITY = 38, /* Fog density */
+ D3DRS_RANGEFOGENABLE = 48, /* Enables range-based fog */
+ D3DRS_STENCILENABLE = 52, /* BOOL enable/disable stenciling */
+ D3DRS_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil test fails */
+ D3DRS_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil test passes and Z test fails */
+ D3DRS_STENCILPASS = 55, /* D3DSTENCILOP to do if both stencil and Z tests pass */
+ D3DRS_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
+ D3DRS_STENCILREF = 57, /* Reference value used in stencil test */
+ D3DRS_STENCILMASK = 58, /* Mask value used in stencil test */
+ D3DRS_STENCILWRITEMASK = 59, /* Write mask applied to values written to stencil buffer */
+ D3DRS_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture blend */
+ D3DRS_WRAP0 = 128, /* wrap for 1st texture coord. set */
+ D3DRS_WRAP1 = 129, /* wrap for 2nd texture coord. set */
+ D3DRS_WRAP2 = 130, /* wrap for 3rd texture coord. set */
+ D3DRS_WRAP3 = 131, /* wrap for 4th texture coord. set */
+ D3DRS_WRAP4 = 132, /* wrap for 5th texture coord. set */
+ D3DRS_WRAP5 = 133, /* wrap for 6th texture coord. set */
+ D3DRS_WRAP6 = 134, /* wrap for 7th texture coord. set */
+ D3DRS_WRAP7 = 135, /* wrap for 8th texture coord. set */
+ D3DRS_CLIPPING = 136,
+ D3DRS_LIGHTING = 137,
+ D3DRS_AMBIENT = 139,
+ D3DRS_FOGVERTEXMODE = 140,
+ D3DRS_COLORVERTEX = 141,
+ D3DRS_LOCALVIEWER = 142,
+ D3DRS_NORMALIZENORMALS = 143,
+ D3DRS_DIFFUSEMATERIALSOURCE = 145,
+ D3DRS_SPECULARMATERIALSOURCE = 146,
+ D3DRS_AMBIENTMATERIALSOURCE = 147,
+ D3DRS_EMISSIVEMATERIALSOURCE = 148,
+ D3DRS_VERTEXBLEND = 151,
+ D3DRS_CLIPPLANEENABLE = 152,
+ D3DRS_POINTSIZE = 154, /* float point size */
+ D3DRS_POINTSIZE_MIN = 155, /* float point size min threshold */
+ D3DRS_POINTSPRITEENABLE = 156, /* BOOL point texture coord control */
+ D3DRS_POINTSCALEENABLE = 157, /* BOOL point size scale enable */
+ D3DRS_POINTSCALE_A = 158, /* float point attenuation A value */
+ D3DRS_POINTSCALE_B = 159, /* float point attenuation B value */
+ D3DRS_POINTSCALE_C = 160, /* float point attenuation C value */
+ D3DRS_MULTISAMPLEANTIALIAS = 161, // BOOL - set to do FSAA with multisample buffer
+ D3DRS_MULTISAMPLEMASK = 162, // DWORD - per-sample enable/disable
+ D3DRS_PATCHEDGESTYLE = 163, // Sets whether patch edges will use float style tessellation
+ D3DRS_DEBUGMONITORTOKEN = 165, // DEBUG ONLY - token to debug monitor
+ D3DRS_POINTSIZE_MAX = 166, /* float point size max threshold */
+ D3DRS_INDEXEDVERTEXBLENDENABLE = 167,
+ D3DRS_COLORWRITEENABLE = 168, // per-channel write enable
+ D3DRS_TWEENFACTOR = 170, // float tween factor
+ D3DRS_BLENDOP = 171, // D3DBLENDOP setting
+ D3DRS_POSITIONDEGREE = 172, // NPatch position interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
+ D3DRS_NORMALDEGREE = 173, // NPatch normal interpolation degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
+ D3DRS_SCISSORTESTENABLE = 174,
+ D3DRS_SLOPESCALEDEPTHBIAS = 175,
+ D3DRS_ANTIALIASEDLINEENABLE = 176,
+ D3DRS_MINTESSELLATIONLEVEL = 178,
+ D3DRS_MAXTESSELLATIONLEVEL = 179,
+ D3DRS_ADAPTIVETESS_X = 180,
+ D3DRS_ADAPTIVETESS_Y = 181,
+ D3DRS_ADAPTIVETESS_Z = 182,
+ D3DRS_ADAPTIVETESS_W = 183,
+ D3DRS_ENABLEADAPTIVETESSELLATION = 184,
+ D3DRS_TWOSIDEDSTENCILMODE = 185, /* BOOL enable/disable 2 sided stenciling */
+ D3DRS_CCW_STENCILFAIL = 186, /* D3DSTENCILOP to do if ccw stencil test fails */
+ D3DRS_CCW_STENCILZFAIL = 187, /* D3DSTENCILOP to do if ccw stencil test passes and Z test fails */
+ D3DRS_CCW_STENCILPASS = 188, /* D3DSTENCILOP to do if both ccw stencil and Z tests pass */
+ D3DRS_CCW_STENCILFUNC = 189, /* D3DCMPFUNC fn. ccw Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
+ D3DRS_COLORWRITEENABLE1 = 190, /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
+ D3DRS_COLORWRITEENABLE2 = 191, /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
+ D3DRS_COLORWRITEENABLE3 = 192, /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
+ D3DRS_BLENDFACTOR = 193, /* D3DCOLOR used for a constant blend factor during alpha blending for devices that support D3DPBLENDCAPS_BLENDFACTOR */
+ D3DRS_SRGBWRITEENABLE = 194, /* Enable rendertarget writes to be DE-linearized to SRGB (for formats that expose D3DUSAGE_QUERY_SRGBWRITE) */
+ D3DRS_DEPTHBIAS = 195,
+ D3DRS_WRAP8 = 198, /* Additional wrap states for vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD */
+ D3DRS_WRAP9 = 199,
+ D3DRS_WRAP10 = 200,
+ D3DRS_WRAP11 = 201,
+ D3DRS_WRAP12 = 202,
+ D3DRS_WRAP13 = 203,
+ D3DRS_WRAP14 = 204,
+ D3DRS_WRAP15 = 205,
+ D3DRS_SEPARATEALPHABLENDENABLE = 206, /* TRUE to enable a separate blending function for the alpha channel */
+ D3DRS_SRCBLENDALPHA = 207, /* SRC blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
+ D3DRS_DESTBLENDALPHA = 208, /* DST blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
+ D3DRS_BLENDOPALPHA = 209, /* Blending operation for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
+
+
+ D3DRS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DRENDERSTATETYPE;
+
+typedef enum _D3DCULL
+{
+ D3DCULL_NONE = 1,
+ D3DCULL_CW = 2,
+ D3DCULL_CCW = 3,
+ D3DCULL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DCULL;
+
+typedef enum _D3DTEXTUREFILTERTYPE
+{
+ D3DTEXF_NONE = 0, // filtering disabled (valid for mip filter only)
+ D3DTEXF_POINT = 1, // nearest
+ D3DTEXF_LINEAR = 2, // linear interpolation
+ D3DTEXF_ANISOTROPIC = 3, // anisotropic
+ D3DTEXF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DTEXTUREFILTERTYPE;
+
+typedef enum _D3DBACKBUFFER_TYPE
+{
+ D3DBACKBUFFER_TYPE_MONO = 0,
+
+ D3DBACKBUFFER_TYPE_FORCE_DWORD = 0x7fffffff
+} D3DBACKBUFFER_TYPE;
+
+#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
+#define D3DTS_WORLD D3DTS_WORLDMATRIX(0)
+#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
+#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
+#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)
+
+typedef enum _D3DCMPFUNC
+{
+ D3DCMP_NEVER = 1,
+ D3DCMP_LESS = 2,
+ D3DCMP_EQUAL = 3,
+ D3DCMP_LESSEQUAL = 4,
+ D3DCMP_GREATER = 5,
+ D3DCMP_NOTEQUAL = 6,
+ D3DCMP_GREATEREQUAL = 7,
+ D3DCMP_ALWAYS = 8,
+ D3DCMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DCMPFUNC;
+
+typedef enum _D3DZBUFFERTYPE
+{
+ D3DZB_FALSE = 0,
+ D3DZB_TRUE = 1, // Z buffering
+ D3DZB_USEW = 2, // W buffering
+ D3DZB_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DZBUFFERTYPE;
+
+typedef enum _D3DFILLMODE
+{
+ D3DFILL_POINT = 1,
+ D3DFILL_WIREFRAME = 2,
+ D3DFILL_SOLID = 3,
+ D3DFILL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DFILLMODE;
+
+typedef enum _D3DBLEND
+{
+ D3DBLEND_ZERO = 1,
+ D3DBLEND_ONE = 2,
+ D3DBLEND_SRCCOLOR = 3,
+ D3DBLEND_INVSRCCOLOR = 4,
+ D3DBLEND_SRCALPHA = 5,
+ D3DBLEND_INVSRCALPHA = 6,
+ D3DBLEND_DESTALPHA = 7,
+ D3DBLEND_INVDESTALPHA = 8,
+ D3DBLEND_DESTCOLOR = 9,
+ D3DBLEND_INVDESTCOLOR = 10,
+ D3DBLEND_SRCALPHASAT = 11,
+ D3DBLEND_BOTHSRCALPHA = 12,
+ D3DBLEND_BOTHINVSRCALPHA = 13,
+ D3DBLEND_BLENDFACTOR = 14, /* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on */
+ D3DBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DBLEND;
+
+// Values for material source
+typedef enum _D3DMATERIALCOLORSOURCE
+{
+ D3DMCS_MATERIAL = 0, // Color from material is used
+ D3DMCS_COLOR1 = 1, // Diffuse vertex color is used
+ D3DMCS_COLOR2 = 2, // Specular vertex color is used
+ D3DMCS_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DMATERIALCOLORSOURCE;
+
+typedef enum _D3DCUBEMAP_FACES
+{
+ D3DCUBEMAP_FACE_POSITIVE_Z = 4,
+
+ D3DCUBEMAP_FACE_FORCE_DWORD = 0x7fffffff
+} D3DCUBEMAP_FACES;
+
+typedef enum _D3DTEXTURETRANSFORMFLAGS
+{
+ D3DTTFF_DISABLE = 0, // texture coordinates are passed directly
+ D3DTTFF_COUNT3 = 3, // rasterizer should expect 3-D texture coords
+ D3DTTFF_PROJECTED = 256, // texcoords to be divided by COUNTth element
+ D3DTTFF_FORCE_DWORD = 0x7fffffff,
+} D3DTEXTURETRANSFORMFLAGS;
+
+// Note: the Linux/win TOGL reorders these. For the Mac we use the same enums as Windows itself.
+
+typedef enum _D3DTEXTUREADDRESS {
+ D3DTADDRESS_WRAP = 1,
+ D3DTADDRESS_CLAMP = 3,
+ D3DTADDRESS_BORDER = 4,
+ D3DTADDRESS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTUREADDRESS;
+
+typedef enum _D3DSHADEMODE
+{
+ D3DSHADE_FLAT = 1,
+ D3DSHADE_GOURAUD = 2,
+ D3DSHADE_PHONG = 3,
+ D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DSHADEMODE;
+
+typedef enum _D3DFOGMODE
+{
+ D3DFOG_NONE = 0,
+ D3DFOG_LINEAR = 3,
+ D3DFOG_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DFOGMODE;
+
+typedef struct _D3DRECT
+{
+ LONG x1;
+ LONG y1;
+ LONG x2;
+ LONG y2;
+} D3DRECT;
+
+typedef enum _D3DSHADER_PARAM_REGISTER_TYPE
+{
+ D3DSPR_TEMP = 0, // Temporary Register File
+ D3DSPR_INPUT = 1, // Input Register File
+ D3DSPR_CONST = 2, // Constant Register File
+ D3DSPR_ADDR = 3, // Address Register (VS)
+ D3DSPR_TEXTURE = 3, // Texture Register File (PS)
+ D3DSPR_RASTOUT = 4, // Rasterizer Register File
+ D3DSPR_ATTROUT = 5, // Attribute Output Register File
+ D3DSPR_TEXCRDOUT = 6, // Texture Coordinate Output Register File
+ D3DSPR_OUTPUT = 6, // Output register file for VS3.0+
+ D3DSPR_CONSTINT = 7, // Constant Integer Vector Register File
+ D3DSPR_COLOROUT = 8, // Color Output Register File
+ D3DSPR_DEPTHOUT = 9, // Depth Output Register File
+ D3DSPR_SAMPLER = 10, // Sampler State Register File
+ D3DSPR_CONST2 = 11, // Constant Register File 2048 - 4095
+ D3DSPR_CONST3 = 12, // Constant Register File 4096 - 6143
+ D3DSPR_CONST4 = 13, // Constant Register File 6144 - 8191
+ D3DSPR_CONSTBOOL = 14, // Constant Boolean register file
+ D3DSPR_LOOP = 15, // Loop counter register file
+ D3DSPR_TEMPFLOAT16 = 16, // 16-bit float temp register file
+ D3DSPR_MISCTYPE = 17, // Miscellaneous (single) registers.
+ D3DSPR_LABEL = 18, // Label
+ D3DSPR_PREDICATE = 19, // Predicate register
+ D3DSPR_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DSHADER_PARAM_REGISTER_TYPE;
+
+typedef struct _D3DMATRIX
+{
+ union
+ {
+ struct
+ {
+ float _11, _12, _13, _14;
+ float _21, _22, _23, _24;
+ float _31, _32, _33, _34;
+ float _41, _42, _43, _44;
+ };
+ float m[4][4];
+ };
+} D3DMATRIX;
+
+typedef struct _D3DVERTEXBUFFER_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+ UINT Size;
+
+ DWORD FVF;
+
+} D3DVERTEXBUFFER_DESC;
+
+class TOGL_CLASS D3DXMATRIX : public D3DMATRIX
+{
+public:
+ D3DXMATRIX operator*( const D3DXMATRIX &o ) const;
+ operator FLOAT* ();
+ float& operator()( int row, int column );
+ const float& operator()( int row, int column ) const;
+};
+
+typedef DWORD D3DCOLOR;
+
+typedef enum _D3DSAMPLERSTATETYPE
+{
+ D3DSAMP_ADDRESSU = 1, /* D3DTEXTUREADDRESS for U coordinate */
+ D3DSAMP_ADDRESSV = 2, /* D3DTEXTUREADDRESS for V coordinate */
+ D3DSAMP_ADDRESSW = 3, /* D3DTEXTUREADDRESS for W coordinate */
+ D3DSAMP_BORDERCOLOR = 4, /* D3DCOLOR */
+ D3DSAMP_MAGFILTER = 5, /* D3DTEXTUREFILTER filter to use for magnification */
+ D3DSAMP_MINFILTER = 6, /* D3DTEXTUREFILTER filter to use for minification */
+ D3DSAMP_MIPFILTER = 7, /* D3DTEXTUREFILTER filter to use between mipmaps during minification */
+ D3DSAMP_MIPMAPLODBIAS = 8, /* float Mipmap LOD bias */
+ D3DSAMP_MAXMIPLEVEL = 9, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */
+ D3DSAMP_MAXANISOTROPY = 10, /* DWORD maximum anisotropy */
+ D3DSAMP_SRGBTEXTURE = 11, /* Default = 0 (which means Gamma 1.0,
+ no correction required.) else correct for
+ Gamma = 2.2 */
+ D3DSAMP_SHADOWFILTER = 12, /* Tells the sampler that it should be doing shadow compares */
+ D3DSAMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DSAMPLERSTATETYPE;
+
+typedef enum _D3DDECLTYPE
+{
+ D3DDECLTYPE_FLOAT1 = 0, // 1D float expanded to (value, 0., 0., 1.)
+ D3DDECLTYPE_FLOAT2 = 1, // 2D float expanded to (value, value, 0., 1.)
+ D3DDECLTYPE_FLOAT3 = 2, // 3D float expanded to (value, value, value, 1.)
+ D3DDECLTYPE_FLOAT4 = 3, // 4D float
+ D3DDECLTYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. range
+ // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
+ D3DDECLTYPE_UBYTE4 = 5, // 4D unsigned byte
+ D3DDECLTYPE_SHORT2 = 6, // 2D signed short expanded to (value, value, 0., 1.)
+ D3DDECLTYPE_SHORT4 = 7, // 4D signed short
+
+// The following types are valid only with vertex shaders >= 2.0
+
+
+ D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to 255.0
+ D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
+ D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
+ D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
+ D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
+ D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
+ D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
+ D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
+ D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values
+ D3DDECLTYPE_UNUSED = 17, // When the type field in a decl is unused.
+} D3DDECLTYPE;
+
+typedef enum _D3DDECLMETHOD
+{
+ D3DDECLMETHOD_DEFAULT = 0,
+ D3DDECLMETHOD_PARTIALU,
+ D3DDECLMETHOD_PARTIALV,
+ D3DDECLMETHOD_CROSSUV, // Normal
+ D3DDECLMETHOD_UV,
+ D3DDECLMETHOD_LOOKUP, // Lookup a displacement map
+ D3DDECLMETHOD_LOOKUPPRESAMPLED, // Lookup a pre-sampled displacement map
+} D3DDECLMETHOD;
+
+typedef enum _D3DDECLUSAGE
+{
+ D3DDECLUSAGE_POSITION = 0,
+ D3DDECLUSAGE_BLENDWEIGHT = 1,
+ D3DDECLUSAGE_BLENDINDICES = 2,
+ D3DDECLUSAGE_NORMAL = 3,
+ D3DDECLUSAGE_PSIZE = 4,
+ D3DDECLUSAGE_TEXCOORD = 5,
+ D3DDECLUSAGE_TANGENT = 6,
+ D3DDECLUSAGE_BINORMAL = 7,
+ D3DDECLUSAGE_TESSFACTOR = 8,
+ D3DDECLUSAGE_PLUGH = 9, // mystery value
+ D3DDECLUSAGE_COLOR = 10,
+ D3DDECLUSAGE_FOG = 11,
+ D3DDECLUSAGE_DEPTH = 12,
+ D3DDECLUSAGE_SAMPLE = 13,
+} D3DDECLUSAGE;
+
+typedef enum _D3DPRIMITIVETYPE
+{
+ D3DPT_POINTLIST = 1,
+ D3DPT_LINELIST = 2,
+ D3DPT_TRIANGLELIST = 4,
+ D3DPT_TRIANGLESTRIP = 5,
+ D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DPRIMITIVETYPE;
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// STRUCTURES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+typedef struct TOGL_CLASS D3DXPLANE
+{
+ float& operator[]( int i );
+ bool operator==( const D3DXPLANE &o );
+ bool operator!=( const D3DXPLANE &o );
+ operator float*();
+ operator const float*() const;
+
+ float a, b, c, d;
+} D3DXPLANE;
+
+typedef enum _D3DVERTEXBLENDFLAGS
+{
+ D3DVBF_DISABLE = 0, // Disable vertex blending
+ D3DVBF_1WEIGHTS = 1, // 2 matrix blending
+ D3DVBF_2WEIGHTS = 2, // 3 matrix blending
+ D3DVBF_3WEIGHTS = 3, // 4 matrix blending
+ D3DVBF_TWEENING = 255, // blending using D3DRS_TWEENFACTOR
+ D3DVBF_0WEIGHTS = 256, // one matrix is used with weight 1.0
+ D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
+} D3DVERTEXBLENDFLAGS;
+
+typedef struct _D3DINDEXBUFFER_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+ UINT Size;
+} D3DINDEXBUFFER_DESC;
+
+typedef struct _D3DVERTEXELEMENT9
+{
+ WORD Stream; // Stream index
+ WORD Offset; // Offset in the stream in bytes
+ BYTE Type; // Data type
+ BYTE Method; // Processing method
+ BYTE Usage; // Semantics
+ BYTE UsageIndex; // Semantic index
+} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;
+
+
+#define MAX_DEVICE_IDENTIFIER_STRING 512
+typedef struct _D3DADAPTER_IDENTIFIER9
+{
+ char Driver[MAX_DEVICE_IDENTIFIER_STRING];
+ char Description[MAX_DEVICE_IDENTIFIER_STRING];
+ char DeviceName[32]; /* Device name for GDI (ex. \\.\DISPLAY1) */
+
+ LARGE_INTEGER DriverVersion; /* Defined for 32 bit components */
+
+ DWORD VendorId;
+ DWORD DeviceId;
+ DWORD SubSysId;
+ DWORD Revision;
+ DWORD VideoMemory;
+
+} D3DADAPTER_IDENTIFIER9;
+
+typedef struct _D3DCOLORVALUE
+{
+ float r;
+ float g;
+ float b;
+ float a;
+} D3DCOLORVALUE;
+
+typedef struct _D3DMATERIAL9
+{
+ D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */
+ D3DCOLORVALUE Ambient; /* Ambient color RGB */
+ D3DCOLORVALUE Specular; /* Specular 'shininess' */
+ D3DCOLORVALUE Emissive; /* Emissive color RGB */
+ float Power; /* Sharpness if specular highlight */
+} D3DMATERIAL9;
+
+typedef struct _D3DVOLUME_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+
+ UINT Width;
+ UINT Height;
+ UINT Depth;
+} D3DVOLUME_DESC;
+
+typedef struct _D3DVIEWPORT9
+{
+ DWORD X;
+ DWORD Y; /* Viewport Top left */
+ DWORD Width;
+ DWORD Height; /* Viewport Dimensions */
+ float MinZ; /* Min/max of clip Volume */
+ float MaxZ;
+} D3DVIEWPORT9;
+
+typedef struct _D3DPSHADERCAPS2_0
+{
+ DWORD Caps;
+ INT DynamicFlowControlDepth;
+ INT NumTemps;
+ INT StaticFlowControlDepth;
+ INT NumInstructionSlots;
+} D3DPSHADERCAPS2_0;
+
+typedef struct _D3DCAPS9
+{
+ /* Device Info */
+ D3DDEVTYPE DeviceType;
+
+ /* Caps from DX7 Draw */
+ DWORD Caps;
+ DWORD Caps2;
+
+ /* Cursor Caps */
+ DWORD CursorCaps;
+
+ /* 3D Device Caps */
+ DWORD DevCaps;
+
+ DWORD PrimitiveMiscCaps;
+ DWORD RasterCaps;
+ DWORD TextureCaps;
+ DWORD TextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9's
+
+ DWORD MaxTextureWidth, MaxTextureHeight;
+ DWORD MaxVolumeExtent;
+
+ DWORD MaxTextureAspectRatio;
+ DWORD MaxAnisotropy;
+
+ DWORD TextureOpCaps;
+ DWORD MaxTextureBlendStages;
+ DWORD MaxSimultaneousTextures;
+
+ DWORD VertexProcessingCaps;
+ DWORD MaxActiveLights;
+ DWORD MaxUserClipPlanes;
+ DWORD MaxVertexBlendMatrices;
+ DWORD MaxVertexBlendMatrixIndex;
+
+ DWORD MaxPrimitiveCount; // max number of primitives per DrawPrimitive call
+ DWORD MaxStreams;
+
+ DWORD VertexShaderVersion;
+ DWORD MaxVertexShaderConst; // number of vertex shader constant registers
+
+ DWORD PixelShaderVersion;
+
+ // Here are the DX9 specific ones
+ DWORD DevCaps2;
+ D3DPSHADERCAPS2_0 PS20Caps;
+
+ DWORD NumSimultaneousRTs; // Will be at least 1
+ DWORD MaxVertexShader30InstructionSlots;
+ DWORD MaxPixelShader30InstructionSlots;
+
+ // only on Posix/GL
+ DWORD FakeSRGBWrite; // 1 for parts which can't support SRGB writes due to driver issues - 0 for others
+ DWORD MixedSizeTargets; // 1 for parts which can mix attachment sizes (RT's color vs depth)
+ DWORD CanDoSRGBReadFromRTs; // 0 when we're on Leopard, 1 when on Snow Leopard
+} D3DCAPS9;
+
+typedef struct _D3DDISPLAYMODE
+{
+ UINT Width;
+ UINT Height;
+ UINT RefreshRate;
+ D3DFORMAT Format;
+} D3DDISPLAYMODE;
+
+typedef struct _D3DGAMMARAMP
+{
+ WORD red [256];
+ WORD green[256];
+ WORD blue [256];
+} D3DGAMMARAMP;
+
+
+/* Resize Optional Parameters */
+typedef struct _D3DPRESENT_PARAMETERS_
+{
+ UINT BackBufferWidth;
+ UINT BackBufferHeight;
+ D3DFORMAT BackBufferFormat;
+ UINT BackBufferCount;
+
+ D3DMULTISAMPLE_TYPE MultiSampleType;
+ DWORD MultiSampleQuality;
+
+ D3DSWAPEFFECT SwapEffect;
+ VD3DHWND hDeviceWindow;
+ BOOL Windowed;
+ BOOL EnableAutoDepthStencil;
+ D3DFORMAT AutoDepthStencilFormat;
+ DWORD Flags;
+
+ /* FullScreen_RefreshRateInHz must be zero for Windowed mode */
+ UINT FullScreen_RefreshRateInHz;
+ UINT PresentationInterval;
+} D3DPRESENT_PARAMETERS;
+
+typedef struct _D3DDEVICE_CREATION_PARAMETERS
+{
+ UINT AdapterOrdinal;
+ D3DDEVTYPE DeviceType;
+ VD3DHWND hFocusWindow;
+ DWORD BehaviorFlags;
+} D3DDEVICE_CREATION_PARAMETERS;
+
+/* Structures for LockBox */
+typedef struct _D3DBOX
+{
+ UINT Left;
+ UINT Top;
+ UINT Right;
+ UINT Bottom;
+ UINT Front;
+ UINT Back;
+} D3DBOX;
+
+typedef struct _D3DLOCKED_BOX
+{
+ INT RowPitch;
+ INT SlicePitch;
+ void* pBits;
+} D3DLOCKED_BOX;
+
+typedef struct _D3DSURFACE_DESC
+{
+ D3DFORMAT Format;
+ D3DRESOURCETYPE Type;
+ DWORD Usage;
+ D3DPOOL Pool;
+
+ D3DMULTISAMPLE_TYPE MultiSampleType;
+ DWORD MultiSampleQuality;
+ UINT Width;
+ UINT Height;
+} D3DSURFACE_DESC;
+
+
+typedef struct _D3DLOCKED_RECT
+{
+ INT Pitch;
+ void* pBits;
+} D3DLOCKED_RECT;
+
+
+typedef struct _D3DRASTER_STATUS
+{
+ BOOL InVBlank;
+ UINT ScanLine;
+} D3DRASTER_STATUS;
+
+typedef enum _D3DLIGHTTYPE
+{
+ D3DLIGHT_POINT = 1,
+ D3DLIGHT_SPOT = 2,
+ D3DLIGHT_DIRECTIONAL = 3,
+ D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DLIGHTTYPE;
+
+typedef struct TOGL_CLASS _D3DVECTOR
+{
+ float x;
+ float y;
+ float z;
+} D3DVECTOR;
+
+class TOGL_CLASS D3DXVECTOR2
+{
+public:
+ operator FLOAT* ();
+ operator CONST FLOAT* () const;
+
+ float x,y;
+};
+
+class TOGL_CLASS D3DXVECTOR3 : public D3DVECTOR
+{
+public:
+ D3DXVECTOR3() {}
+ D3DXVECTOR3( float a, float b, float c );
+ operator FLOAT* ();
+ operator CONST FLOAT* () const;
+};
+
+typedef enum _D3DXINCLUDE_TYPE
+{
+ D3DXINC_LOCAL,
+
+ // force 32-bit size enum
+ D3DXINC_FORCE_DWORD = 0x7fffffff
+
+} D3DXINCLUDE_TYPE;
+
+typedef struct _D3DLIGHT9
+{
+ D3DLIGHTTYPE Type; /* Type of light source */
+ D3DCOLORVALUE Diffuse; /* Diffuse color of light */
+ D3DCOLORVALUE Specular; /* Specular color of light */
+ D3DCOLORVALUE Ambient; /* Ambient color of light */
+ D3DVECTOR Position; /* Position in world space */
+ D3DVECTOR Direction; /* Direction in world space */
+ float Range; /* Cutoff range */
+ float Falloff; /* Falloff */
+ float Attenuation0; /* Constant attenuation */
+ float Attenuation1; /* Linear attenuation */
+ float Attenuation2; /* Quadratic attenuation */
+ float Theta; /* Inner angle of spotlight cone */
+ float Phi; /* Outer angle of spotlight cone */
+} D3DLIGHT9;
+
+class TOGL_CLASS D3DXVECTOR4
+{
+public:
+ D3DXVECTOR4() {}
+ D3DXVECTOR4( float a, float b, float c, float d );
+
+ float x,y,z,w;
+};
+
+//----------------------------------------------------------------------------
+// D3DXMACRO:
+// ----------
+// Preprocessor macro definition. The application pass in a NULL-terminated
+// array of this structure to various D3DX APIs. This enables the application
+// to #define tokens at runtime, before the file is parsed.
+//----------------------------------------------------------------------------
+
+typedef struct _D3DXMACRO
+{
+ LPCSTR Name;
+ LPCSTR Definition;
+
+} D3DXMACRO, *LPD3DXMACRO;
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+//
+// Also look for any functions marked with "**** FIXED FUNCTION STUFF"
+//
+// It's only laying around here so we don't have to chop up the shader system a lot to strip out the fixed function code paths.
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+typedef enum _D3DTRANSFORMSTATETYPE
+{
+ D3DTS_VIEW = 2,
+ D3DTS_PROJECTION = 3,
+ D3DTS_TEXTURE0 = 16,
+ D3DTS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DTRANSFORMSTATETYPE;
+
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+typedef enum _D3DTEXTUREOP
+{
+ // Control
+ D3DTOP_DISABLE = 1, // disables stage
+ D3DTOP_SELECTARG1 = 2, // the default
+ D3DTOP_SELECTARG2 = 3,
+
+ // Modulate
+ D3DTOP_MODULATE = 4, // multiply args together
+ D3DTOP_MODULATE2X = 5, // multiply and 1 bit
+ D3DTOP_MODULATE4X = 6, // multiply and 2 bits
+
+ // Add
+ D3DTOP_ADD = 7, // add arguments together
+ D3DTOP_ADDSIGNED = 8, // add with -0.5 bias
+ D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit
+ D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation
+ D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product
+ // Arg1 + Arg2 - Arg1*Arg2
+ // = Arg1 + (1-Arg1)*Arg2
+
+ // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
+ D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha
+ D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha
+ D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRS_TEXTUREFACTOR
+
+ // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
+ D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha
+ D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color
+
+ // Specular mapping
+ D3DTOP_PREMODULATE = 17, // modulate with next texture before use
+ D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB
+ // COLOROP only
+ D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A
+ // COLOROP only
+ D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB
+ // COLOROP only
+ D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A
+ // COLOROP only
+
+ // Bump mapping
+ D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation
+ D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel
+
+ // This can do either diffuse or specular bump mapping with correct input.
+ // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B)
+ // where each component has been scaled and offset to make it signed.
+ // The result is replicated into all four (including alpha) channels.
+ // This is a valid COLOROP only.
+ D3DTOP_DOTPRODUCT3 = 24,
+
+ // Triadic ops
+ D3DTOP_MULTIPLYADD = 25, // Arg0 + Arg1*Arg2
+ D3DTOP_LERP = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2
+
+ D3DTOP_FORCE_DWORD = 0x7fffffff,
+} D3DTEXTUREOP;
+
+// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+typedef enum _D3DTEXTURESTAGESTATETYPE
+{
+ D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */
+ D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */
+ D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */
+ D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */
+ D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */
+ D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */
+ D3DTSS_BUMPENVMAT00 = 7, /* float (bump mapping matrix) */
+ D3DTSS_BUMPENVMAT01 = 8, /* float (bump mapping matrix) */
+ D3DTSS_BUMPENVMAT10 = 9, /* float (bump mapping matrix) */
+ D3DTSS_BUMPENVMAT11 = 10, /* float (bump mapping matrix) */
+ D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */
+ D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */
+ D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */
+ D3DTSS_COLORARG0 = 26, /* D3DTA_* third arg for triadic ops */
+ D3DTSS_RESULTARG = 28, /* D3DTA_* arg for result (CURRENT or TEMP) */
+
+
+ D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTURESTAGESTATETYPE;
+
+//===========================================================================//
+
+enum GLMVertexAttributeIndex
+{
+ kGLMGenericAttr00 = 0,
+ kGLMGenericAttr01,
+ kGLMGenericAttr02,
+ kGLMGenericAttr03,
+ kGLMGenericAttr04,
+ kGLMGenericAttr05,
+ kGLMGenericAttr06,
+ kGLMGenericAttr07,
+ kGLMGenericAttr08,
+ kGLMGenericAttr09,
+ kGLMGenericAttr10,
+ kGLMGenericAttr11,
+ kGLMGenericAttr12,
+ kGLMGenericAttr13,
+ kGLMGenericAttr14,
+ kGLMGenericAttr15,
+
+ kGLMVertexAttributeIndexMax // ideally < 32
+};
+
+struct GLMVertexAttributeDesc // all the info you need to do vertex setup for one attribute
+{
+ CGLMBuffer *m_buffer; // NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired
+ GLuint m_datasize; // comp count of the attribute (1-4)
+ GLenum m_datatype; // data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)
+ GLuint m_stride;
+ GLuint m_offset; // net offset to attribute 'zero' within the buffer.
+ GLboolean m_normalized; // apply to any fixed point data that needs normalizing, esp color bytes
+
+ // may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer
+ // simpler alternative is to do shoot-down inside the vertex/index buffer free calls.
+ // I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..
+
+#define EQ(fff) ( (src.fff) == (fff) )
+ // test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..
+ bool operator==(const GLMVertexAttributeDesc& src) const { return EQ(m_buffer) && EQ(m_offset) && EQ(m_stride) && EQ(m_datatype) && EQ(m_normalized) && EQ(m_datasize); }
+#undef EQ
+
+ uint m_bufferRevision; // only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event
+};
+
+
+#define MAX_D3DVERTEXELEMENTS 16
+
+struct D3DVERTEXELEMENT9_GL
+{
+ // fields right out of the original decl element (copied)
+ D3DVERTEXELEMENT9 m_dxdecl; // d3d info
+ // WORD Stream; // Stream index
+ // WORD Offset; // Offset in the stream in bytes
+ // BYTE Type; // Data type
+ // BYTE Method; // Processing method
+ // BYTE Usage; // Semantics
+ // BYTE UsageIndex; // Semantic index
+
+ GLMVertexAttributeDesc m_gldecl;
+ // CGLMBuffer *m_buffer; // late-dropped from selected stream desc (left NULL, will replace with stream source buffer at sync time)
+ // GLuint m_datasize; // component count (1,2,3,4) of the attrib
+ // GLenum m_datatype; // data type of the attribute (GL_FLOAT et al)
+ // GLuint m_stride; // late-dropped from stream desc
+ // GLuint m_offset; // net offset to attribute 'zero' within the stream data. Add the stream offset before passing to GL.
+ // GLuint m_normalized; // net offset to attribute 'zero' within the stream data. Add the stream offset before passing to GL.
+};
+
+struct IDirect3DDevice9Params
+{
+ UINT m_adapter;
+ D3DDEVTYPE m_deviceType;
+ VD3DHWND m_focusWindow;
+ DWORD m_behaviorFlags;
+ D3DPRESENT_PARAMETERS m_presentationParameters;
+};
+
+#define D3D_MAX_STREAMS 4
+struct D3DStreamDesc
+{
+ IDirect3DVertexBuffer9 *m_vtxBuffer;
+ uint m_offset;
+ uint m_stride;
+};
+
+struct D3DIndexDesc
+{
+ IDirect3DIndexBuffer9 *m_idxBuffer;
+};
+
+// we latch sampler values until draw time and then convert them all to GL form
+// note these are similar in name to the fields of a GLMTexSamplingParams but contents are not
+// particularly in the texture filtering area
+
+struct D3DSamplerDesc
+{
+ D3DTEXTUREADDRESS m_addressModes[3]; // D3DTEXTUREADDRESS modes for S,T,R
+ DWORD m_borderColor; // DWORD bordercolor
+ D3DTEXTUREFILTERTYPE m_magFilter; // mag filter
+ D3DTEXTUREFILTERTYPE m_minFilter; // min filter
+ D3DTEXTUREFILTERTYPE m_mipFilter; // mip filter
+ float m_mipmapBias; // float: mipmap bias
+ DWORD m_maxMipLevel; // DWORD 0..(n-1) LOD index of largest map to use (0 == largest)
+ DWORD m_maxAniso; // D3DSAMP_MAXANISOTROPY max aniso
+ DWORD m_srgb; // D3DSAMP_SRGBTEXTURE 0 = no SRGB sampling
+ DWORD m_shadowFilter; // D3DSAMP_SHADOWFILTER
+};
+
+// Tracking and naming sampler dimensions
+#define SAMPLER_TYPE_2D 0
+#define SAMPLER_TYPE_CUBE 1
+#define SAMPLER_TYPE_3D 2
+#define SAMPLER_TYPE_UNUSED 3
+
+#endif // DXABSTRACT_TYPES_H
diff --git a/mp/src/public/togl/osx/glentrypoints.h b/mp/src/public/togl/osx/glentrypoints.h new file mode 100644 index 00000000..1ae4423c --- /dev/null +++ b/mp/src/public/togl/osx/glentrypoints.h @@ -0,0 +1,329 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glentrypoints.h
+//
+//===============================================================================
+
+#ifndef GLENTRYPOINTS_H
+#define GLENTRYPOINTS_H
+
+#pragma once
+
+#ifdef DX_TO_GL_ABSTRACTION
+
+#include "tier0/platform.h"
+#include "tier0/dynfunction.h"
+#include "tier0/vprof_telemetry.h"
+#include "interface.h"
+
+#include "togl/rendermechanism.h"
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+
+void *VoidFnPtrLookup_GlMgr(const char *fn, bool &okay, const bool bRequired, void *fallback=NULL);
+
+#if GL_TELEMETRY_ZONES || GL_TRACK_API_TIME
+class CGLExecuteHelperBase
+{
+public:
+ inline void StartCall(const char *pName);
+ inline void StopCall(const char *pName);
+#if GL_TRACK_API_TIME
+ TmU64 m_nStartTime;
+#endif
+};
+
+template < class FunctionType, typename Result >
+class CGLExecuteHelper : public CGLExecuteHelperBase
+{
+public:
+ inline CGLExecuteHelper(FunctionType pFn, const char *pName ) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(); StopCall(pName); }
+ template<typename A> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a); StopCall(pName); }
+ template<typename A, typename B> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b); StopCall(pName); }
+ template<typename A, typename B, typename C> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h, i); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h, i, j); StopCall(pName); }
+
+ inline operator Result() const { return m_Result; }
+ inline operator char*() const { return (char*)m_Result; }
+
+ FunctionType m_pFn;
+
+ Result m_Result;
+};
+
+template < class FunctionType>
+class CGLExecuteHelper<FunctionType, void> : public CGLExecuteHelperBase
+{
+public:
+ inline CGLExecuteHelper(FunctionType pFn, const char *pName ) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(); StopCall(pName); }
+ template<typename A> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a); StopCall(pName); }
+ template<typename A, typename B> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b); StopCall(pName); }
+ template<typename A, typename B, typename C> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h, i); StopCall(pName); }
+ template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h, i, j); StopCall(pName); }
+
+ FunctionType m_pFn;
+};
+#endif
+
+template < class FunctionType, typename Result >
+class CDynamicFunctionOpenGLBase
+{
+public:
+ // Construct with a NULL function pointer. You must manually call
+ // Lookup() before you can call a dynamic function through this interface.
+ CDynamicFunctionOpenGLBase() : m_pFn(NULL) {}
+
+ // Construct and do a lookup right away. You will need to make sure that
+ // the lookup actually succeeded, as the gl library might have failed to load
+ // or (fn) might not exist in it.
+ CDynamicFunctionOpenGLBase(const char *fn, FunctionType fallback=NULL) : m_pFn(NULL)
+ {
+ Lookup(fn, fallback);
+ }
+
+ // Construct and do a lookup right away. See comments in Lookup() about what (okay) does.
+ CDynamicFunctionOpenGLBase(const char *fn, bool &okay, FunctionType fallback=NULL) : m_pFn(NULL)
+ {
+ Lookup(fn, okay, fallback);
+ }
+
+ // Load library if necessary, look up symbol. Returns true and sets
+ // m_pFn on successful lookup, returns false otherwise. If the
+ // function pointer is already looked up, this return true immediately.
+ // Use Reset() first if you want to look up the symbol again.
+ // This function will return false immediately unless (okay) is true.
+ // This allows you to chain lookups like this:
+ // bool okay = true;
+ // x.Lookup(lib, "x", okay);
+ // y.Lookup(lib, "y", okay);
+ // z.Lookup(lib, "z", okay);
+ // if (okay) { printf("All functions were loaded successfully!\n"); }
+ // If you supply a fallback, it'll be used if the lookup fails (and if
+ // non-NULL, means this will always return (okay)).
+ bool Lookup(const char *fn, bool &okay, FunctionType fallback=NULL)
+ {
+ if (!okay)
+ return false;
+ else if (this->m_pFn == NULL)
+ {
+ this->m_pFn = (FunctionType) VoidFnPtrLookup_GlMgr(fn, okay, false, (void *) fallback);
+ this->SetFuncName( fn );
+ }
+ return okay;
+ }
+
+ // Load library if necessary, look up symbol. Returns true and sets
+ // m_pFn on successful lookup, returns false otherwise. If the
+ // function pointer is already looked up, this return true immediately.
+ // Use Reset() first if you want to look up the symbol again.
+ // This function will return false immediately unless (okay) is true.
+ // If you supply a fallback, it'll be used if the lookup fails (and if
+ // non-NULL, means this will always return true).
+ bool Lookup(const char *fn, FunctionType fallback=NULL)
+ {
+ bool okay = true;
+ return Lookup(fn, okay, fallback);
+ }
+
+ // Invalidates the current lookup. Makes the function pointer NULL. You
+ // will need to call Lookup() before you can call a dynamic function
+ // through this interface again.
+ void Reset() { m_pFn = NULL; }
+
+ // Force this to be a specific function pointer.
+ void Force(FunctionType ptr) { m_pFn = ptr; }
+
+ // Retrieve the actual function pointer.
+ FunctionType Pointer() const { return m_pFn; }
+
+#if GL_TELEMETRY_ZONES || GL_TRACK_API_TIME
+ #if GL_TELEMETRY_ZONES
+ #define GL_FUNC_NAME m_szName
+ #else
+ #define GL_FUNC_NAME ""
+ #endif
+
+ inline CGLExecuteHelper<FunctionType, Result> operator() () const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME ); }
+
+ template<typename T>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a); }
+
+ template<typename T, typename U>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b); }
+
+ template<typename T, typename U, typename V>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c ) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c); }
+
+ template<typename T, typename U, typename V, typename W>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d); }
+
+ template<typename T, typename U, typename V, typename W, typename X>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A, typename B>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h, B i) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h, i); }
+
+ template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A, typename B, typename C>
+ inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h, B i, C j) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h, i, j); }
+#else
+ operator FunctionType() const { return m_pFn; }
+#endif
+
+ // Can be used to verify that we have an actual function looked up and
+ // ready to call: if (!MyDynFunc) { printf("Function not found!\n"); }
+ operator bool () const { return m_pFn != NULL; }
+ bool operator !() const { return m_pFn == NULL; }
+
+protected:
+ FunctionType m_pFn;
+
+#if GL_TELEMETRY_ZONES
+ char m_szName[32];
+ inline void SetFuncName(const char *pFn) { V_strncpy( m_szName, pFn, sizeof( m_szName ) ); }
+#else
+ inline void SetFuncName(const char *pFn) { (void)pFn; }
+#endif
+};
+
+// This works a lot like CDynamicFunctionMustInit, but we use SDL_GL_GetProcAddress().
+template < const bool bRequired, class FunctionType, typename Result >
+class CDynamicFunctionOpenGL : public CDynamicFunctionOpenGLBase< FunctionType, Result >
+{
+private: // forbid default constructor.
+ CDynamicFunctionOpenGL() {}
+
+public:
+ CDynamicFunctionOpenGL(const char *fn, FunctionType fallback=NULL)
+ {
+ bool okay = true;
+ Lookup(fn, okay, fallback);
+ this->SetFuncName( fn );
+ }
+
+ CDynamicFunctionOpenGL(const char *fn, bool &okay, FunctionType fallback=NULL)
+ {
+ Lookup(fn, okay, fallback);
+ this->SetFuncName( fn );
+ }
+
+ // Please note this is not virtual.
+ // !!! FIXME: we might want to fall back and try "EXT" or "ARB" versions in some case.
+ bool Lookup(const char *fn, bool &okay, FunctionType fallback=NULL)
+ {
+ if (this->m_pFn == NULL)
+ {
+ this->m_pFn = (FunctionType) VoidFnPtrLookup_GlMgr(fn, okay, bRequired, (void *) fallback);
+ this->SetFuncName( fn );
+ }
+ return okay;
+ }
+};
+
+
+// This provides all the entry points for a given OpenGL context.
+// ENTRY POINTS ARE ONLY VALID FOR THE CONTEXT THAT WAS CURRENT WHEN
+// YOU LOOKED THEM UP. 99% of the time, this is not a problem, but
+// that 1% is really hard to track down. Always access the GL
+// through this class!
+class COpenGLEntryPoints
+{
+public:
+ // The GL context you are looking up entry points for must be current when you construct this object!
+ COpenGLEntryPoints();
+
+ uint64 m_nTotalGLCycles, m_nTotalGLCalls;
+
+ int m_nOpenGLVersionMajor; // if GL_VERSION is 2.1.0, this will be set to 2.
+ int m_nOpenGLVersionMinor; // if GL_VERSION is 2.1.0, this will be set to 1.
+ int m_nOpenGLVersionPatch; // if GL_VERSION is 2.1.0, this will be set to 0.
+ bool m_bHave_OpenGL;
+
+ #define GL_EXT(x,glmajor,glminor) bool m_bHave_##x;
+ #define GL_FUNC(ext,req,ret,fn,arg,call) CDynamicFunctionOpenGL< req, ret (APIENTRY *) arg, ret > fn;
+ #define GL_FUNC_VOID(ext,req,fn,arg,call) CDynamicFunctionOpenGL< req, void (APIENTRY *) arg, void > fn;
+ #include "togl/glfuncs.inl"
+ #undef GL_FUNC_VOID
+ #undef GL_FUNC
+ #undef GL_EXT
+};
+
+// This will be set to the current OpenGL context's entry points.
+extern COpenGLEntryPoints *gGL;
+typedef void * (*GL_GetProcAddressCallbackFunc_t)(const char *, bool &, const bool, void *);
+
+#ifdef TOGL_DLL_EXPORT
+ DLL_EXPORT COpenGLEntryPoints *ToGLConnectLibraries( CreateInterfaceFn factory );
+ DLL_EXPORT void ToGLDisconnectLibraries();
+ DLL_EXPORT COpenGLEntryPoints *GetOpenGLEntryPoints(GL_GetProcAddressCallbackFunc_t callback);
+#else
+ DLL_IMPORT COpenGLEntryPoints *ToGLConnectLibraries( CreateInterfaceFn factory );
+ DLL_IMPORT void ToGLDisconnectLibraries();
+ DLL_IMPORT COpenGLEntryPoints *GetOpenGLEntryPoints(GL_GetProcAddressCallbackFunc_t callback);
+#endif
+
+#if GL_TELEMETRY_ZONES || GL_TRACK_API_TIME
+inline void CGLExecuteHelperBase::StartCall(const char *pName)
+{
+ (void)pName;
+
+#if GL_TELEMETRY_ZONES
+ tmEnter( TELEMETRY_LEVEL3, TMZF_NONE, pName );
+#endif
+
+#if GL_TRACK_API_TIME
+ m_nStartTime = tmFastTime();
+#endif
+}
+
+inline void CGLExecuteHelperBase::StopCall(const char *pName)
+{
+#if GL_TRACK_API_TIME
+ uint64 nTotalCycles = tmFastTime() - m_nStartTime;
+#endif
+
+#if GL_TELEMETRY_ZONES
+ tmLeave( TELEMETRY_LEVEL3 );
+#endif
+
+#if GL_TRACK_API_TIME
+ //double flMilliseconds = g_Telemetry.flRDTSCToMilliSeconds * nTotalCycles;
+ if (gGL)
+ {
+ gGL->m_nTotalGLCycles += nTotalCycles;
+ gGL->m_nTotalGLCalls++;
+ }
+#endif
+}
+#endif
+
+#endif // DX_TO_GL_ABSTRACTION
+
+#endif // GLENTRYPOINTS_H
diff --git a/mp/src/public/togl/osx/glfuncs.h b/mp/src/public/togl/osx/glfuncs.h new file mode 100644 index 00000000..484786c6 --- /dev/null +++ b/mp/src/public/togl/osx/glfuncs.h @@ -0,0 +1,184 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+// !!! FIXME: Some of these aren't base OpenGL...pick out the extensions.
+// !!! FIXME: Also, look up these -1, -1 versions numbers.
+GL_FUNC(OpenGL,true,GLenum,glGetError,(void),())
+GL_FUNC_VOID(OpenGL,true,glActiveTexture,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glAlphaFunc,(GLenum a,GLclampf b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glAttachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBegin,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glBindAttribLocationARB,(GLhandleARB a,GLuint b,const GLcharARB *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glBindBufferARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindProgramARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindTexture,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBlendColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glBlendEquation,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glBlendFunc,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBufferDataARB,(GLenum a,GLsizeiptrARB b,const GLvoid *c,GLenum d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glClear,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glClearColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glClearDepth,(GLclampd a),(a))
+GL_FUNC_VOID(OpenGL,true,glClearStencil,(GLint a),(a))
+GL_FUNC_VOID(OpenGL,true,glClipPlane,(GLenum a,const GLdouble *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glColorMask,(GLboolean a,GLboolean b,GLboolean c,GLboolean d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glCompileShaderARB,(GLhandleARB a),(a))
+GL_FUNC_VOID(OpenGL,true,glCompressedTexImage2D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLint f,GLsizei g,const GLvoid *h),(a,b,c,d,e,f,g,h))
+GL_FUNC_VOID(OpenGL,true,glCompressedTexImage3D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLsizei h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC(OpenGL,true,GLhandleARB,glCreateProgramObjectARB,(void),())
+GL_FUNC(OpenGL,true,GLhandleARB,glCreateShaderObjectARB,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteBuffersARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteObjectARB,(GLhandleARB a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteProgramsARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteQueriesARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteShader,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteTextures,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDepthFunc,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDepthMask,(GLboolean a),(a))
+GL_FUNC_VOID(OpenGL,true,glDepthRange,(GLclampd a,GLclampd b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDetachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDisable,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDisableVertexAttribArray,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawArrays,(GLenum a,GLint b,GLsizei c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glDrawBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawRangeElements,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glEnable,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glEnableVertexAttribArray,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glEnd,(void),())
+GL_FUNC_VOID(OpenGL,true,glFinish,(void),())
+GL_FUNC_VOID(OpenGL,true,glFlush,(void),())
+GL_FUNC_VOID(OpenGL,true,glFrontFace,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glGenBuffersARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenProgramsARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenQueriesARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenTextures,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetBooleanv,(GLenum a,GLboolean *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetCompressedTexImage,(GLenum a,GLint b,GLvoid *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGetDoublev,(GLenum a,GLdouble *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetFloatv,(GLenum a,GLfloat *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetInfoLogARB,(GLhandleARB a,GLsizei b,GLsizei *c,GLcharARB *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glGetIntegerv,(GLenum a,GLint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetObjectParameterivARB,(GLhandleARB a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGetProgramivARB,(GLenum a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC(OpenGL,true,const GLubyte *,glGetString,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glGetTexImage,(GLenum a,GLint b,GLenum c,GLenum d,GLvoid *e),(a,b,c,d,e))
+GL_FUNC(OpenGL,true,GLint,glGetUniformLocationARB,(GLhandleARB a,const GLcharARB *b),(a,b))
+GL_FUNC(OpenGL,true,GLboolean,glIsEnabled,(GLenum a),(a))
+GL_FUNC(OpenGL,true,GLboolean,glIsTexture,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glLinkProgramARB,(GLhandleARB a),(a))
+GL_FUNC(OpenGL,true,GLvoid*,glMapBufferARB,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glOrtho,(GLdouble a,GLdouble b,GLdouble c,GLdouble d,GLdouble e,GLdouble f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glPixelStorei,(GLenum a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPolygonMode,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPolygonOffset,(GLfloat a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPopAttrib,(void),())
+GL_FUNC_VOID(OpenGL,true,glProgramStringARB,(GLenum a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glPushAttrib,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glReadBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glScissor,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glShaderSourceARB,(GLhandleARB a,GLsizei b,const GLcharARB **c,const GLint *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glStencilFunc,(GLenum a,GLint b,GLuint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glStencilMask,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glStencilOp,(GLenum a,GLenum b,GLenum c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexCoord2f,(GLfloat a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glTexImage2D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLint f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC_VOID(OpenGL,true,glTexImage3D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLenum h,GLenum i,const GLvoid *j),(a,b,c,d,e,f,g,h,i,j))
+GL_FUNC_VOID(OpenGL,true,glTexParameterfv,(GLenum a,GLenum b,const GLfloat *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexParameteri,(GLenum a,GLenum b,GLint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexSubImage2D,(GLenum a,GLint b,GLint c,GLint d,GLsizei e,GLsizei f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC_VOID(OpenGL,true,glUniform1f,(GLint a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform1i,(GLint a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform1iARB,(GLint a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform4fv,(GLint a,GLsizei b,const GLfloat *c),(a,b,c))
+GL_FUNC(OpenGL,true,GLboolean,glUnmapBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glUseProgram,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glVertex3f,(GLfloat a,GLfloat b,GLfloat c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glVertexAttribPointer,(GLuint a,GLint b,GLenum c,GLboolean d,GLsizei e,const GLvoid *f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glViewport,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glEnableClientState,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDisableClientState,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glClientActiveTexture,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glVertexPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glTexCoordPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glProgramEnvParameters4fvEXT,(GLenum a,GLuint b,GLsizei c,const GLfloat *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glColor4sv,(const GLshort *a),(a))
+GL_FUNC_VOID(OpenGL,true,glStencilOpSeparate,(GLenum a,GLenum b,GLenum c,GLenum d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glStencilFuncSeparate,(GLenum a,GLenum b,GLint c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glGetTexLevelParameteriv,(GLenum a,GLint b,GLenum c,GLint *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glColor4f,(GLfloat a,GLfloat b,GLfloat c,GLfloat d),(a,b,c,d))
+GL_EXT(GL_EXT_framebuffer_object,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindFramebufferEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindRenderbufferEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC(GL_EXT_framebuffer_object,false,GLenum,glCheckFramebufferStatusEXT,(GLenum a),(a))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteRenderbuffersEXT,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferRenderbufferEXT,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture2DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture3DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenFramebuffersEXT,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenRenderbuffersEXT,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteFramebuffersEXT,(GLsizei a,const GLuint *b),(a,b))
+GL_EXT(GL_EXT_framebuffer_blit,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_blit,false,glBlitFramebufferEXT,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
+GL_EXT(GL_EXT_framebuffer_multisample,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_multisample,false,glRenderbufferStorageMultisampleEXT,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
+GL_EXT(GL_APPLE_fence,-1,-1)
+GL_FUNC(GL_APPLE_fence,false,GLboolean,glTestFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glSetFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glFinishFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glDeleteFencesAPPLE,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_APPLE_fence,false,glGenFencesAPPLE,(GLsizei a,GLuint *b),(a,b))
+GL_EXT(GL_NV_fence,-1,-1)
+GL_FUNC(GL_NV_fence,false,GLboolean,glTestFenceNV,(GLuint a),(a))
+GL_FUNC_VOID(GL_NV_fence,false,glSetFenceNV,(GLuint a,GLenum b),(a,b))
+GL_FUNC_VOID(GL_NV_fence,false,glFinishFenceNV,(GLuint a),(a))
+GL_FUNC_VOID(GL_NV_fence,false,glDeleteFencesNV,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_NV_fence,false,glGenFencesNV,(GLsizei a,GLuint *b),(a,b))
+GL_EXT(GL_ARB_sync,3,2)
+#ifdef HAVE_GL_ARB_SYNC
+GL_FUNC_VOID(GL_ARB_sync,false,glGetSynciv,(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e),(a,b,c,d,e))
+GL_FUNC(GL_ARB_sync,false,GLenum,glClientWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_sync,false,glWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_sync,false,glDeleteSync,(GLsync a),(a))
+GL_FUNC(GL_ARB_sync,false,GLsync,glFenceSync,(GLenum a, GLbitfield b),(a,b))
+#endif
+GL_EXT(GL_EXT_draw_buffers2,-1,-1)
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glColorMaskIndexedEXT,(GLuint a,GLboolean b,GLboolean c,GLboolean d,GLboolean e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glEnableIndexedEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glDisableIndexedEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glGetBooleanIndexedvEXT,(GLenum a,GLuint b,GLboolean *c),(a,b,c))
+GL_EXT(GL_EXT_bindable_uniform,-1,-1)
+GL_FUNC_VOID(GL_EXT_bindable_uniform,false,glUniformBufferEXT,(GLuint a,GLint b,GLuint c),(a,b,c))
+GL_EXT(GL_APPLE_flush_buffer_range,-1,-1)
+GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glBufferParameteriAPPLE,(GLenum a,GLenum b,GLint c),(a,b,c))
+GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glFlushMappedBufferRangeAPPLE,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
+GL_EXT(GL_ARB_map_buffer_range,-1,-1)
+GL_FUNC(GL_ARB_map_buffer_range,false,void*,glMapBufferRange,(GLenum a,GLintptr b,GLsizeiptr c,GLbitfield d),(a,b,c,d))
+GL_FUNC_VOID(GL_ARB_map_buffer_range,false,glFlushMappedBufferRange,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
+GL_EXT(GL_ARB_occlusion_query,-1,-1)
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glBeginQueryARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glEndQueryARB,(GLenum a),(a))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectivARB,(GLuint a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectuivARB,(GLuint a,GLenum b,GLuint *c),(a,b,c))
+GL_EXT(GL_APPLE_texture_range,-1,-1)
+GL_FUNC_VOID(GL_APPLE_texture_range,false,glTextureRangeAPPLE,(GLenum a,GLsizei b,void *c),(a,b,c))
+GL_FUNC_VOID(GL_APPLE_texture_range,false,glGetTexParameterPointervAPPLE,(GLenum a,GLenum b,void* *c),(a,b,c))
+GL_EXT(GL_APPLE_client_storage,-1,-1)
+GL_EXT(GL_ARB_uniform_buffer,-1,-1)
+GL_EXT(GL_ARB_vertex_array_bgra,-1,-1)
+GL_EXT(GL_EXT_vertex_array_bgra,-1,-1)
+GL_EXT(GL_ARB_framebuffer_object,3,0)
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindFramebuffer,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindRenderbuffer,(GLenum a,GLuint b),(a,b))
+GL_FUNC(GL_ARB_framebuffer_object,false,GLenum,glCheckFramebufferStatus,(GLenum a),(a))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteRenderbuffers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferRenderbuffer,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture2D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture3D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenFramebuffers,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenRenderbuffers,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteFramebuffers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBlitFramebuffer,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glRenderbufferStorageMultisample,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
+GL_EXT(GL_GREMEDY_string_marker,-1,-1)
+GL_FUNC_VOID(GL_GREMEDY_string_marker,false,glStringMarkerGREMEDY,(GLsizei a,const void *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPushClientAttrib,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glPopClientAttrib,(void),())
+
diff --git a/mp/src/public/togl/osx/glmdebug.h b/mp/src/public/togl/osx/glmdebug.h new file mode 100644 index 00000000..5981677d --- /dev/null +++ b/mp/src/public/togl/osx/glmdebug.h @@ -0,0 +1,157 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef GLMDEBUG_H
+#define GLMDEBUG_H
+
+#include "tier0/platform.h"
+#include <stdarg.h>
+
+// include this anywhere you need to be able to compile-out code related specifically to GLM debugging.
+
+// we expect DEBUG to be driven by the build system so you can include this header anywhere.
+// when we come out, GLMDEBUG will be defined to a value - 0, 1, or 2
+// 0 means no GLM debugging is possible
+// 1 means it's possible and resulted from being a debug build
+// 2 means it's possible and resulted from being manually forced on for a release build
+
+#ifdef POSIX
+ #ifndef GLMDEBUG
+ #ifdef DEBUG
+ #define GLMDEBUG 1 // normally 1 here, testing
+ #else
+ // #define GLMDEBUG 2 // don't check this in enabled..
+ #endif
+
+ #ifndef GLMDEBUG
+ #define GLMDEBUG 0
+ #endif
+ #endif
+#else
+ #ifndef GLMDEBUG
+ #define GLMDEBUG 0
+ #endif
+#endif
+
+
+//===============================================================================
+// debug channels
+
+enum EGLMDebugChannel
+{
+ ePrintf,
+ eDebugger,
+ eGLProfiler
+};
+
+#if GLMDEBUG
+ // make all these prototypes disappear in non GLMDEBUG
+ void GLMDebugInitialize( bool forceReinit=false );
+
+ bool GLMDetectOGLP( void );
+ bool GLMDetectGDB( void );
+ uint GLMDetectAvailableChannels( void );
+
+ uint GLMDebugChannelMask( uint *newValue = NULL );
+ // note that GDB and OGLP can both come and go during run - forceCheck will allow that to be detected.
+ // mask returned is in form of 1<<n, n from EGLMDebugChannel
+#endif
+
+//===============================================================================
+// debug message flavors
+
+enum EGLMDebugFlavor
+{
+ eAllFlavors, // 0
+ eDebugDump, // 1 debug dump flavor -D-
+ eTenure, // 2 code tenures > <
+ eComment, // 3 one off messages ---
+ eMatrixData, // 4 matrix data -M-
+ eShaderData, // 5 shader data (params) -S-
+ eFrameBufData, // 6 FBO data (attachments) -F-
+ eDXStuff, // 7 dxabstract spew -X-
+ eAllocations, // 8 tracking allocs and frees -A-
+ eSlowness, // 9 slow things happening (srgb flips..) -Z-
+ eDefaultFlavor, // not specified (no marker)
+ eFlavorCount
+};
+uint GLMDebugFlavorMask( uint *newValue = NULL );
+
+// make all these prototypes disappear in non GLMDEBUG
+#if GLMDEBUG
+ // these are unconditional outputs, they don't interrogate the string
+ void GLMStringOut( const char *string );
+ void GLMStringOutIndented( const char *string, int indentColumns );
+
+ #ifdef TOGL_DLL_EXPORT
+ // these will look at the string to guess its flavor: <, >, ---, -M-, -S-
+ DLL_EXPORT void GLMPrintfVA( const char *fmt, va_list vargs );
+ DLL_EXPORT void GLMPrintf( const char *fmt, ... );
+ #else
+ DLL_IMPORT void GLMPrintfVA( const char *fmt, va_list vargs );
+ DLL_IMPORT void GLMPrintf( const char *fmt, ... );
+ #endif
+
+ // these take an explicit flavor with a default value
+ void GLMPrintStr( const char *str, EGLMDebugFlavor flavor = eDefaultFlavor );
+
+ #define GLMPRINTTEXT_NUMBEREDLINES 0x80000000
+ void GLMPrintText( const char *str, EGLMDebugFlavor flavor = eDefaultFlavor, uint options=0 ); // indent each newline
+
+ int GLMIncIndent( int indentDelta );
+ int GLMGetIndent( void );
+ void GLMSetIndent( int indent );
+
+#endif
+
+// helpful macro if you are in a position to call GLM functions directly (i.e. you live in materialsystem / shaderapidx9)
+#if GLMDEBUG
+ #define GLMPRINTF(args) GLMPrintf args
+ #define GLMPRINTSTR(args) GLMPrintStr args
+ #define GLMPRINTTEXT(args) GLMPrintText args
+#else
+ #define GLMPRINTF(args)
+ #define GLMPRINTSTR(args)
+ #define GLMPRINTTEXT(args)
+#endif
+
+
+//===============================================================================
+// knob twiddling
+#ifdef TOGL_DLL_EXPORT
+ DLL_EXPORT float GLMKnob( char *knobname, float *setvalue ); // Pass NULL to not-set the knob value
+ DLL_EXPORT float GLMKnobToggle( char *knobname );
+#else
+ DLL_IMPORT float GLMKnob( char *knobname, float *setvalue ); // Pass NULL to not-set the knob value
+ DLL_IMPORT float GLMKnobToggle( char *knobname );
+#endif
+
+//===============================================================================
+// other stuff
+
+#if GLMDEBUG
+void GLMTriggerDebuggerBreak();
+inline void GLMDebugger( void )
+{
+ if (GLMDebugChannelMask() & (1<<eDebugger))
+ {
+ DebuggerBreak();
+ }
+
+ if (GLMDebugChannelMask() & (1<<eGLProfiler))
+ {
+ GLMTriggerDebuggerBreak();
+ }
+}
+#else
+ #define GLMDebugger() do { } while(0)
+#endif
+
+// helpers for CGLSetOption - no op if no profiler
+void GLMProfilerClearTrace( void );
+void GLMProfilerEnableTrace( bool enable );
+
+// helpers for CGLSetParameter - no op if no profiler
+void GLMProfilerDumpState( void );
+
+void CheckGLError( int line );
+
+#endif // GLMDEBUG_H
diff --git a/mp/src/public/togl/osx/glmdisplay.h b/mp/src/public/togl/osx/glmdisplay.h new file mode 100644 index 00000000..fdb594fe --- /dev/null +++ b/mp/src/public/togl/osx/glmdisplay.h @@ -0,0 +1,177 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmdisplay.h
+// display related stuff - used by both GLMgr and the CocoaMgr
+//
+//===============================================================================
+
+#ifndef GLMDISPLAY_H
+#define GLMDISPLAY_H
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#include <OpenGL/CGLTypes.h>
+#include <OpenGL/CGLRenderers.h>
+#include <OpenGL/CGLCurrent.h>
+
+typedef uint32_t CGDirectDisplayID;
+typedef uint32_t CGOpenGLDisplayMask;
+typedef double CGRefreshRate;
+
+//#include <ApplicationServices/ApplicationServices.h>
+#elif defined(LINUX)
+#include "tier0/platform.h"
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+typedef void _PseudoNSGLContext; // aka NSOpenGLContext
+typedef _PseudoNSGLContext *PseudoNSGLContextPtr;
+
+struct GLMDisplayModeInfoFields
+{
+ uint m_modePixelWidth;
+ uint m_modePixelHeight;
+ uint m_modeRefreshHz;
+ // are we even going to talk about bit depth... not yet
+};
+
+struct GLMDisplayInfoFields
+{
+#ifdef OSX
+ CGDirectDisplayID m_cgDisplayID;
+ CGOpenGLDisplayMask m_glDisplayMask; // result of CGDisplayIDToOpenGLDisplayMask on the cg_displayID.
+#endif
+ uint m_displayPixelWidth;
+ uint m_displayPixelHeight;
+};
+
+struct GLMRendererInfoFields
+{
+ /*properties of interest and their desired values.
+
+ kCGLRPFullScreen = 54, true
+ kCGLRPAccelerated = 73, true
+ kCGLRPWindow = 80, true
+
+ kCGLRPRendererID = 70, informational
+ kCGLRPDisplayMask = 84, informational
+ kCGLRPBufferModes = 100, informational
+ kCGLRPColorModes = 103, informational
+ kCGLRPAccumModes = 104, informational
+ kCGLRPDepthModes = 105, informational
+ kCGLRPStencilModes = 106, informational
+ kCGLRPMaxAuxBuffers = 107, informational
+ kCGLRPMaxSampleBuffers = 108, informational
+ kCGLRPMaxSamples = 109, informational
+ kCGLRPSampleModes = 110, informational
+ kCGLRPSampleAlpha = 111, informational
+ kCGLRPVideoMemory = 120, informational
+ kCGLRPTextureMemory = 121, informational
+ kCGLRPRendererCount = 128 number of renderers in the CGLRendererInfoObj under examination
+
+ kCGLRPOffScreen = 53, D/C
+ kCGLRPRobust = 75, FALSE or D/C - aka we're asking for no-fallback
+ kCGLRPBackingStore = 76, D/C
+ kCGLRPMPSafe = 78, D/C
+ kCGLRPMultiScreen = 81, D/C
+ kCGLRPCompliant = 83, D/C
+ */
+
+
+ //--------------------------- info we have from CGL renderer queries, IOKit, Gestalt
+ //--------------------------- these are set up in the displayDB by CocoaMgr
+ GLint m_fullscreen;
+ GLint m_accelerated;
+ GLint m_windowed;
+
+ GLint m_rendererID;
+ GLint m_displayMask;
+ GLint m_bufferModes;
+ GLint m_colorModes;
+ GLint m_accumModes;
+ GLint m_depthModes;
+ GLint m_stencilModes;
+
+ GLint m_maxAuxBuffers;
+ GLint m_maxSampleBuffers;
+ GLint m_maxSamples;
+ GLint m_sampleModes;
+ GLint m_sampleAlpha;
+
+ GLint m_vidMemory;
+ GLint m_texMemory;
+
+ uint m_pciVendorID;
+ uint m_pciDeviceID;
+ char m_pciModelString[64];
+ char m_driverInfoString[64];
+
+ //--------------------------- OS version related - set up by CocoaMgr
+
+ // OS version found
+ uint m_osComboVersion; // 0x00XXYYZZ : XX major, YY minor, ZZ minor minor : 10.6.3 --> 0x000A0603. 10.5.8 --> 0x000A0508.
+
+ //--------------------------- shorthands - also set up by CocoaMgr - driven by vendorid / deviceid
+
+ bool m_ati;
+ bool m_atiR5xx;
+ bool m_atiR6xx;
+ bool m_atiR7xx;
+ bool m_atiR8xx;
+ bool m_atiNewer;
+
+ bool m_intel;
+ bool m_intel95x;
+ bool m_intel3100;
+ bool m_intelNewer;
+
+ bool m_nv;
+ bool m_nvG7x;
+ bool m_nvG8x;
+ bool m_nvNewer;
+
+ //--------------------------- context query results - left blank in the display DB - but valid in a GLMContext (call ctx->Caps() to get a const ref)
+
+ // booleans
+ bool m_hasGammaWrites; // aka glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT) / glEnable(GL_FRAMEBUFFER_SRGB_EXT)
+ bool m_hasMixedAttachmentSizes; // aka ARB_fbo in 10.6.3 - test for min OS vers, then exported ext string
+ bool m_hasBGRA; // aka GL_BGRA vertex attribs in 10.6.3 - - test for min OS vers, then exported ext string
+ bool m_hasNewFullscreenMode; // aka 10.6.x "big window" fullscreen mode
+ bool m_hasNativeClipVertexMode; // aka GLSL gl_ClipVertex does not fall back to SW- OS version and folklore-based
+ bool m_hasOcclusionQuery; // occlusion query: do you speak it ?!
+ bool m_hasFramebufferBlit; // framebuffer blit: know what I'm sayin?!
+ bool m_hasPerfPackage1; // means new MTGL, fast OQ, fast uniform upload, NV can resolve flipped (late summer 2010 post 10.6.4 update)
+
+ // counts
+ int m_maxAniso; // aniso limit - context query
+
+ // other exts
+ bool m_hasBindableUniforms;
+ bool m_hasUniformBuffers;
+
+ // runtime options that aren't negotiable once set
+ bool m_hasDualShaders; // must supply CLI arg "-glmdualshaders" or we go GLSL only
+
+ //--------------------------- " can'ts " - specific problems that need to be worked around
+
+ bool m_cantBlitReliably; // Intel chipsets have problems blitting sRGB sometimes
+ bool m_cantAttachSRGB; // NV G8x on 10.5.8 can't have srgb tex on FBO color - separate issue from hasGammaWrites
+ bool m_cantResolveFlipped; // happens on NV in 10.6.4 and prior - console variable "gl_can_resolve_flipped" can overrule
+ bool m_cantResolveScaled; // happens everywhere per GL spec but may be relaxed some day - console variable "gl_can_resolve_scaled" can overrule
+ bool m_costlyGammaFlips; // this means that sRGB sampling state affects shader code gen, resulting in state-dependent code regen
+
+
+ //--------------------------- " bads " - known bad drivers
+ bool m_badDriver1064NV; // this is the bad NVIDIA driver on 10.6.4 - stutter, tex corruption, black screen issues
+};
+
+
+
+#endif
diff --git a/mp/src/public/togl/osx/glmdisplaydb.h b/mp/src/public/togl/osx/glmdisplaydb.h new file mode 100644 index 00000000..4588aff3 --- /dev/null +++ b/mp/src/public/togl/osx/glmdisplaydb.h @@ -0,0 +1,115 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef GLMDISPLAYDB_H
+#define GLMDISPLAYDB_H
+
+#include "tier1/utlvector.h"
+
+//===============================================================================
+
+// modes, displays, and renderers
+// think of renderers as being at the top of a tree.
+// each renderer has displays hanging off of it.
+// each display has modes hanging off of it.
+// the tree is populated on demand and then queried as needed.
+
+//===============================================================================
+
+// GLMDisplayModeInfoFields is in glmdisplay.h
+
+class GLMDisplayMode
+{
+public:
+ GLMDisplayModeInfoFields m_info;
+
+ GLMDisplayMode( uint width, uint height, uint refreshHz );
+ GLMDisplayMode() { };
+ ~GLMDisplayMode( void );
+
+
+ void Init( uint width, uint height, uint refreshHz );
+ void Dump( int which );
+};
+
+//===============================================================================
+
+// GLMDisplayInfoFields is in glmdisplay.h
+
+class GLMDisplayInfo
+{
+public:
+ GLMDisplayInfoFields m_info;
+ CUtlVector< GLMDisplayMode* > *m_modes; // starts out NULL, set by PopulateModes
+
+ GLMDisplayInfo( void );
+ ~GLMDisplayInfo( void );
+
+ void PopulateModes( void );
+
+ void Dump( int which );
+};
+
+//===============================================================================
+
+// GLMRendererInfoFields is in glmdisplay.h
+
+class GLMRendererInfo
+{
+public:
+ GLMRendererInfoFields m_info;
+ GLMDisplayInfo *m_display; // starts out NULL, set by PopulateDisplays
+
+ GLMRendererInfo ( GLMRendererInfoFields *info );
+ ~GLMRendererInfo ( void );
+
+ void PopulateDisplays();
+ void Dump( int which );
+};
+
+//===============================================================================
+
+// this is just a tuple describing fake adapters which are really renderer/display pairings.
+// dxabstract bridges the gap between the d3d adapter-centric world and the GL renderer+display world.
+// this makes it straightforward to handle cases like two video cards with two displays on one, and one on the other -
+// you get three fake adapters which represent each useful screen.
+
+// the constraint that dxa will have to follow though, is that if the user wants to change their
+// display selection for full screen, they would only be able to pick on that has the same underlying renderer.
+// can't change fakeAdapter from one to another with different GL renderer under it. Screen hop but no card hop.
+
+struct GLMFakeAdapter
+{
+ int m_rendererIndex;
+ int m_displayIndex;
+};
+
+class GLMDisplayDB
+{
+public:
+ CUtlVector< GLMRendererInfo* > *m_renderers; // starts out NULL, set by PopulateRenderers
+
+ CUtlVector< GLMFakeAdapter > m_fakeAdapters;
+
+ GLMDisplayDB ( void );
+ ~GLMDisplayDB ( void );
+
+ virtual void PopulateRenderers( void );
+ virtual void PopulateFakeAdapters( uint realRendererIndex ); // fake adapters = one real adapter times however many displays are on it
+ virtual void Populate( void );
+
+ // The info-get functions return false on success.
+ virtual int GetFakeAdapterCount( void );
+ virtual bool GetFakeAdapterInfo( int fakeAdapterIndex, int *rendererOut, int *displayOut, GLMRendererInfoFields *rendererInfoOut, GLMDisplayInfoFields *displayInfoOut );
+
+ virtual int GetRendererCount( void );
+ virtual bool GetRendererInfo( int rendererIndex, GLMRendererInfoFields *infoOut );
+
+ virtual int GetDisplayCount( int rendererIndex );
+ virtual bool GetDisplayInfo( int rendererIndex, int displayIndex, GLMDisplayInfoFields *infoOut );
+
+ virtual int GetModeCount( int rendererIndex, int displayIndex );
+ virtual bool GetModeInfo( int rendererIndex, int displayIndex, int modeIndex, GLMDisplayModeInfoFields *infoOut );
+
+ virtual void Dump( void );
+};
+
+#endif // GLMDISPLAYDB_H
diff --git a/mp/src/public/togl/osx/glmgr.h b/mp/src/public/togl/osx/glmgr.h new file mode 100644 index 00000000..1e951ca9 --- /dev/null +++ b/mp/src/public/togl/osx/glmgr.h @@ -0,0 +1,1088 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmgr.h
+// singleton class, common basis for managing GL contexts
+// responsible for tracking adapters and contexts
+//
+//===============================================================================
+
+#ifndef GLMGR_H
+#define GLMGR_H
+
+#pragma once
+
+#undef HAVE_GL_ARB_SYNC
+#ifdef LINUX
+#define HAVE_GL_ARB_SYNC 1
+#endif
+
+#include "glentrypoints.h"
+#include "glmdebug.h"
+#include "glmdisplay.h"
+#include "glmgrext.h"
+#include "glmgrbasics.h"
+#include "cglmtex.h"
+#include "cglmfbo.h"
+#include "cglmprogram.h"
+#include "cglmbuffer.h"
+#include "cglmquery.h"
+
+#include "tier0/vprof_telemetry.h"
+#include "materialsystem/ishader.h"
+#include "dxabstract_types.h"
+
+
+#ifdef LINUX
+#define Debugger DebuggerBreak
+#undef CurrentTime
+
+// prevent some conflicts in SDL headers...
+#undef M_PI
+#include <stdint.h>
+#ifndef _STDINT_H_
+#define _STDINT_H_ 1
+#endif
+
+#include "SDL/SDL.h"
+#endif
+
+//===============================================================================
+// glue to call out to Obj-C land (these are in glmgrcocoa.mm)
+#ifdef OSX
+PseudoNSGLContextPtr GetCurrentNSGLContext( );
+CGLContextObj GetCGLContextFromNSGL( PseudoNSGLContextPtr nsglCtx );
+#endif
+
+#include "tier0/dynfunction.h"
+
+//===============================================================================
+
+// parrot the D3D present parameters, more or less... "adapter" translates into "active display index" per the m_activeDisplayCount below.
+class GLMDisplayParams
+{
+ public:
+
+ // presumption, these indices are in sync with the current display DB that GLMgr has handy
+ //int m_rendererIndex; // index of renderer (-1 if root context)
+ //int m_displayIndex; // index of display in renderer - for FS
+ //int m_modeIndex; // index of mode in display - for FS
+
+ void *m_focusWindow; // (VD3DHWND aka WindowRef) - what window does this context display into
+
+ bool m_fsEnable; // fullscreen on or not
+ bool m_vsyncEnable; // vsync on or not
+
+ // height and width have to match the display mode info if full screen.
+
+ uint m_backBufferWidth; // pixel width (aka screen h-resolution if full screen)
+ uint m_backBufferHeight; // pixel height (aka screen v-resolution if full screen)
+ D3DFORMAT m_backBufferFormat; // pixel format
+ uint m_multiSampleCount; // 0 means no MSAA, 2 means 2x MSAA, etc
+ // uint m_multiSampleQuality; // no MSAA quality control yet
+
+ bool m_enableAutoDepthStencil; // generally set to 'TRUE' per CShaderDeviceDx8::SetPresentParameters
+ D3DFORMAT m_autoDepthStencilFormat;
+
+ uint m_fsRefreshHz; // if full screen, this refresh rate (likely 0 for LCD's)
+
+ //uint m_rootRendererID; // only used if m_rendererIndex is -1.
+ //uint m_rootDisplayMask; // only used if m_rendererIndex is -1.
+
+ bool m_mtgl; // enable multi threaded GL driver
+};
+
+//===============================================================================
+
+class GLMgr
+{
+public:
+
+ //===========================================================================
+ // class methods - singleton
+ static void NewGLMgr( void ); // instantiate singleton..
+ static GLMgr *aGLMgr( void ); // return singleton..
+ static void DelGLMgr( void ); // tear down singleton..
+
+ //===========================================================================
+ // plain methods
+
+ #if 0 // turned all these off while new approach is coded
+ void RefreshDisplayDB( void ); // blow away old display DB, make a new one
+ GLMDisplayDB *GetDisplayDB( void ); // get a ptr to the one GLMgr keeps. only valid til next refresh.
+
+ // eligible renderers will be ranked by desirability starting at index 0 within the db
+ // within each renderer, eligible displays will be ranked some kind of desirability (area? dist from menu bar?)
+ // within each display, eligible modes will be ranked by descending areas
+
+ // calls supplying indices are implicitly making reference to the current DB
+ bool CaptureDisplay( int rendIndex, int displayIndex, bool captureAll ); // capture one display or all displays
+ void ReleaseDisplays( void ); // release all captures
+
+ int GetDisplayMode( int rendIndex, int displayIndex ); // retrieve current display res (returns modeIndex)
+ void SetDisplayMode( GLMDisplayParams *params ); // set the display res (only useful for FS)
+ #endif
+
+ GLMContext *NewContext( GLMDisplayParams *params ); // this will have to change
+ void DelContext( GLMContext *context );
+
+ // with usage of CGLMacro.h we could dispense with the "current context" thing
+ // and just declare a member variable of GLMContext, allowing each glXXX call to be routed directly
+ // to the correct context
+ void SetCurrentContext( GLMContext *context ); // make current in calling thread only
+ GLMContext *GetCurrentContext( void );
+
+protected:
+ friend class GLMContext;
+
+ GLMgr();
+ ~GLMgr();
+};
+
+
+//===========================================================================//
+
+// helper function to do enable or disable in one step
+inline void glSetEnable( GLenum which, bool enable )
+{
+ if (enable)
+ gGL->glEnable(which);
+ else
+ gGL->glDisable(which);
+}
+
+// helper function for int vs enum clarity
+inline void glGetEnumv( GLenum which, GLenum *dst )
+{
+ gGL->glGetIntegerv( which, (int*)dst );
+}
+
+//===========================================================================//
+//
+// types to support the GLMContext
+//
+//===========================================================================//
+
+// Each state set/get path we are providing caching for, needs its own struct and a comparison operator.
+// we also provide an enum of how many such types there are, handy for building dirty masks etc.
+
+// shorthand macros
+#define EQ(fff) ( (src.fff) == (fff) )
+
+//rasterizer
+struct GLAlphaTestEnable_t { GLint enable; bool operator==(const GLAlphaTestEnable_t& src) const { return EQ(enable); } };
+struct GLAlphaTestFunc_t { GLenum func; GLclampf ref; bool operator==(const GLAlphaTestFunc_t& src) const { return EQ(func) && EQ(ref); } };
+struct GLCullFaceEnable_t { GLint enable; bool operator==(const GLCullFaceEnable_t& src) const { return EQ(enable); } };
+struct GLCullFrontFace_t { GLenum value; bool operator==(const GLCullFrontFace_t& src) const { return EQ(value); } };
+struct GLPolygonMode_t { GLenum values[2]; bool operator==(const GLPolygonMode_t& src) const { return EQ(values[0]) && EQ(values[1]); } };
+struct GLDepthBias_t { GLfloat factor; GLfloat units; bool operator==(const GLDepthBias_t& src) const { return EQ(factor) && EQ(units); } };
+struct GLScissorEnable_t { GLint enable; bool operator==(const GLScissorEnable_t& src) const { return EQ(enable); } };
+struct GLScissorBox_t { GLint x,y; GLsizei width, height; bool operator==(const GLScissorBox_t& src) const { return EQ(x) && EQ(y) && EQ(width) && EQ(height); } };
+struct GLAlphaToCoverageEnable_t{ GLint enable; bool operator==(const GLAlphaToCoverageEnable_t& src) const { return EQ(enable); } };
+struct GLViewportBox_t { GLint x,y; GLsizei width, height; bool operator==(const GLViewportBox_t& src) const { return EQ(x) && EQ(y) && EQ(width) && EQ(height); } };
+struct GLViewportDepthRange_t { GLdouble near,far; bool operator==(const GLViewportDepthRange_t& src) const { return EQ(near) && EQ(far); } };
+struct GLClipPlaneEnable_t { GLint enable; bool operator==(const GLClipPlaneEnable_t& src) const { return EQ(enable); } };
+struct GLClipPlaneEquation_t { GLfloat x,y,z,w; bool operator==(const GLClipPlaneEquation_t& src) const { return EQ(x) && EQ(y) && EQ(z) && EQ(w); } };
+
+//blend
+struct GLColorMaskSingle_t { char r,g,b,a; bool operator==(const GLColorMaskSingle_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLColorMaskMultiple_t { char r,g,b,a; bool operator==(const GLColorMaskMultiple_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLBlendEnable_t { GLint enable; bool operator==(const GLBlendEnable_t& src) const { return EQ(enable); } };
+struct GLBlendFactor_t { GLenum srcfactor,dstfactor; bool operator==(const GLBlendFactor_t& src) const { return EQ(srcfactor) && EQ(dstfactor); } };
+struct GLBlendEquation_t { GLenum equation; bool operator==(const GLBlendEquation_t& src) const { return EQ(equation); } };
+struct GLBlendColor_t { GLfloat r,g,b,a; bool operator==(const GLBlendColor_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLBlendEnableSRGB_t { GLint enable; bool operator==(const GLBlendEnableSRGB_t& src) const { return EQ(enable); } };
+
+//depth
+struct GLDepthTestEnable_t { GLint enable; bool operator==(const GLDepthTestEnable_t& src) const { return EQ(enable); } };
+struct GLDepthFunc_t { GLenum func; bool operator==(const GLDepthFunc_t& src) const { return EQ(func); } };
+struct GLDepthMask_t { char mask; bool operator==(const GLDepthMask_t& src) const { return EQ(mask); } };
+
+//stencil
+struct GLStencilTestEnable_t { GLint enable; bool operator==(const GLStencilTestEnable_t& src) const { return EQ(enable); } };
+struct GLStencilFunc_t { GLenum frontfunc, backfunc; GLint ref; GLuint mask; bool operator==(const GLStencilFunc_t& src) const { return EQ(frontfunc) && EQ(backfunc) && EQ(ref) && EQ(mask); } };
+struct GLStencilOp_t { GLenum sfail; GLenum dpfail; GLenum dppass; bool operator==(const GLStencilOp_t& src) const { return EQ(sfail) && EQ(dpfail) && EQ(dppass); } };
+struct GLStencilWriteMask_t { GLint mask; bool operator==(const GLStencilWriteMask_t& src) const { return EQ(mask); } };
+
+//clearing
+struct GLClearColor_t { GLfloat r,g,b,a; bool operator==(const GLClearColor_t& src) const { return EQ(r) && EQ(g) && EQ(b) && EQ(a); } };
+struct GLClearDepth_t { GLdouble d; bool operator==(const GLClearDepth_t& src) const { return EQ(d); } };
+struct GLClearStencil_t { GLint s; bool operator==(const GLClearStencil_t& src) const { return EQ(s); } };
+
+#undef EQ
+
+enum EGLMStateBlockType
+{
+ kGLAlphaTestEnable,
+ kGLAlphaTestFunc,
+
+ kGLCullFaceEnable,
+ kGLCullFrontFace,
+
+ kGLPolygonMode,
+
+ kGLDepthBias,
+
+ kGLScissorEnable,
+ kGLScissorBox,
+
+ kGLViewportBox,
+ kGLViewportDepthRange,
+
+ kGLClipPlaneEnable,
+ kGLClipPlaneEquation,
+
+ kGLColorMaskSingle,
+ kGLColorMaskMultiple,
+
+ kGLBlendEnable,
+ kGLBlendFactor,
+ kGLBlendEquation,
+ kGLBlendColor,
+ kGLBlendEnableSRGB,
+
+ kGLDepthTestEnable,
+ kGLDepthFunc,
+ kGLDepthMask,
+
+ kGLStencilTestEnable,
+ kGLStencilFunc,
+ kGLStencilOp,
+ kGLStencilWriteMask,
+
+ kGLClearColor,
+ kGLClearDepth,
+ kGLClearStencil,
+
+ kGLAlphaToCoverageEnable,
+
+ kGLMStateBlockLimit
+};
+
+//===========================================================================//
+
+// templated functions representing GL R/W bottlenecks
+// one set of set/get/getdefault is instantiated for each of the GL*** types above.
+
+// use these from the non array state objects
+template<typename T> void GLContextSet( T *src );
+template<typename T> void GLContextGet( T *dst );
+template<typename T> void GLContextGetDefault( T *dst );
+
+// use these from the array state objects
+template<typename T> void GLContextSetIndexed( T *src, int index );
+template<typename T> void GLContextGetIndexed( T *dst, int index );
+template<typename T> void GLContextGetDefaultIndexed( T *dst, int index );
+
+//===========================================================================//
+
+// caching state object template. One of these is instantiated in the context per unique struct type above
+template<typename T> class GLState
+{
+ public:
+
+ GLState<T>()
+ {
+ dirty = false;
+ memset( &data, 0, sizeof(data) );
+ };
+
+ // write: client src into cache
+ // common case is both false. dirty is calculated, context write is deferred.
+ void Write( T *src, bool noCompare=false, bool noDefer=false )
+ {
+ if (noCompare)
+ {
+ dirty = true;
+ }
+ else
+ {
+ // only == is implemented, so test for equal and negate
+ // note, you only set dirty if mismatch, you never clear it until flush
+ if ( !(data == *src) )
+ {
+ dirty = true;
+ }
+ }
+
+ data = *src;
+
+ if (noDefer)
+ {
+ Flush( true ); // dirty becomes false
+ }
+ };
+
+ // write cache->context if dirty or forced.
+ void Flush( bool noDefer=false )
+ {
+ if (dirty || noDefer)
+ {
+ GLContextSet( &data );
+ GLMCheckError();
+ // good place for some error checking here
+ dirty = false;
+ }
+ };
+
+ // default: write default value to cache, optionally write through
+ void Default( bool noDefer=false )
+ {
+ GLContextGetDefault( &data ); // read default values directly to our cache copy
+ dirty = true;
+ Flush(noDefer);
+ };
+
+ // read: sel = 0 for cache, 1 for context
+ void Read( T *dst, int sel )
+ {
+ if (sel==0)
+ {
+ *dst = data;
+ }
+ else
+ {
+ GLContextGet( dst );
+ GLMCheckError();
+ }
+ };
+
+ // check: verify that context equals cache, return true if mismatched or if illegal values seen
+ bool Check ( void )
+ {
+ T temp;
+ bool result;
+
+ GLContextGet( &temp );
+ GLMCheckError();
+ result = !(temp == data);
+ return result;
+ };
+
+ protected:
+ T data;
+ bool dirty;
+};
+
+// caching state object template - with multiple values behind it that are indexed
+template<typename T, int COUNT> class GLStateArray
+{
+ public:
+
+ GLStateArray<T,COUNT>()
+ {
+ memset( &dirty, 0, sizeof(dirty) );
+ memset( &data, 0, sizeof(data) );
+ };
+
+ // write: client src into cache
+ // common case is both false. dirty is calculated, context write is deferred.
+ void WriteIndex( T *src, int index, bool noCompare=false, bool noDefer=false )
+ {
+ if (noCompare)
+ {
+ dirty[index] = true;
+ }
+ else
+ {
+ // only == is implemented, so test for equal and negate
+ // note, you only set dirty if mismatch, you never clear it until flush
+ if (! (data[index] == *src) )
+ {
+ dirty[index] = true;
+ }
+ }
+
+ data[index] = *src;
+
+ if (noDefer)
+ {
+ FlushIndex( index, true ); // dirty becomes false
+ }
+ };
+
+ // write cache->context if dirty or forced.
+ void FlushIndex( int index, bool noDefer=false )
+ {
+ if (dirty[index] || noDefer)
+ {
+ GLContextSetIndexed( &data[index], index );
+ GLMCheckError();
+ dirty[index] = false;
+ }
+ };
+
+ // write all slots in the array
+ void Flush( bool noDefer=false )
+ {
+ for( int i=0; i<COUNT; i++)
+ {
+ FlushIndex( i, noDefer );
+ }
+ }
+
+ // default: write default value to cache, optionally write through
+ void DefaultIndex( int index, bool noDefer=false )
+ {
+ GLContextGetDefaultIndexed( &data[index], index ); // read default values directly to our cache copy
+ dirty[index] = true;
+ Flush(noDefer);
+ };
+
+ void Default( void )
+ {
+ for( int i=0; i<COUNT; i++)
+ {
+ DefaultIndex( i );
+ }
+ }
+
+ // read: sel = 0 for cache, 1 for context
+ void ReadIndex( T *dst, int index, int sel )
+ {
+ if (sel==0)
+ {
+ *dst = data[index];
+ }
+ else
+ {
+ GLContextGetIndexed( dst, index );
+ GLMCheckError();
+ }
+ };
+
+ // check: verify that context equals cache, return true if mismatched or if illegal values seen
+ bool CheckIndex( int index )
+ {
+ T temp;
+ bool result;
+
+ GLContextGetIndexed( &temp, index );
+ GLMCheckError();
+ result = !(temp == data[index]);
+
+ return result;
+ };
+
+ bool Check( void )
+ {
+ T temp;
+ bool result = false;
+
+ for( int i=0; i<COUNT; i++)
+ {
+ result |= CheckIndex( i );
+ }
+
+ return result;
+ };
+
+ protected:
+ T data [COUNT];
+ bool dirty [COUNT];
+};
+
+
+//===========================================================================//
+
+struct GLMTexSampler
+{
+ GLMTexSamplingParams m_samp;
+ CGLMTex *m_drawTex; // tex which must be bound at time of draw
+ CGLMTex *m_boundTex; // tex which is actually bound now (if does not match, a rebind is needed to draw)
+};
+
+#ifdef NEVER
+//===========================================================================//
+
+enum GLMVertexAttributeIndex
+{
+ kGLMGenericAttr00 = 0,
+ kGLMGenericAttr01,
+ kGLMGenericAttr02,
+ kGLMGenericAttr03,
+ kGLMGenericAttr04,
+ kGLMGenericAttr05,
+ kGLMGenericAttr06,
+ kGLMGenericAttr07,
+ kGLMGenericAttr08,
+ kGLMGenericAttr09,
+ kGLMGenericAttr10,
+ kGLMGenericAttr11,
+ kGLMGenericAttr12,
+ kGLMGenericAttr13,
+ kGLMGenericAttr14,
+ kGLMGenericAttr15,
+
+ kGLMVertexAttributeIndexMax // ideally < 32
+};
+
+struct GLMVertexAttributeDesc // all the info you need to do vertex setup for one attribute
+{
+ CGLMBuffer *m_buffer; // NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired
+ GLuint m_datasize; // comp count of the attribute (1-4)
+ GLenum m_datatype; // data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)
+ GLuint m_stride;
+ GLuint m_offset; // net offset to attribute 'zero' within the buffer.
+ GLboolean m_normalized; // apply to any fixed point data that needs normalizing, esp color bytes
+
+ // may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer
+ // simpler alternative is to do shoot-down inside the vertex/index buffer free calls.
+ // I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..
+
+#define EQ(fff) ( (src.fff) == (fff) )
+ // test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..
+ bool operator==(const GLMVertexAttributeDesc& src) const { return EQ(m_buffer) && EQ(m_offset) && EQ(m_stride) && EQ(m_datatype) && EQ(m_normalized) && EQ(m_datasize); }
+#undef EQ
+
+ uint m_bufferRevision; // only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event
+};
+
+// GLMContext will maintain one of these structures inside the context to represent the current state.
+// Client can supply a new one when it wants to change the setup.
+//FIXME GLMContext can do the work to migrate from old setup to new setup as efficiently as possible (but it doesn't yet)
+#endif
+
+struct GLMVertexSetup
+{
+ uint m_attrMask; // which attrs are enabled (1<<n) mask where n is a GLMVertexAttributeIndex.
+
+ GLMVertexAttributeDesc m_attrs[ kGLMVertexAttributeIndexMax ];
+
+ // copied in from dxabstract, not strictly needed for operation, helps debugging
+ unsigned char m_vtxAttribMap[16];
+
+ /* high nibble is usage per _D3DDECLUSAGE
+ typedef enum _D3DDECLUSAGE
+ {
+ D3DDECLUSAGE_POSITION = 0,
+ D3DDECLUSAGE_BLENDWEIGHT = 1,
+ D3DDECLUSAGE_BLENDINDICES = 2,
+ D3DDECLUSAGE_NORMAL = 3,
+ D3DDECLUSAGE_PSIZE = 4,
+ D3DDECLUSAGE_TEXCOORD = 5,
+ D3DDECLUSAGE_TANGENT = 6,
+ D3DDECLUSAGE_BINORMAL = 7,
+ D3DDECLUSAGE_TESSFACTOR = 8,
+ D3DDECLUSAGE_PLUGH = 9, // mystery value
+ D3DDECLUSAGE_COLOR = 10,
+ D3DDECLUSAGE_FOG = 11,
+ D3DDECLUSAGE_DEPTH = 12,
+ D3DDECLUSAGE_SAMPLE = 13,
+ } D3DDECLUSAGE;
+
+ low nibble is usageindex (i.e. POSITION0, POSITION1, etc)
+ array position is attrib number.
+ */
+};
+
+//===========================================================================//
+
+//FIXME magic numbers here
+
+#define kGLMProgramParamFloat4Limit 256
+#define kGLMProgramParamBoolLimit 16
+#define kGLMProgramParamInt4Limit 16
+
+#define kGLMVertexProgramParamFloat4Limit 256
+#define kGLMFragmentProgramParamFloat4Limit 32
+
+struct GLMProgramParamsF
+{
+ float m_values[kGLMProgramParamFloat4Limit][4]; // float4's 256 of them
+ uint m_dirtySlotCount; // index of slot past highest dirty (assume 0 for base of range)
+};
+
+struct GLMProgramParamsB
+{
+ int m_values[kGLMProgramParamBoolLimit]; // bools, 4 of them
+ uint m_dirtySlotCount;
+};
+
+struct GLMProgramParamsI
+{
+ int m_values[kGLMProgramParamInt4Limit][4]; // int4s, 16 of them
+ uint m_dirtySlotCount;
+};
+
+enum EGLMParamWriteMode
+{
+ eParamWriteAllSlots, // glUniform4fv of the maximum size (not recommended if shader is down-sizing the decl)
+ eParamWriteShaderSlots, // glUniform4fv of the active slot count ("highwater")
+ eParamWriteShaderSlotsOptional, // glUniform4fv of the active slot count ("highwater") - but only if at least one has been written - it's optional
+ eParamWriteDirtySlotRange // glUniform4fv of the 0-N range where N is highest dirty slot
+};
+
+enum EGLMAttribWriteMode
+{
+ eAttribWriteAll,
+ eAttribWriteDirty
+};
+
+//===========================================================================//
+
+#if GLMDEBUG
+enum EGLMDebugCallSite
+{
+ eBeginFrame, // inside begin frame func - frame number has been inc'd, batch number should be -1
+ eClear, // inside clear func
+ eDrawElements, // inside repeat loop, prior to draw call - batch numberhas been inc'd
+ eEndFrame, // end frame
+ ePresent // before showing pixels
+};
+
+// caller should zero one of these out and fill in the m_caller before invoking the hook
+struct GLMDebugHookInfo
+{
+ // info from the caller to the debug hook
+ EGLMDebugCallSite m_caller;
+
+
+ // state the hook uses to keep track of progress within a single run of the caller
+ int m_iteration; // which call to the hook is this. if it's zero, it precedes any action in the caller.
+
+
+ // bools used to communicate between caller and hook
+ bool m_loop; // hook tells caller to loop around again (don't exit)
+ bool m_holding; // current mood of hook, are we holding on this batch (i.e. rerun)
+
+ // specific info for a draw call
+ GLenum m_drawMode;
+ GLuint m_drawStart;
+ GLuint m_drawEnd;
+ GLsizei m_drawCount;
+ GLenum m_drawType;
+ const GLvoid *m_drawIndices;
+};
+#endif
+
+//===========================================================================//
+
+#define kGLMUserClipPlanes 2
+#define kGLMScratchFBOCount 4
+
+class GLMContext
+{
+ public:
+ // set/check current context (perq for many other calls)
+ void MakeCurrent( bool bRenderThread = false );
+ void ReleaseCurrent( bool bRenderThread = false );
+
+ // CheckCurrent has been removed (it no longer compiled). To minimize churn I'm leaving
+ // the inline NOP version.
+ // DO NOT change this to non-inlined. It's called all over the place from very hot codepaths.
+ FORCEINLINE void CheckCurrent( void ) { }
+
+ void PopulateCaps( void ); // fill out later portions of renderer info record which need context queries
+ void DumpCaps( void ); // printf all the caps info (you can call this in release too)
+ const GLMRendererInfoFields& Caps( void ); // peek at the caps record
+
+ // state cache/mirror
+ void SetDefaultStates( void );
+ void FlushStates( bool noDefer = false );
+ void VerifyStates( void );
+
+ // textures
+ // Lock and Unlock reqs go directly to the tex object
+ CGLMTex *NewTex( GLMTexLayoutKey *key, char *debugLabel=NULL );
+ void DelTex( CGLMTex *tex );
+
+ // options for Blit (replacement for ResolveTex and BlitTex)
+ // pass NULL for dstTex if you want to target GL_BACK with the blit. You get y-flip with that, don't change the dstrect yourself.
+ void Blit2( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter );
+
+ // tex blit (via FBO blit)
+ void BlitTex( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter, bool useBlitFB = true );
+
+ // MSAA resolve - we do this in GLMContext because it has to do a bunch of FBO/blit gymnastics
+ void ResolveTex( CGLMTex *tex, bool forceDirty=false );
+
+ // texture pre-load (residency forcing) - normally done one-time but you can force it
+ void PreloadTex( CGLMTex *tex, bool force=false );
+
+ // samplers
+ void SetSamplerTex( int sampler, CGLMTex *tex );
+ void SetSamplerParams( int sampler, GLMTexSamplingParams *params );
+
+ // render targets (FBO's)
+ CGLMFBO *NewFBO( void );
+ void DelFBO( CGLMFBO *fbo );
+ void SetDrawingFBO( CGLMFBO *fbo ); // as with samplers, the notion of the target FBO is latched til draw time and then checked
+
+ // programs
+ CGLMProgram *NewProgram( EGLMProgramType type, char *progString );
+ void DelProgram( CGLMProgram *prog );
+ void NullProgram( void ); // de-ac all shader state
+
+ void SetDrawingProgram( EGLMProgramType type, CGLMProgram *prog ); // set NULL for no program
+ void SetDrawingLang( EGLMProgramLang lang, bool immediate=false ); // choose ARB or GLSL. immediate=false defers lang change to top of frame
+
+ void LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp ); // ensure this combo has been linked and is in the GLSL pair cache
+ void ClearShaderPairCache( void ); // call this to shoot down all the linked pairs
+ void QueryShaderPair( int index, GLMShaderPairInfo *infoOut ); // this lets you query the shader pair cache for saving its state
+
+ // buffers
+ // Lock and Unlock reqs go directly to the buffer object
+ CGLMBuffer *NewBuffer( EGLMBufferType type, uint size, uint options );
+ void DelBuffer( CGLMBuffer *buff );
+
+ void SetIndexBuffer( CGLMBuffer *buff );
+ void SetVertexAttributes( GLMVertexSetup *setup );
+ // note, no API is exposed for setting a single attribute source.
+ // come prepared with a complete block of attributes to use.
+
+ // Queries
+ CGLMQuery *NewQuery( GLMQueryParams *params );
+ void DelQuery( CGLMQuery *query );
+
+ // "slot" means a vec4-sized thing
+ // these write into .env parameter space
+ void SetProgramParametersF( EGLMProgramType type, uint baseSlot, float *slotData, uint slotCount ); // take vec4f's
+ void SetProgramParametersB( EGLMProgramType type, uint baseSlot, int *slotData, uint boolCount ); // take "BOOL" aka int
+ void SetProgramParametersI( EGLMProgramType type, uint baseSlot, int *slotData, uint slotCount ); // take int4s
+
+ // state sync
+ void FlushDrawStates( bool shadersOn=true ); // pushes all drawing state - samplers, tex, programs, etc.
+
+ // drawing
+ void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
+ void CheckNative( void );
+
+ // clearing
+ void Clear( bool color, unsigned long colorValue, bool depth, float depthValue, bool stencil, unsigned int stencilValue, GLScissorBox_t *rect = NULL );
+
+ // display
+ //void SetVSyncEnable( bool vsyncOn );
+ //void SetFullScreen( bool fsOn, int screenIndex ); // will be latched for next BeginFrame
+ //void ActivateFullScreen( bool fsOn, int screenIndex ); // will be called by BeginFrame
+ bool SetDisplayParams( GLMDisplayParams *params ); // either the first time setup, or a change to new setup
+
+ void Present( CGLMTex *tex ); // somewhat hardwired for the time being
+
+ // mode switch / reset
+ void Reset( void ); // not a lot of args for now..
+
+ // writers for the state block inputs
+
+ void WriteAlphaTestEnable ( GLAlphaTestEnable_t *src );
+ void WriteAlphaTestFunc ( GLAlphaTestFunc_t *src );
+ void WriteCullFaceEnable ( GLCullFaceEnable_t *src );
+ void WriteCullFrontFace ( GLCullFrontFace_t *src );
+ void WritePolygonMode ( GLPolygonMode_t *src );
+ void WriteDepthBias ( GLDepthBias_t *src );
+ void WriteClipPlaneEnable ( GLClipPlaneEnable_t *src, int which );
+ void WriteClipPlaneEquation ( GLClipPlaneEquation_t *src, int which );
+ void WriteScissorEnable ( GLScissorEnable_t *src );
+ void WriteScissorBox ( GLScissorBox_t *src );
+ void WriteAlphaToCoverageEnable ( GLAlphaToCoverageEnable_t *src );
+ void WriteViewportBox ( GLViewportBox_t *src );
+ void WriteViewportDepthRange ( GLViewportDepthRange_t *src );
+ void WriteColorMaskSingle ( GLColorMaskSingle_t *src );
+ void WriteColorMaskMultiple ( GLColorMaskMultiple_t *src, int which );
+ void WriteBlendEnable ( GLBlendEnable_t *src );
+ void WriteBlendFactor ( GLBlendFactor_t *src );
+ void WriteBlendEquation ( GLBlendEquation_t *src );
+ void WriteBlendColor ( GLBlendColor_t *src );
+ void WriteBlendEnableSRGB ( GLBlendEnableSRGB_t *src );
+ void WriteDepthTestEnable ( GLDepthTestEnable_t *src );
+ void WriteDepthFunc ( GLDepthFunc_t *src );
+ void WriteDepthMask ( GLDepthMask_t *src );
+ void WriteStencilTestEnable ( GLStencilTestEnable_t *src );
+ void WriteStencilFunc ( GLStencilFunc_t *src );
+ void WriteStencilOp ( GLStencilOp_t *src, int which );
+ void WriteStencilWriteMask ( GLStencilWriteMask_t *src );
+ void WriteClearColor ( GLClearColor_t *src );
+ void WriteClearDepth ( GLClearDepth_t *src );
+ void WriteClearStencil ( GLClearStencil_t *src );
+
+
+ // debug stuff
+ void BeginFrame( void );
+ void EndFrame( void );
+
+ // new interactive debug stuff
+#if GLMDEBUG
+ void DebugDump( GLMDebugHookInfo *info, uint options, uint vertDumpMode );
+ void DebugHook( GLMDebugHookInfo *info );
+ void DebugPresent( void );
+ void DebugClear( void );
+#endif
+
+ FORCEINLINE DWORD GetCurrentOwnerThreadId() const { return m_nCurOwnerThreadId; }
+
+ protected:
+ friend class GLMgr; // only GLMgr can make GLMContext objects
+ friend class GLMRendererInfo; // only GLMgr can make GLMContext objects
+ friend class CGLMTex; // tex needs to be able to do binds
+ friend class CGLMFBO; // fbo needs to be able to do binds
+ friend class CGLMProgram;
+ friend class CGLMShaderPair;
+ friend class CGLMShaderPairCache;
+ friend class CGLMBuffer;
+ friend class GLMTester; // tester class needs access back into GLMContext
+
+ friend class IDirect3D9;
+ friend class IDirect3DDevice9;
+
+ // methods------------------------------------------
+
+ // old GLMContext( GLint displayMask, GLint rendererID, PseudoNSGLContextPtr nsglShareCtx );
+ GLMContext( GLMDisplayParams *params );
+ ~GLMContext();
+
+ // textures
+ void SelectTMU( int tmu ); // wrapper for glActiveTexture()
+ int BindTexToTMU( CGLMTex *tex, int tmu, bool noCheck=false );
+
+ // render targets / FBO's
+ void BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint = GL_FRAMEBUFFER_EXT ); // you can also choose GL_READ_FRAMEBUFFER_EXT / GL_DRAW_FRAMEBUFFER_EXT
+
+ // programs
+ //void BindProgramToCtx( EGLMProgramType type, CGLMProgram *prog ); // will set program mode enable appropriately
+
+ // buffers
+ void BindBufferToCtx( EGLMBufferType type, CGLMBuffer *buff, bool force = false ); // does not twiddle any enables.
+
+ // debug font
+ void GenDebugFontTex( void );
+ void DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string );
+
+ // members------------------------------------------
+
+ // context
+ DWORD m_nCurOwnerThreadId;
+
+ GLMRendererInfoFields m_caps;
+
+ bool m_displayParamsValid; // is there a param block copied in yet
+ GLMDisplayParams m_displayParams; // last known display config, either via constructor, or by SetDisplayParams...
+
+#if defined(USE_SDL)
+ int m_pixelFormatAttribs[100]; // more than enough
+ void * m_ctx;
+#endif
+
+ // texture form table
+ CGLMTexLayoutTable *m_texLayoutTable;
+
+ // context state mirrors
+
+ GLState<GLAlphaTestEnable_t> m_AlphaTestEnable;
+
+ GLState<GLAlphaTestFunc_t> m_AlphaTestFunc;
+
+ GLState<GLCullFaceEnable_t> m_CullFaceEnable;
+ GLState<GLCullFrontFace_t> m_CullFrontFace;
+ GLState<GLPolygonMode_t> m_PolygonMode;
+
+ GLState<GLDepthBias_t> m_DepthBias;
+
+ GLStateArray<GLClipPlaneEnable_t,kGLMUserClipPlanes> m_ClipPlaneEnable;
+ GLStateArray<GLClipPlaneEquation_t,kGLMUserClipPlanes> m_ClipPlaneEquation; // dxabstract puts them directly into param slot 253(0) and 254(1)
+
+ GLState<GLScissorEnable_t> m_ScissorEnable;
+ GLState<GLScissorBox_t> m_ScissorBox;
+
+ GLState<GLAlphaToCoverageEnable_t> m_AlphaToCoverageEnable;
+
+ GLState<GLViewportBox_t> m_ViewportBox;
+ GLState<GLViewportDepthRange_t> m_ViewportDepthRange;
+
+ GLState<GLColorMaskSingle_t> m_ColorMaskSingle;
+ GLStateArray<GLColorMaskMultiple_t,8> m_ColorMaskMultiple; // need an official constant for the color buffers limit
+
+ GLState<GLBlendEnable_t> m_BlendEnable;
+ GLState<GLBlendFactor_t> m_BlendFactor;
+ GLState<GLBlendEquation_t> m_BlendEquation;
+ GLState<GLBlendColor_t> m_BlendColor;
+ GLState<GLBlendEnableSRGB_t> m_BlendEnableSRGB; // write to this one to transmit intent to write SRGB encoded pixels to drawing FB
+ bool m_FakeBlendEnableSRGB; // writes to above will be shunted here if fake SRGB is in effect.
+
+ GLState<GLDepthTestEnable_t> m_DepthTestEnable;
+ GLState<GLDepthFunc_t> m_DepthFunc;
+ GLState<GLDepthMask_t> m_DepthMask;
+
+ GLState<GLStencilTestEnable_t> m_StencilTestEnable; // global stencil test enable
+ GLState<GLStencilFunc_t> m_StencilFunc; // holds front and back stencil funcs
+ GLStateArray<GLStencilOp_t,2> m_StencilOp; // indexed: 0=front 1=back
+ GLState<GLStencilWriteMask_t> m_StencilWriteMask;
+
+ GLState<GLClearColor_t> m_ClearColor;
+ GLState<GLClearDepth_t> m_ClearDepth;
+ GLState<GLClearStencil_t> m_ClearStencil;
+
+ // texture bindings and sampler setup
+ int m_activeTexture; // mirror for glActiveTexture
+ GLMTexSampler m_samplers[GLM_SAMPLER_COUNT];
+
+ // texture lock tracking - CGLMTex objects share usage of this
+ CUtlVector< GLMTexLockDesc > m_texLocks;
+
+ // render target binding - check before draw
+ // similar to tex sampler mechanism, we track "bound" from "chosen for drawing" separately,
+ // so binding for creation/setup need not disrupt any notion of what will be used at draw time
+
+ CGLMFBO *m_boundDrawFBO; // FBO on GL_DRAW_FRAMEBUFFER bind point
+ CGLMFBO *m_boundReadFBO; // FBO on GL_READ_FRAMEBUFFER bind point
+ // ^ both are set if you bind to GL_FRAMEBUFFER_EXT
+
+ CGLMFBO *m_drawingFBO; // what FBO should be bound at draw time (to both read/draw bp's).
+
+ CGLMFBO *m_blitReadFBO;
+ CGLMFBO *m_blitDrawFBO; // scratch FBO's for framebuffer blit
+
+ CGLMFBO *m_scratchFBO[ kGLMScratchFBOCount ]; // general purpose FBO's for internal use
+
+ CUtlVector< CGLMFBO* > m_fboTable; // each live FBO goes in the table
+
+ // program bindings
+ EGLMProgramLang m_drawingLangAtFrameStart; // selector for start of frame (spills into m_drawingLang)
+ EGLMProgramLang m_drawingLang; // selector for which language we desire to draw with on the next batch
+ CGLMProgram *m_drawingProgram[ kGLMNumProgramTypes ];
+
+ GLMProgramParamsF m_programParamsF[ kGLMNumProgramTypes ];
+ GLMProgramParamsB m_programParamsB[ kGLMNumProgramTypes ]; // two banks, but only the vertex one is used
+ GLMProgramParamsI m_programParamsI[ kGLMNumProgramTypes ]; // two banks, but only the vertex one is used
+ EGLMParamWriteMode m_paramWriteMode;
+
+ CGLMProgram *m_nullFragmentProgram; // write opaque black. Activate when caller asks for null FP
+
+ CGLMProgram *m_preloadTexVertexProgram; // programs to help preload textures (dummies)
+ CGLMProgram *m_preload2DTexFragmentProgram;
+ CGLMProgram *m_preload3DTexFragmentProgram;
+ CGLMProgram *m_preloadCubeTexFragmentProgram;
+
+ CGLMProgram *m_boundProgram[ kGLMNumProgramTypes ];
+
+ CGLMShaderPairCache *m_pairCache; // GLSL only
+ CGLMShaderPair *m_boundPair; // GLSL only
+ uint m_boundPairRevision; // GLSL only
+ GLhandleARB m_boundPairProgram; // GLSL only
+
+ // buffer bindings
+ CGLMBuffer *m_lastKnownBufferBinds[ kGLMNumBufferTypes ]; // tracked per bind point for dupe-bind-absorb
+ GLMVertexAttributeDesc m_lastKnownVertexAttribs[ kGLMVertexAttributeIndexMax ]; // tracked per attrib for dupe-set-absorb
+ uint m_lastKnownVertexAttribMask; // tracked for dupe-enable-absorb
+
+ CGLMBuffer *m_drawIndexBuffer; // ... ? do we need dupe tracking for index buffer setup? ?
+
+ GLMVertexSetup m_drawVertexSetup;
+
+ EGLMAttribWriteMode m_attribWriteMode;
+
+ bool m_slowCheckEnable; // turn this on or no native checking is done ("-glmassertslow" or "-glmsspewslow")
+ bool m_slowAssertEnable; // turn this on to assert on a non-native batch "-glmassertslow"
+ bool m_slowSpewEnable; // turn this on to log non-native batches to stdout "-glmspewslow"
+
+ // debug font texture
+ CGLMTex *m_debugFontTex; // might be NULL unless you call GenDebugFontTex
+ CGLMBuffer *m_debugFontIndices; // up to 1024 indices (256 chars times 4)
+ CGLMBuffer *m_debugFontVertices; // up to 1024 verts
+
+ // batch/frame debugging support
+ int m_debugFrameIndex; // init to -1. Increment at BeginFrame
+ int m_debugBatchIndex; // init to -1. Increment at any draw call
+
+#if GLMDEBUG
+ // interactive (DebugHook) debug support
+
+ // using these you can implement frame advance, batch single step, and batch rewind (let it run til next frame and hold on prev batch #)
+ int m_holdFrameBegin; // -1 if no hold req'd, otherwise # of frame to hold at (at beginframe time)
+ int m_holdFrameEnd; // -1 if no hold req'd, otherwise # of frame to hold at (at endframe time)
+
+ int m_holdBatch,m_holdBatchFrame; // -1 if no hold, else # of batch&frame to hold at (both must be set)
+ // these can be expired/cleared to -1 if the frame passes without a hit
+ // may be desirable to re-pause in that event, as user was expecting a hold to occur
+
+ bool m_debugDelayEnable; // allow sleep delay
+ uint m_debugDelay; // sleep time per hook call in microseconds (for usleep())
+
+ // pre-draw global toggles / options
+ bool m_autoClearColor,m_autoClearDepth,m_autoClearStencil;
+ float m_autoClearColorValues[4];
+
+ // debug knobs
+ int m_selKnobIndex;
+ float m_selKnobMinValue,m_selKnobMaxValue,m_selKnobIncrement;
+#endif
+
+};
+
+struct GLMTestParams
+{
+ GLMContext *m_ctx;
+ int *m_testList; // -1 termed
+
+ bool m_glErrToDebugger;
+ bool m_glErrToConsole;
+
+ bool m_intlErrToDebugger;
+ bool m_intlErrToConsole;
+
+ int m_frameCount; // how many frames to test.
+};
+
+class GLMTester
+{
+ public:
+
+ GLMTester(GLMTestParams *params);
+ ~GLMTester();
+
+
+ // optionally callable by test routines to get basic drawables wired up
+ void StdSetup( void );
+ void StdCleanup( void );
+
+ // callable by test routines to clear the frame or present it
+ void Clear( void );
+ void Present( int seed );
+
+ // error reporting
+ void CheckGLError( char *comment ); // obey m_params setting for console / debugger response
+ void InternalError( int errcode, char *comment ); // if errcode!=0, obey m_params setting for console / debugger response
+
+ void RunTests();
+
+ void RunOneTest( int testindex );
+
+ // test routines themselves
+ void Test0();
+ void Test1();
+ void Test2();
+ void Test3();
+
+ GLMTestParams m_params; // copy of caller's params, do not mutate...
+
+ // std-setup stuff
+ int m_drawWidth, m_drawHeight;
+ CGLMFBO *m_drawFBO;
+ CGLMTex *m_drawColorTex;
+ CGLMTex *m_drawDepthTex;
+};
+
+class CShowPixelsParams
+{
+public:
+ GLuint m_srcTexName;
+ int m_width,m_height;
+ bool m_vsyncEnable;
+ bool m_fsEnable; // want receiving view to be full screen. for now, just target the main screen. extend later.
+ bool m_useBlit; // use FBO blit - sending context says it is available.
+ bool m_noBlit; // the back buffer has already been populated by the caller (perhaps via direct MSAA resolve from multisampled RT tex)
+ bool m_onlySyncView; // react to full/windowed state change only, do not present bits
+};
+
+
+#define kMaxCrawlFrames 100
+#define kMaxCrawlText (kMaxCrawlFrames * 256)
+class CStackCrawlParams
+{
+ public:
+ uint m_frameLimit; // input: max frames to retrieve
+ uint m_frameCount; // output: frames found
+ void *m_crawl[kMaxCrawlFrames]; // call site addresses
+ char *m_crawlNames[kMaxCrawlFrames]; // pointers into text following, one per decoded name
+ char m_crawlText[kMaxCrawlText];
+};
+
+#endif
diff --git a/mp/src/public/togl/osx/glmgrbasics.h b/mp/src/public/togl/osx/glmgrbasics.h new file mode 100644 index 00000000..559bc10f --- /dev/null +++ b/mp/src/public/togl/osx/glmgrbasics.h @@ -0,0 +1,299 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmgrbasics.h
+// types, common headers, forward declarations, utilities
+//
+//===============================================================================
+
+#ifndef GLMBASICS_H
+#define GLMBASICS_H
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#include <OpenGL/CGLTypes.h>
+#include <OpenGL/CGLRenderers.h>
+#include <OpenGL/CGLCurrent.h>
+#include <OpenGL/CGLProfiler.h>
+//#include <ApplicationServices/ApplicationServices.h>
+#elif defined(LINUX)
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+#include "tier0/platform.h"
+
+#include "bitmap/imageformat.h"
+#include "bitvec.h"
+#include "tier1/checksum_md5.h"
+#include "tier1/utlvector.h"
+#include "tier1/convar.h"
+
+#include <sys/stat.h>
+
+#include "dxabstract_types.h"
+
+// types
+struct GLMRect;
+typedef void *PseudoGLContextPtr;
+
+
+ // 3-d integer box (used for texture lock/unlock etc)
+struct GLMRegion
+{
+ int xmin,xmax;
+ int ymin,ymax;
+ int zmin,zmax;
+};
+
+struct GLMRect // follows GL convention - if coming from the D3D rect you will need to fiddle the Y's
+{
+ int xmin; // left
+ int ymin; // bottom
+ int xmax; // right
+ int ymax; // top
+};
+
+// macros
+
+//#define GLMassert(x) assert(x)
+
+// forward decls
+class GLMgr; // singleton
+class GLMContext; // GL context
+class CGLMContextTester; // testing class
+class CGLMTex;
+class CGLMFBO;
+class CGLMProgram;
+class CGLMBuffer;
+
+
+// utilities
+
+typedef enum
+{
+ // D3D codes
+ eD3D_DEVTYPE,
+ eD3D_FORMAT,
+ eD3D_RTYPE,
+ eD3D_USAGE,
+ eD3D_RSTATE, // render state
+ eD3D_SIO, // D3D shader bytecode
+ eD3D_VTXDECLUSAGE,
+
+ // CGL codes
+ eCGL_RENDID,
+
+ // OpenGL error codes
+ eGL_ERROR,
+
+ // OpenGL enums
+ eGL_ENUM,
+ eGL_RENDERER
+
+} GLMThing_t;
+
+const char* GLMDecode( GLMThing_t type, unsigned long value ); // decode a numeric const
+const char* GLMDecodeMask( GLMThing_t type, unsigned long value ); // decode a bitmask
+
+void GLMStop( void ); // aka Debugger()
+void GLMCheckError( bool noStop = false, bool noLog= false );
+void GLMEnableTrace( bool on );
+
+// expose these in release now
+// Mimic PIX events so we can decorate debug spew
+void GLMBeginPIXEvent( const char *str );
+void GLMEndPIXEvent( void );
+
+//===============================================================================
+// knob twiddling
+float GLMKnob( char *knobname, float *setvalue ); // Pass NULL to not-set the knob value
+float GLMKnobToggle( char *knobname );
+
+//===============================================================================
+// other stuff
+
+// helpers for CGLSetOption - no op if no profiler
+void GLMProfilerClearTrace( void );
+void GLMProfilerEnableTrace( bool enable );
+
+// helpers for CGLSetParameter - no op if no profiler
+void GLMProfilerDumpState( void );
+
+
+//===============================================================================
+// classes
+
+// helper class making function tracking easier to wire up
+#if GLMDEBUG
+class GLMFuncLogger
+{
+ public:
+
+ // simple function log
+ GLMFuncLogger( const char *funcName )
+ {
+ m_funcName = funcName;
+ m_earlyOut = false;
+
+ GLMPrintf( ">%s", m_funcName );
+ };
+
+ // more advanced version lets you pass args (i.e. called parameters or anything else of interest)
+ // no macro for this one, since no easy way to pass through the args as well as the funcname
+ GLMFuncLogger( const char *funcName, char *fmt, ... )
+ {
+ m_funcName = funcName;
+ m_earlyOut = false;
+
+ // this acts like GLMPrintf here
+ // all the indent policy is down in GLMPrintfVA
+ // which means we need to inject a ">" at the front of the format string to make this work... sigh.
+
+ char modifiedFmt[2000];
+ modifiedFmt[0] = '>';
+ strcpy( modifiedFmt+1, fmt );
+
+ va_list vargs;
+ va_start(vargs, fmt);
+ GLMPrintfVA( modifiedFmt, vargs );
+ va_end( vargs );
+ }
+
+ ~GLMFuncLogger( )
+ {
+ if (m_earlyOut)
+ {
+ GLMPrintf( "<%s (early out)", m_funcName );
+ }
+ else
+ {
+ GLMPrintf( "<%s", m_funcName );
+ }
+ };
+
+ void EarlyOut( void )
+ {
+ m_earlyOut = true;
+ };
+
+ const char *m_funcName; // set at construction time
+ bool m_earlyOut;
+};
+
+// handy macro to go with the function tracking class
+#define GLM_FUNC GLMFuncLogger _logger_ ( __FUNCTION__ )
+#else
+#define GLM_FUNC
+#endif
+
+
+// class to keep an in-memory mirror of a file which may be getting edited during run
+class CGLMFileMirror
+{
+public:
+ CGLMFileMirror( char *fullpath ); // just associates mirror with file. if file exists it will be read.
+ //if non existent it will be created with size zero
+ ~CGLMFileMirror( );
+
+ bool HasData( void ); // see if data avail
+ void GetData( char **dataPtr, uint *dataSizePtr ); // read it out
+ void SetData( char *data, uint dataSize ); // put data in (and write it to disk)
+ bool PollForChanges( void ); // check disk copy. If different, read it back in and return true.
+
+ void UpdateStatInfo( void ); // make sure stat info is current for our file
+ void ReadFile( void );
+ void WriteFile( void );
+
+ void OpenInEditor( bool foreground=false ); // pass TRUE if you would like the editor to pop to foreground
+
+ /// how about a "wait for change" method..
+
+ char *m_path; // fullpath to file
+ bool m_exists;
+ struct stat m_stat; // stat results for the file (last time checked)
+
+ char *m_data; // content of file
+ uint m_size; // length of content
+
+};
+
+// class based on the file mirror, that makes it easy to edit them outside the app.
+
+// it receives an initial block of text from the engine, and hashes it. ("orig")
+// it munges it by duplicating all the text after the "!!" line, and appending it in commented form. ("munged")
+// a mirror file is activated, using a filename based on the hash from the orig text.
+// if there is already content on disk matching that filename, use that content *unless* the 'blitz' parameter is set.
+// (i.e. engine is instructing this subsystem to wipe out any old/modified variants of the text)
+
+
+class CGLMEditableTextItem
+{
+public:
+ CGLMEditableTextItem( char *text, uint size, bool forceOverwrite, char *prefix, char *suffix = NULL ); // create a text blob from text source, optional filename suffix
+ ~CGLMEditableTextItem( );
+
+ bool HasData( void );
+ bool PollForChanges( void ); // return true if stale i.e. you need to get a new edition
+ void GetCurrentText( char **textOut, uint *sizeOut ); // query for read access to the active blob (could be the original, could be external edited copy)
+ void OpenInEditor( bool foreground=false ); // call user attention to this text
+
+ // internal methods
+ void GenHashOfOrigText( void );
+ void GenBaseNameAndFullPath( char *prefix, char *suffix );
+ void GenMungedText( bool fromMirror );
+
+ // members
+ // orig
+ uint m_origSize;
+ char *m_origText; // what was submitted
+ unsigned char m_origDigest[MD5_DIGEST_LENGTH]; // digest of what was submitted
+
+ // munged
+ uint m_mungedSize;
+ char *m_mungedText; // re-processed edition, initial content submission to the file mirror
+
+ // mirror
+ char *m_mirrorBaseName; // generated from the hash of the orig text, plus the label / prefix
+ char *m_mirrorFullPath; // base name
+ CGLMFileMirror *m_mirror; // file mirror itself. holds "official" copy for GetCurrentText to return.
+};
+
+
+// debug font
+extern unsigned char g_glmDebugFontMap[16384];
+
+// class for cracking multi-part text blobs
+// sections are demarcated by beginning-of-line markers submitted in a table by the caller
+
+struct GLMTextSection
+{
+ int m_markerIndex; // based on table of markers passed in to constructor
+ uint m_textOffset; // where is the text - offset
+ int m_textLength; // how big is the section
+};
+
+class CGLMTextSectioner
+{
+public:
+ CGLMTextSectioner( char *text, int textSize, char **markers ); // constructor finds all the sections
+ ~CGLMTextSectioner( );
+
+ int Count( void ); // how many sections found
+ void GetSection( int index, uint *offsetOut, uint *lengthOut, int *markerIndexOut );
+ // find section, size, what marker
+ // note that more than one section can be marked similarly.
+ // so policy isn't made here, you walk the sections and decide what to do if there are dupes.
+
+ //members
+
+ //section table
+ CUtlVector< GLMTextSection > m_sectionTable;
+};
+
+#endif
diff --git a/mp/src/public/togl/osx/glmgrext.h b/mp/src/public/togl/osx/glmgrext.h new file mode 100644 index 00000000..1fc4edce --- /dev/null +++ b/mp/src/public/togl/osx/glmgrext.h @@ -0,0 +1,93 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// glmgrext.h
+// helper file for extension testing and runtime importing of entry points
+//
+//===============================================================================
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#elif defined(LINUX)
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+#ifndef GL_EXT_framebuffer_sRGB
+ #define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9
+ #define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA
+#endif
+
+#ifndef ARB_texture_rg
+ #define GL_COMPRESSED_RED 0x8225
+ #define GL_COMPRESSED_RG 0x8226
+ #define GL_RG 0x8227
+ #define GL_RG_INTEGER 0x8228
+ #define GL_R8 0x8229
+ #define GL_R16 0x822A
+ #define GL_RG8 0x822B
+ #define GL_RG16 0x822C
+ #define GL_R16F 0x822D
+ #define GL_R32F 0x822E
+ #define GL_RG16F 0x822F
+ #define GL_RG32F 0x8230
+ #define GL_R8I 0x8231
+ #define GL_R8UI 0x8232
+ #define GL_R16I 0x8233
+ #define GL_R16UI 0x8234
+ #define GL_R32I 0x8235
+ #define GL_R32UI 0x8236
+ #define GL_RG8I 0x8237
+ #define GL_RG8UI 0x8238
+ #define GL_RG16I 0x8239
+ #define GL_RG16UI 0x823A
+ #define GL_RG32I 0x823B
+ #define GL_RG32UI 0x823C
+#endif
+
+#ifndef GL_EXT_bindable_uniform
+ #define GL_UNIFORM_BUFFER_EXT 0x8DEE
+#endif
+
+// unpublished extension enums (thus the "X")
+
+// from EXT_framebuffer_multisample_blit_scaled..
+#define XGL_SCALED_RESOLVE_FASTEST_EXT 0x90BA
+#define XGL_SCALED_RESOLVE_NICEST_EXT 0x90BB
+
+#ifndef GL_TEXTURE_MINIMIZE_STORAGE_APPLE
+#define GL_TEXTURE_MINIMIZE_STORAGE_APPLE 0x85B6
+#endif
+
+#ifndef GL_ALL_COMPLETED_NV
+#define GL_ALL_COMPLETED_NV 0x84F2
+#endif
+
+#ifndef GL_MAP_READ_BIT
+#define GL_MAP_READ_BIT 0x0001
+#endif
+
+#ifndef GL_MAP_WRITE_BIT
+#define GL_MAP_WRITE_BIT 0x0002
+#endif
+
+#ifndef GL_MAP_INVALIDATE_RANGE_BIT
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#endif
+
+#ifndef GL_MAP_INVALIDATE_BUFFER_BIT
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#endif
+
+#ifndef GL_MAP_FLUSH_EXPLICIT_BIT
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#endif
+
+#ifndef GL_MAP_UNSYNCHRONIZED_BIT
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#endif
+
diff --git a/mp/src/public/togl/rendermechanism.h b/mp/src/public/togl/rendermechanism.h new file mode 100644 index 00000000..b409c4ac --- /dev/null +++ b/mp/src/public/togl/rendermechanism.h @@ -0,0 +1,70 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef RENDERMECHANISM_H
+#define RENDERMECHANISM_H
+
+#if defined(DX_TO_GL_ABSTRACTION)
+
+#undef PROTECTED_THINGS_ENABLE
+
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include "tier0/basetypes.h"
+#include "tier0/platform.h"
+
+#if defined(LINUX) || defined(_WIN32)
+
+#include "togl/linuxwin/glmdebug.h"
+#include "togl/linuxwin/glbase.h"
+#include "togl/linuxwin/glentrypoints.h"
+#include "togl/linuxwin/glmdisplay.h"
+#include "togl/linuxwin/glmdisplaydb.h"
+#include "togl/linuxwin/glmgrbasics.h"
+#include "togl/linuxwin/glmgrext.h"
+#include "togl/linuxwin/cglmbuffer.h"
+#include "togl/linuxwin/cglmtex.h"
+#include "togl/linuxwin/cglmfbo.h"
+#include "togl/linuxwin/cglmprogram.h"
+#include "togl/linuxwin/cglmquery.h"
+#include "togl/linuxwin/glmgr.h"
+#include "togl/linuxwin/dxabstract_types.h"
+#include "togl/linuxwin/dxabstract.h"
+
+#elif defined(OSX)
+#include "togl/osx/glmdebug.h"
+//#include "togl/osx/glbase.h"
+#include "togl/osx/glentrypoints.h"
+#include "togl/osx/glmdisplay.h"
+#include "togl/osx/glmdisplaydb.h"
+#include "togl/osx/glmgrbasics.h"
+#include "togl/osx/glmgrext.h"
+#include "togl/osx/cglmbuffer.h"
+#include "togl/osx/cglmtex.h"
+#include "togl/osx/cglmfbo.h"
+#include "togl/osx/cglmprogram.h"
+#include "togl/osx/cglmquery.h"
+#include "togl/osx/glmgr.h"
+#include "togl/osx/dxabstract_types.h"
+#include "togl/osx/dxabstract.h"
+
+#endif
+
+#else
+ //USE_ACTUAL_DX
+ #ifdef WIN32
+ #ifdef _X360
+ #include "d3d9.h"
+ #include "d3dx9.h"
+ #else
+ #include <windows.h>
+ #include "../../dx9sdk/include/d3d9.h"
+ #include "../../dx9sdk/include/d3dx9.h"
+ #endif
+ typedef HWND VD3DHWND;
+ #endif
+
+ #define GLMPRINTF(args)
+ #define GLMPRINTSTR(args)
+ #define GLMPRINTTEXT(args)
+#endif // defined(DX_TO_GL_ABSTRACTION)
+
+#endif // RENDERMECHANISM_H
diff --git a/mp/src/public/vgui/IVGui.h b/mp/src/public/vgui/IVGui.h index 06a3ec8c..e512538a 100644 --- a/mp/src/public/vgui/IVGui.h +++ b/mp/src/public/vgui/IVGui.h @@ -95,6 +95,10 @@ public: // data accessor for above
virtual bool GetShouldVGuiControlSleep() = 0;
+
+ // enables VR mode
+ virtual void SetVRMode( bool bVRMode ) = 0;
+ virtual bool GetVRMode() = 0;
};
#define VGUI_IVGUI_INTERFACE_VERSION "VGUI_ivgui008"
|