OGRE  1.8
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-2013 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 
82 
85  {
89  size_t coordIndex;
93  const Frustum *frustum;
95  IDirect3DBaseTexture9 *pTex;
97  IDirect3DBaseTexture9 *pVertexTex;
98  } mTexStageDesc[OGRE_MAX_TEXTURE_LAYERS];
99 
100  // Array of up to 8 lights, indexed as per API
101  // Note that a null value indicates a free slot
102  Light* mLights[MAX_LIGHTS];
103  D3D9DriverList* getDirect3DDrivers();
104  void refreshD3DSettings();
105  void refreshFSAAOptions();
106 
107  void setD3D9Light( size_t index, Light* light );
108 
109  // state management methods, very primitive !!!
110  HRESULT __SetRenderState(D3DRENDERSTATETYPE state, DWORD value);
111  HRESULT __SetSamplerState(DWORD sampler, D3DSAMPLERSTATETYPE type, DWORD value);
112  HRESULT __SetTextureStageState(DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value);
113 
114  HRESULT __SetFloatRenderState(D3DRENDERSTATETYPE state, Real value)
115  {
116 #if OGRE_DOUBLE_PRECISION == 1
117  float temp = static_cast<float>(value);
118  return __SetRenderState(state, *((LPDWORD)(&temp)));
119 #else
120  return __SetRenderState(state, *((LPDWORD)(&value)));
121 #endif
122  }
123 
125  DWORD _getCurrentAnisotropy(size_t unit);
127  bool _checkMultiSampleQuality(D3DMULTISAMPLE_TYPE type, DWORD *outQuality, D3DFORMAT format, UINT adapterNum, D3DDEVTYPE deviceType, BOOL fullScreen);
128 
134 
136 
137 
139  virtual RenderSystemCapabilities* createRenderSystemCapabilities() const;
140  RenderSystemCapabilities* updateRenderSystemCapabilities(D3D9RenderWindow* renderWindow);
141 
143  virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary);
144 
145 
146  void convertVertexShaderCaps(RenderSystemCapabilities* rsc) const;
147  void convertPixelShaderCaps(RenderSystemCapabilities* rsc) const;
148  bool checkVertexTextureFormats(D3D9RenderWindow* renderWindow) const;
149  void detachRenderTargetImpl(const String& name);
150 
151  HashMap<IDirect3DDevice9*, unsigned short> mCurrentLights;
154 
155  D3DXMATRIX mDxViewMat, mDxProjMat, mDxWorldMat;
156 
158  // List of additional windows after the first (swap chains)
160 
163  typedef HashMap<unsigned int, D3DFORMAT> DepthStencilHash;
165 
167 
168  protected:
169  void setClipPlanesImpl(const PlaneList& clipPlanes);
170  public:
171  // constructor
172  D3D9RenderSystem( HINSTANCE hInstance );
173  // destructor
174  ~D3D9RenderSystem();
175 
176  virtual void initConfigOptions();
177 
178  // Overridden RenderSystem functions
179  ConfigOptionMap& getConfigOptions();
180  String validateConfigOptions();
181  RenderWindow* _initialise( bool autoCreateWindow, const String& windowTitle = "OGRE Render Window" );
183  RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
184  bool fullScreen, const NameValuePairList *miscParams = 0);
185 
187  bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
188  RenderWindowList& createdWindows);
189 
191  DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget );
192 
198  DepthBuffer* _addManualDepthBuffer( IDirect3DDevice9* depthSurfaceDevice, IDirect3DSurface9 *surf );
199 
210  void _cleanupDepthBuffers( IDirect3DDevice9 *creator );
211 
219  void _cleanupDepthBuffers( IDirect3DSurface9 *manualSurface );
220 
224  void _setRenderTarget(RenderTarget *target);
225 
227  virtual MultiRenderTarget * createMultiRenderTarget(const String & name);
228 
230  virtual RenderTarget * detachRenderTarget(const String &name);
231 
232  String getErrorDescription( long errorNumber ) const;
233  const String& getName() const;
234  // Low-level overridden members
235  void setConfigOption( const String &name, const String &value );
236  void reinitialise();
237  void shutdown();
238  void setAmbientLight( float r, float g, float b );
239  void setShadingType( ShadeOptions so );
240  void setLightingEnabled( bool enabled );
241  void destroyRenderTarget(const String& name);
242  VertexElementType getColourVertexElementType() const;
243  void setStencilCheckEnabled(bool enabled);
244  void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS,
245  uint32 refValue = 0, uint32 mask = 0xFFFFFFFF,
246  StencilOperation stencilFailOp = SOP_KEEP,
247  StencilOperation depthFailOp = SOP_KEEP,
248  StencilOperation passOp = SOP_KEEP,
249  bool twoSidedOperation = false);
250  void setNormaliseNormals(bool normalise);
251 
252  // Low-level overridden members, mainly for internal use
253  void _useLights(const LightList& lights, unsigned short limit);
254  void _setWorldMatrix( const Matrix4 &m );
255  void _setViewMatrix( const Matrix4 &m );
256  void _setProjectionMatrix( const Matrix4 &m );
257  void _setSurfaceParams( const ColourValue &ambient, const ColourValue &diffuse, const ColourValue &specular, const ColourValue &emissive, Real shininess, TrackVertexColourType tracking );
258  void _setPointSpritesEnabled(bool enabled);
259  void _setPointParameters(Real size, bool attenuationEnabled,
260  Real constant, Real linear, Real quadratic, Real minSize, Real maxSize);
261  void _setTexture(size_t unit, bool enabled, const TexturePtr &texPtr);
262  void _setVertexTexture(size_t unit, const TexturePtr& tex);
263  void _disableTextureUnit(size_t texUnit);
264  void _setTextureCoordSet( size_t unit, size_t index );
265  void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m,
266  const Frustum* frustum = 0);
267  void _setTextureBlendMode( size_t unit, const LayerBlendModeEx& bm );
268  void _setTextureAddressingMode(size_t stage, const TextureUnitState::UVWAddressingMode& uvw);
269  void _setTextureBorderColour(size_t stage, const ColourValue& colour);
270  void _setTextureMipmapBias(size_t unit, float bias);
271  void _setTextureMatrix( size_t unit, const Matrix4 &xform );
272  void _setSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op );
273  void _setSeparateSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha, SceneBlendFactor destFactorAlpha, SceneBlendOperation op, SceneBlendOperation alphaOp );
274  void _setAlphaRejectSettings( CompareFunction func, unsigned char value, bool alphaToCoverage );
275  void _setViewport( Viewport *vp );
276  void _beginFrame();
277  virtual RenderSystemContext* _pauseFrame(void);
278  virtual void _resumeFrame(RenderSystemContext* context);
279  void _endFrame();
280  void _setCullingMode( CullingMode mode );
281  void _setDepthBufferParams( bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL );
282  void _setDepthBufferCheckEnabled( bool enabled = true );
283  void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha);
284  void _setDepthBufferWriteEnabled(bool enabled = true);
285  void _setDepthBufferFunction( CompareFunction func = CMPF_LESS_EQUAL );
286  void _setDepthBias(float constantBias, float slopeScaleBias);
287  void _setFog( FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White, Real expDensity = 1.0, Real linearStart = 0.0, Real linearEnd = 1.0 );
288  void _convertProjectionMatrix(const Matrix4& matrix,
289  Matrix4& dest, bool forGpuProgram = false);
290  void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
291  Matrix4& dest, bool forGpuProgram = false);
292  void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top, Real nearPlane,
293  Real farPlane, Matrix4& dest, bool forGpuProgram = false);
294  void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
295  Matrix4& dest, bool forGpuProgram = false);
296  void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
297  bool forGpuProgram);
298  void _setPolygonMode(PolygonMode level);
299  void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter);
300  void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy);
301  void setVertexDeclaration(VertexDeclaration* decl);
302  void setVertexDeclaration(VertexDeclaration* decl, bool useGlobalInstancingVertexBufferIsAvailable);
303  void setVertexBufferBinding(VertexBufferBinding* binding);
304  void setVertexBufferBinding(VertexBufferBinding* binding, size_t numberOfInstances, bool useGlobalInstancingVertexBufferIsAvailable, bool indexesUsed);
305  void _render(const RenderOperation& op);
309  void bindGpuProgram(GpuProgram* prg);
313  void unbindGpuProgram(GpuProgramType gptype);
317  void bindGpuProgramParameters(GpuProgramType gptype,
318  GpuProgramParametersSharedPtr params, uint16 variabilityMask);
319  void bindGpuProgramPassIterationParameters(GpuProgramType gptype);
320 
321  void setScissorTest(bool enabled, size_t left = 0, size_t top = 0, size_t right = 800, size_t bottom = 600);
322  void clearFrameBuffer(unsigned int buffers,
323  const ColourValue& colour = ColourValue::Black,
324  Real depth = 1.0f, unsigned short stencil = 0);
325  void setClipPlane (ushort index, Real A, Real B, Real C, Real D);
326  void enableClipPlane (ushort index, bool enable);
327  HardwareOcclusionQuery* createHardwareOcclusionQuery();
328  Real getHorizontalTexelOffset();
329  Real getVerticalTexelOffset();
330  Real getMinimumDepthInputValue();
331  Real getMaximumDepthInputValue();
332  void registerThread();
333  void unregisterThread();
334  void preExtraThreadsStarted();
335  void postExtraThreadsStarted();
336 
337  static D3D9ResourceManager* getResourceManager();
338  static D3D9DeviceManager* getDeviceManager();
339  static IDirect3D9* getDirect3D9();
340  static UINT getResourceCreationDeviceCount();
341  static IDirect3DDevice9* getResourceCreationDevice(UINT index);
342  static IDirect3DDevice9* getActiveD3D9Device();
343 
347  D3DFORMAT _getDepthStencilFormatFor(D3DFORMAT fmt);
348 
352  bool _checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage);
353 
355  void determineFSAASettings(IDirect3DDevice9* d3d9Device, size_t fsaa, const String& fsaaHint, D3DFORMAT d3dPixelFormat,
356  bool fullScreen, D3DMULTISAMPLE_TYPE *outMultisampleType, DWORD *outMultisampleQuality);
357 
359  unsigned int getDisplayMonitorCount() const;
360 
362  virtual void beginProfileEvent( const String &eventName );
363 
365  virtual void endProfileEvent( void );
366 
368  virtual void markProfileEvent( const String &eventName );
369 
371  void fireDeviceEvent( D3D9Device* device, const String & name );
372 
374  MultiheadUseType getMultiheadUse() const { return mMultiheadUse; }
375  protected:
377  DWORD getSamplerId(size_t unit);
378 
380  void notifyOnDeviceLost(D3D9Device* device);
381 
383  void notifyOnDeviceReset(D3D9Device* device);
384 
385  private:
386  friend class D3D9Device;
387  friend class D3D9DeviceManager;
388  };
389 }
390 #endif
Manages the target rendering window.
A 'canvas' which can receive the results of a rendering operation.
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
HashMap< IDirect3DDevice9 *, unsigned short > mCurrentLights
float Real
Software floating point type.
unsigned int uint32
Definition: OgrePlatform.h:270
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:553
Defines a plane in 3D space.
Definition: OgrePlane.h:61
FogMode
Fog modes.
Definition: OgreCommon.h:124
Leave the stencil buffer unchanged.
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:85
eD3DTexType
enum identifying D3D9 tex. types
#define MAX_LIGHTS
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:93
vector< D3D9RenderWindow * >::type D3D9RenderWindowList
structure holding texture unit settings for every stage
SceneBlendFactor
Blending factors for manually blending objects with the scene.
bool mUseNVPerfHUD
NVPerfHUD allowed?
Device manager interface.
D3D9GpuProgramManager * mGpuProgramManager
D3D9Mappings::eD3DTexType texType
the type of the texture
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:138
No fog. Duh.
Definition: OgreCommon.h:127
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:767
static D3D9RenderSystem * msD3D9RenderSystem
Fast singleton access.
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:73
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:70
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:116
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
Specialisation of SharedPtr to allow SharedPtr to be assigned to TexturePtr.
Definition: OgreTexture.h:443
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
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:46
size_t coordIndex
which texCoordIndex to use
TextureType
Enum identifying the texture type.
Definition: OgreTexture.h:68
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:182
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
vector< RenderWindowDescription >::type RenderWindowDescriptionList
Render window creation parameters container.
Definition: OgreCommon.h:764
unsigned short uint16
Definition: OgrePlatform.h:271
D3D9DriverList * mDriverList
List of D3D drivers installed (video cards)
D3D9DeviceManager * mDeviceManager
Factory class for D3D9 HLSL programs.
StencilOperation
Enum describing the various actions which can be taken onthe stencil buffer.
FilterOptions
Filtering options for textures / mipmaps.
Definition: OgreCommon.h:103
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:67
int TrackVertexColourType
An enumeration describing which material properties should track the vertex colours.
Definition: OgreCommon.h:279
Class which manages blending of both colour and alpha components.
void _cleanupDepthBuffers(bool bCleanManualBuffers=true)
Removes all depth buffers.
DepthStencilHash mDepthStencilHash
D3D9RenderWindowList mRenderWindows