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-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __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 
126  {
127  public:
130  RenderSystem();
131 
134  virtual ~RenderSystem();
135 
138  virtual const String& getName(void) const = 0;
139 
161  virtual ConfigOptionMap& getConfigOptions(void) = 0;
162 
182  virtual void setConfigOption(const String &name, const String &value) = 0;
183 
186  virtual HardwareOcclusionQuery* createHardwareOcclusionQuery(void) = 0;
187 
190  virtual void destroyHardwareOcclusionQuery(HardwareOcclusionQuery *hq);
191 
196  virtual String validateConfigOptions(void) = 0;
197 
212  virtual RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
213 
214  /*
215  Returns whether under the current render system buffers marked as TU_STATIC can be locked for update
216  @remarks
217  Needed in the implementation of DirectX9 with DirectX9Ex driver
218  */
219  virtual bool isStaticBufferLockable() const { return true; }
220 
222  virtual RenderSystemCapabilities* createRenderSystemCapabilities() const = 0;
223 
231  RenderSystemCapabilities* getMutableCapabilities(){ return mCurrentCapabilities; }
232 
239  virtual void useCustomRenderSystemCapabilities(RenderSystemCapabilities* capabilities);
240 
243  virtual void reinitialise(void) = 0;
244 
247  virtual void shutdown(void);
248 
249 
252  virtual void setAmbientLight(float r, float g, float b) = 0;
253 
256  virtual void setShadingType(ShadeOptions so) = 0;
257 
263  virtual void setLightingEnabled(bool enabled) = 0;
264 
271  void setWBufferEnabled(bool enabled);
272 
275  bool getWBufferEnabled(void) const;
276 
513  virtual RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
514  bool fullScreen, const NameValuePairList *miscParams = 0) = 0;
515 
531  virtual bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
532  RenderWindowList& createdWindows);
533 
534 
539  virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0;
540 
542  virtual void destroyRenderWindow(const String& name);
544  virtual void destroyRenderTexture(const String& name);
546  virtual void destroyRenderTarget(const String& name);
547 
550  virtual void attachRenderTarget( RenderTarget &target );
554  virtual RenderTarget * getRenderTarget( const String &name );
560  virtual RenderTarget * detachRenderTarget( const String &name );
561 
564 
567  return RenderTargetIterator( mRenderTargets.begin(), mRenderTargets.end() );
568  }
571  virtual String getErrorDescription(long errorNumber) const = 0;
572 
575  HardwareVertexBufferSharedPtr getGlobalInstanceVertexBuffer() const;
578  void setGlobalInstanceVertexBuffer(const HardwareVertexBufferSharedPtr val);
581  VertexDeclaration* getGlobalInstanceVertexBufferVertexDeclaration() const;
584  void setGlobalInstanceVertexBufferVertexDeclaration( VertexDeclaration* val);
587  size_t getGlobalNumberOfInstances() const;
590  void setGlobalNumberOfInstances(const size_t val);
591 
594  void setFixedPipelineEnabled(bool enabled);
595 
598  bool getFixedPipelineEnabled(void) const;
599 
605  virtual void setDepthBufferFor( RenderTarget *renderTarget );
606 
607  // ------------------------------------------------------------------------
608  // Internal Rendering Access
609  // All methods below here are normally only called by other OGRE classes
610  // They can be called by library user if required
611  // ------------------------------------------------------------------------
612 
613 
617  virtual void _useLights(const LightList& lights, unsigned short limit) = 0;
620  virtual bool areFixedFunctionLightsInViewSpace() const { return false; }
622  virtual void _setWorldMatrix(const Matrix4 &m) = 0;
624  virtual void _setWorldMatrices(const Matrix4* m, unsigned short count);
626  virtual void _setViewMatrix(const Matrix4 &m) = 0;
628  virtual void _setProjectionMatrix(const Matrix4 &m) = 0;
634  virtual void _setTextureUnitSettings(size_t texUnit, TextureUnitState& tl);
636  virtual void _disableTextureUnit(size_t texUnit);
638  virtual void _disableTextureUnitsFrom(size_t texUnit);
672  virtual void _setSurfaceParams(const ColourValue &ambient,
673  const ColourValue &diffuse, const ColourValue &specular,
674  const ColourValue &emissive, Real shininess,
675  TrackVertexColourType tracking = TVC_NONE) = 0;
676 
682  virtual void _setPointSpritesEnabled(bool enabled) = 0;
683 
694  virtual void _setPointParameters(Real size, bool attenuationEnabled,
695  Real constant, Real linear, Real quadratic, Real minSize, Real maxSize) = 0;
696 
697 
710  virtual void _setTexture(size_t unit, bool enabled,
711  const TexturePtr &texPtr) = 0;
725  virtual void _setTexture(size_t unit, bool enabled, const String &texname);
726 
736  virtual void _setVertexTexture(size_t unit, const TexturePtr& tex);
737 
747  virtual void _setTextureCoordSet(size_t unit, size_t index) = 0;
748 
756  virtual void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m,
757  const Frustum* frustum = 0) = 0;
758 
765  virtual void _setTextureBlendMode(size_t unit, const LayerBlendModeEx& bm) = 0;
766 
773  virtual void _setTextureUnitFiltering(size_t unit, FilterOptions minFilter,
774  FilterOptions magFilter, FilterOptions mipFilter);
775 
781  virtual void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter) = 0;
782 
787  virtual void _setTextureUnitCompareEnabled(size_t unit, bool compare) = 0;
788 
789 
794  virtual void _setTextureUnitCompareFunction(size_t unit, CompareFunction function) = 0;
795 
796 
798  virtual void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy) = 0;
799 
801  virtual void _setTextureAddressingMode(size_t unit, const TextureUnitState::UVWAddressingMode& uvw) = 0;
802 
804  virtual void _setTextureBorderColour(size_t unit, const ColourValue& colour) = 0;
805 
814  virtual void _setTextureMipmapBias(size_t unit, float bias) = 0;
815 
820  virtual void _setTextureMatrix(size_t unit, const Matrix4& xform) = 0;
821 
832  virtual void _setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op = SBO_ADD) = 0;
833 
846  virtual void _setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha,
847  SceneBlendFactor destFactorAlpha, SceneBlendOperation op = SBO_ADD, SceneBlendOperation alphaOp = SBO_ADD) = 0;
848 
855  virtual void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage) = 0;
856 
860  virtual void _setTextureProjectionRelativeTo(bool enabled, const Vector3& pos);
861 
869  virtual DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget ) = 0;
870 
878  void _cleanupDepthBuffers( bool bCleanManualBuffers=true );
879 
884  virtual void _beginFrame(void) = 0;
885 
886  //Dummy structure for render system contexts - implementing RenderSystems can extend
887  //as needed
894  virtual RenderSystemContext* _pauseFrame(void);
901  virtual void _resumeFrame(RenderSystemContext* context);
902 
906  virtual void _endFrame(void) = 0;
914  virtual void _setViewport(Viewport *vp) = 0;
916  virtual Viewport* _getViewport(void);
917 
929  virtual void _setCullingMode(CullingMode mode) = 0;
930 
931  virtual CullingMode _getCullingMode(void) const;
932 
946  virtual void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL) = 0;
947 
952  virtual void _setDepthBufferCheckEnabled(bool enabled = true) = 0;
957  virtual void _setDepthBufferWriteEnabled(bool enabled = true) = 0;
965  virtual void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL) = 0;
973  virtual void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha) = 0;
996  virtual void _setDepthBias(float constantBias, float slopeScaleBias = 0.0f) = 0;
1008  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;
1009 
1010 
1012  virtual void _beginGeometryCount(void);
1014  virtual unsigned int _getFaceCount(void) const;
1016  virtual unsigned int _getBatchCount(void) const;
1018  virtual unsigned int _getVertexCount(void) const;
1019 
1028  virtual void convertColourValue(const ColourValue& colour, uint32* pDest);
1032  virtual VertexElementType getColourVertexElementType(void) const = 0;
1033 
1040  virtual void _convertProjectionMatrix(const Matrix4& matrix,
1041  Matrix4& dest, bool forGpuProgram = false) = 0;
1042 
1049  virtual void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1050  Matrix4& dest, bool forGpuProgram = false) = 0;
1051 
1058  virtual void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top,
1059  Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false) = 0;
1066  virtual void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1067  Matrix4& dest, bool forGpuProgram = false) = 0;
1068 
1085  virtual void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
1086  bool forGpuProgram) = 0;
1087 
1089  virtual void _setPolygonMode(PolygonMode level) = 0;
1090 
1097  virtual void setStencilCheckEnabled(bool enabled) = 0;
1113  /*virtual bool hasHardwareStencil(void) = 0;*/
1114 
1153  virtual void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS,
1154  uint32 refValue = 0, uint32 compareMask = 0xFFFFFFFF, uint32 writeMask = 0xFFFFFFFF,
1155  StencilOperation stencilFailOp = SOP_KEEP,
1156  StencilOperation depthFailOp = SOP_KEEP,
1157  StencilOperation passOp = SOP_KEEP,
1158  bool twoSidedOperation = false) = 0;
1159 
1160 
1161 
1163  virtual void setVertexDeclaration(VertexDeclaration* decl) = 0;
1165  virtual void setVertexBufferBinding(VertexBufferBinding* binding) = 0;
1166 
1177  virtual void setNormaliseNormals(bool normalise) = 0;
1178 
1191  virtual void _render(const RenderOperation& op);
1192 
1194  const RenderSystemCapabilities* getCapabilities(void) const { return mCurrentCapabilities; }
1195 
1196 
1199  virtual const DriverVersion& getDriverVersion(void) const { return mDriverVersion; }
1200 
1210  virtual const String& _getDefaultViewportMaterialScheme(void) const;
1211 
1216  virtual void bindGpuProgram(GpuProgram* prg);
1217 
1223  virtual void bindGpuProgramParameters(GpuProgramType gptype,
1224  GpuProgramParametersSharedPtr params, uint16 variabilityMask) = 0;
1225 
1228  virtual void bindGpuProgramPassIterationParameters(GpuProgramType gptype) = 0;
1233  virtual void unbindGpuProgram(GpuProgramType gptype);
1234 
1236  virtual bool isGpuProgramBound(GpuProgramType gptype);
1237 
1243  uint16 getNativeShadingLanguageVersion() const { return mNativeShadingLanguageVersion; }
1244 
1247  virtual void setClipPlanes(const PlaneList& clipPlanes);
1248 
1250  virtual void addClipPlane (const Plane &p);
1252  virtual void addClipPlane (Real A, Real B, Real C, Real D);
1253 
1256  virtual void resetClipPlanes();
1257 
1259  virtual void _initRenderTargets(void);
1260 
1264  virtual void _notifyCameraRemoved(const Camera* cam);
1265 
1267  virtual void _updateAllRenderTargets(bool swapBuffers = true);
1270  virtual void _swapAllRenderTargetBuffers();
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 
1503 
1511 
1512  // Texture manager
1513  // A concrete class of this will be created and
1514  // made available under the TextureManager singleton,
1515  // managed by the RenderSystem
1517 
1518  // Active viewport (dest for future rendering operations)
1520 
1522 
1523  bool mWBuffer;
1524 
1525  size_t mBatchCount;
1526  size_t mFaceCount;
1528 
1530  ColourValue mManualBlendColours[OGRE_MAX_TEXTURE_LAYERS][2];
1531 
1533 
1536 
1545 
1552 
1555 
1560  bool updatePassIterationRenderState(void);
1561 
1564 
1566  virtual void fireEvent(const String& name, const NameValuePairList* params = 0);
1567 
1570 
1573 
1580 
1581  // Recording user clip planes
1583  // Indicator that we need to re-set the clip planes on next render call
1585 
1590 
1592  virtual void setClipPlanesImpl(const PlaneList& clipPlanes) = 0;
1593 
1595  virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary) = 0;
1596 
1597 
1600 
1603 
1604 
1605 
1606  };
1609 }
1610 
1611 #include "OgreHeaderSuffix.h"
1612 
1613 #endif

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 Wed Oct 16 2013 14:35:44