OGRE  1.9.0
OgreRenderSystem.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 __RenderSystem_H_
29 #define __RenderSystem_H_
30 
31 // Precompiler options
32 #include "OgrePrerequisites.h"
33 
34 #include "OgreString.h"
35 
36 #include "OgreTextureUnitState.h"
37 #include "OgreCommon.h"
38 
39 #include "OgreMaterialManager.h"
40 #include "OgreRenderOperation.h"
42 #include "OgreRenderTarget.h"
43 #include "OgreRenderTexture.h"
44 #include "OgreFrameListener.h"
45 #include "OgreConfigOptionMap.h"
46 #include "OgreGpuProgram.h"
47 #include "OgrePlane.h"
48 #include "OgreIteratorWrappers.h"
49 #include "OgreHeaderPrefix.h"
50 
51 namespace Ogre
52 {
64 
65  class TextureManager;
68  {
79  };
82  {
99  };
100 
101 
124  {
125  public:
128  RenderSystem();
129 
132  virtual ~RenderSystem();
133 
136  virtual const String& getName(void) const = 0;
137 
159  virtual ConfigOptionMap& getConfigOptions(void) = 0;
160 
180  virtual void setConfigOption(const String &name, const String &value) = 0;
181 
184  virtual HardwareOcclusionQuery* createHardwareOcclusionQuery(void) = 0;
185 
188  virtual void destroyHardwareOcclusionQuery(HardwareOcclusionQuery *hq);
189 
194  virtual String validateConfigOptions(void) = 0;
195 
210  virtual RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
211 
212  /*
213  Returns whether under the current render system buffers marked as TU_STATIC can be locked for update
214  @remarks
215  Needed in the implementation of DirectX9 with DirectX9Ex driver
216  */
217  virtual bool isStaticBufferLockable() const { return true; }
218 
220  virtual RenderSystemCapabilities* createRenderSystemCapabilities() const = 0;
221 
229  RenderSystemCapabilities* getMutableCapabilities(){ return mCurrentCapabilities; }
230 
237  virtual void useCustomRenderSystemCapabilities(RenderSystemCapabilities* capabilities);
238 
241  virtual void reinitialise(void) = 0;
242 
245  virtual void shutdown(void);
246 
247 
250  virtual void setAmbientLight(float r, float g, float b) = 0;
251 
254  virtual void setShadingType(ShadeOptions so) = 0;
255 
261  virtual void setLightingEnabled(bool enabled) = 0;
262 
269  void setWBufferEnabled(bool enabled);
270 
273  bool getWBufferEnabled(void) const;
274 
605  virtual RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
606  bool fullScreen, const NameValuePairList *miscParams = 0) = 0;
607 
624  virtual bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
625  RenderWindowList& createdWindows);
626 
627 
632  virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0;
633 
635  virtual void destroyRenderWindow(const String& name);
637  virtual void destroyRenderTexture(const String& name);
639  virtual void destroyRenderTarget(const String& name);
640 
643  virtual void attachRenderTarget( RenderTarget &target );
647  virtual RenderTarget * getRenderTarget( const String &name );
653  virtual RenderTarget * detachRenderTarget( const String &name );
654 
657 
660  return RenderTargetIterator( mRenderTargets.begin(), mRenderTargets.end() );
661  }
664  virtual String getErrorDescription(long errorNumber) const = 0;
665 
668  HardwareVertexBufferSharedPtr getGlobalInstanceVertexBuffer() const;
671  void setGlobalInstanceVertexBuffer(const HardwareVertexBufferSharedPtr &val);
674  VertexDeclaration* getGlobalInstanceVertexBufferVertexDeclaration() const;
677  void setGlobalInstanceVertexBufferVertexDeclaration( VertexDeclaration* val);
680  size_t getGlobalNumberOfInstances() const;
683  void setGlobalNumberOfInstances(const size_t val);
684 
687  void setFixedPipelineEnabled(bool enabled);
688 
691  bool getFixedPipelineEnabled(void) const;
692 
698  virtual void setDepthBufferFor( RenderTarget *renderTarget );
699 
700  // ------------------------------------------------------------------------
701  // Internal Rendering Access
702  // All methods below here are normally only called by other OGRE classes
703  // They can be called by library user if required
704  // ------------------------------------------------------------------------
705 
706 
710  virtual void _useLights(const LightList& lights, unsigned short limit) = 0;
713  virtual bool areFixedFunctionLightsInViewSpace() const { return false; }
715  virtual void _setWorldMatrix(const Matrix4 &m) = 0;
717  virtual void _setWorldMatrices(const Matrix4* m, unsigned short count);
719  virtual void _setViewMatrix(const Matrix4 &m) = 0;
721  virtual void _setProjectionMatrix(const Matrix4 &m) = 0;
727  virtual void _setTextureUnitSettings(size_t texUnit, TextureUnitState& tl);
729  virtual void _disableTextureUnit(size_t texUnit);
731  virtual void _disableTextureUnitsFrom(size_t texUnit);
765  virtual void _setSurfaceParams(const ColourValue &ambient,
766  const ColourValue &diffuse, const ColourValue &specular,
767  const ColourValue &emissive, Real shininess,
768  TrackVertexColourType tracking = TVC_NONE) = 0;
769 
775  virtual void _setPointSpritesEnabled(bool enabled) = 0;
776 
787  virtual void _setPointParameters(Real size, bool attenuationEnabled,
788  Real constant, Real linear, Real quadratic, Real minSize, Real maxSize) = 0;
789 
790 
803  virtual void _setTexture(size_t unit, bool enabled,
804  const TexturePtr &texPtr) = 0;
818  virtual void _setTexture(size_t unit, bool enabled, const String &texname);
819 
829  virtual void _setVertexTexture(size_t unit, const TexturePtr& tex);
830 
840  virtual void _setTextureCoordSet(size_t unit, size_t index) = 0;
841 
849  virtual void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m,
850  const Frustum* frustum = 0) = 0;
851 
858  virtual void _setTextureBlendMode(size_t unit, const LayerBlendModeEx& bm) = 0;
859 
866  virtual void _setTextureUnitFiltering(size_t unit, FilterOptions minFilter,
867  FilterOptions magFilter, FilterOptions mipFilter);
868 
874  virtual void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter) = 0;
875 
880  virtual void _setTextureUnitCompareEnabled(size_t unit, bool compare) = 0;
881 
882 
887  virtual void _setTextureUnitCompareFunction(size_t unit, CompareFunction function) = 0;
888 
889 
891  virtual void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy) = 0;
892 
894  virtual void _setTextureAddressingMode(size_t unit, const TextureUnitState::UVWAddressingMode& uvw) = 0;
895 
897  virtual void _setTextureBorderColour(size_t unit, const ColourValue& colour) = 0;
898 
907  virtual void _setTextureMipmapBias(size_t unit, float bias) = 0;
908 
913  virtual void _setTextureMatrix(size_t unit, const Matrix4& xform) = 0;
914 
925  virtual void _setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op = SBO_ADD) = 0;
926 
939  virtual void _setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha,
940  SceneBlendFactor destFactorAlpha, SceneBlendOperation op = SBO_ADD, SceneBlendOperation alphaOp = SBO_ADD) = 0;
941 
948  virtual void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage) = 0;
949 
953  virtual void _setTextureProjectionRelativeTo(bool enabled, const Vector3& pos);
954 
962  virtual DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget ) = 0;
963 
971  void _cleanupDepthBuffers( bool bCleanManualBuffers=true );
972 
977  virtual void _beginFrame(void) = 0;
978 
979  //Dummy structure for render system contexts - implementing RenderSystems can extend
980  //as needed
987  virtual RenderSystemContext* _pauseFrame(void);
994  virtual void _resumeFrame(RenderSystemContext* context);
995 
999  virtual void _endFrame(void) = 0;
1007  virtual void _setViewport(Viewport *vp) = 0;
1009  virtual Viewport* _getViewport(void);
1010 
1022  virtual void _setCullingMode(CullingMode mode) = 0;
1023 
1024  virtual CullingMode _getCullingMode(void) const;
1025 
1039  virtual void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL) = 0;
1040 
1045  virtual void _setDepthBufferCheckEnabled(bool enabled = true) = 0;
1050  virtual void _setDepthBufferWriteEnabled(bool enabled = true) = 0;
1058  virtual void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL) = 0;
1066  virtual void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha) = 0;
1089  virtual void _setDepthBias(float constantBias, float slopeScaleBias = 0.0f) = 0;
1101  virtual void _setFog(FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White, Real expDensity = 1.0, Real linearStart = 0.0, Real linearEnd = 1.0) = 0;
1102 
1103 
1105  virtual void _beginGeometryCount(void);
1107  virtual unsigned int _getFaceCount(void) const;
1109  virtual unsigned int _getBatchCount(void) const;
1111  virtual unsigned int _getVertexCount(void) const;
1112 
1121  virtual void convertColourValue(const ColourValue& colour, uint32* pDest);
1125  virtual VertexElementType getColourVertexElementType(void) const = 0;
1126 
1133  virtual void _convertProjectionMatrix(const Matrix4& matrix,
1134  Matrix4& dest, bool forGpuProgram = false) = 0;
1135 
1142  virtual void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1143  Matrix4& dest, bool forGpuProgram = false) = 0;
1144 
1151  virtual void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top,
1152  Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false) = 0;
1159  virtual void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1160  Matrix4& dest, bool forGpuProgram = false) = 0;
1161 
1178  virtual void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
1179  bool forGpuProgram) = 0;
1180 
1182  virtual void _setPolygonMode(PolygonMode level) = 0;
1183 
1190  virtual void setStencilCheckEnabled(bool enabled) = 0;
1206  /*virtual bool hasHardwareStencil(void) = 0;*/
1207 
1246  virtual void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS,
1247  uint32 refValue = 0, uint32 compareMask = 0xFFFFFFFF, uint32 writeMask = 0xFFFFFFFF,
1248  StencilOperation stencilFailOp = SOP_KEEP,
1249  StencilOperation depthFailOp = SOP_KEEP,
1250  StencilOperation passOp = SOP_KEEP,
1251  bool twoSidedOperation = false) = 0;
1252 
1253 
1254 
1256  virtual void setVertexDeclaration(VertexDeclaration* decl) = 0;
1258  virtual void setVertexBufferBinding(VertexBufferBinding* binding) = 0;
1259 
1270  virtual void setNormaliseNormals(bool normalise) = 0;
1271 
1284  virtual void _render(const RenderOperation& op);
1285 
1287  const RenderSystemCapabilities* getCapabilities(void) const { return mCurrentCapabilities; }
1288 
1289 
1292  virtual const DriverVersion& getDriverVersion(void) const { return mDriverVersion; }
1293 
1303  virtual const String& _getDefaultViewportMaterialScheme(void) const;
1304 
1309  virtual void bindGpuProgram(GpuProgram* prg);
1310 
1316  virtual void bindGpuProgramParameters(GpuProgramType gptype,
1317  GpuProgramParametersSharedPtr params, uint16 variabilityMask) = 0;
1318 
1321  virtual void bindGpuProgramPassIterationParameters(GpuProgramType gptype) = 0;
1326  virtual void unbindGpuProgram(GpuProgramType gptype);
1327 
1329  virtual bool isGpuProgramBound(GpuProgramType gptype);
1330 
1336  uint16 getNativeShadingLanguageVersion() const { return mNativeShadingLanguageVersion; }
1337 
1340  virtual void setClipPlanes(const PlaneList& clipPlanes);
1341 
1343  virtual void addClipPlane (const Plane &p);
1345  virtual void addClipPlane (Real A, Real B, Real C, Real D);
1346 
1349  virtual void resetClipPlanes();
1350 
1352  virtual void _initRenderTargets(void);
1353 
1357  virtual void _notifyCameraRemoved(const Camera* cam);
1358 
1360  virtual void _updateAllRenderTargets(bool swapBuffers = true);
1363  virtual void _swapAllRenderTargetBuffers();
1364 
1367  virtual void setInvertVertexWinding(bool invert);
1368 
1372  virtual bool getInvertVertexWinding(void) const;
1373 
1385  virtual void setScissorTest(bool enabled, size_t left = 0, size_t top = 0,
1386  size_t right = 800, size_t bottom = 600) = 0;
1387 
1395  virtual void clearFrameBuffer(unsigned int buffers,
1396  const ColourValue& colour = ColourValue::Black,
1397  Real depth = 1.0f, unsigned short stencil = 0) = 0;
1407  virtual Real getHorizontalTexelOffset(void) = 0;
1417  virtual Real getVerticalTexelOffset(void) = 0;
1418 
1427  virtual Real getMinimumDepthInputValue(void) = 0;
1436  virtual Real getMaximumDepthInputValue(void) = 0;
1442  virtual void setCurrentPassIterationCount(const size_t count) { mCurrentPassIterationCount = count; }
1443 
1453  virtual void setDeriveDepthBias(bool derive, float baseValue = 0.0f,
1454  float multiplier = 0.0f, float slopeScale = 0.0f)
1455  {
1456  mDerivedDepthBias = derive;
1457  mDerivedDepthBiasBase = baseValue;
1458  mDerivedDepthBiasMultiplier = multiplier;
1459  mDerivedDepthBiasSlopeScale = slopeScale;
1460  }
1461 
1465  virtual void _setRenderTarget(RenderTarget *target) = 0;
1466 
1472  {
1473  public:
1475  virtual ~Listener() {}
1476 
1482  virtual void eventOccurred(const String& eventName,
1483  const NameValuePairList* parameters = 0) = 0;
1484  };
1498  virtual void addListener(Listener* l);
1501  virtual void removeListener(Listener* l);
1502 
1507  virtual const StringVector& getRenderSystemEvents(void) const { return mEventNames; }
1508 
1525  virtual void preExtraThreadsStarted() = 0;
1526 
1527  /* Tell the rendersystem to perform any tasks it needs to directly
1528  after other threads which might access the rendering API are registered.
1529  @see RenderSystem::preExtraThreadsStarted
1530  */
1531  virtual void postExtraThreadsStarted() = 0;
1532 
1545  virtual void registerThread() = 0;
1546 
1550  virtual void unregisterThread() = 0;
1551 
1556  virtual unsigned int getDisplayMonitorCount() const = 0;
1557 
1561  virtual void beginProfileEvent( const String &eventName ) = 0;
1562 
1566  virtual void endProfileEvent( void ) = 0;
1567 
1572  virtual void markProfileEvent( const String &event ) = 0;
1573 
1576  virtual bool hasAnisotropicMipMapFilter() const = 0;
1577 
1583  virtual void getCustomAttribute(const String& name, void* pData);
1584 
1585  protected:
1586 
1589 
1596 
1604 
1605  // Texture manager
1606  // A concrete class of this will be created and
1607  // made available under the TextureManager singleton,
1608  // managed by the RenderSystem
1610 
1611  // Active viewport (dest for future rendering operations)
1613 
1615 
1616  bool mWBuffer;
1617 
1618  size_t mBatchCount;
1619  size_t mFaceCount;
1621 
1623  ColourValue mManualBlendColours[OGRE_MAX_TEXTURE_LAYERS][2];
1624 
1626 
1629 
1638 
1645 
1648 
1653  bool updatePassIterationRenderState(void);
1654 
1657 
1659  virtual void fireEvent(const String& name, const NameValuePairList* params = 0);
1660 
1663 
1666 
1673 
1674  // Recording user clip planes
1676  // Indicator that we need to re-set the clip planes on next render call
1678 
1683 
1685  virtual void setClipPlanesImpl(const PlaneList& clipPlanes) = 0;
1686 
1688  virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary) = 0;
1689 
1690 
1693 
1696 
1697 
1698 
1699  };
1702 }
1703 
1704 #include "OgreHeaderSuffix.h"
1705 
1706 #endif
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160
virtual void setDeriveDepthBias(bool derive, float baseValue=0.0f, float multiplier=0.0f, float slopeScale=0.0f)
Tell the render system whether to derive a depth bias on its own based on the values passed to it in ...
A 'canvas' which can receive the results of a rendering operation.
RenderTarget * mActiveRenderTarget
The Active render target.
virtual bool areFixedFunctionLightsInViewSpace() const
Are fixed-function lights provided in view space? Affects optimisation.
GpuProgramParametersSharedPtr mActiveVertexGpuProgramParameters
The Active Gpu programs and Gpu program parameters.
Invert the bits of the stencil buffer.
DriverVersion mDriverVersion
Class for loading & managing textures.
FogMode
Fog modes.
Definition: OgreCommon.h:121
Increase the stencil value by 1, wrapping back to 0 when incrementing the maximum value.
virtual void setCurrentPassIterationCount(const size_t count)
set the current multi pass count value.
Texture addressing mode for each texture coordinate.
Environment map based on vertex positions.
#define _OgreExport
Definition: OgrePlatform.h:260
VertexElementType
Vertex element type, used to identify the base types of the vertex contents.
size_t mDisabledTexUnitsFrom
Texture units from this upwards are disabled.
list< HardwareOcclusionQuery * >::type HardwareOcclusionQueryList
VertexDeclaration * mGlobalInstanceVertexBufferVertexDeclaration
Vertex declaration for the global vertex buffer for the global instancing.
std::vector< T, A > type
Increase the stencil value by 1, clamping at the maximum value.
Leave the stencil buffer unchanged.
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Class representing colour.
float Real
Software floating point type.
static const ColourValue Black
vector< String >::type StringVector
vector< RenderWindowDescription >::type RenderWindowDescriptionList
Render window creation parameters container.
Definition: OgreCommon.h:761
RenderSystemCapabilities * mRealCapabilities
Used to store the capabilities of the graphics card.
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57
TextureManager * mTextureManager
multimap< uchar, RenderTarget * >::type RenderTargetPriorityMap
MapIterator< Ogre::RenderTargetMap > RenderTargetIterator
Iterator over RenderTargets.
Defines a plane in 3D space.
Definition: OgrePlane.h:61
static const ColourValue White
vector< RenderWindow * >::type RenderWindowList
Render window container.
Definition: OgreCommon.h:764
map< uint16, DepthBufferVec >::type DepthBufferMap
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
RenderSystemCapabilities * mCurrentCapabilities
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
Shared pointer implementation used to share vertex buffers.
#define OGRE_MAX_TEXTURE_LAYERS
Define max number of texture layers allowed per pass on any card.
Definition: OgreConfig.h:72
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:135
Class representing the state of a single texture unit during a Pass of a Technique,...
uint16 mNativeShadingLanguageVersion
int TrackVertexColourType
An enumeration describing which material properties should track the vertex colours.
Definition: OgreCommon.h:276
Class which manages blending of both colour and alpha components.
Defines the functionality of a 3D API.
map< String, ConfigOption >::type ConfigOptionMap
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
GpuProgramParametersSharedPtr mActiveTesselationHullGpuProgramParameters
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:64
DepthBufferMap mDepthBufferPool
DepthBuffers to be attached to render targets.
TexCoordCalcMethod
Enum describing the ways to generate texture coordinates.
bool mDerivedDepthBias
Indicator whether to update the depth bias per render call.
HardwareOcclusionQueryList mHwOcclusionQueries
_StringBase String
An abstract class that contains a depth/stencil buffer.
No calculated texture coordinates.
GpuProgramType
Enumerates the types of programs which can run on the GPU.
Defines a listener on the custom events that this render system can raise.
singleton class for storing the capabilities of the graphics card.
bool mEnableFixedPipeline
Indicator whether fixed pipeline is enabled.
map< String, RenderTarget * >::type RenderTargetMap
Set the stencil value to zero.
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
GpuProgramParametersSharedPtr mActiveComputeGpuProgramParameters
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
GpuProgramParametersSharedPtr mActiveGeometryGpuProgramParameters
RenderTargetMap mRenderTargets
The render targets.
unsigned int uint32
Definition: OgrePlatform.h:344
RenderTargetPriorityMap mPrioritisedRenderTargets
The render targets, ordered by priority.
GpuProgramParametersSharedPtr mActiveFragmentGpuProgramParameters
Defines a program which runs on the GPU such as a vertex or fragment program.
SceneBlendFactor
Blending factors for manually blending objects with the scene.
FilterOptions
Filtering options for textures / mipmaps.
Definition: OgreCommon.h:100
Set the stencil value to the reference value.
Environment map based on vertex normals.
Manages the target rendering window.
This is a abstract class that that provides the interface for the query class for hardware occlusion.
No fog. Duh.
Definition: OgreCommon.h:124
Decrease the stencil value by 1, wrapping when decrementing 0.
virtual const DriverVersion & getDriverVersion(void) const
Returns the driver version.
StencilOperation
Enum describing the various actions which can be taken on the stencil buffer.
Decrease the stencil value by 1, clamping at 0.
'New' rendering operation using vertex buffers.
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the cu...
virtual bool isStaticBufferLockable() const
virtual const StringVector & getRenderSystemEvents(void) const
Gets a list of the rendersystem specific events that this rendersystem can raise.
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:113
size_t mCurrentPassIterationCount
Number of times to render the current state.
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:179
SceneBlendOperation
Blending operations controls how objects are blended into the scene.
RenderSystemCapabilities * getMutableCapabilities()
Get a pointer to the current capabilities being used by the RenderSystem.
virtual RenderTargetIterator getRenderTargetIterator(void)
Returns a specialised MapIterator over all render targets attached to the RenderSystem.
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:85
This class represents a render target that renders to multiple RenderTextures at once.
uint16 getNativeShadingLanguageVersion() const
Gets the native shading language version for this render system.
StringVector mEventNames
List of names of events this rendersystem may raise.
ListenerList mEventListeners
HardwareVertexBufferSharedPtr mGlobalInstanceVertexBuffer
Global vertex buffer for global instancing.
list< Listener * >::type ListenerList
vector< DepthBuffer * >::type DepthBufferVec
unsigned short uint16
Definition: OgrePlatform.h:345
const RenderSystemCapabilities * getCapabilities(void) const
Gets the capabilities of the render system.
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
GpuProgramParametersSharedPtr mActiveTesselationDomainGpuProgramParameters
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
size_t mGlobalNumberOfInstances
Number of global instances (this number will be multiply by the render op instance number)
FilterType
Definition: OgreCommon.h:90