OgreRenderSystem.h
Go to the documentation of this file.
/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org
Copyright (c) 2000-2013 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __RenderSystem_H_
#define __RenderSystem_H_
// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreString.h"
#include "OgreTextureUnitState.h"
#include "OgreCommon.h"
#include "OgreMaterialManager.h"
#include "OgreRenderOperation.h"
#include "OgreRenderSystemCapabilities.h"
#include "OgreRenderTarget.h"
#include "OgreRenderTexture.h"
#include "OgreFrameListener.h"
#include "OgreConfigOptionMap.h"
#include "OgreGpuProgram.h"
#include "OgrePlane.h"
#include "OgreIteratorWrappers.h"
#include "OgreHeaderPrefix.h"
namespace Ogre
{
typedef vector<DepthBuffer*>::type DepthBufferVec;
typedef map< uint16, DepthBufferVec >::type DepthBufferMap;
typedef map< String, RenderTarget * >::type RenderTargetMap;
typedef multimap<uchar, RenderTarget * >::type RenderTargetPriorityMap;
class TextureManager;
enum TexCoordCalcMethod
{
TEXCALC_NONE,
TEXCALC_ENVIRONMENT_MAP,
TEXCALC_ENVIRONMENT_MAP_PLANAR,
TEXCALC_ENVIRONMENT_MAP_REFLECTION,
TEXCALC_ENVIRONMENT_MAP_NORMAL,
TEXCALC_PROJECTIVE_TEXTURE
};
enum StencilOperation
{
SOP_KEEP,
SOP_ZERO,
SOP_REPLACE,
SOP_INCREMENT,
SOP_DECREMENT,
SOP_INCREMENT_WRAP,
SOP_DECREMENT_WRAP,
SOP_INVERT
};
class _OgreExport RenderSystem : public RenderSysAlloc
{
public:
RenderSystem();
virtual ~RenderSystem();
virtual const String& getName(void) const = 0;
virtual ConfigOptionMap& getConfigOptions(void) = 0;
virtual void setConfigOption(const String &name, const String &value) = 0;
virtual HardwareOcclusionQuery* createHardwareOcclusionQuery(void) = 0;
virtual void destroyHardwareOcclusionQuery(HardwareOcclusionQuery *hq);
virtual String validateConfigOptions(void) = 0;
virtual RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
/*
Returns whether under the current render system buffers marked as TU_STATIC can be locked for update
@remarks
Needed in the implementation of DirectX9 with DirectX9Ex driver
*/
virtual bool isStaticBufferLockable() const { return true; }
virtual RenderSystemCapabilities* createRenderSystemCapabilities() const = 0;
RenderSystemCapabilities* getMutableCapabilities(){ return mCurrentCapabilities; }
virtual void useCustomRenderSystemCapabilities(RenderSystemCapabilities* capabilities);
virtual void reinitialise(void) = 0;
virtual void shutdown(void);
virtual void setAmbientLight(float r, float g, float b) = 0;
virtual void setShadingType(ShadeOptions so) = 0;
virtual void setLightingEnabled(bool enabled) = 0;
void setWBufferEnabled(bool enabled);
bool getWBufferEnabled(void) const;
virtual RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
bool fullScreen, const NameValuePairList *miscParams = 0) = 0;
virtual bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
RenderWindowList& createdWindows);
virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0;
virtual void destroyRenderWindow(const String& name);
virtual void destroyRenderTexture(const String& name);
virtual void destroyRenderTarget(const String& name);
virtual void attachRenderTarget( RenderTarget &target );
virtual RenderTarget * getRenderTarget( const String &name );
virtual RenderTarget * detachRenderTarget( const String &name );
typedef MapIterator<Ogre::RenderTargetMap> RenderTargetIterator;
virtual RenderTargetIterator getRenderTargetIterator(void) {
return RenderTargetIterator( mRenderTargets.begin(), mRenderTargets.end() );
}
virtual String getErrorDescription(long errorNumber) const = 0;
HardwareVertexBufferSharedPtr getGlobalInstanceVertexBuffer() const;
void setGlobalInstanceVertexBuffer(const HardwareVertexBufferSharedPtr &val);
VertexDeclaration* getGlobalInstanceVertexBufferVertexDeclaration() const;
void setGlobalInstanceVertexBufferVertexDeclaration( VertexDeclaration* val);
size_t getGlobalNumberOfInstances() const;
void setGlobalNumberOfInstances(const size_t val);
void setFixedPipelineEnabled(bool enabled);
bool getFixedPipelineEnabled(void) const;
virtual void setDepthBufferFor( RenderTarget *renderTarget );
// ------------------------------------------------------------------------
// Internal Rendering Access
// All methods below here are normally only called by other OGRE classes
// They can be called by library user if required
// ------------------------------------------------------------------------
virtual void _useLights(const LightList& lights, unsigned short limit) = 0;
virtual bool areFixedFunctionLightsInViewSpace() const { return false; }
virtual void _setWorldMatrix(const Matrix4 &m) = 0;
virtual void _setWorldMatrices(const Matrix4* m, unsigned short count);
virtual void _setViewMatrix(const Matrix4 &m) = 0;
virtual void _setProjectionMatrix(const Matrix4 &m) = 0;
virtual void _setTextureUnitSettings(size_t texUnit, TextureUnitState& tl);
virtual void _disableTextureUnit(size_t texUnit);
virtual void _disableTextureUnitsFrom(size_t texUnit);
virtual void _setSurfaceParams(const ColourValue &ambient,
const ColourValue &diffuse, const ColourValue &specular,
const ColourValue &emissive, Real shininess,
TrackVertexColourType tracking = TVC_NONE) = 0;
virtual void _setPointSpritesEnabled(bool enabled) = 0;
virtual void _setPointParameters(Real size, bool attenuationEnabled,
Real constant, Real linear, Real quadratic, Real minSize, Real maxSize) = 0;
virtual void _setTexture(size_t unit, bool enabled,
const TexturePtr &texPtr) = 0;
virtual void _setTexture(size_t unit, bool enabled, const String &texname);
virtual void _setVertexTexture(size_t unit, const TexturePtr& tex);
virtual void _setTextureCoordSet(size_t unit, size_t index) = 0;
virtual void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m,
const Frustum* frustum = 0) = 0;
virtual void _setTextureBlendMode(size_t unit, const LayerBlendModeEx& bm) = 0;
virtual void _setTextureUnitFiltering(size_t unit, FilterOptions minFilter,
FilterOptions magFilter, FilterOptions mipFilter);
virtual void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter) = 0;
virtual void _setTextureUnitCompareEnabled(size_t unit, bool compare) = 0;
virtual void _setTextureUnitCompareFunction(size_t unit, CompareFunction function) = 0;
virtual void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy) = 0;
virtual void _setTextureAddressingMode(size_t unit, const TextureUnitState::UVWAddressingMode& uvw) = 0;
virtual void _setTextureBorderColour(size_t unit, const ColourValue& colour) = 0;
virtual void _setTextureMipmapBias(size_t unit, float bias) = 0;
virtual void _setTextureMatrix(size_t unit, const Matrix4& xform) = 0;
virtual void _setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op = SBO_ADD) = 0;
virtual void _setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha,
SceneBlendFactor destFactorAlpha, SceneBlendOperation op = SBO_ADD, SceneBlendOperation alphaOp = SBO_ADD) = 0;
virtual void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage) = 0;
virtual void _setTextureProjectionRelativeTo(bool enabled, const Vector3& pos);
virtual DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget ) = 0;
void _cleanupDepthBuffers( bool bCleanManualBuffers=true );
virtual void _beginFrame(void) = 0;
//Dummy structure for render system contexts - implementing RenderSystems can extend
//as needed
struct RenderSystemContext { };
virtual RenderSystemContext* _pauseFrame(void);
virtual void _resumeFrame(RenderSystemContext* context);
virtual void _endFrame(void) = 0;
virtual void _setViewport(Viewport *vp) = 0;
virtual Viewport* _getViewport(void);
virtual void _setCullingMode(CullingMode mode) = 0;
virtual CullingMode _getCullingMode(void) const;
virtual void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL) = 0;
virtual void _setDepthBufferCheckEnabled(bool enabled = true) = 0;
virtual void _setDepthBufferWriteEnabled(bool enabled = true) = 0;
virtual void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL) = 0;
virtual void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha) = 0;
virtual void _setDepthBias(float constantBias, float slopeScaleBias = 0.0f) = 0;
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;
virtual void _beginGeometryCount(void);
virtual unsigned int _getFaceCount(void) const;
virtual unsigned int _getBatchCount(void) const;
virtual unsigned int _getVertexCount(void) const;
virtual void convertColourValue(const ColourValue& colour, uint32* pDest);
virtual VertexElementType getColourVertexElementType(void) const = 0;
virtual void _convertProjectionMatrix(const Matrix4& matrix,
Matrix4& dest, bool forGpuProgram = false) = 0;
virtual void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
Matrix4& dest, bool forGpuProgram = false) = 0;
virtual void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top,
Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false) = 0;
virtual void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
Matrix4& dest, bool forGpuProgram = false) = 0;
virtual void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
bool forGpuProgram) = 0;
virtual void _setPolygonMode(PolygonMode level) = 0;
virtual void setStencilCheckEnabled(bool enabled) = 0;
/*virtual bool hasHardwareStencil(void) = 0;*/
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) = 0;
virtual void setVertexDeclaration(VertexDeclaration* decl) = 0;
virtual void setVertexBufferBinding(VertexBufferBinding* binding) = 0;
virtual void setNormaliseNormals(bool normalise) = 0;
virtual void _render(const RenderOperation& op);
const RenderSystemCapabilities* getCapabilities(void) const { return mCurrentCapabilities; }
virtual const DriverVersion& getDriverVersion(void) const { return mDriverVersion; }
virtual const String& _getDefaultViewportMaterialScheme(void) const;
virtual void bindGpuProgram(GpuProgram* prg);
virtual void bindGpuProgramParameters(GpuProgramType gptype,
GpuProgramParametersSharedPtr params, uint16 variabilityMask) = 0;
virtual void bindGpuProgramPassIterationParameters(GpuProgramType gptype) = 0;
virtual void unbindGpuProgram(GpuProgramType gptype);
virtual bool isGpuProgramBound(GpuProgramType gptype);
uint16 getNativeShadingLanguageVersion() const { return mNativeShadingLanguageVersion; }
virtual void setClipPlanes(const PlaneList& clipPlanes);
virtual void addClipPlane (const Plane &p);
virtual void addClipPlane (Real A, Real B, Real C, Real D);
virtual void resetClipPlanes();
virtual void _initRenderTargets(void);
virtual void _notifyCameraRemoved(const Camera* cam);
virtual void _updateAllRenderTargets(bool swapBuffers = true);
virtual void _swapAllRenderTargetBuffers();
virtual void setInvertVertexWinding(bool invert);
virtual bool getInvertVertexWinding(void) const;
virtual void setScissorTest(bool enabled, size_t left = 0, size_t top = 0,
size_t right = 800, size_t bottom = 600) = 0;
virtual void clearFrameBuffer(unsigned int buffers,
const ColourValue& colour = ColourValue::Black,
Real depth = 1.0f, unsigned short stencil = 0) = 0;
virtual Real getHorizontalTexelOffset(void) = 0;
virtual Real getVerticalTexelOffset(void) = 0;
virtual Real getMinimumDepthInputValue(void) = 0;
virtual Real getMaximumDepthInputValue(void) = 0;
virtual void setCurrentPassIterationCount(const size_t count) { mCurrentPassIterationCount = count; }
virtual void setDeriveDepthBias(bool derive, float baseValue = 0.0f,
float multiplier = 0.0f, float slopeScale = 0.0f)
{
mDerivedDepthBias = derive;
mDerivedDepthBiasBase = baseValue;
mDerivedDepthBiasMultiplier = multiplier;
mDerivedDepthBiasSlopeScale = slopeScale;
}
virtual void _setRenderTarget(RenderTarget *target) = 0;
class _OgreExport Listener
{
public:
Listener() {}
virtual ~Listener() {}
virtual void eventOccurred(const String& eventName,
const NameValuePairList* parameters = 0) = 0;
};
virtual void addListener(Listener* l);
virtual void removeListener(Listener* l);
virtual const StringVector& getRenderSystemEvents(void) const { return mEventNames; }
virtual void preExtraThreadsStarted() = 0;
/* Tell the rendersystem to perform any tasks it needs to directly
after other threads which might access the rendering API are registered.
@see RenderSystem::preExtraThreadsStarted
*/
virtual void postExtraThreadsStarted() = 0;
virtual void registerThread() = 0;
virtual void unregisterThread() = 0;
virtual unsigned int getDisplayMonitorCount() const = 0;
virtual void beginProfileEvent( const String &eventName ) = 0;
virtual void endProfileEvent( void ) = 0;
virtual void markProfileEvent( const String &event ) = 0;
virtual bool hasAnisotropicMipMapFilter() const = 0;
virtual void getCustomAttribute(const String& name, void* pData);
protected:
DepthBufferMap mDepthBufferPool;
RenderTargetMap mRenderTargets;
RenderTargetPriorityMap mPrioritisedRenderTargets;
RenderTarget * mActiveRenderTarget;
GpuProgramParametersSharedPtr mActiveVertexGpuProgramParameters;
GpuProgramParametersSharedPtr mActiveGeometryGpuProgramParameters;
GpuProgramParametersSharedPtr mActiveFragmentGpuProgramParameters;
GpuProgramParametersSharedPtr mActiveTesselationHullGpuProgramParameters;
GpuProgramParametersSharedPtr mActiveTesselationDomainGpuProgramParameters;
GpuProgramParametersSharedPtr mActiveComputeGpuProgramParameters;
// Texture manager
// A concrete class of this will be created and
// made available under the TextureManager singleton,
// managed by the RenderSystem
TextureManager* mTextureManager;
// Active viewport (dest for future rendering operations)
Viewport* mActiveViewport;
CullingMode mCullingMode;
bool mWBuffer;
size_t mBatchCount;
size_t mFaceCount;
size_t mVertexCount;
ColourValue mManualBlendColours[OGRE_MAX_TEXTURE_LAYERS][2];
bool mInvertVertexWinding;
size_t mDisabledTexUnitsFrom;
size_t mCurrentPassIterationCount;
size_t mCurrentPassIterationNum;
bool mDerivedDepthBias;
float mDerivedDepthBiasBase;
float mDerivedDepthBiasMultiplier;
float mDerivedDepthBiasSlopeScale;
HardwareVertexBufferSharedPtr mGlobalInstanceVertexBuffer;
VertexDeclaration* mGlobalInstanceVertexBufferVertexDeclaration;
size_t mGlobalNumberOfInstances;
bool mEnableFixedPipeline;
bool updatePassIterationRenderState(void);
StringVector mEventNames;
virtual void fireEvent(const String& name, const NameValuePairList* params = 0);
typedef list<Listener*>::type ListenerList;
ListenerList mEventListeners;
typedef list<HardwareOcclusionQuery*>::type HardwareOcclusionQueryList;
HardwareOcclusionQueryList mHwOcclusionQueries;
bool mVertexProgramBound;
bool mGeometryProgramBound;
bool mFragmentProgramBound;
bool mTesselationHullProgramBound;
bool mTesselationDomainProgramBound;
bool mComputeProgramBound;
// Recording user clip planes
PlaneList mClipPlanes;
// Indicator that we need to re-set the clip planes on next render call
bool mClipPlanesDirty;
RenderSystemCapabilities* mRealCapabilities;
RenderSystemCapabilities* mCurrentCapabilities;
bool mUseCustomCapabilities;
virtual void setClipPlanesImpl(const PlaneList& clipPlanes) = 0;
virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary) = 0;
DriverVersion mDriverVersion;
uint16 mNativeShadingLanguageVersion;
bool mTexProjRelative;
Vector3 mTexProjRelativeOrigin;
};
}
#include "OgreHeaderSuffix.h"
#endif
Ogre::PlaneList
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160
Ogre::RenderSystem::setDeriveDepthBias
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 ...
Definition: OgreRenderSystem.h:1376
Ogre::RenderTarget
A &#39;canvas&#39; which can receive the results of a rendering operation.
Definition: OgreRenderTarget.h:65
Ogre::RenderSystem::mActiveRenderTarget
RenderTarget * mActiveRenderTarget
The Active render target.
Definition: OgreRenderSystem.h:1518
Ogre::RenderSystem::mVertexProgramBound
bool mVertexProgramBound
Definition: OgreRenderSystem.h:1590
Ogre::RenderSystem::areFixedFunctionLightsInViewSpace
virtual bool areFixedFunctionLightsInViewSpace() const
Are fixed-function lights provided in view space? Affects optimisation.
Definition: OgreRenderSystem.h:636
Ogre::RenderSystem::mTexProjRelative
bool mTexProjRelative
Definition: OgreRenderSystem.h:1617
Ogre::RenderSystem::mActiveVertexGpuProgramParameters
GpuProgramParametersSharedPtr mActiveVertexGpuProgramParameters
The Active GPU programs and gpu program parameters.
Definition: OgreRenderSystem.h:1521
Ogre::RenderSystem::mClipPlanes
PlaneList mClipPlanes
Definition: OgreRenderSystem.h:1598
Ogre::SOP_INVERT
Invert the bits of the stencil buffer.
Definition: OgreRenderSystem.h:98
Ogre::RenderSystem::mDriverVersion
DriverVersion mDriverVersion
Definition: OgreRenderSystem.h:1614
Ogre::TextureManager
Class for loading & managing textures.
Definition: OgreTextureManager.h:60
Ogre::FogMode
FogMode
Fog modes.
Definition: OgreCommon.h:121
Ogre::SOP_INCREMENT_WRAP
Increase the stencil value by 1, wrapping back to 0 when incrementing the maximum value...
Definition: OgreRenderSystem.h:94
Ogre::RenderSystem::setCurrentPassIterationCount
virtual void setCurrentPassIterationCount(const size_t count)
set the current multi pass count value.
Definition: OgreRenderSystem.h:1365
Ogre::TextureUnitState::UVWAddressingMode
Texture addressing mode for each texture coordinate.
Definition: OgreTextureUnitState.h:141
Ogre::TEXCALC_ENVIRONMENT_MAP_PLANAR
Environment map based on vertex positions.
Definition: OgreRenderSystem.h:74
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::list
Definition: OgrePrerequisites.h:505
Ogre::RenderSystem::mDerivedDepthBiasSlopeScale
float mDerivedDepthBiasSlopeScale
Definition: OgreRenderSystem.h:1560
Ogre::VertexElementType
VertexElementType
Vertex element type, used to identify the base types of the vertex contents.
Definition: OgreHardwareVertexBuffer.h:123
Ogre::CMPF_ALWAYS_PASS
Definition: OgreCommon.h:67
Ogre::RenderSystem::mDisabledTexUnitsFrom
size_t mDisabledTexUnitsFrom
Texture units from this upwards are disabled.
Definition: OgreRenderSystem.h:1551
Ogre::RenderSystem::HardwareOcclusionQueryList
list< HardwareOcclusionQuery * >::type HardwareOcclusionQueryList
Definition: OgreRenderSystem.h:1587
Ogre::RenderSystem::mGlobalInstanceVertexBufferVertexDeclaration
VertexDeclaration * mGlobalInstanceVertexBufferVertexDeclaration
a vertex declaration for the global vertex buffer for the global instancing
Definition: OgreRenderSystem.h:1565
Ogre::vector::type
std::vector< T, A > type
Definition: OgrePrerequisites.h:494
Ogre::SOP_INCREMENT
Increase the stencil value by 1, clamping at the maximum value.
Definition: OgreRenderSystem.h:90
Ogre::RenderSystem::mTexProjRelativeOrigin
Vector3 mTexProjRelativeOrigin
Definition: OgreRenderSystem.h:1618
Ogre::RenderSystem::RenderSystemContext
Definition: OgreRenderSystem.h:904
Ogre::SOP_KEEP
Leave the stencil buffer unchanged.
Definition: OgreRenderSystem.h:84
Ogre::MapIterator
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Definition: OgreIteratorWrapper.h:319
OgrePlane.h
Ogre::RenderSystem::mBatchCount
size_t mBatchCount
Definition: OgreRenderSystem.h:1541
Ogre::ColourValue
Class representing colour.
Definition: OgreColourValue.h:57
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::ColourValue::Black
static const ColourValue Black
Definition: OgreColourValue.h:61
OgreString.h
OgreTextureUnitState.h
Ogre::StringVector
vector< String >::type StringVector
Definition: OgreStringVector.h:45
Ogre::RenderWindowDescriptionList
vector< RenderWindowDescription >::type RenderWindowDescriptionList
Render window creation parameters container.
Definition: OgreCommon.h:761
Ogre::RenderSystem::mRealCapabilities
RenderSystemCapabilities * mRealCapabilities
Used to store the capabilities of the graphics card.
Definition: OgreRenderSystem.h:1603
Ogre::Viewport
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57
Ogre::RenderSystem::mTextureManager
TextureManager * mTextureManager
Definition: OgreRenderSystem.h:1532
OgreFrameListener.h
Ogre::RenderTargetPriorityMap
multimap< uchar, RenderTarget *>::type RenderTargetPriorityMap
Definition: OgreRenderSystem.h:63
Ogre::RenderSystem::RenderTargetIterator
MapIterator< Ogre::RenderTargetMap > RenderTargetIterator
Iterator over RenderTargets.
Definition: OgreRenderSystem.h:579
Ogre::Plane
Defines a plane in 3D space.
Definition: OgrePlane.h:61
Ogre::RenderSystem::mClipPlanesDirty
bool mClipPlanesDirty
Definition: OgreRenderSystem.h:1600
Ogre::ColourValue::White
static const ColourValue White
Definition: OgreColourValue.h:62
Ogre::RenderWindowList
vector< RenderWindow * >::type RenderWindowList
Render window container.
Definition: OgreCommon.h:764
OgreCommon.h
Ogre::RenderSystem::mUseCustomCapabilities
bool mUseCustomCapabilities
Definition: OgreRenderSystem.h:1605
OgreRenderSystemCapabilities.h
Ogre::RenderSystem::mWBuffer
bool mWBuffer
Definition: OgreRenderSystem.h:1539
Ogre::DepthBufferMap
map< uint16, DepthBufferVec >::type DepthBufferMap
Definition: OgreRenderSystem.h:61
Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Ogre::TEXCALC_ENVIRONMENT_MAP_NORMAL
Definition: OgreRenderSystem.h:76
Ogre::Vector3
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
Ogre::RenderSystem::mTesselationHullProgramBound
bool mTesselationHullProgramBound
Definition: OgreRenderSystem.h:1593
Ogre::RenderSystem::mCurrentCapabilities
RenderSystemCapabilities * mCurrentCapabilities
Definition: OgreRenderSystem.h:1604
Ogre::RenderSystem::mCullingMode
CullingMode mCullingMode
Definition: OgreRenderSystem.h:1537
Ogre::VertexDeclaration
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
Definition: OgreHardwareVertexBuffer.h:337
Ogre::HardwareVertexBufferSharedPtr
Shared pointer implementation used to share vertex buffers.
Definition: OgreHardwareVertexBuffer.h:86
OGRE_MAX_TEXTURE_LAYERS
#define OGRE_MAX_TEXTURE_LAYERS
Define max number of texture layers allowed per pass on any card.
Definition: OgreConfig.h:72
Ogre::RenderSystem::mCurrentPassIterationNum
size_t mCurrentPassIterationNum
Definition: OgreRenderSystem.h:1555
Ogre::CullingMode
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:135
Ogre::TextureUnitState
Class representing the state of a single texture unit during a Pass of a Technique, of a Material.
Definition: OgreTextureUnitState.h:62
OgrePrerequisites.h
Ogre::RenderSystem::mGeometryProgramBound
bool mGeometryProgramBound
Definition: OgreRenderSystem.h:1591
Ogre::RenderSystem::mNativeShadingLanguageVersion
uint16 mNativeShadingLanguageVersion
Definition: OgreRenderSystem.h:1615
Ogre::TrackVertexColourType
int TrackVertexColourType
An enumeration describing which material properties should track the vertex colours.
Definition: OgreCommon.h:276
Ogre::TEXCALC_ENVIRONMENT_MAP_REFLECTION
Definition: OgreRenderSystem.h:75
Ogre::RenderSystem::mFragmentProgramBound
bool mFragmentProgramBound
Definition: OgreRenderSystem.h:1592
Ogre::HashedVector
A hashed vector.
Definition: OgreCommon.h:332
Ogre::RenderSystem::mInvertVertexWinding
bool mInvertVertexWinding
Definition: OgreRenderSystem.h:1548
Ogre::LayerBlendModeEx
Class which manages blending of both colour and alpha components.
Definition: OgreBlendMode.h:139
Ogre::RenderSystem
Defines the functionality of a 3D API.
Definition: OgreRenderSystem.h:125
Ogre::ConfigOptionMap
map< String, ConfigOption >::type ConfigOptionMap
Definition: OgreConfigOptionMap.h:58
Ogre::NameValuePairList
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
Ogre::RenderSystem::mActiveTesselationHullGpuProgramParameters
GpuProgramParametersSharedPtr mActiveTesselationHullGpuProgramParameters
Definition: OgreRenderSystem.h:1524
Ogre::CompareFunction
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:64
Ogre::RenderSystem::mDepthBufferPool
DepthBufferMap mDepthBufferPool
DepthBuffers to be attached to render targets.
Definition: OgreRenderSystem.h:1511
Ogre::TexCoordCalcMethod
TexCoordCalcMethod
Enum describing the ways to generate texture coordinates.
Definition: OgreRenderSystem.h:67
Ogre::RenderSystem::mDerivedDepthBias
bool mDerivedDepthBias
Whether to update the depth bias per render call.
Definition: OgreRenderSystem.h:1557
OgreRenderOperation.h
Ogre::RenderSystem::mHwOcclusionQueries
HardwareOcclusionQueryList mHwOcclusionQueries
Definition: OgreRenderSystem.h:1588
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::DepthBuffer
An abstract class that contains a depth/stencil buffer.
Definition: OgreDepthBuffer.h:82
Ogre::TEXCALC_NONE
No calculated texture coordinates.
Definition: OgreRenderSystem.h:70
Ogre::GpuProgramType
GpuProgramType
Enumerates the types of programs which can run on the GPU.
Definition: OgreGpuProgram.h:50
Ogre::RenderSystem::Listener
Defines a listener on the custom events that this render system can raise.
Definition: OgreRenderSystem.h:1394
Ogre::RenderSystem::mDerivedDepthBiasMultiplier
float mDerivedDepthBiasMultiplier
Definition: OgreRenderSystem.h:1559
Ogre::RenderSystemCapabilities
singleton class for storing the capabilities of the graphics card.
Definition: OgreRenderSystemCapabilities.h:279
Ogre::RenderSystem::mActiveViewport
Viewport * mActiveViewport
Definition: OgreRenderSystem.h:1535
Ogre::RenderSystem::mEnableFixedPipeline
bool mEnableFixedPipeline
is fixed pipeline enabled
Definition: OgreRenderSystem.h:1570
Ogre::RenderTargetMap
map< String, RenderTarget *>::type RenderTargetMap
Definition: OgreRenderSystem.h:62
Ogre::SOP_ZERO
Set the stencil value to zero.
Definition: OgreRenderSystem.h:86
Ogre::Camera
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
OgreHeaderSuffix.h
Ogre::RenderSystem::mActiveComputeGpuProgramParameters
GpuProgramParametersSharedPtr mActiveComputeGpuProgramParameters
Definition: OgreRenderSystem.h:1526
Ogre::RenderSystem::Listener::Listener
Listener()
Definition: OgreRenderSystem.h:1397
Ogre::VertexBufferBinding
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
Definition: OgreHardwareVertexBuffer.h:521
Ogre::RenderSystem::mActiveGeometryGpuProgramParameters
GpuProgramParametersSharedPtr mActiveGeometryGpuProgramParameters
Definition: OgreRenderSystem.h:1522
OgreMaterialManager.h
Ogre::RenderSystem::mRenderTargets
RenderTargetMap mRenderTargets
The render targets.
Definition: OgreRenderSystem.h:1514
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:359
OgreRenderTexture.h
Ogre::RenderSystem::mPrioritisedRenderTargets
RenderTargetPriorityMap mPrioritisedRenderTargets
The render targets, ordered by priority.
Definition: OgreRenderSystem.h:1516
OgreIteratorWrappers.h
Ogre::RenderSystem::mTesselationDomainProgramBound
bool mTesselationDomainProgramBound
Definition: OgreRenderSystem.h:1594
Ogre::RenderSystem::mActiveFragmentGpuProgramParameters
GpuProgramParametersSharedPtr mActiveFragmentGpuProgramParameters
Definition: OgreRenderSystem.h:1523
Ogre::GpuProgram
Defines a program which runs on the GPU such as a vertex or fragment program.
Definition: OgreGpuProgram.h:69
Ogre::SceneBlendFactor
SceneBlendFactor
Blending factors for manually blending objects with the scene.
Definition: OgreBlendMode.h:234
Ogre::FilterOptions
FilterOptions
Filtering options for textures / mipmaps.
Definition: OgreCommon.h:100
OgreRenderTarget.h
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::SOP_REPLACE
Set the stencil value to the reference value.
Definition: OgreRenderSystem.h:88
Ogre::TEXCALC_ENVIRONMENT_MAP
Environment map based on vertex normals.
Definition: OgreRenderSystem.h:72
Ogre::SBO_ADD
Definition: OgreBlendMode.h:255
Ogre::RenderWindow
Manages the target rendering window.
Definition: OgreRenderWindow.h:62
OgreConfigOptionMap.h
Ogre::HardwareOcclusionQuery
This is a abstract class that that provides the interface for the query class for hardware occlusion...
Definition: OgreHardwareOcclusionQuery.h:51
Ogre::RenderSystem::mComputeProgramBound
bool mComputeProgramBound
Definition: OgreRenderSystem.h:1595
Ogre::FOG_NONE
No fog. Duh.
Definition: OgreCommon.h:124
Ogre::SOP_DECREMENT_WRAP
Decrease the stencil value by 1, wrapping when decrementing 0.
Definition: OgreRenderSystem.h:96
Ogre::RenderSystem::mFaceCount
size_t mFaceCount
Definition: OgreRenderSystem.h:1542
Ogre::SharedPtr< Texture >
Ogre::RenderSystem::getDriverVersion
virtual const DriverVersion & getDriverVersion(void) const
Returns the driver version.
Definition: OgreRenderSystem.h:1215
OgreHeaderPrefix.h
Ogre::StencilOperation
StencilOperation
Enum describing the various actions which can be taken on the stencil buffer.
Definition: OgreRenderSystem.h:81
Ogre::CMPF_LESS_EQUAL
Definition: OgreCommon.h:69
Ogre::SOP_DECREMENT
Decrease the stencil value by 1, clamping at 0.
Definition: OgreRenderSystem.h:92
Ogre::RenderOperation
&#39;New&#39; rendering operation using vertex buffers.
Definition: OgreRenderOperation.h:45
Ogre::DriverVersion
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the cu...
Definition: OgreRenderSystemCapabilities.h:215
Ogre::RenderSystem::isStaticBufferLockable
virtual bool isStaticBufferLockable() const
Definition: OgreRenderSystem.h:219
Ogre::RenderSystem::getRenderSystemEvents
virtual const StringVector & getRenderSystemEvents(void) const
Gets a list of the rendersystem specific events that this rendersystem can raise. ...
Definition: OgreRenderSystem.h:1430
Ogre::map
Definition: OgrePrerequisites.h:533
Ogre::ShadeOptions
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:113
Ogre::RenderSystem::mCurrentPassIterationCount
size_t mCurrentPassIterationCount
number of times to render the current state
Definition: OgreRenderSystem.h:1554
Ogre::PolygonMode
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:179
Ogre::SceneBlendOperation
SceneBlendOperation
Blending operations controls how objects are blended into the scene.
Definition: OgreBlendMode.h:253
Ogre::RenderSystem::getMutableCapabilities
RenderSystemCapabilities * getMutableCapabilities()
Get a pointer to the current capabilities being used by the RenderSystem.
Definition: OgreRenderSystem.h:231
Ogre::TVC_NONE
Definition: OgreCommon.h:278
Ogre::RenderSystem::getRenderTargetIterator
virtual RenderTargetIterator getRenderTargetIterator(void)
Returns a specialised MapIterator over all render targets attached to the RenderSystem.
Definition: OgreRenderSystem.h:582
Ogre::Frustum
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:85
Ogre::MultiRenderTarget
This class represents a render target that renders to multiple RenderTextures at once.
Definition: OgreRenderTexture.h:69
Ogre::RenderSystem::getNativeShadingLanguageVersion
uint16 getNativeShadingLanguageVersion() const
Gets the native shading language version for this render system.
Definition: OgreRenderSystem.h:1259
Ogre::RenderSystem::mEventNames
StringVector mEventNames
List of names of events this rendersystem may raise.
Definition: OgreRenderSystem.h:1579
Ogre::RenderSystem::Listener::~Listener
virtual ~Listener()
Definition: OgreRenderSystem.h:1398
Ogre::RenderSystem::mEventListeners
ListenerList mEventListeners
Definition: OgreRenderSystem.h:1585
Ogre::RenderSystem::mVertexCount
size_t mVertexCount
Definition: OgreRenderSystem.h:1543
Ogre::RenderSystem::mGlobalInstanceVertexBuffer
HardwareVertexBufferSharedPtr mGlobalInstanceVertexBuffer
a global vertex buffer for global instancing
Definition: OgreRenderSystem.h:1563
Ogre::RenderSystem::ListenerList
list< Listener * >::type ListenerList
Definition: OgreRenderSystem.h:1584
Ogre::DepthBufferVec
vector< DepthBuffer * >::type DepthBufferVec
Definition: OgreRenderSystem.h:60
OgreGpuProgram.h
Ogre::uint16
unsigned short uint16
Definition: OgrePlatform.h:360
Ogre::RenderSystem::getCapabilities
const RenderSystemCapabilities * getCapabilities(void) const
Gets the capabilities of the render system.
Definition: OgreRenderSystem.h:1210
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:58
Ogre::RenderSystem::mDerivedDepthBiasBase
float mDerivedDepthBiasBase
Definition: OgreRenderSystem.h:1558
Ogre::RenderSystem::mActiveTesselationDomainGpuProgramParameters
GpuProgramParametersSharedPtr mActiveTesselationDomainGpuProgramParameters
Definition: OgreRenderSystem.h:1525
Ogre::Radian
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
Ogre::RenderSystem::mGlobalNumberOfInstances
size_t mGlobalNumberOfInstances
the number of global instances (this number will be multiply by the render op instance number) ...
Definition: OgreRenderSystem.h:1567
Ogre::TEXCALC_PROJECTIVE_TEXTURE
Projective texture.
Definition: OgreRenderSystem.h:78
Ogre::multimap
Definition: OgrePrerequisites.h:547
Ogre::FilterType
FilterType
Definition: OgreCommon.h:90

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.