d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
62 Commits
25 Branches
6 Tags
221 MiB
Tree: 597f9da3b0
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '597f9da3b0'
${ noResults }
source-engine/public/togl/linuxwin/glmgr.h

2436 lines
81 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
// TOGL CODE LICENSE
//
// Copyright 2011-2014 Valve Corporation
// All Rights Reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// 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
#ifndef OSX
#define HAVE_GL_ARB_SYNC 1
#endif
#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/tslist.h"
#include "tier0/vprof_telemetry.h"
#include "materialsystem/IShader.h"
#include "dxabstract_types.h"
#include "tier0/icommandline.h"
#undef FORCEINLINE
#define FORCEINLINE inline
//===============================================================================
#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 256
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 OSX
#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 )
#ifdef HAVE_GL_ARB_SYNC
, m_nSyncObj( 0 )
#endif
{
}
~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()
{
#ifdef HAVE_GL_ARB_SYNC
if ( m_nSyncObj )
{
gGL->glDeleteSync( m_nSyncObj );
}
m_nSyncObj = gGL->glFenceSync( GL_SYNC_GPU_COMMANDS_COMPLETE, 0 );
#endif
}
void BlockUntilNotBusy()
{
#ifdef HAVE_GL_ARB_SYNC
if ( m_nSyncObj )
{
gGL->glClientWaitSync( m_nSyncObj, GL_SYNC_FLUSH_COMMANDS_BIT, 3000000000000ULL );
gGL->glDeleteSync( m_nSyncObj );
m_nSyncObj = 0;
}
#endif
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;
#ifdef HAVE_GL_ARB_SYNC
GLsync m_nSyncObj;
#endif
};
#endif // !OSX
//===========================================================================//
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, uint levels=1, 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, int minLod, float lodBias );
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 ValidateShaderPair( CGLMProgram *vp, CGLMProgram *fp );
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
#ifndef OSX
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 );
#else
void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, CGLMBuffer *pIndexBuf );
#endif
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();
#ifndef OSX
FORCEINLINE GLuint FindSamplerObject( const GLMTexSamplingParams &desiredParams );
#endif
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 );
GLuint CreateTex( GLenum texBind, GLenum internalFormat );
void CleanupTex( GLenum texBind, GLMTexLayout* pLayout, GLuint tex );
void DestroyTex( GLenum texBind, GLMTexLayout* pLayout, GLuint tex );
GLuint FillTexCache( bool holdOne, int newTextures );
void PurgeTexCache( );
// debug font
void GenDebugFontTex( void );
void DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string );
#ifndef OSX
CPinnedMemoryBuffer *GetCurPinnedMemoryBuffer( ) { return &m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer]; }
#endif
CPersistentBuffer* GetCurPersistentBuffer( EGLMBufferType type ) { return &( m_persistentBuffer[m_nCurPersistentBuffer][type] ); }
// members------------------------------------------
// context
DWORD m_nCurOwnerThreadId;
uint m_nThreadOwnershipReleaseCounter;
bool m_bUseSamplerObjects;
bool m_bTexClientStorage;
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...
#if defined( USE_SDL )
int m_pixelFormatAttribs[100]; // more than enough
PseudoNSGLContextPtr m_nsctx;
void * m_ctx;
#endif
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
uint m_fragDataMask;
// 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 ];
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;
#if defined( OSX ) && defined( GLMDEBUG )
CGLMProgram *m_boundProgram[ kGLMNumProgramTypes ];
#endif
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;
struct TextureEntry_t
{
GLenum m_nTexBind;
GLenum m_nInternalFormat;
GLuint m_nTexName;
};
GLuint m_destroyPBO;
CUtlVector< TextureEntry_t > m_availableTextures;
#ifndef OSX
enum { cNumPinnedMemoryBuffers = 4 };
CPinnedMemoryBuffer m_PinnedMemoryBuffers[cNumPinnedMemoryBuffers];
uint m_nCurPinnedMemoryBuffer;
#endif
enum { cNumPersistentBuffers = 3 };
CPersistentBuffer m_persistentBuffer[cNumPersistentBuffers][kGLMNumBufferTypes];
uint m_nCurPersistentBuffer;
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
void ProcessTextureDeletes();
CTSQueue<CGLMTex*> m_DeleteTextureQueue;
};
#ifndef OSX
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 (pIndexBuf->m_bUsingPersistentBuffer)
{
indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_nPersistentBufferStartOffset );
}
//#if GLMDEBUG
#if 0
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
}
#endif // #ifndef OSX
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 ) )
{
// changes here to handle vertex shaders which use constants before and after the bone array i.e. before c58 and after c216
// a better change may be to modify the shaders and place the bone consts at either start or end - would simplify this and the flush code
// the current supporting code (shader translator(dx9asmtogl2), param setting(here) and flushing(glmgr_flush.inl) should work unchanged, even if the const mapping is changed.
int firstDirty = (int)baseSlot;
int highWater = (int)(baseSlot + slotCount);
if ( highWater <= DXABSTRACT_VS_FIRST_BONE_SLOT )
{
m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty );
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater );
}
else if ( highWater <= (DXABSTRACT_VS_LAST_BONE_SLOT+1) )
{
if ( firstDirty < DXABSTRACT_VS_FIRST_BONE_SLOT )
{
m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty );
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, MIN( DXABSTRACT_VS_FIRST_BONE_SLOT, highWater ) );
firstDirty = DXABSTRACT_VS_FIRST_BONE_SLOT;
}
int nNumActualBones = ( firstDirty + slotCount ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone, nNumActualBones );
}
else
{
const int maxBoneSlots = ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
if ( firstDirty > DXABSTRACT_VS_LAST_BONE_SLOT )
{
m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty - maxBoneSlots );
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater - maxBoneSlots );
}
else if ( firstDirty >= DXABSTRACT_VS_FIRST_BONE_SLOT )
{
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = DXABSTRACT_VS_LAST_BONE_SLOT + 1;
m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, DXABSTRACT_VS_FIRST_BONE_SLOT );
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater - maxBoneSlots );
}
else
{
int nNumActualBones = ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone, nNumActualBones );
m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty );
m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater - maxBoneSlots );
}
}
}
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 || type==kGLMFragmentProgram );
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, int minLod, float lodBias )
{
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 ) );
Assert( minLod < ( 1 << GLM_PACKED_SAMPLER_PARAMS_MIN_LOD_BITS ) );
GLMTexSamplingParams &params = 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;
params.m_packed.m_minLOD = minLod;
params.m_lodBias = lodBias;
}
FORCEINLINE void GLMContext::SetSamplerBorderColor( int sampler, DWORD Value )
{
m_samplers[sampler].m_samp.m_borderColor = Value;
}
FORCEINLINE void GLMContext::SetSamplerMipMapLODBias( int sampler, DWORD Value )
{
typedef union {
DWORD asDword;
float asFloat;
} Convert_t;
Convert_t c;
c.asDword = Value;
m_samplers[sampler].m_samp.m_lodBias = c.asFloat;
}
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->GetHandle() : 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->GetHandle() : 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 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( const 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 // GLMGR_H