OgreRenderSystem.h
Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004 (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org
00006 
00007 Copyright (c) 2000-2011 Torus Knot Software Ltd
00008 
00009 Permission is hereby granted, free of charge, to any person obtaining a copy
00010 of this software and associated documentation files (the "Software"), to deal
00011 in the Software without restriction, including without limitation the rights
00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00013 copies of the Software, and to permit persons to whom the Software is
00014 furnished to do so, subject to the following conditions:
00015 
00016 The above copyright notice and this permission notice shall be included in
00017 all copies or substantial portions of the Software.
00018 
00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00025 THE SOFTWARE.
00026 -----------------------------------------------------------------------------
00027 */
00028 #ifndef __RenderSystem_H_
00029 #define __RenderSystem_H_
00030 
00031 // Precompiler options
00032 #include "OgrePrerequisites.h"
00033 
00034 #include "OgreString.h"
00035 
00036 #include "OgreTextureUnitState.h"
00037 #include "OgreCommon.h"
00038 
00039 #include "OgreRenderOperation.h"
00040 #include "OgreRenderSystemCapabilities.h"
00041 #include "OgreRenderTarget.h"
00042 #include "OgreRenderTexture.h"
00043 #include "OgreFrameListener.h"
00044 #include "OgreConfigOptionMap.h"
00045 #include "OgreGpuProgram.h"
00046 #include "OgrePlane.h"
00047 #include "OgreIteratorWrappers.h"
00048 
00049 namespace Ogre
00050 {
00058     typedef map< String, RenderTarget * >::type RenderTargetMap;
00059     typedef multimap<uchar, RenderTarget * >::type RenderTargetPriorityMap;
00060 
00061     class TextureManager;
00063     enum TexCoordCalcMethod
00064     {
00066         TEXCALC_NONE,
00068         TEXCALC_ENVIRONMENT_MAP,
00070         TEXCALC_ENVIRONMENT_MAP_PLANAR,
00071         TEXCALC_ENVIRONMENT_MAP_REFLECTION,
00072         TEXCALC_ENVIRONMENT_MAP_NORMAL,
00074         TEXCALC_PROJECTIVE_TEXTURE
00075     };
00077     enum StencilOperation
00078     {
00080         SOP_KEEP,
00082         SOP_ZERO,
00084         SOP_REPLACE,
00086         SOP_INCREMENT,
00088         SOP_DECREMENT,
00090         SOP_INCREMENT_WRAP,
00092         SOP_DECREMENT_WRAP,
00094         SOP_INVERT
00095     };
00096 
00097 
00121     class _OgreExport RenderSystem : public RenderSysAlloc
00122     {
00123     public:
00126         RenderSystem();
00127 
00130         virtual ~RenderSystem();
00131 
00134         virtual const String& getName(void) const = 0;
00135 
00157         virtual ConfigOptionMap& getConfigOptions(void) = 0;
00158 
00178         virtual void setConfigOption(const String &name, const String &value) = 0;
00179 
00182         virtual HardwareOcclusionQuery* createHardwareOcclusionQuery(void) = 0;
00183 
00186         virtual void destroyHardwareOcclusionQuery(HardwareOcclusionQuery *hq);
00187 
00192         virtual String validateConfigOptions(void) = 0;
00193 
00210         virtual RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
00211 
00212 
00214         virtual RenderSystemCapabilities* createRenderSystemCapabilities() const = 0;
00215 
00222         virtual void useCustomRenderSystemCapabilities(RenderSystemCapabilities* capabilities);
00223 
00226         virtual void reinitialise(void) = 0;
00227 
00230         virtual void shutdown(void);
00231 
00232 
00235         virtual void setAmbientLight(float r, float g, float b) = 0;
00236 
00239         virtual void setShadingType(ShadeOptions so) = 0;
00240 
00246         virtual void setLightingEnabled(bool enabled) = 0;
00247 
00254         void setWBufferEnabled(bool enabled);
00255 
00258         bool getWBufferEnabled(void) const;
00259 
00466         virtual RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height, 
00467             bool fullScreen, const NameValuePairList *miscParams = 0) = 0;
00468 
00484         virtual bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions, 
00485             RenderWindowList& createdWindows);
00486 
00487         
00492         virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0; 
00493 
00495         virtual void destroyRenderWindow(const String& name);
00497         virtual void destroyRenderTexture(const String& name);
00499         virtual void destroyRenderTarget(const String& name);
00500 
00503         virtual void attachRenderTarget( RenderTarget &target );
00507         virtual RenderTarget * getRenderTarget( const String &name );
00513         virtual RenderTarget * detachRenderTarget( const String &name );
00514 
00516         typedef MapIterator<Ogre::RenderTargetMap> RenderTargetIterator;
00517 
00519         virtual RenderTargetIterator getRenderTargetIterator(void) {
00520             return RenderTargetIterator( mRenderTargets.begin(), mRenderTargets.end() );
00521         }
00524         virtual String getErrorDescription(long errorNumber) const = 0;
00525 
00539         void setWaitForVerticalBlank(bool enabled);
00540 
00543         bool getWaitForVerticalBlank(void) const;
00544 
00545         // ------------------------------------------------------------------------
00546         //                     Internal Rendering Access
00547         // All methods below here are normally only called by other OGRE classes
00548         // They can be called by library user if required
00549         // ------------------------------------------------------------------------
00550 
00551 
00555         virtual void _useLights(const LightList& lights, unsigned short limit) = 0;
00558         virtual bool areFixedFunctionLightsInViewSpace() const { return false; }
00560         virtual void _setWorldMatrix(const Matrix4 &m) = 0;
00562         virtual void _setWorldMatrices(const Matrix4* m, unsigned short count);
00564         virtual void _setViewMatrix(const Matrix4 &m) = 0;
00566         virtual void _setProjectionMatrix(const Matrix4 &m) = 0;
00572         virtual void _setTextureUnitSettings(size_t texUnit, TextureUnitState& tl);
00574         virtual void _disableTextureUnit(size_t texUnit);
00576         virtual void _disableTextureUnitsFrom(size_t texUnit);
00610         virtual void _setSurfaceParams(const ColourValue &ambient,
00611             const ColourValue &diffuse, const ColourValue &specular,
00612             const ColourValue &emissive, Real shininess,
00613             TrackVertexColourType tracking = TVC_NONE) = 0;
00614 
00620         virtual void _setPointSpritesEnabled(bool enabled) = 0;
00621 
00632         virtual void _setPointParameters(Real size, bool attenuationEnabled, 
00633             Real constant, Real linear, Real quadratic, Real minSize, Real maxSize) = 0;
00634 
00635 
00648         virtual void _setTexture(size_t unit, bool enabled, 
00649             const TexturePtr &texPtr) = 0;
00663         virtual void _setTexture(size_t unit, bool enabled, const String &texname);
00664 
00674         virtual void _setVertexTexture(size_t unit, const TexturePtr& tex);
00675 
00685         virtual void _setTextureCoordSet(size_t unit, size_t index) = 0;
00686 
00694         virtual void _setTextureCoordCalculation(size_t unit, TexCoordCalcMethod m, 
00695             const Frustum* frustum = 0) = 0;
00696 
00703         virtual void _setTextureBlendMode(size_t unit, const LayerBlendModeEx& bm) = 0;
00704 
00711         virtual void _setTextureUnitFiltering(size_t unit, FilterOptions minFilter,
00712             FilterOptions magFilter, FilterOptions mipFilter);
00713 
00719         virtual void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter) = 0;
00720 
00722         virtual void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy) = 0;
00723 
00725         virtual void _setTextureAddressingMode(size_t unit, const TextureUnitState::UVWAddressingMode& uvw) = 0;
00726 
00728         virtual void _setTextureBorderColour(size_t unit, const ColourValue& colour) = 0;
00729 
00738         virtual void _setTextureMipmapBias(size_t unit, float bias) = 0;
00739 
00744         virtual void _setTextureMatrix(size_t unit, const Matrix4& xform) = 0;
00745 
00756         virtual void _setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op = SBO_ADD) = 0;
00757 
00770         virtual void _setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha, 
00771             SceneBlendFactor destFactorAlpha, SceneBlendOperation op = SBO_ADD, SceneBlendOperation alphaOp = SBO_ADD) = 0;
00772 
00779         virtual void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage) = 0;
00780 
00784         virtual void _setTextureProjectionRelativeTo(bool enabled, const Vector3& pos);
00789         virtual void _beginFrame(void) = 0;
00790         
00791         //Dummy structure for render system contexts - implementing RenderSystems can extend
00792         //as needed
00793         struct RenderSystemContext { };
00799         virtual RenderSystemContext* _pauseFrame(void);
00806         virtual void _resumeFrame(RenderSystemContext* context);
00807 
00811         virtual void _endFrame(void) = 0;
00819         virtual void _setViewport(Viewport *vp) = 0;
00821         virtual Viewport* _getViewport(void);
00822 
00834         virtual void _setCullingMode(CullingMode mode) = 0;
00835 
00836         virtual CullingMode _getCullingMode(void) const;
00837 
00851         virtual void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL) = 0;
00852 
00857         virtual void _setDepthBufferCheckEnabled(bool enabled = true) = 0;
00862         virtual void _setDepthBufferWriteEnabled(bool enabled = true) = 0;
00870         virtual void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL) = 0;
00878         virtual void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha) = 0;
00901         virtual void _setDepthBias(float constantBias, float slopeScaleBias = 0.0f) = 0;
00913         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;
00914 
00915 
00917         virtual void _beginGeometryCount(void);
00919         virtual unsigned int _getFaceCount(void) const;
00921         virtual unsigned int _getBatchCount(void) const;
00923         virtual unsigned int _getVertexCount(void) const;
00924 
00933         virtual void convertColourValue(const ColourValue& colour, uint32* pDest);
00937         virtual VertexElementType getColourVertexElementType(void) const = 0;
00938 
00945         virtual void _convertProjectionMatrix(const Matrix4& matrix,
00946             Matrix4& dest, bool forGpuProgram = false) = 0;
00947 
00954         virtual void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane, 
00955             Matrix4& dest, bool forGpuProgram = false) = 0;
00956 
00963         virtual void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top, 
00964             Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false) = 0;
00971         virtual void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane, 
00972             Matrix4& dest, bool forGpuProgram = false) = 0;
00973 
00990         virtual void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane, 
00991             bool forGpuProgram) = 0;
00992 
00994         virtual void _setPolygonMode(PolygonMode level) = 0;
00995 
01002         virtual void setStencilCheckEnabled(bool enabled) = 0;
01018         /*virtual bool hasHardwareStencil(void) = 0;*/
01019 
01055         virtual void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS, 
01056             uint32 refValue = 0, uint32 mask = 0xFFFFFFFF, 
01057             StencilOperation stencilFailOp = SOP_KEEP, 
01058             StencilOperation depthFailOp = SOP_KEEP,
01059             StencilOperation passOp = SOP_KEEP, 
01060             bool twoSidedOperation = false) = 0;
01061 
01062 
01063 
01065         virtual void setVertexDeclaration(VertexDeclaration* decl) = 0;
01067         virtual void setVertexBufferBinding(VertexBufferBinding* binding) = 0;
01068 
01079         virtual void setNormaliseNormals(bool normalise) = 0;
01080 
01093         virtual void _render(const RenderOperation& op);
01094 
01096         const RenderSystemCapabilities* getCapabilities(void) const { return mCurrentCapabilities; }
01097 
01098 
01101         virtual const DriverVersion& getDriverVersion(void) const { return mDriverVersion; }
01102 
01107         virtual void bindGpuProgram(GpuProgram* prg);
01108 
01114         virtual void bindGpuProgramParameters(GpuProgramType gptype, 
01115             GpuProgramParametersSharedPtr params, uint16 variabilityMask) = 0;
01116 
01119         virtual void bindGpuProgramPassIterationParameters(GpuProgramType gptype) = 0;
01124         virtual void unbindGpuProgram(GpuProgramType gptype);
01125 
01127         virtual bool isGpuProgramBound(GpuProgramType gptype);
01128 
01131         virtual void setClipPlanes(const PlaneList& clipPlanes);
01132 
01134         virtual void addClipPlane (const Plane &p);
01136         virtual void addClipPlane (Real A, Real B, Real C, Real D);
01137 
01140         virtual void resetClipPlanes();
01141 
01143         virtual void _initRenderTargets(void);
01144 
01148         virtual void _notifyCameraRemoved(const Camera* cam);
01149 
01151         virtual void _updateAllRenderTargets(bool swapBuffers = true);
01154         virtual void _swapAllRenderTargetBuffers(bool waitForVsync = true);
01155 
01158         virtual void setInvertVertexWinding(bool invert);
01159 
01163         virtual bool getInvertVertexWinding(void) const;
01164 
01176         virtual void setScissorTest(bool enabled, size_t left = 0, size_t top = 0, 
01177             size_t right = 800, size_t bottom = 600) = 0;
01178 
01186         virtual void clearFrameBuffer(unsigned int buffers, 
01187             const ColourValue& colour = ColourValue::Black, 
01188             Real depth = 1.0f, unsigned short stencil = 0) = 0;
01198         virtual Real getHorizontalTexelOffset(void) = 0;
01208         virtual Real getVerticalTexelOffset(void) = 0;
01209 
01218         virtual Real getMinimumDepthInputValue(void) = 0;
01227         virtual Real getMaximumDepthInputValue(void) = 0;
01233         virtual void setCurrentPassIterationCount(const size_t count) { mCurrentPassIterationCount = count; }
01234 
01244         virtual void setDeriveDepthBias(bool derive, float baseValue = 0.0f,
01245             float multiplier = 0.0f, float slopeScale = 0.0f)
01246         {
01247             mDerivedDepthBias = derive;
01248             mDerivedDepthBiasBase = baseValue;
01249             mDerivedDepthBiasMultiplier = multiplier;
01250             mDerivedDepthBiasSlopeScale = slopeScale;
01251         }
01252 
01256         virtual void _setRenderTarget(RenderTarget *target) = 0;
01257 
01262         class _OgreExport Listener
01263         {
01264         public:
01265             Listener() {}
01266             virtual ~Listener() {}
01267 
01273             virtual void eventOccurred(const String& eventName, 
01274                 const NameValuePairList* parameters = 0) = 0;
01275         };
01289         virtual void addListener(Listener* l);
01292         virtual void removeListener(Listener* l);
01293 
01298         virtual const StringVector& getRenderSystemEvents(void) const { return mEventNames; }
01299 
01316         virtual void preExtraThreadsStarted() = 0;
01317 
01318         /* Tell the rendersystem to perform any tasks it needs to directly
01319         after other threads which might access the rendering API are registered.
01320         @see RenderSystem::preExtraThreadsStarted
01321         */
01322         virtual void postExtraThreadsStarted() = 0;
01323 
01336         virtual void registerThread() = 0;
01337 
01341         virtual void unregisterThread() = 0;
01342 
01347         virtual unsigned int getDisplayMonitorCount() const = 0;
01348     protected:
01349 
01350 
01352         RenderTargetMap mRenderTargets;
01354         RenderTargetPriorityMap mPrioritisedRenderTargets;
01356         RenderTarget * mActiveRenderTarget;
01358         GpuProgramParametersSharedPtr mActiveVertexGpuProgramParameters;
01359         GpuProgramParametersSharedPtr mActiveGeometryGpuProgramParameters;
01360         GpuProgramParametersSharedPtr mActiveFragmentGpuProgramParameters;
01361 
01362         // Texture manager
01363         // A concrete class of this will be created and
01364         // made available under the TextureManager singleton,
01365         // managed by the RenderSystem
01366         TextureManager* mTextureManager;
01367 
01368         // Active viewport (dest for future rendering operations)
01369         Viewport* mActiveViewport;
01370 
01371         CullingMode mCullingMode;
01372 
01373         bool mVSync;
01374         unsigned int mVSyncInterval;
01375         bool mWBuffer;
01376 
01377         size_t mBatchCount;
01378         size_t mFaceCount;
01379         size_t mVertexCount;
01380 
01382         ColourValue mManualBlendColours[OGRE_MAX_TEXTURE_LAYERS][2];
01383 
01384         bool mInvertVertexWinding;
01385 
01387         size_t mDisabledTexUnitsFrom;
01388 
01390         size_t mCurrentPassIterationCount;
01391         size_t mCurrentPassIterationNum;
01393         bool mDerivedDepthBias;
01394         float mDerivedDepthBiasBase;
01395         float mDerivedDepthBiasMultiplier;
01396         float mDerivedDepthBiasSlopeScale;
01397 
01402         bool updatePassIterationRenderState(void);
01403 
01405         StringVector mEventNames;
01406 
01408         virtual void fireEvent(const String& name, const NameValuePairList* params = 0);
01409 
01410         typedef list<Listener*>::type ListenerList;
01411         ListenerList mEventListeners;
01412 
01413         typedef list<HardwareOcclusionQuery*>::type HardwareOcclusionQueryList;
01414         HardwareOcclusionQueryList mHwOcclusionQueries;
01415 
01416         bool mVertexProgramBound;
01417         bool mGeometryProgramBound;
01418         bool mFragmentProgramBound;
01419 
01420         // Recording user clip planes
01421         PlaneList mClipPlanes;
01422         // Indicator that we need to re-set the clip planes on next render call
01423         bool mClipPlanesDirty;
01424 
01426         RenderSystemCapabilities* mRealCapabilities;
01427         RenderSystemCapabilities* mCurrentCapabilities;
01428         bool mUseCustomCapabilities;
01429 
01431         virtual void setClipPlanesImpl(const PlaneList& clipPlanes) = 0;
01432 
01434         virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary) = 0;
01435 
01436 
01437         DriverVersion mDriverVersion;
01438 
01439         bool mTexProjRelative;
01440         Vector3 mTexProjRelativeOrigin;
01441 
01442 
01443 
01444     };
01447 }
01448 
01449 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sat Jan 14 2012 18:40:43