OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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 "OgreTextureUnitState.h"
35 #include "OgreCommon.h"
36 
38 #include "OgreConfigOptionMap.h"
39 #include "OgreGpuProgram.h"
40 #include "OgrePlane.h"
42 #include "OgreHeaderPrefix.h"
43 
44 namespace Ogre
45 {
56 
57  class TextureManager;
60  {
71  };
72 
73 
98  {
99  public:
102  RenderSystem();
103 
106  virtual ~RenderSystem();
107 
110  virtual const String& getName(void) const = 0;
111 
133  virtual ConfigOptionMap& getConfigOptions(void) = 0;
134 
154  virtual void setConfigOption(const String &name, const String &value) = 0;
155 
158  virtual HardwareOcclusionQuery* createHardwareOcclusionQuery(void) = 0;
159 
162  virtual void destroyHardwareOcclusionQuery(HardwareOcclusionQuery *hq);
163 
168  virtual String validateConfigOptions(void) = 0;
169 
184  virtual RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
185 
186  /*
187  Returns whether under the current render system buffers marked as TU_STATIC can be locked for update
188  @remarks
189  Needed in the implementation of DirectX9 with DirectX9Ex driver
190  */
191  virtual bool isStaticBufferLockable() const { return true; }
192 
194  virtual RenderSystemCapabilities* createRenderSystemCapabilities() const = 0;
195 
203  RenderSystemCapabilities* getMutableCapabilities(){ return mCurrentCapabilities; }
204 
211  virtual void useCustomRenderSystemCapabilities(RenderSystemCapabilities* capabilities);
212 
215  virtual void reinitialise(void) = 0;
216 
219  virtual void shutdown(void);
220 
221 
224  virtual void setAmbientLight(float r, float g, float b) = 0;
225 
228  virtual void setShadingType(ShadeOptions so) = 0;
229 
235  virtual void setLightingEnabled(bool enabled) = 0;
236 
243  void setWBufferEnabled(bool enabled);
244 
247  bool getWBufferEnabled(void) const;
248 
501  virtual RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
502  bool fullScreen, const NameValuePairList *miscParams = 0) = 0;
503 
519  virtual bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
520  RenderWindowList& createdWindows);
521 
522 
527  virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0;
528 
530  virtual void destroyRenderWindow(const String& name);
532  virtual void destroyRenderTexture(const String& name);
534  virtual void destroyRenderTarget(const String& name);
535 
538  virtual void attachRenderTarget( RenderTarget &target );
542  virtual RenderTarget * getRenderTarget( const String &name );
548  virtual RenderTarget * detachRenderTarget( const String &name );
549 
552 
555  return RenderTargetIterator( mRenderTargets.begin(), mRenderTargets.end() );
556  }
559  virtual String getErrorDescription(long errorNumber) const = 0;
560 
563  HardwareVertexBufferSharedPtr getGlobalInstanceVertexBuffer() const;
566  void setGlobalInstanceVertexBuffer(const HardwareVertexBufferSharedPtr &val);
569  VertexDeclaration* getGlobalInstanceVertexBufferVertexDeclaration() const;
572  void setGlobalInstanceVertexBufferVertexDeclaration( VertexDeclaration* val);
575  size_t getGlobalNumberOfInstances() const;
578  void setGlobalNumberOfInstances(const size_t val);
579 
582  void setFixedPipelineEnabled(bool enabled);
583 
586  bool getFixedPipelineEnabled(void) const;
587 
593  virtual void setDepthBufferFor( RenderTarget *renderTarget );
594 
595  // ------------------------------------------------------------------------
596  // Internal Rendering Access
597  // All methods below here are normally only called by other OGRE classes
598  // They can be called by library user if required
599  // ------------------------------------------------------------------------
600 
601 
605  virtual void _useLights(const LightList& lights, unsigned short limit) = 0;
608  virtual bool areFixedFunctionLightsInViewSpace() const { return false; }
610  virtual void _setWorldMatrix(const Matrix4 &m) = 0;
612  virtual void _setWorldMatrices(const Matrix4* m, unsigned short count);
614  virtual void _setViewMatrix(const Matrix4 &m) = 0;
616  virtual void _setProjectionMatrix(const Matrix4 &m) = 0;
622  virtual void _setTextureUnitSettings(size_t texUnit, TextureUnitState& tl);
624  virtual void _setBindingType(TextureUnitState::BindingType bindigType);
626  virtual void _disableTextureUnit(size_t texUnit);
628  virtual void _disableTextureUnitsFrom(size_t texUnit);
662  virtual void _setSurfaceParams(const ColourValue &ambient,
663  const ColourValue &diffuse, const ColourValue &specular,
664  const ColourValue &emissive, Real shininess,
665  TrackVertexColourType tracking = TVC_NONE) = 0;
666 
672  virtual void _setPointSpritesEnabled(bool enabled) = 0;
673 
684  virtual void _setPointParameters(Real size, bool attenuationEnabled,
685  Real constant, Real linear, Real quadratic, Real minSize, Real maxSize) = 0;
686 
687 
700  virtual void _setTexture(size_t unit, bool enabled,
701  const TexturePtr &texPtr) = 0;
715  virtual void _setTexture(size_t unit, bool enabled, const String &texname);
716 
727  virtual void _setVertexTexture(size_t unit, const TexturePtr& tex);
728  virtual void _setGeometryTexture(size_t unit, const TexturePtr& tex);
729  virtual void _setComputeTexture(size_t unit, const TexturePtr& tex);
730  virtual void _setTessellationHullTexture(size_t unit, const TexturePtr& tex);
731  virtual void _setTessellationDomainTexture(size_t unit, const TexturePtr& tex);
732 
742  virtual void _setTextureCoordSet(size_t unit, size_t index) = 0;
743 
751  virtual void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m,
752  const Frustum* frustum = 0) = 0;
753 
760  virtual void _setTextureBlendMode(size_t unit, const LayerBlendModeEx& bm) = 0;
761 
768  virtual void _setTextureUnitFiltering(size_t unit, FilterOptions minFilter,
769  FilterOptions magFilter, FilterOptions mipFilter);
770 
776  virtual void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter) = 0;
777 
782  virtual void _setTextureUnitCompareEnabled(size_t unit, bool compare) = 0;
783 
784 
789  virtual void _setTextureUnitCompareFunction(size_t unit, CompareFunction function) = 0;
790 
791 
793  virtual void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy) = 0;
794 
796  virtual void _setTextureAddressingMode(size_t unit, const TextureUnitState::UVWAddressingMode& uvw) = 0;
797 
799  virtual void _setTextureBorderColour(size_t unit, const ColourValue& colour) = 0;
800 
809  virtual void _setTextureMipmapBias(size_t unit, float bias) = 0;
810 
815  virtual void _setTextureMatrix(size_t unit, const Matrix4& xform) = 0;
816 
827  virtual void _setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op = SBO_ADD) = 0;
828 
841  virtual void _setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha,
842  SceneBlendFactor destFactorAlpha, SceneBlendOperation op = SBO_ADD, SceneBlendOperation alphaOp = SBO_ADD) = 0;
843 
850  virtual void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage) = 0;
851 
855  virtual void _setTextureProjectionRelativeTo(bool enabled, const Vector3& pos);
856 
864  virtual DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget ) = 0;
865 
873  void _cleanupDepthBuffers( bool bCleanManualBuffers=true );
874 
879  virtual void _beginFrame(void) = 0;
880 
881  //Dummy structure for render system contexts - implementing RenderSystems can extend
882  //as needed
889  virtual RenderSystemContext* _pauseFrame(void);
896  virtual void _resumeFrame(RenderSystemContext* context);
897 
901  virtual void _endFrame(void) = 0;
909  virtual void _setViewport(Viewport *vp) = 0;
911  virtual Viewport* _getViewport(void);
912 
924  virtual void _setCullingMode(CullingMode mode) = 0;
925 
926  virtual CullingMode _getCullingMode(void) const;
927 
941  virtual void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL) = 0;
942 
947  virtual void _setDepthBufferCheckEnabled(bool enabled = true) = 0;
952  virtual void _setDepthBufferWriteEnabled(bool enabled = true) = 0;
960  virtual void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL) = 0;
968  virtual void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha) = 0;
991  virtual void _setDepthBias(float constantBias, float slopeScaleBias = 0.0f) = 0;
1003  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;
1004 
1005 
1007  virtual void _beginGeometryCount(void);
1009  virtual unsigned int _getFaceCount(void) const;
1011  virtual unsigned int _getBatchCount(void) const;
1013  virtual unsigned int _getVertexCount(void) const;
1014 
1023  virtual void convertColourValue(const ColourValue& colour, uint32* pDest);
1027  virtual VertexElementType getColourVertexElementType(void) const = 0;
1028 
1035  virtual void _convertProjectionMatrix(const Matrix4& matrix,
1036  Matrix4& dest, bool forGpuProgram = false) = 0;
1037 
1044  virtual void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1045  Matrix4& dest, bool forGpuProgram = false) = 0;
1046 
1053  virtual void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top,
1054  Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false) = 0;
1061  virtual void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1062  Matrix4& dest, bool forGpuProgram = false) = 0;
1063 
1080  virtual void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
1081  bool forGpuProgram) = 0;
1082 
1084  virtual void _setPolygonMode(PolygonMode level) = 0;
1085 
1097  // virtual void setDepthCheckEnabled(bool enabled) = 0;
1098 
1105  virtual void setStencilCheckEnabled(bool enabled) = 0;
1121  /*virtual bool hasHardwareStencil(void) = 0;*/
1122 
1162  uint32 refValue = 0, uint32 compareMask = 0xFFFFFFFF, uint32 writeMask = 0xFFFFFFFF,
1163  StencilOperation stencilFailOp = SOP_KEEP,
1164  StencilOperation depthFailOp = SOP_KEEP,
1165  StencilOperation passOp = SOP_KEEP,
1166  bool twoSidedOperation = false,
1167  bool readBackAsTexture = false) {};
1168 
1169 
1170 
1172  virtual void setVertexDeclaration(VertexDeclaration* decl) = 0;
1174  virtual void setVertexBufferBinding(VertexBufferBinding* binding) = 0;
1175 
1186  virtual void setNormaliseNormals(bool normalise) = 0;
1187 
1200  virtual void _render(const RenderOperation& op);
1201 
1202  virtual void _renderUsingReadBackAsTexture(unsigned int secondPass,Ogre::String variableName,unsigned int StartSlot);
1203 
1205  const RenderSystemCapabilities* getCapabilities(void) const { return mCurrentCapabilities; }
1206 
1207 
1210  virtual const DriverVersion& getDriverVersion(void) const { return mDriverVersion; }
1211 
1221  virtual const String& _getDefaultViewportMaterialScheme(void) const;
1222 
1227  virtual void bindGpuProgram(GpuProgram* prg);
1228 
1234  virtual void bindGpuProgramParameters(GpuProgramType gptype,
1235  GpuProgramParametersSharedPtr params, uint16 variabilityMask) = 0;
1236 
1239  virtual void bindGpuProgramPassIterationParameters(GpuProgramType gptype) = 0;
1244  virtual void unbindGpuProgram(GpuProgramType gptype);
1245 
1247  virtual bool isGpuProgramBound(GpuProgramType gptype);
1248 
1254  uint16 getNativeShadingLanguageVersion() const { return mNativeShadingLanguageVersion; }
1255 
1258  virtual void setClipPlanes(const PlaneList& clipPlanes);
1259 
1261  virtual void addClipPlane (const Plane &p);
1263  virtual void addClipPlane (Real A, Real B, Real C, Real D);
1264 
1267  virtual void resetClipPlanes();
1268 
1270  virtual void _initRenderTargets(void);
1271 
1274  virtual void setInvertVertexWinding(bool invert);
1275 
1279  virtual bool getInvertVertexWinding(void) const;
1280 
1292  virtual void setScissorTest(bool enabled, size_t left = 0, size_t top = 0,
1293  size_t right = 800, size_t bottom = 600) = 0;
1294 
1302  virtual void clearFrameBuffer(unsigned int buffers,
1303  const ColourValue& colour = ColourValue::Black,
1304  Real depth = 1.0f, unsigned short stencil = 0) = 0;
1314  virtual Real getHorizontalTexelOffset(void) = 0;
1324  virtual Real getVerticalTexelOffset(void) = 0;
1325 
1334  virtual Real getMinimumDepthInputValue(void) = 0;
1343  virtual Real getMaximumDepthInputValue(void) = 0;
1349  virtual void setCurrentPassIterationCount(const size_t count) { mCurrentPassIterationCount = count; }
1350 
1360  virtual void setDeriveDepthBias(bool derive, float baseValue = 0.0f,
1361  float multiplier = 0.0f, float slopeScale = 0.0f)
1362  {
1363  mDerivedDepthBias = derive;
1364  mDerivedDepthBiasBase = baseValue;
1365  mDerivedDepthBiasMultiplier = multiplier;
1366  mDerivedDepthBiasSlopeScale = slopeScale;
1367  }
1368 
1372  virtual void _setRenderTarget(RenderTarget *target) = 0;
1373 
1379  {
1380  public:
1382  virtual ~Listener() {}
1383 
1389  virtual void eventOccurred(const String& eventName,
1390  const NameValuePairList* parameters = 0) = 0;
1391  };
1405  virtual void addListener(Listener* l);
1408  virtual void removeListener(Listener* l);
1409 
1414  virtual const StringVector& getRenderSystemEvents(void) const { return mEventNames; }
1415 
1432  virtual void preExtraThreadsStarted() = 0;
1433 
1434  /* Tell the rendersystem to perform any tasks it needs to directly
1435  after other threads which might access the rendering API are registered.
1436  @see RenderSystem::preExtraThreadsStarted
1437  */
1438  virtual void postExtraThreadsStarted() = 0;
1439 
1452  virtual void registerThread() = 0;
1453 
1457  virtual void unregisterThread() = 0;
1458 
1463  virtual unsigned int getDisplayMonitorCount() const = 0;
1464 
1468  virtual void beginProfileEvent( const String &eventName ) = 0;
1469 
1473  virtual void endProfileEvent( void ) = 0;
1474 
1479  virtual void markProfileEvent( const String &event ) = 0;
1480 
1483  virtual bool hasAnisotropicMipMapFilter() const = 0;
1484 
1490  virtual void getCustomAttribute(const String& name, void* pData);
1491 
1492  protected:
1493 
1496 
1501 
1509 
1510  // Texture manager
1511  // A concrete class of this will be created and
1512  // made available under the TextureManager singleton,
1513  // managed by the RenderSystem
1515 
1516  // Active viewport (dest for future rendering operations)
1518 
1520 
1521  bool mWBuffer;
1522 
1523  size_t mBatchCount;
1524  size_t mFaceCount;
1526 
1528  ColourValue mManualBlendColours[OGRE_MAX_TEXTURE_LAYERS][2];
1529 
1531 
1534 
1543 
1550 
1553 
1558  bool updatePassIterationRenderState(void);
1559 
1562 
1564  virtual void fireEvent(const String& name, const NameValuePairList* params = 0);
1565 
1568 
1571 
1578 
1579  // Recording user clip planes
1581  // Indicator that we need to re-set the clip planes on next render call
1583 
1588 
1590  virtual void setClipPlanesImpl(const PlaneList& clipPlanes) = 0;
1591 
1593  virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary) = 0;
1594 
1595 
1598 
1601 
1602 
1603 
1604  };
1607 }
1608 
1609 #include "OgreHeaderSuffix.h"
1610 
1611 #endif
virtual const DriverVersion & getDriverVersion(void) const
Returns the driver version.
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.
GpuProgramParametersSharedPtr mActiveFragmentGpuProgramParameters
RenderSystemCapabilities * mCurrentCapabilities
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:79
float Real
Software floating point type.
unsigned int uint32
Definition: OgrePlatform.h:420
#define _OgreExport
Definition: OgrePlatform.h:255
std::vector< T, A > type
GpuProgramParametersSharedPtr mActiveGeometryGpuProgramParameters
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
bool mEnableFixedPipeline
is fixed pipeline enabled
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:580
bool mDerivedDepthBias
Whether to update the depth bias per render call.
Defines a plane in 3D space.
Definition: OgrePlane.h:61
FogMode
Fog modes.
Definition: OgreCommon.h:152
GpuProgramParametersSharedPtr mActiveComputeGpuProgramParameters
map< String, RenderTarget * >::type RenderTargetMap
Class for loading & managing textures.
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
GpuProgramParametersSharedPtr mActiveTessellationHullGpuProgramParameters
virtual void setCurrentPassIterationCount(const size_t count)
set the current multi pass count value.
StringVector mEventNames
List of names of events this rendersystem may raise.
RenderSystemCapabilities * mRealCapabilities
Used to store the capabilities of the graphics card.
Defines a program which runs on the GPU such as a vertex or fragment program.
VertexDeclaration * mGlobalInstanceVertexBufferVertexDeclaration
a vertex declaration for the global vertex buffer for the global instancing
TexCoordCalcMethod
Enum describing the ways to generate texture coordinates.
MapIterator< Ogre::RenderTargetMap > RenderTargetIterator
Iterator over RenderTargets.
Shared pointer implementation used to share vertex buffers.
FilterType
Definition: OgreCommon.h:121
vector< DepthBuffer * >::type DepthBufferVec
SceneBlendFactor
Blending factors for manually blending objects with the scene.
BindingType
The type of unit to bind the texture settings to.
Environment map based on vertex positions.
RenderTarget * mActiveRenderTarget
The Active render target.
size_t mGlobalNumberOfInstances
the number of global instances (this number will be multiply by the render op instance number) ...
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:166
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
No fog. Duh.
Definition: OgreCommon.h:155
uint16 getNativeShadingLanguageVersion() const
Gets the native shading language version for this render system.
This class represents a render target that renders to multiple RenderTextures at once.
No calculated texture coordinates.
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
ListenerList mEventListeners
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160
HardwareOcclusionQueryList mHwOcclusionQueries
#define OGRE_MAX_TEXTURE_LAYERS
Define max number of texture layers allowed per pass on any card.
Definition: OgreConfig.h:72
DepthBufferMap mDepthBufferPool
DepthBuffers to be attached to render targets.
size_t mDisabledTexUnitsFrom
Texture units from this upwards are disabled.
virtual const StringVector & getRenderSystemEvents(void) const
Gets a list of the rendersystem specific events that this rendersystem can raise. ...
An abstract class that contains a depth/stencil buffer.
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the cu...
virtual RenderTargetIterator getRenderTargetIterator(void)
Returns a specialised MapIterator over all render targets attached to the RenderSystem.
const RenderSystemCapabilities * getCapabilities(void) const
Gets the capabilities of the render system.
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:144
uint16 mNativeShadingLanguageVersion
Texture addressing mode for each texture coordinate.
map< String, ConfigOption >::type ConfigOptionMap
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
VertexElementType
Vertex element type, used to identify the base types of the vertex contents.
vector< String >::type StringVector
RenderSystemCapabilities * getMutableCapabilities()
Get a pointer to the current capabilities being used by the RenderSystem.
DriverVersion mDriverVersion
size_t mCurrentPassIterationCount
number of times to render the current state
Standard 3-dimensional vector.
Definition: OgreVector3.h:50
StencilOperation
Enum describing the various actions which can be taken on the stencil buffer.
Definition: OgreCommon.h:87
GpuProgramParametersSharedPtr mActiveVertexGpuProgramParameters
The Active GPU programs and gpu program parameters.
virtual void setStencilBufferParams(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0, uint32 compareMask=0xFFFFFFFF, uint32 writeMask=0xFFFFFFFF, StencilOperation stencilFailOp=SOP_KEEP, StencilOperation depthFailOp=SOP_KEEP, StencilOperation passOp=SOP_KEEP, bool twoSidedOperation=false, bool readBackAsTexture=false)
Determines if this system supports hardware accelerated stencil buffer.
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 ...
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...
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:49
virtual bool areFixedFunctionLightsInViewSpace() const
Are fixed-function lights provided in view space? Affects optimisation.
TextureManager * mTextureManager
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:210
virtual bool isStaticBufferLockable() const
static const ColourValue Black
SceneBlendOperation
Blending operations controls how objects are blended into the scene.
singleton class for storing the capabilities of the graphics card.
list< HardwareOcclusionQuery * >::type HardwareOcclusionQueryList
HardwareVertexBufferSharedPtr mGlobalInstanceVertexBuffer
a global vertex buffer for global instancing
map< uint16, DepthBufferVec >::type DepthBufferMap
_StringBase String
Definition: OgreCommon.h:53
GpuProgramParametersSharedPtr mActiveTessellationDomainGpuProgramParameters
vector< RenderWindowDescription >::type RenderWindowDescriptionList
Render window creation parameters container.
Definition: OgreCommon.h:791
unsigned short uint16
Definition: OgrePlatform.h:421
FilterOptions
Filtering options for textures / mipmaps.
Definition: OgreCommon.h:131
Environment map based on vertex normals.
Defines the functionality of a 3D API.
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:74
Class representing the state of a single texture unit during a Pass of a Technique, of a Material.
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.
RenderTargetMap mRenderTargets
The render targets.
Defines a listener on the custom events that this render system can raise.
list< Listener * >::type ListenerList