# 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-2009 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
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sun May 8 2011 20:28:08