OgreGLES2RenderSystem.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 
29 #ifndef __GLES2RenderSystem_H__
30 #define __GLES2RenderSystem_H__
31 
32 #include "OgreGLES2Prerequisites.h"
33 
34 #include "OgreMaterialManager.h"
35 #include "OgreRenderSystem.h"
36 #include "OgreGLES2GpuProgram.h"
37 
38 namespace Ogre {
39  class GLES2Context;
40  class GLES2Support;
41  class GLES2RTTManager;
42  class GLES2GpuProgramManager;
43  class GLSLESProgramFactory;
44  class GLES2StateCacheManager;
45 #if !OGRE_NO_GLES2_CG_SUPPORT
46  class GLSLESCgProgramFactory;
47 #endif
48  class GLSLESGpuProgram;
49  class HardwareBufferManager;
50 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
51  class AndroidResourceManager;
52 #endif
53 
58  {
59  private:
64 
68 
70  size_t mTextureCoordIndex[OGRE_MAX_TEXTURE_LAYERS];
71 
73  GLenum mTextureTypes[OGRE_MAX_TEXTURE_LAYERS];
74 
77 
78  GLfloat mAutoTextureMatrix[16];
79 
81 
84 
87 
88  /* The main GL context - main thread only */
90 
91  /* The current GL context - main thread only */
93 
97 
100 #if !OGRE_NO_GLES2_CG_SUPPORT
102 #endif
104 
111 
114 
115  // local data member of _render that were moved here to improve performance
116  // (save allocations)
119 
120  GLint getCombinedMinMipFilter(void) const;
121 
124 
125  GLint getTextureAddressingMode(TextureUnitState::TextureAddressingMode tam) const;
126  GLenum getBlendMode(SceneBlendFactor ogreBlend) const;
127  void bindVertexElementToGpu( const VertexElement &elem, HardwareVertexBufferSharedPtr vertexBuffer,
128  const size_t vertexStart,
129  vector<GLuint>::type &attribsBound,
130  vector<GLuint>::type &instanceAttribsBound,
131  bool updateVAO);
132 
133  // Mipmap count of the actual bounded texture
135  GLint mViewport[4];
136  GLint mScissor[4];
137 
138  public:
139  // Default constructor / destructor
141  virtual ~GLES2RenderSystem();
142 
143  friend class ShaderGeneratorTechniqueResolverListener;
144 
145  // ----------------------------------
146  // Overridden RenderSystem functions
147  // ----------------------------------
151  const String& getName(void) const;
155  ConfigOptionMap& getConfigOptions(void);
159  void setConfigOption(const String &name, const String &value);
163  String validateConfigOptions(void);
167  RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render NativeWindowType");
171  virtual RenderSystemCapabilities* createRenderSystemCapabilities() const;
175  void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary);
179  void reinitialise(void); // Used if settings changed mid-rendering
183  void shutdown(void);
187  void setAmbientLight(float r, float g, float b) { }; // Not supported
191  void setShadingType(ShadeOptions so) { }; // Not supported
195  void setLightingEnabled(bool enabled) { }; // Not supported
196 
198  RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
199  bool fullScreen, const NameValuePairList *miscParams = 0);
200 
202  DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget );
203 
205  void _getDepthStencilFormatFor( GLenum internalColourFormat, GLenum *depthFormat,
206  GLenum *stencilFormat );
207 
209  virtual MultiRenderTarget * createMultiRenderTarget(const String & name);
210 
214  void destroyRenderWindow(RenderWindow* pWin);
218  String getErrorDescription(long errorNumber) const;
222  VertexElementType getColourVertexElementType(void) const;
226  void setNormaliseNormals(bool normalise) { }; // Not supported
227 
228  // -----------------------------
229  // Low-level overridden members
230  // -----------------------------
234  void _useLights(const LightList& lights, unsigned short limit) { }; // Not supported
238  bool areFixedFunctionLightsInViewSpace() const { return true; }
242  void _setWorldMatrix(const Matrix4 &m);
246  void _setViewMatrix(const Matrix4 &m);
250  void _setProjectionMatrix(const Matrix4 &m);
254  void _setSurfaceParams(const ColourValue &ambient,
255  const ColourValue &diffuse, const ColourValue &specular,
256  const ColourValue &emissive, Real shininess,
257  TrackVertexColourType tracking) {}
261  void _setPointParameters(Real size, bool attenuationEnabled,
262  Real constant, Real linear, Real quadratic, Real minSize, Real maxSize) {}
266  void _setPointSpritesEnabled(bool enabled) {}
270  void _setTexture(size_t unit, bool enabled, const TexturePtr &tex);
274  void _setTextureCoordSet(size_t stage, size_t index);
279  const Frustum* frustum = 0) { }; // Not supported
283  void _setTextureBlendMode(size_t stage, const LayerBlendModeEx& bm) { }; // Not supported
287  void _setTextureAddressingMode(size_t stage, const TextureUnitState::UVWAddressingMode& uvw);
291  void _setTextureBorderColour(size_t stage, const ColourValue& colour) { }; // Not supported
295  void _setTextureMipmapBias(size_t unit, float bias) { }; // Not supported
299  void _setTextureMatrix(size_t stage, const Matrix4& xform) { }; // Not supported
303  void _setViewport(Viewport *vp);
307  void _beginFrame(void);
311  void _endFrame(void);
315  void _setCullingMode(CullingMode mode);
319  void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL);
323  void _setDepthBufferCheckEnabled(bool enabled = true);
327  void _setDepthBufferWriteEnabled(bool enabled = true);
331  void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL);
335  void _setDepthBias(float constantBias, float slopeScaleBias);
339  void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha);
343  void _setFog(FogMode mode, const ColourValue& colour, Real density, Real start, Real end);
347  void _convertProjectionMatrix(const Matrix4& matrix,
348  Matrix4& dest, bool forGpuProgram = false);
352  void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
353  Matrix4& dest, bool forGpuProgram = false);
357  void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top,
358  Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false);
362  void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
363  Matrix4& dest, bool forGpuProgram = false);
367  void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
368  bool forGpuProgram);
372  void setClipPlane (ushort index, Real A, Real B, Real C, Real D);
376  void enableClipPlane (ushort index, bool enable);
380  void _setPolygonMode(PolygonMode level);
384  void setStencilCheckEnabled(bool enabled);
388  void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS,
389  uint32 refValue = 0, uint32 compareMask = 0xFFFFFFFF, uint32 writeMask = 0xFFFFFFFF,
390  StencilOperation stencilFailOp = SOP_KEEP,
391  StencilOperation depthFailOp = SOP_KEEP,
392  StencilOperation passOp = SOP_KEEP,
393  bool twoSidedOperation = false);
397  void _setTextureUnitCompareFunction(size_t unit, CompareFunction function);
401  void _setTextureUnitCompareEnabled(size_t unit, bool compare);
405  virtual void _setTextureUnitFiltering(size_t unit, FilterOptions minFilter,
406  FilterOptions magFilter, FilterOptions mipFilter);
410  void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter);
414  void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy);
418  virtual bool hasAnisotropicMipMapFilter() const { return false; }
422  void setVertexDeclaration(VertexDeclaration* decl);
426  void setVertexDeclaration(VertexDeclaration* decl, VertexBufferBinding* binding);
434  void _render(const RenderOperation& op);
438  void setScissorTest(bool enabled, size_t left = 0, size_t top = 0, size_t right = 800, size_t bottom = 600);
439 
440  void clearFrameBuffer(unsigned int buffers,
441  const ColourValue& colour = ColourValue::Black,
442  Real depth = 1.0f, unsigned short stencil = 0);
443  HardwareOcclusionQuery* createHardwareOcclusionQuery(void);
444  Real getHorizontalTexelOffset(void) { return 0.0; } // No offset in GL
445  Real getVerticalTexelOffset(void) { return 0.0; } // No offset in GL
446  Real getMinimumDepthInputValue(void) { return -1.0f; } // Range [-1.0f, 1.0f]
447  Real getMaximumDepthInputValue(void) { return 1.0f; } // Range [-1.0f, 1.0f]
448  OGRE_MUTEX(mThreadInitMutex);
449  void registerThread();
450  void unregisterThread();
451  void preExtraThreadsStarted();
452  void postExtraThreadsStarted();
453  void setClipPlanesImpl(const Ogre::PlaneList& planeList) {}
454  GLES2Support* getGLSupportRef() { return mGLSupport; }
455 
456  // ----------------------------------
457  // GLES2RenderSystem specific members
458  // ----------------------------------
460  GLES2Context* _getMainContext() { return mMainContext; }
468  void _unregisterContext(GLES2Context *context);
471  void _switchContext(GLES2Context *context);
475  void _oneTimeContextInitialization();
476  void initialiseContext(RenderWindow* primary);
480  void _setRenderTarget(RenderTarget *target);
481 
482  GLES2Support* getGLES2Support() { return mGLSupport; }
483  GLint convertCompareFunction(CompareFunction func) const;
484  GLint convertStencilOp(StencilOperation op, bool invert = false) const;
485 
486  void bindGpuProgram(GpuProgram* prg);
487  void unbindGpuProgram(GpuProgramType gptype);
488  void bindGpuProgramParameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params, uint16 mask);
489  void bindGpuProgramPassIterationParameters(GpuProgramType gptype);
490 
492  void _setSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op );
494  void _setSeparateSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha, SceneBlendFactor destFactorAlpha, SceneBlendOperation op, SceneBlendOperation alphaOp );
496  void _setAlphaRejectSettings( CompareFunction func, unsigned char value, bool alphaToCoverage );
498  unsigned int getDisplayMonitorCount() const;
499 
501  GLfloat _getCurrentAnisotropy(size_t unit);
502 
503  void _setSceneBlendingOperation(SceneBlendOperation op);
504  void _setSeparateSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp);
505 
506  unsigned int getDiscardBuffers(void);
507 
508  void _destroyDepthBuffer(RenderWindow* pRenderWnd);
509 
511  virtual void beginProfileEvent( const String &eventName );
512 
514  virtual void endProfileEvent( void );
515 
517  virtual void markProfileEvent( const String &eventName );
518 
519 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
520  void resetRenderer(RenderWindow* pRenderWnd);
521 
522  static AndroidResourceManager* getResourceManager();
523  private:
525 #endif
526  };
527 }
528 
529 #endif
Ogre::HashedVector< Light * >
Ogre::GLES2RenderSystem::_setPointSpritesEnabled
void _setPointSpritesEnabled(bool enabled)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:266
Ogre::TextureUnitState::TextureAddressingMode
TextureAddressingMode
Texture addressing modes - default is TAM_WRAP.
Definition: OgreTextureUnitState.h:126
Ogre::GLES2RenderSystem::mWorldMatrix
Matrix4 mWorldMatrix
Definition: OgreGLES2RenderSystem.h:62
Ogre::RenderSystem
Defines the functionality of a 3D API.
Definition: OgreRenderSystem.h:125
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::Plane
Defines a plane in 3D space.
Definition: OgrePlane.h:61
Ogre::GLES2RenderSystem::mRenderAttribsBound
vector< GLuint >::type mRenderAttribsBound
Definition: OgreGLES2RenderSystem.h:117
Ogre::DepthBuffer
An abstract class that contains a depth/stencil buffer.
Definition: OgreDepthBuffer.h:82
Ogre::HardwareOcclusionQuery
This is a abstract class that that provides the interface for the query class for hardware occlusion.
Definition: OgreHardwareOcclusionQuery.h:51
Ogre::GLES2GpuProgramManager
Definition: OgreGLES2GpuProgramManager.h:37
Ogre::ushort
unsigned short ushort
Definition: OgrePrerequisites.h:113
Ogre::GLES2RenderSystem::getMinimumDepthInputValue
Real getMinimumDepthInputValue(void)
Gets the minimum (closest) depth value to be used when rendering using identity transforms.
Definition: OgreGLES2RenderSystem.h:446
Ogre::GLES2RenderSystem::mRTTManager
GLES2RTTManager * mRTTManager
Manager object for creating render textures.
Definition: OgreGLES2RenderSystem.h:110
OgreGLES2GpuProgram.h
Ogre::GLES2RenderSystem::mHardwareBufferManager
HardwareBufferManager * mHardwareBufferManager
Definition: OgreGLES2RenderSystem.h:103
Ogre::GLES2RenderSystem::setNormaliseNormals
void setNormaliseNormals(bool normalise)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:226
Ogre::GLES2RenderSystem::mGLInitialised
bool mGLInitialised
Check if the GL system has already been initialised.
Definition: OgreGLES2RenderSystem.h:113
OgreMaterialManager.h
Ogre::RenderWindow
Manages the target rendering window.
Definition: OgreRenderWindow.h:62
Ogre::GLES2RenderSystem::mMipFilter
FilterOptions mMipFilter
Definition: OgreGLES2RenderSystem.h:67
Ogre::GLES2RenderSystem::hasAnisotropicMipMapFilter
virtual bool hasAnisotropicMipMapFilter() const
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:418
Ogre::GLES2RenderSystem::setClipPlanesImpl
void setClipPlanesImpl(const Ogre::PlaneList &planeList)
Internal method used to set the underlying clip planes when needed.
Definition: OgreGLES2RenderSystem.h:453
Ogre::GLES2RenderSystem::mViewMatrix
Matrix4 mViewMatrix
View matrix to set world against.
Definition: OgreGLES2RenderSystem.h:61
Ogre::GLES2RenderSystem::getGLES2Support
GLES2Support * getGLES2Support()
Definition: OgreGLES2RenderSystem.h:482
Ogre::GpuProgram
Defines a program which runs on the GPU such as a vertex or fragment program.
Definition: OgreGpuProgram.h:69
Ogre::GLES2RenderSystem::mGLSLESCgProgramFactory
GLSLESCgProgramFactory * mGLSLESCgProgramFactory
Definition: OgreGLES2RenderSystem.h:101
Ogre::GLES2RenderSystem::mCurrentContext
GLES2Context * mCurrentContext
Definition: OgreGLES2RenderSystem.h:92
Ogre::FogMode
FogMode
Fog modes.
Definition: OgreCommon.h:121
Ogre::CMPF_ALWAYS_PASS
@ CMPF_ALWAYS_PASS
Definition: OgreCommon.h:67
Ogre::uint16
unsigned short uint16
Definition: OgrePlatform.h:360
Ogre::GLES2RenderSystem::_useLights
void _useLights(const LightList &lights, unsigned short limit)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:234
Ogre::GLES2RenderSystem::getHorizontalTexelOffset
Real getHorizontalTexelOffset(void)
Returns the horizontal texel offset value required for mapping texel origins to pixel origins in this...
Definition: OgreGLES2RenderSystem.h:444
Ogre::GLES2RenderSystem::getGLSupportRef
GLES2Support * getGLSupportRef()
Definition: OgreGLES2RenderSystem.h:454
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:359
Ogre::GLES2RenderSystem::setVertexBufferBinding
void setVertexBufferBinding(VertexBufferBinding *binding)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:430
Ogre::SOP_KEEP
@ SOP_KEEP
Leave the stencil buffer unchanged.
Definition: OgreRenderSystem.h:84
Ogre::GLES2RenderSystem::mCurTexMipCount
size_t mCurTexMipCount
Definition: OgreGLES2RenderSystem.h:134
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::GLES2RenderSystem::_setPointParameters
void _setPointParameters(Real size, bool attenuationEnabled, Real constant, Real linear, Real quadratic, Real minSize, Real maxSize)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:261
Ogre::GLES2RenderSystem::mBackgroundContextList
GLES2ContextList mBackgroundContextList
List of background thread contexts.
Definition: OgreGLES2RenderSystem.h:96
Ogre::LayerBlendModeEx
Class which manages blending of both colour and alpha components.
Definition: OgreBlendMode.h:139
Ogre::NameValuePairList
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
Ogre::GLES2RenderSystem::areFixedFunctionLightsInViewSpace
bool areFixedFunctionLightsInViewSpace() const
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:238
Ogre::GLES2RenderSystem::_setSurfaceParams
void _setSurfaceParams(const ColourValue &ambient, const ColourValue &diffuse, const ColourValue &specular, const ColourValue &emissive, Real shininess, TrackVertexColourType tracking)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:254
Ogre::CompareFunction
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:64
Ogre::GpuProgramType
GpuProgramType
Enumerates the types of programs which can run on the GPU.
Definition: OgreGpuProgram.h:50
OGRE_MUTEX
#define OGRE_MUTEX(name)
Definition: OgreThreadDefinesBoost.h:47
Ogre::VertexBufferBinding
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
Definition: OgreHardwareVertexBuffer.h:521
Ogre::GLES2RenderSystem::_setTextureBorderColour
void _setTextureBorderColour(size_t stage, const ColourValue &colour)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:291
Ogre::VertexElementType
VertexElementType
Vertex element type, used to identify the base types of the vertex contents.
Definition: OgreHardwareVertexBuffer.h:123
Ogre::StencilOperation
StencilOperation
Enum describing the various actions which can be taken on the stencil buffer.
Definition: OgreRenderSystem.h:81
Ogre::GLES2RenderSystem::_setTextureMipmapBias
void _setTextureMipmapBias(size_t unit, float bias)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:295
Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Ogre::RenderTarget
A 'canvas' which can receive the results of a rendering operation.
Definition: OgreRenderTarget.h:65
Ogre::list
Definition: OgrePrerequisites.h:505
Ogre::ConfigOptionMap
map< String, ConfigOption >::type ConfigOptionMap
Definition: OgreConfigOptionMap.h:58
Ogre::SceneBlendFactor
SceneBlendFactor
Blending factors for manually blending objects with the scene.
Definition: OgreBlendMode.h:234
Ogre::Viewport
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57
Ogre::GLES2RenderSystem::mGpuProgramManager
GLES2GpuProgramManager * mGpuProgramManager
Definition: OgreGLES2RenderSystem.h:98
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::GLES2RenderSystem::setAmbientLight
void setAmbientLight(float r, float g, float b)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:187
Ogre::GLES2RenderSystem::mGLSLESProgramFactory
GLSLESProgramFactory * mGLSLESProgramFactory
Definition: OgreGLES2RenderSystem.h:99
Ogre::GLES2RenderSystem::setLightingEnabled
void setLightingEnabled(bool enabled)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:195
Ogre::GLES2RenderSystem::mCurrentFragmentProgram
GLES2GpuProgram * mCurrentFragmentProgram
Definition: OgreGLES2RenderSystem.h:123
Ogre::VertexElement
This class declares the usage of a single vertex buffer as a component of a complete VertexDeclaratio...
Definition: OgreHardwareVertexBuffer.h:167
Ogre::GLES2RenderSystem::mGLSupport
GLES2Support * mGLSupport
GL support class, used for creating windows etc.
Definition: OgreGLES2RenderSystem.h:83
Ogre::FilterOptions
FilterOptions
Filtering options for textures / mipmaps.
Definition: OgreCommon.h:100
Ogre::Radian
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
Ogre::HardwareBufferManager
Singleton wrapper for hardware buffer manager.
Definition: OgreHardwareBufferManager.h:429
Ogre::RenderSystemCapabilities
singleton class for storing the capabilities of the graphics card.
Definition: OgreRenderSystemCapabilities.h:279
Ogre::GLES2RenderSystem::mMinFilter
FilterOptions mMinFilter
Last min & mip filtering options, so we can combine them.
Definition: OgreGLES2RenderSystem.h:66
Ogre::GLSLESProgramFactory
Factory class for GLSL ES programs.
Definition: OgreGLSLESProgramFactory.h:39
Ogre::CMPF_LESS_EQUAL
@ CMPF_LESS_EQUAL
Definition: OgreCommon.h:69
Ogre::MultiRenderTarget
This class represents a render target that renders to multiple RenderTextures at once.
Definition: OgreRenderTexture.h:69
Ogre::CullingMode
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:135
Ogre::GLES2RenderSystem::GLES2ContextList
list< GLES2Context * >::type GLES2ContextList
Definition: OgreGLES2RenderSystem.h:94
Ogre::GLES2RenderSystem::mStateCacheManager
GLES2StateCacheManager * mStateCacheManager
State cache manager which responsible to reduce redundant state changes.
Definition: OgreGLES2RenderSystem.h:86
Ogre::TrackVertexColourType
int TrackVertexColourType
An enumeration describing which material properties should track the vertex colours.
Definition: OgreCommon.h:276
Ogre::GLES2RenderSystem::mMainContext
GLES2Context * mMainContext
Definition: OgreGLES2RenderSystem.h:89
Ogre::GLES2Context
Class that encapsulates an GL context.
Definition: OgreGLES2Context.h:41
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::SharedPtr< Texture >
Ogre::GLES2RenderSystem::_setTextureCoordCalculation
void _setTextureCoordCalculation(size_t stage, TexCoordCalcMethod m, const Frustum *frustum=0)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:278
Ogre::GLES2GpuProgram
Generalised low-level GL program, can be applied to multiple types (eg ARB and NV)
Definition: OgreGLES2GpuProgram.h:39
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::ColourValue
Class representing colour.
Definition: OgreColourValue.h:57
Ogre::GLES2RTTManager
Manager/factory for RenderTextures.
Definition: OgreGLES2RenderTexture.h:61
Ogre::GLES2RenderSystem::mCurrentVertexProgram
GLES2GpuProgram * mCurrentVertexProgram
Definition: OgreGLES2RenderSystem.h:122
_OgreGLES2Export
#define _OgreGLES2Export
Definition: OgreGLES2Prerequisites.h:260
Ogre::GLES2RenderSystem::getVerticalTexelOffset
Real getVerticalTexelOffset(void)
Returns the vertical texel offset value required for mapping texel origins to pixel origins in this r...
Definition: OgreGLES2RenderSystem.h:445
Ogre::GLES2RenderSystem::_setTextureMatrix
void _setTextureMatrix(size_t stage, const Matrix4 &xform)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:299
Ogre::GLES2RenderSystem::_setTextureBlendMode
void _setTextureBlendMode(size_t stage, const LayerBlendModeEx &bm)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:283
Ogre::GLES2RenderSystem::mResourceManager
static AndroidResourceManager * mResourceManager
Definition: OgreGLES2RenderSystem.h:524
Ogre::ColourValue::Black
static const ColourValue Black
Definition: OgreColourValue.h:61
Ogre::ShadeOptions
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:113
Ogre::TextureUnitState::UVWAddressingMode
Texture addressing mode for each texture coordinate.
Definition: OgreTextureUnitState.h:141
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::GLES2RenderSystem::_getMainContext
GLES2Context * _getMainContext()
Returns the main context.
Definition: OgreGLES2RenderSystem.h:460
Ogre::GLES2RenderSystem::mFixedFunctionTextureUnits
unsigned short mFixedFunctionTextureUnits
Number of fixed-function texture units.
Definition: OgreGLES2RenderSystem.h:76
Ogre::GLES2RenderSystem::mTextureMatrix
Matrix4 mTextureMatrix
Definition: OgreGLES2RenderSystem.h:63
Ogre::GLES2RenderSystem::setShadingType
void setShadingType(ShadeOptions so)
See RenderSystem.
Definition: OgreGLES2RenderSystem.h:191
Ogre::GLES2RenderSystem::mUseAutoTextureMatrix
bool mUseAutoTextureMatrix
Definition: OgreGLES2RenderSystem.h:80
Ogre::GLES2StateCacheManager
An in memory cache of the OpenGL ES state.
Definition: OgreGLES2StateCacheManager.h:53
Ogre::vector
Definition: OgrePrerequisites.h:491
Ogre::TexCoordCalcMethod
TexCoordCalcMethod
Enum describing the ways to generate texture coordinates.
Definition: OgreRenderSystem.h:67
Ogre::GLES2RenderSystem
Implementation of GL ES 2.x as a rendering system.
Definition: OgreGLES2RenderSystem.h:57
Ogre::GLSLESCgProgramFactory
Factory class for GLSL ES programs.
Definition: OgreGLSLESCgProgramFactory.h:39
Ogre::FilterType
FilterType
Definition: OgreCommon.h:90
Ogre::PlaneList
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160
Ogre::PolygonMode
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:179
Ogre::GLES2RenderSystem::getMaximumDepthInputValue
Real getMaximumDepthInputValue(void)
Gets the maximum (farthest) depth value to be used when rendering using identity transforms.
Definition: OgreGLES2RenderSystem.h:447
Ogre::RenderOperation
'New' rendering operation using vertex buffers.
Definition: OgreRenderOperation.h:45
OgreGLES2Prerequisites.h
Ogre::GLES2RenderSystem::mRenderInstanceAttribsBound
vector< GLuint >::type mRenderInstanceAttribsBound
Definition: OgreGLES2RenderSystem.h:118
Ogre::SceneBlendOperation
SceneBlendOperation
Blending operations controls how objects are blended into the scene.
Definition: OgreBlendMode.h:253
Ogre::GLES2Support
Definition: OgreGLES2Support.h:41
Ogre::AndroidResourceManager
Definition: include/EGL/Android/OgreAndroidResourceManager.h:37
OgreRenderSystem.h

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Tue Apr 13 2021 08:53:15