OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
OgreD3D9RenderSystem.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org
6 
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __D3D9RENDERSYSTEM_H__
29 #define __D3D9RENDERSYSTEM_H__
30 
31 #include "OgreD3D9Prerequisites.h"
32 #include "OgreString.h"
33 #include "OgreStringConverter.h"
34 #include "OgreRenderSystem.h"
36 #include "OgreD3D9Mappings.h"
37 
38 namespace Ogre
39 {
40 #define MAX_LIGHTS 8
41 
42  class D3D9DriverList;
43  class D3D9Driver;
44  class D3D9Device;
45  class D3D9DeviceManager;
46  class D3D9ResourceManager;
47 
52  {
53  public:
55  {
58  mutNo
59  };
60 
61  private:
63  IDirect3D9* mD3D;
64  // Stored options
66  size_t mFSAASamples;
68 
70  HINSTANCE mhInstance;
71 
88 
91  {
95  size_t coordIndex;
99  const Frustum *frustum;
101  IDirect3DBaseTexture9 *pTex;
103  IDirect3DBaseTexture9 *pVertexTex;
104  } mTexStageDesc[OGRE_MAX_TEXTURE_LAYERS];
105 
106  // Array of up to 8 lights, indexed as per API
107  // Note that a null value indicates a free slot
108  Light* mLights[MAX_LIGHTS];
109  D3D9DriverList* getDirect3DDrivers();
110  void refreshD3DSettings();
111  void refreshFSAAOptions();
112 
113  void setD3D9Light( size_t index, const Light* light );
114 
115  // state management methods, very primitive !!!
116  HRESULT __SetRenderState(D3DRENDERSTATETYPE state, DWORD value);
117  HRESULT __SetSamplerState(DWORD sampler, D3DSAMPLERSTATETYPE type, DWORD value);
118  HRESULT __SetTextureStageState(DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value);
119 
120  HRESULT __SetFloatRenderState(D3DRENDERSTATETYPE state, Real value)
121  {
122 #if OGRE_DOUBLE_PRECISION == 1
123  float temp = static_cast<float>(value);
124  return __SetRenderState(state, *((LPDWORD)(&temp)));
125 #else
126  return __SetRenderState(state, *((LPDWORD)(&value)));
127 #endif
128  }
129 
131  DWORD _getCurrentAnisotropy(size_t unit);
133  bool _checkMultiSampleQuality(D3DMULTISAMPLE_TYPE type, DWORD *outQuality, D3DFORMAT format, UINT adapterNum, D3DDEVTYPE deviceType, BOOL fullScreen);
134 
140 
142 
143 
145  virtual RenderSystemCapabilities* createRenderSystemCapabilities() const;
146  RenderSystemCapabilities* updateRenderSystemCapabilities(D3D9RenderWindow* renderWindow);
147 
149  virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary);
150 
151 
152  void convertVertexShaderCaps(RenderSystemCapabilities* rsc) const;
153  void convertPixelShaderCaps(RenderSystemCapabilities* rsc) const;
154  bool checkVertexTextureFormats(D3D9RenderWindow* renderWindow) const;
155  void detachRenderTargetImpl(const String& name);
156 
157  HashMap<IDirect3DDevice9*, unsigned short> mCurrentLights;
160 
161  D3DXMATRIX mDxViewMat, mDxProjMat, mDxWorldMat;
162 
164  // List of additional windows after the first (swap chains)
166 
169  typedef HashMap<unsigned int, D3DFORMAT> DepthStencilHash;
171 
173 
174  protected:
175  void setClipPlanesImpl(const PlaneList& clipPlanes);
176  public:
177  // constructor
178  D3D9RenderSystem( HINSTANCE hInstance );
179  // destructor
180  ~D3D9RenderSystem();
181 
182  virtual void initConfigOptions();
183 
184  // Overridden RenderSystem functions
185  ConfigOptionMap& getConfigOptions();
186  String validateConfigOptions();
187  RenderWindow* _initialise( bool autoCreateWindow, const String& windowTitle = "OGRE Render Window" );
189  RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
190  bool fullScreen, const NameValuePairList *miscParams = 0);
191 
193  bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
194  RenderWindowList& createdWindows);
195 
197  DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget );
198 
204  DepthBuffer* _addManualDepthBuffer( IDirect3DDevice9* depthSurfaceDevice, IDirect3DSurface9 *surf );
205 
216  void _cleanupDepthBuffers( IDirect3DDevice9 *creator );
217 
225  void _cleanupDepthBuffers( IDirect3DSurface9 *manualSurface );
226 
230  void _setRenderTarget(RenderTarget *target);
231 
233  virtual MultiRenderTarget * createMultiRenderTarget(const String & name);
234 
236  virtual RenderTarget * detachRenderTarget(const String &name);
237 
238  String getErrorDescription( long errorNumber ) const;
239  const String& getName() const;
240  // Low-level overridden members
241  void setConfigOption( const String &name, const String &value );
242  void reinitialise();
243  void shutdown();
244  void setAmbientLight( float r, float g, float b );
245  void setShadingType( ShadeOptions so );
246  void setLightingEnabled( bool enabled );
247  void destroyRenderTarget(const String& name);
248  VertexElementType getColourVertexElementType() const;
249  void setStencilCheckEnabled(bool enabled);
250  void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS,
251  uint32 refValue = 0, uint32 compareMask = 0xFFFFFFFF, uint32 writeMask = 0xFFFFFFFF,
252  StencilOperation stencilFailOp = SOP_KEEP,
253  StencilOperation depthFailOp = SOP_KEEP,
254  StencilOperation passOp = SOP_KEEP,
255  bool twoSidedOperation = false,
256  bool readBackAsTexture = false);
257  void setNormaliseNormals(bool normalise);
258 
259  // Low-level overridden members, mainly for internal use
260  void _useLights(const LightList& lights, unsigned short limit);
261  void _setWorldMatrix( const Matrix4 &m );
262  void _setViewMatrix( const Matrix4 &m );
263  void _setProjectionMatrix( const Matrix4 &m );
264  void _setSurfaceParams( const ColourValue &ambient, const ColourValue &diffuse, const ColourValue &specular, const ColourValue &emissive, Real shininess, TrackVertexColourType tracking );
265  void _setPointSpritesEnabled(bool enabled);
266  void _setPointParameters(Real size, bool attenuationEnabled,
267  Real constant, Real linear, Real quadratic, Real minSize, Real maxSize);
268  void _setTexture(size_t unit, bool enabled, const TexturePtr &texPtr);
269  void _setVertexTexture(size_t unit, const TexturePtr& tex);
270  void _disableTextureUnit(size_t texUnit);
271  void _setTextureCoordSet( size_t unit, size_t index );
272  void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m,
273  const Frustum* frustum = 0);
274  void _setTextureBlendMode( size_t unit, const LayerBlendModeEx& bm );
275  void _setTextureAddressingMode(size_t stage, const TextureUnitState::UVWAddressingMode& uvw);
276  void _setTextureBorderColour(size_t stage, const ColourValue& colour);
277  void _setTextureMipmapBias(size_t unit, float bias);
278  void _setTextureMatrix( size_t unit, const Matrix4 &xform );
279  void _setSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op );
280  void _setSeparateSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha, SceneBlendFactor destFactorAlpha, SceneBlendOperation op, SceneBlendOperation alphaOp );
281  void _setAlphaRejectSettings( CompareFunction func, unsigned char value, bool alphaToCoverage );
282  void _setViewport( Viewport *vp );
283  void _beginFrame();
284  virtual RenderSystemContext* _pauseFrame(void);
285  virtual void _resumeFrame(RenderSystemContext* context);
286  void _endFrame();
287  void _setCullingMode( CullingMode mode );
288  void _setDepthBufferParams( bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL );
289  void _setDepthBufferCheckEnabled( bool enabled = true );
290  void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha);
291  void _setDepthBufferWriteEnabled(bool enabled = true);
292  void _setDepthBufferFunction( CompareFunction func = CMPF_LESS_EQUAL );
293  void _setDepthBias(float constantBias, float slopeScaleBias);
294  void _setFog( FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White, Real expDensity = 1.0, Real linearStart = 0.0, Real linearEnd = 1.0 );
295  void _convertProjectionMatrix(const Matrix4& matrix,
296  Matrix4& dest, bool forGpuProgram = false);
297  void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
298  Matrix4& dest, bool forGpuProgram = false);
299  void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top, Real nearPlane,
300  Real farPlane, Matrix4& dest, bool forGpuProgram = false);
301  void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
302  Matrix4& dest, bool forGpuProgram = false);
303  void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
304  bool forGpuProgram);
305  void _setPolygonMode(PolygonMode level);
306  void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter);
307  void _setTextureUnitCompareFunction(size_t unit, CompareFunction function);
308  void _setTextureUnitCompareEnabled(size_t unit, bool compare);
309  void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy);
310  void setVertexDeclaration(VertexDeclaration* decl);
311  void setVertexDeclaration(VertexDeclaration* decl, bool useGlobalInstancingVertexBufferIsAvailable);
312  void setVertexBufferBinding(VertexBufferBinding* binding);
313  void setVertexBufferBinding(VertexBufferBinding* binding, size_t numberOfInstances, bool useGlobalInstancingVertexBufferIsAvailable, bool indexesUsed);
314  void _render(const RenderOperation& op);
318  void bindGpuProgram(GpuProgram* prg);
322  void unbindGpuProgram(GpuProgramType gptype);
326  void bindGpuProgramParameters(GpuProgramType gptype,
327  GpuProgramParametersSharedPtr params, uint16 variabilityMask);
328  void bindGpuProgramPassIterationParameters(GpuProgramType gptype);
329 
330  void setScissorTest(bool enabled, size_t left = 0, size_t top = 0, size_t right = 800, size_t bottom = 600);
331  void clearFrameBuffer(unsigned int buffers,
332  const ColourValue& colour = ColourValue::Black,
333  Real depth = 1.0f, unsigned short stencil = 0);
334  void setClipPlane (ushort index, Real A, Real B, Real C, Real D);
335  void enableClipPlane (ushort index, bool enable);
336  HardwareOcclusionQuery* createHardwareOcclusionQuery();
337  Real getHorizontalTexelOffset();
338  Real getVerticalTexelOffset();
339  Real getMinimumDepthInputValue();
340  Real getMaximumDepthInputValue();
341  void registerThread();
342  void unregisterThread();
343  void preExtraThreadsStarted();
344  void postExtraThreadsStarted();
345 
346  /*
347  Returns whether under the current render system buffers marked as TU_STATIC can be locked for update
348  */
349  virtual bool isStaticBufferLockable() const { return !mIsDirectX9Ex; }
350 
353  static bool isDirectX9Ex() { return msD3D9RenderSystem->mIsDirectX9Ex; }
354 
355  static D3D9ResourceManager* getResourceManager();
356  static D3D9DeviceManager* getDeviceManager();
357  static IDirect3D9* getDirect3D9();
358  static UINT getResourceCreationDeviceCount();
359  static IDirect3DDevice9* getResourceCreationDevice(UINT index);
360  static IDirect3DDevice9* getActiveD3D9Device();
361  static IDirect3DDevice9* getActiveD3D9DeviceIfExists();
362 
366  D3DFORMAT _getDepthStencilFormatFor(D3DFORMAT fmt);
367 
371  bool _checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage);
372 
374  void determineFSAASettings(IDirect3DDevice9* d3d9Device, size_t fsaa, const String& fsaaHint, D3DFORMAT d3dPixelFormat,
375  bool fullScreen, D3DMULTISAMPLE_TYPE *outMultisampleType, DWORD *outMultisampleQuality);
376 
378  unsigned int getDisplayMonitorCount() const;
380  virtual bool hasAnisotropicMipMapFilter() const { return false; }
381 
383  virtual void beginProfileEvent( const String &eventName );
384 
386  virtual void endProfileEvent( void );
387 
389  virtual void markProfileEvent( const String &eventName );
390 
392  void fireDeviceEvent( D3D9Device* device, const String & name );
393 
395  MultiheadUseType getMultiheadUse() const { return mMultiheadUse; }
396  protected:
398  DWORD getSamplerId(size_t unit);
399 
401  void notifyOnDeviceLost(D3D9Device* device);
402 
404  void notifyOnDeviceReset(D3D9Device* device);
405 
406  private:
407  friend class D3D9Device;
408  friend class D3D9DeviceManager;
409  };
410 }
411 #endif
Leave the stencil buffer unchanged.
Definition: OgreCommon.h:90
Manages the target rendering window.
A 'canvas' which can receive the results of a rendering operation.
static bool isDirectX9Ex()
Tells whether the system is initialized with DirectX 9Ex driver Read more in http://msdn.microsoft.com/en-us/library/windows/desktop/ee890072(v=vs.85).aspx.
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:79
HashMap< IDirect3DDevice9 *, unsigned short > mCurrentLights
float Real
Software floating point type.
unsigned int uint32
Definition: OgrePlatform.h:420
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:580
Defines a plane in 3D space.
Definition: OgrePlane.h:61
FogMode
Fog modes.
Definition: OgreCommon.h:152
Class representing colour.
GpuProgramType
Enumerates the types of programs which can run on the GPU.
static const ColourValue White
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:84
eD3DTexType
enum identifying D3D9 tex. types
#define MAX_LIGHTS
virtual bool isStaticBufferLockable() const
Defines a program which runs on the GPU such as a vertex or fragment program.
TexCoordCalcMethod
Enum describing the ways to generate texture coordinates.
IDirect3DBaseTexture9 * pVertexTex
vertex texture
FilterType
Definition: OgreCommon.h:121
vector< D3D9RenderWindow * >::type D3D9RenderWindowList
structure holding texture unit settings for every stage
SceneBlendFactor
Blending factors for manually blending objects with the scene.
bool mAllowDirectX9Ex
Tells whether to attempt to initialize the system with DirectX 9Ex driver Read more in http://msdn...
bool mUseNVPerfHUD
NVPerfHUD allowed?
Device manager interface.
virtual bool hasAnisotropicMipMapFilter() const
Determines if the system has anisotropic mip map filter support.
D3D9GpuProgramManager * mGpuProgramManager
D3D9Mappings::eD3DTexType texType
the type of the texture
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:166
No fog. Duh.
Definition: OgreCommon.h:155
D3D9HLSLProgramFactory * mHLSLProgramFactory
This class represents a render target that renders to multiple RenderTextures at once.
This is a abstract class that that provides the interface for the query class for hardware occlusion...
vector< RenderWindow * >::type RenderWindowList
Render window container.
Definition: OgreCommon.h:794
static D3D9RenderSystem * msD3D9RenderSystem
Fast singleton access.
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:70
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160
#define OGRE_MAX_TEXTURE_LAYERS
Define max number of texture layers allowed per pass on any card.
Definition: OgreConfig.h:72
MultiheadUseType getMultiheadUse() const
Returns how multihead should be activated.
An abstract class that contains a depth/stencil buffer.
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:144
TexCoordCalcMethod autoTexCoordType
type of auto tex. calc. used
PixelFormat
The pixel format used for images, textures, and render surfaces.
Texture addressing mode for each texture coordinate.
map< String, ConfigOption >::type ConfigOptionMap
#define _OgreD3D9Export
bool mIsDirectX9Ex
Tells whether the system is initialized with DirectX 9Ex driver Read more in http://msdn.microsoft.com/en-us/library/windows/desktop/ee890072(v=vs.85).aspx.
D3D9ResourceManager * mResourceManager
VertexElementType
Vertex element type, used to identify the base types of the vertex contents.
HRESULT __SetFloatRenderState(D3DRENDERSTATETYPE state, Real value)
D3D9HardwareBufferManagerBase as a Singleton.
MultiheadUseType mMultiheadUse
const Frustum * frustum
Frustum, used if the above is projection.
Implementation of DirectX9 as a rendering system.
unsigned short ushort
StencilOperation
Enum describing the various actions which can be taken on the stencil buffer.
Definition: OgreCommon.h:87
IDirect3D9 * mD3D
Direct3D.
HashMap< unsigned int, D3DFORMAT > DepthStencilHash
Mapping of texture format -> DepthStencil.
High level interface of Direct3D9 Device.
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:56
'New' rendering operation using vertex buffers.
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
D3D9HardwareBufferManager * mHardwareBufferManager
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:49
size_t coordIndex
which texCoordIndex to use
TextureType
Enum identifying the texture type.
Definition: OgreTexture.h:76
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:210
HINSTANCE mhInstance
instance
bool mPerStageConstantSupport
Per-stage constant support? (not in main caps since D3D specific & minor)
static const ColourValue Black
SceneBlendOperation
Blending operations controls how objects are blended into the scene.
Matrix4 mViewMatrix
Saved last view matrix.
singleton class for storing the capabilities of the graphics card.
_StringBase String
Definition: OgreCommon.h:53
vector< RenderWindowDescription >::type RenderWindowDescriptionList
Render window creation parameters container.
Definition: OgreCommon.h:791
unsigned short uint16
Definition: OgrePlatform.h:421
D3D9DriverList * mDriverList
List of D3D drivers installed (video cards)
D3D9DeviceManager * mDeviceManager
Factory class for D3D9 HLSL programs.
FilterOptions
Filtering options for textures / mipmaps.
Definition: OgreCommon.h:131
Defines the functionality of a 3D API.
D3D9Driver * mActiveD3DDriver
Currently active driver.
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:74
int TrackVertexColourType
An enumeration describing which material properties should track the vertex colours.
Definition: OgreCommon.h:221
Class which manages blending of both colour and alpha components.
void _cleanupDepthBuffers(bool bCleanManualBuffers=true)
Removes all depth buffers.
DepthStencilHash mDepthStencilHash
D3D9RenderWindowList mRenderWindows