diff options
Diffstat (limited to 'Runtime/GfxDevice/threaded/GfxDeviceClient.h')
| -rw-r--r-- | Runtime/GfxDevice/threaded/GfxDeviceClient.h | 423 |
1 files changed, 423 insertions, 0 deletions
diff --git a/Runtime/GfxDevice/threaded/GfxDeviceClient.h b/Runtime/GfxDevice/threaded/GfxDeviceClient.h new file mode 100644 index 0000000..017fd88 --- /dev/null +++ b/Runtime/GfxDevice/threaded/GfxDeviceClient.h @@ -0,0 +1,423 @@ +#pragma once +#if ENABLE_MULTITHREADED_CODE + +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/GfxDevice/TransformState.h" +#include "Runtime/GfxDevice/threaded/ClientIDMapper.h" +#include "Runtime/GfxDevice/threaded/ThreadedDeviceStates.h" +#include "Runtime/Utilities/dynamic_array.h" + +class ThreadedStreamBuffer; +class GfxDeviceWorker; +class GfxDeviceWindow; +class ThreadedWindow; +class ThreadedDynamicVBO; +struct DisplayListContext; + +enum +{ + kClientDeviceThreaded = 1 << 0, + kClientDeviceForceRef = 1 << 1, + kClientDeviceUseRealDevice = 1 << 2, + kClientDeviceClientProcess = 1 << 3, + kClientDeviceWorkerProcess = 1 << 4, +}; + +GfxDevice* CreateClientGfxDevice(GfxDeviceRenderer renderer, UInt32 flags, size_t bufferSize = 0, void *buffer=0); +bool GfxDeviceWorkerProcessRunCommand(); + +#define GFX_DEVICE_CLIENT_TRACK_TEXGEN (GFX_SUPPORTS_OPENGLES20 || GFX_SUPPORTS_OPENGLES30) + + +class GfxDeviceClient : public GfxDevice +{ +public: + GfxDeviceClient(bool threaded, bool clientProcess, size_t bufferSize = 0, void *buffer=0); + GFX_API ~GfxDeviceClient(); + + GFX_API void InvalidateState(); + #if GFX_DEVICE_VERIFY_ENABLE + GFX_API void VerifyState(); + #endif + + GFX_API void SetMaxBufferedFrames (int bufferSize); + + GFX_API void Clear (UInt32 clearFlags, const float color[4], float depth, int stencil); + GFX_API void SetUserBackfaceMode( bool enable ); + GFX_API void SetWireframe(bool wire); + GFX_API bool GetWireframe() const; + + GFX_API void SetInvertProjectionMatrix( bool enable ); + GFX_API bool GetInvertProjectionMatrix() const; + + #if GFX_USES_VIEWPORT_OFFSET + GFX_API void SetViewportOffset( float x, float y ); + GFX_API void GetViewportOffset( float &x, float &y ) const; + #endif + + GFX_API GPUSkinningInfo *CreateGPUSkinningInfo(); + GFX_API void DeleteGPUSkinningInfo(GPUSkinningInfo *info); + GFX_API void SkinOnGPU( GPUSkinningInfo * info, bool lastThisFrame ); + GFX_API void UpdateSkinSourceData(GPUSkinningInfo *info, const void *vertData, const BoneInfluence *skinData, bool dirty); + GFX_API void UpdateSkinBonePoses(GPUSkinningInfo *info, const int boneCount, const Matrix4x4f* poses); + + GFX_API DeviceBlendState* CreateBlendState(const GfxBlendState& state); + GFX_API DeviceDepthState* CreateDepthState(const GfxDepthState& state); + GFX_API DeviceStencilState* CreateStencilState(const GfxStencilState& state); + GFX_API DeviceRasterState* CreateRasterState(const GfxRasterState& state); + + GFX_API void RecordSetBlendState(const DeviceBlendState* state, const ShaderLab::FloatVal& alphaRef, const ShaderLab::PropertySheet* props); + GFX_API void SetBlendState(const DeviceBlendState* state, float alphaRef); + GFX_API void SetDepthState(const DeviceDepthState* state); + GFX_API void SetStencilState(const DeviceStencilState* state, int stencilRef); + GFX_API void SetRasterState(const DeviceRasterState* state); + GFX_API void SetSRGBWrite (const bool); + GFX_API bool GetSRGBWrite (); + + #if UNITY_XENON + GFX_API void SetNullPixelShader(); + GFX_API void SetHiZEnable( const HiZstate hiz_enable ); + GFX_API void SetHiStencilState( const bool hiStencilEnable, const bool hiStencilWriteEnable, const int hiStencilRef, const CompareFunction cmpfunc ); + GFX_API void HiStencilFlush( const HiSflush flushtype ); + #endif + + GFX_API void SetWorldMatrix( const float matrix[16] ); + GFX_API void SetViewMatrix( const float matrix[16] ); + GFX_API void SetProjectionMatrix(const Matrix4x4f& matrix); + GFX_API void GetMatrix( float outMatrix[16] ) const; + + GFX_API const float* GetWorldMatrix() const; + GFX_API const float* GetViewMatrix() const; + GFX_API const float* GetProjectionMatrix() const; + GFX_API const float* GetDeviceProjectionMatrix() const; + + GFX_API void SetInverseScale( float invScale ); + + GFX_API void SetNormalizationBackface( NormalizationMode mode, bool backface ); + + GFX_API void SetFFLighting( bool on, bool separateSpecular, ColorMaterialMode colorMaterial ); + GFX_API void RecordSetMaterial( const ShaderLab::VectorVal& ambient, const ShaderLab::VectorVal& diffuse, const ShaderLab::VectorVal& specular, const ShaderLab::VectorVal& emissive, const ShaderLab::FloatVal& shininess, const ShaderLab::PropertySheet* props ); + GFX_API void SetMaterial( const float ambient[4], const float diffuse[4], const float specular[4], const float emissive[4], const float shininess ); + GFX_API void RecordSetColor( const ShaderLab::VectorVal& color, const ShaderLab::PropertySheet* props ); + GFX_API void SetColor( const float color[4] ); + GFX_API void SetViewport( int x, int y, int width, int height ); + GFX_API void GetViewport( int* values ) const; + + GFX_API void SetScissorRect( int x, int y, int width, int height ); + GFX_API void DisableScissor(); + GFX_API bool IsScissorEnabled() const; + GFX_API void GetScissorRect( int values[4] ) const; + + GFX_API TextureCombinersHandle CreateTextureCombiners( int count, const ShaderLab::TextureBinding* texEnvs, const ShaderLab::PropertySheet* props, bool hasVertexColorOrLighting, bool usesAddSpecular ); + GFX_API void DeleteTextureCombiners( TextureCombinersHandle& textureCombiners ); + GFX_API void SetTextureCombiners( TextureCombinersHandle textureCombiners, const ShaderLab::PropertySheet* props ); + + GFX_API void SetTexture (ShaderType shaderType, int unit, int samplerUnit, TextureID texture, TextureDimension dim, float bias); + GFX_API void SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace ); + GFX_API void SetTextureTransform( int unit, TextureDimension dim, TexGenMode texGen, bool identity, const float matrix[16]); + GFX_API void SetTextureName( TextureID texture, char const* name ); + + GFX_API void SetMaterialProperties(const MaterialPropertyBlock& block); + + GFX_API GpuProgram* CreateGpuProgram( const std::string& source, CreateGpuProgramOutput& output ); + GFX_API void SetShadersMainThread( ShaderLab::SubProgram* programs[kShaderTypeCount], const ShaderLab::PropertySheet* props ); + GFX_API bool IsShaderActive( ShaderType type ) const; + GFX_API void DestroySubProgram( ShaderLab::SubProgram* subprogram ); + GFX_API void SetConstantBufferInfo (int id, int size); + + GFX_API void DisableLights( int startLight ); + GFX_API void SetLight( int light, const GfxVertexLight& data); + GFX_API void SetAmbient( const float ambient[4] ); + + GFX_API void RecordEnableFog( FogMode fogMode, const ShaderLab::FloatVal& fogStart, const ShaderLab::FloatVal& fogEnd, const ShaderLab::FloatVal& fogDensity, const ShaderLab::VectorVal& fogColor, const ShaderLab::PropertySheet* props ); + GFX_API void EnableFog( const GfxFogParams& fog ); + GFX_API void DisableFog(); + + GFX_API VBO* CreateVBO(); + GFX_API void DeleteVBO( VBO* vbo ); + GFX_API DynamicVBO& GetDynamicVBO(); + + GFX_API void BeginSkinning( int maxSkinCount ); + GFX_API bool SkinMesh( const SkinMeshInfo& skin, VBO* vbo ); + GFX_API void EndSkinning(); + +#if GFX_ENABLE_DRAW_CALL_BATCHING + GFX_API void BeginStaticBatching(const ChannelAssigns& channels, GfxPrimitiveType topology); + GFX_API void StaticBatchMesh( UInt32 firstVertex, UInt32 vertexCount, const IndexBufferData& indices, UInt32 firstIndexByte, UInt32 indexCount ); + GFX_API void EndStaticBatching( VBO& vbo, const Matrix4x4f& matrix, TransformType transformType, int sourceChannels ); + + GFX_API void BeginDynamicBatching( const ChannelAssigns& shaderChannel, UInt32 channelsInVBO, size_t maxVertices, size_t maxIndices, GfxPrimitiveType topology); + GFX_API void DynamicBatchMesh( const Matrix4x4f& matrix, const VertexBufferData& vertices, UInt32 firstVertex, UInt32 vertexCount, const IndexBufferData& indices, UInt32 firstIndexByte, UInt32 indexCount ); +#if ENABLE_SPRITES + GFX_API void DynamicBatchSprite(const Matrix4x4f* matrix, const SpriteRenderData* rd, ColorRGBA32 color); +#endif + GFX_API void EndDynamicBatching( TransformType transformType ); +#endif + + GFX_API void AddBatchingStats( int batchedTris, int batchedVerts, int batchedCalls ); + +#if UNITY_XENON + GFX_API RawVBO* CreateRawVBO( UInt32 size, UInt32 flags ); + GFX_API void DeleteRawVBO( RawVBO* vbo ); + + GFX_API void EnablePersistDisplayOnQuit( bool enabled ); + GFX_API void OnLastFrameCallback(); + + GFX_API void RegisterTexture2D( TextureID tid, IDirect3DBaseTexture9* texture ); + GFX_API void PatchTexture2D( TextureID tid, IDirect3DBaseTexture9* texture ); + GFX_API void DeleteTextureEntryOnly( TextureID textureID ); + GFX_API void UnbindAndDelayReleaseTexture( IDirect3DBaseTexture9* texture ); + GFX_API void SetTextureWrapModes( TextureID textureID, TextureWrapMode wrapU, TextureWrapMode wrapV, TextureWrapMode wrapW ); + + GFX_API xenon::IVideoPlayer* CreateVideoPlayer(bool fullscreen); + GFX_API void DeleteVideoPlayer(xenon::IVideoPlayer* player); +#endif + + GFX_API RenderSurfaceHandle CreateRenderColorSurface (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, RenderTextureFormat format, UInt32 createFlags); + GFX_API RenderSurfaceHandle CreateRenderDepthSurface (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags); + GFX_API void DestroyRenderSurface (RenderSurfaceHandle& rs); + GFX_API void DiscardContents (RenderSurfaceHandle& rs); + GFX_API void IgnoreNextUnresolveOnCurrentRenderTarget(); + GFX_API void IgnoreNextUnresolveOnRS(RenderSurfaceHandle rs); + GFX_API void SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face = kCubeFaceUnknown); + GFX_API void SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face, UInt32 flags); + GFX_API void ResolveColorSurface (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle); + GFX_API void ResolveDepthIntoTexture (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle); + + GFX_API RenderSurfaceHandle GetActiveRenderColorSurface (int index); + GFX_API RenderSurfaceHandle GetActiveRenderDepthSurface (); + + GFX_API bool IsRenderTargetConfigValid(UInt32 width, UInt32 height, RenderTextureFormat colorFormat, DepthBufferFormat depthFormat); + + GFX_API void SetSurfaceFlags(RenderSurfaceHandle surf, UInt32 flags, UInt32 keepFlags); + + GFX_API void UploadTexture2D( TextureID texture, TextureDimension dimension, UInt8* srcData, int srcSize, int width, int height, TextureFormat format, int mipCount, UInt32 uploadFlags, int skipMipLevels, TextureUsageMode usageMode, TextureColorSpace colorSpace ); + GFX_API void UploadTextureSubData2D( TextureID texture, UInt8* srcData, int srcSize, int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace ); + GFX_API void UploadTextureCube( TextureID texture, UInt8* srcData, int srcSize, int faceDataSize, int size, TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace ); + GFX_API void UploadTexture3D( TextureID texture, UInt8* srcData, int srcSize, int width, int height, int depth, TextureFormat format, int mipCount, UInt32 uploadFlags ); + GFX_API void DeleteTexture( TextureID texture ); + + GFX_API PresentMode GetPresentMode(); + + GFX_API void BeginFrame(); + GFX_API void EndFrame(); + GFX_API void PresentFrame(); + GFX_API bool IsValidState(); + GFX_API bool HandleInvalidState(); + GFX_API void ResetDynamicResources(); + GFX_API bool IsReadyToBeginFrame(); + GFX_API void FinishRendering(); + GFX_API UInt32 InsertCPUFence(); + GFX_API UInt32 GetNextCPUFence(); + GFX_API void WaitOnCPUFence(UInt32 fence); + + GFX_API void AcquireThreadOwnership(); + GFX_API void ReleaseThreadOwnership(); + + GFX_API void ImmediateVertex( float x, float y, float z ); + GFX_API void ImmediateNormal( float x, float y, float z ); + GFX_API void ImmediateColor( float r, float g, float b, float a ); + GFX_API void ImmediateTexCoordAll( float x, float y, float z ); + GFX_API void ImmediateTexCoord( int unit, float x, float y, float z ); + GFX_API void ImmediateBegin( GfxPrimitiveType type ); + GFX_API void ImmediateEnd(); + + // Recording display lists + GFX_API bool BeginRecording(); + GFX_API bool EndRecording( GfxDisplayList** outDisplayList ); + + // Capturing screen shots / blits + GFX_API bool CaptureScreenshot( int left, int bottom, int width, int height, UInt8* rgba32 ); + GFX_API bool ReadbackImage( ImageReference& image, int left, int bottom, int width, int height, int destX, int destY ); + GFX_API void GrabIntoRenderTexture (RenderSurfaceHandle rs, RenderSurfaceHandle rd, int x, int y, int width, int height); + + // Any housekeeping around draw calls + GFX_API void BeforeDrawCall( bool immediateMode ); + + GFX_API bool IsPositionRequiredForTexGen (int texStageIndex) const; + GFX_API bool IsNormalRequiredForTexGen (int texStageIndex) const; + GFX_API bool IsPositionRequiredForTexGen() const; + GFX_API bool IsNormalRequiredForTexGen() const; + + GFX_API void SetActiveContext (void* ctx); + + GFX_API void ResetFrameStats(); + GFX_API void BeginFrameStats(); + GFX_API void EndFrameStats(); + GFX_API void SaveDrawStats(); + GFX_API void RestoreDrawStats(); + GFX_API void SynchronizeStats(); + + GFX_API void* GetNativeGfxDevice(); + GFX_API void* GetNativeTexturePointer(TextureID id); + GFX_API UInt32 GetNativeTextureID(TextureID id); +#if ENABLE_TEXTUREID_MAP + GFX_API intptr_t CreateExternalTextureFromNative(intptr_t nativeTex); + GFX_API void UpdateExternalTextureFromNative(TextureID tex, intptr_t nativeTex); +#endif + + GFX_API void InsertCustomMarker (int marker); + + GFX_API void SetComputeBufferData (ComputeBufferID bufferHandle, const void* data, size_t size); + GFX_API void GetComputeBufferData (ComputeBufferID bufferHandle, void* dest, size_t destSize); + GFX_API void CopyComputeBufferCount (ComputeBufferID srcBuffer, ComputeBufferID dstBuffer, UInt32 dstOffset); + + GFX_API void SetRandomWriteTargetTexture (int index, TextureID tid); + GFX_API void SetRandomWriteTargetBuffer (int index, ComputeBufferID bufferHandle); + GFX_API void ClearRandomWriteTargets (); + + GFX_API ComputeProgramHandle CreateComputeProgram (const UInt8* code, size_t codeSize); + GFX_API void DestroyComputeProgram (ComputeProgramHandle& cpHandle); + GFX_API void CreateComputeConstantBuffers (unsigned count, const UInt32* sizes, ConstantBufferHandle* outCBs); + GFX_API void DestroyComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs); + GFX_API void CreateComputeBuffer (ComputeBufferID id, size_t count, size_t stride, UInt32 flags); + GFX_API void DestroyComputeBuffer (ComputeBufferID handle); + GFX_API void UpdateComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs, UInt32 cbDirty, size_t dataSize, const UInt8* data, const UInt32* cbSizes, const UInt32* cbOffsets, const int* bindPoints); + GFX_API void UpdateComputeResources ( + unsigned texCount, const TextureID* textures, const int* texBindPoints, + unsigned samplerCount, const unsigned* samplers, + unsigned inBufferCount, const ComputeBufferID* inBuffers, const int* inBufferBindPoints, + unsigned outBufferCount, const ComputeBufferID* outBuffers, const TextureID* outTextures, const UInt32* outBufferBindPoints); + GFX_API void DispatchComputeProgram (ComputeProgramHandle cpHandle, unsigned threadsX, unsigned threadsY, unsigned threadsZ); + + GFX_API void DrawNullGeometry (GfxPrimitiveType topology, int vertexCount, int instanceCount); + GFX_API void DrawNullGeometryIndirect (GfxPrimitiveType topology, ComputeBufferID bufferHandle, UInt32 bufferOffset); + + +#if ENABLE_PROFILER + GFX_API void BeginProfileEvent (const char* name); + GFX_API void EndProfileEvent (); + GFX_API void ProfileControl (GfxProfileControl ctrl, unsigned param); + GFX_API GfxTimerQuery* CreateTimerQuery(); + GFX_API void DeleteTimerQuery(GfxTimerQuery* query); + GFX_API void BeginTimerQueries(); + GFX_API void EndTimerQueries(); +#endif + + // Editor-only stuff +#if UNITY_EDITOR + GFX_API void SetAntiAliasFlag( bool aa ); + GFX_API void DrawUserPrimitives( GfxPrimitiveType type, int vertexCount, UInt32 vertexChannels, const void* data, int stride ); + GFX_API int GetCurrentTargetAA() const; +#endif + +#if UNITY_EDITOR && UNITY_WIN + //ToDo: This is windows specific code, we should replace HWND window with something more abstract + GFX_API GfxDeviceWindow* CreateGfxWindow( HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias ); + + void SetActiveWindow(ClientDeviceWindow* handle); + void WindowReshape(ClientDeviceWindow* handle, int width, int height, DepthBufferFormat depthFormat, int antiAlias); + void WindowDestroy(ClientDeviceWindow* handle); + void BeginRendering(ClientDeviceWindow* handle); + void EndRendering(ClientDeviceWindow* handle, bool presentContent); +#endif + +#if UNITY_WIN + GFX_API int GetCurrentTargetWidth() const; + GFX_API int GetCurrentTargetHeight() const; + GFX_API void SetCurrentTargetSize(int width, int height); + GFX_API void SetCurrentWindowSize(int width, int height); +#endif + +#if GFX_OPENGLESxx_ONLY || GFX_SUPPORTS_MOLEHILL + GFX_API void ReloadResources() {}; +#endif + + bool IsThreaded() const { return m_Threaded; } + bool IsSerializing() const { return m_Serialize; } + + ThreadedStreamBuffer* GetCommandQueue() const { return m_CommandQueue; } + GfxDeviceWorker* GetGfxDeviceWorker() const { return m_DeviceWorker; } + + void SetRealGfxDevice(GfxThreadableDevice* realDevice); + void WriteBufferData(const void* data, int size); + void ReadbackData(dynamic_array<UInt8>& data, const SInt32 chunkSize = 16384); + void SubmitCommands(); + void DoLockstep(); + + void QueryGraphicsCaps (); + + GFX_API RenderTextureFormat GetDefaultRTFormat() const; + GFX_API RenderTextureFormat GetDefaultHDRRTFormat() const; + +private: + friend class ThreadedDisplayList; + void UpdateFogDisabled(); + void UpdateFogEnabled(const GfxFogParams& fogParams); + void UpdateShadersActive(bool shadersActive[kShaderTypeCount]); + +private: + void CreateShaderParameters( ShaderLab::SubProgram* program, FogMode fogMode ); + + void CheckMainThread() const; + void BeforeRenderTargetChange(int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle); + void AfterRenderTargetChange(); + void WaitForPendingPresent(); + void WaitForSignal(); + + typedef std::map< GfxBlendState, ClientDeviceBlendState, memcmp_less<GfxBlendState> > CachedBlendStates; + typedef std::map< GfxDepthState, ClientDeviceDepthState, memcmp_less<GfxDepthState> > CachedDepthStates; + typedef std::map< GfxStencilState, ClientDeviceStencilState, memcmp_less<GfxStencilState> > CachedStencilStates; + typedef std::map< GfxRasterState, ClientDeviceRasterState, memcmp_less<GfxRasterState> > CachedRasterStates; + + GfxDeviceWorker* m_DeviceWorker; + GfxThreadableDevice* m_RealDevice; + bool m_Threaded; + bool m_Serialize; + int m_RecordDepth; + int m_MaxCallDepth; + ThreadedStreamBuffer* m_CommandQueue; + DisplayListContext* m_DisplayListStack; + DisplayListContext* m_CurrentContext; + DynamicVBO* m_DynamicVBO; + bool m_InvertProjectionMatrix; + #if GFX_USES_VIEWPORT_OFFSET + Vector2f m_ViewportOffset; + #endif + CachedBlendStates m_CachedBlendStates; + CachedDepthStates m_CachedDepthStates; + CachedStencilStates m_CachedStencilStates; + CachedRasterStates m_CachedRasterStates; + TransformState m_TransformState; + ClientDeviceRect m_Viewport; + ClientDeviceRect m_ScissorRect; + int m_ScissorEnabled; + RenderSurfaceHandle m_ActiveRenderColorSurfaces[kMaxSupportedRenderTargets]; + RenderSurfaceHandle m_ActiveRenderDepthSurface; + int m_CurrentTargetWidth; + int m_CurrentTargetHeight; + int m_CurrentWindowWidth; + int m_CurrentWindowHeight; + int m_ThreadOwnershipCount; + UInt32 m_CurrentCPUFence; + UInt32 m_PresentFrameID; + bool m_PresentPending; + bool m_Wireframe; + bool m_sRGBWrite; + dynamic_array<UInt8> m_ReadbackData; + +#if GFX_DEVICE_CLIENT_TRACK_TEXGEN + // TEMP: we can actually grab this info from shader, but for now lets just workaround it with minimal impact + // anyway, we should kill ffp (pretty please) + // TODO: it might be needed on more platforms, but for now i care only about gles + UInt8 posForTexGen; + UInt8 nrmForTexGen; + + void SetTexGen(int unit, TexGenMode mode); + void DropTexGen(int unit); +#endif + +public: +#if ENABLE_GFXDEVICE_REMOTE_PROCESS + ClientIDMapper m_BlendStateMapper; + ClientIDMapper m_DepthStateMapper; + ClientIDMapper m_StencilStateMapper; + ClientIDMapper m_RasterStateMapper; + ClientIDMapper m_TextureCombinerMapper; + ClientIDMapper m_VBOMapper; + ClientIDMapper m_RenderSurfaceMapper; + ClientIDMapper m_GpuProgramParametersMapper; +#endif +}; + +#endif |