E:/Programming/MyProject/K_Game_hg/GameEngine/include/render/RenderDriver.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _RENDER_DRIVER_H_
#define _RENDER_DRIVER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Matrix4.h>
#include <render/Material.h>
#include <render/BlendMode.h>
#include <render/Color.h>
#include <render/RenderOperation.h>

#include <vector>

namespace core
{
class sphere3d;
}

namespace resource
{
enum BufferUsage;
enum PixelFormat;
}

namespace render
{

class Frustum;
class Light;
class Camera;
class MeshData;
class Overlay;
class PanelOverlay;
class TextOverlay;
class Font;
class MeshData;
class Viewport;
class RenderWindow;
class RenderDriver;
class FrameEventReceiver;
struct FrameEvent;
class Shader;
class VertexBuffer;
class IndexBuffer;
class PixelBuffer;
class Texture;
class ShaderParamData;
enum IndexType;
enum ShaderType;

#define GAME_MAX_TEXTURE_LAYERS 16

#define GAME_MAX_SIMULTANEOUS_LIGHTS 8

class ENGINE_PUBLIC_EXPORT RenderDriver
{
public:

        // Default Constructor
        RenderDriver();

        // Destructor
        virtual ~RenderDriver();

        virtual void initialize();

        virtual void start();

        virtual void stop();
        
        virtual RenderWindow* createRenderWindow(s32 width, s32 height, s32 colorDepth,
                bool fullScreen, s32 left = 0, s32 top = 0, bool depthBuffer = true, void* windowId = NULL) = 0;

        virtual VertexBuffer* createVertexBuffer(u32 vertexSize, u32 numVertices, resource::BufferUsage usage, bool useShadowBuffer = false) = 0;
        virtual void removeVertexBuffer(VertexBuffer* buf) = 0;

        virtual IndexBuffer* createIndexBuffer(IndexType idxType, u32 numIndexes, resource::BufferUsage usage, bool useShadowBuffer = false) = 0;
        virtual void removeIndexBuffer(IndexBuffer* buf) = 0;

        virtual PixelBuffer* createPixelBuffer(u32 width, u32 height, u32 depth, resource::PixelFormat format, resource::BufferUsage usage, bool useShadowBuffer = false) = 0;
        virtual void removePixelBuffer(PixelBuffer* buf) = 0;

        virtual void beginFrame(Viewport *vp) = 0;

        virtual void render(RenderOperation& op);

        virtual void renderGrid(u32 lineSpacing, u32 lineNumber) = 0;

        virtual void renderTestPlane(u32 lineSpacing, u32 lineNumber) = 0;//just for testing

        virtual void renderWorldAxes() = 0;

        virtual void renderAxes(const core::vector3d& position, const core::vector3d& right, const core::vector3d& target, const core::vector3d& up) = 0;//for debugging

        virtual void renderBoundingSphere(const core::sphere3d& sphere) = 0;//for debugging

        virtual void renderBoundingBox(const core::aabox3d& box) = 0;//for debugging

        virtual void renderFrustumVolume(const core::vector3d* corners) = 0;//for debugging

        virtual void endFrame() = 0;

        virtual void beginGeometryCount();

        virtual u32 getVertexCount();

        virtual u32 getFaceCount();

        virtual void endGeometryCount();

        virtual void setViewport(Viewport *vp) = 0;

        virtual void setWorldMatrix(const core::matrix4& m) = 0;

        virtual void setViewMatrix(const core::matrix4& m) = 0;

        virtual void setProjectionMatrix(const core::matrix4& m) = 0;

        core::matrix4& getWorldMatrix();

        core::matrix4& getViewMatrix();

        core::matrix4& getProjectionMatrix();

        virtual void convertProjectionMatrix(const core::matrix4& matrix, core::matrix4& dest);

        virtual void setShadingType(ShadeOptions so) = 0;

        virtual void setSurfaceParams(const Color& ambient, const Color& diffuse,
                        const Color& specular, const Color& emissive, f32 shininess) = 0;

        virtual void setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor) = 0;
        
        virtual void setTextureUnitSettings(u32 texUnit, TextureUnit* tu);

        virtual void disableTextureUnit(u32 texUnit);

        virtual void disableTextureUnitsFrom(u32 texUnit);
        
        virtual void setTexture(bool enabled, u32 unit, Texture* tex) = 0;

        virtual void setTextureCoordSet(u32 unit, u32 index);

        virtual void setTextureBlendMode(u32 unit, const LayerBlendMode& bm) = 0;

        virtual void setLightingEnabled(bool enabled) = 0;

        virtual void setAmbientLight(f32 red, f32 green, f32 blue, f32 alpha) = 0;

        virtual void setLights(const std::vector<Light*>& lights) = 0;

        virtual void setDepthBufferCheckEnabled(bool enabled = true) = 0;

        virtual void setDepthBufferWriteEnabled(bool enabled = true) = 0;

        virtual void setFog(FogMode mode = FM_NONE, const Color& color = Color::White, f32 expDensity = 1.0f, f32 linearStart = 0.0f, f32 linearEnd = 1.0f) = 0;

        virtual u32 getNumTextureUnits() = 0;

        virtual void bindShader(Shader* shader);

        virtual void unbindShader(ShaderType type);

        virtual bool isShaderBound(ShaderType type);

        virtual void updateShaderAutoParameters(Shader* shader, ShaderParamData& data);

        virtual f32 getMinimumDepthInputValue() = 0;
        virtual f32 getMaximumDepthInputValue() = 0;

        virtual f32 getHorizontalTexelOffset() = 0;
        virtual f32 getVerticalTexelOffset() = 0;

protected:

        u32 mFaceCount;
        u32 mVertexCount;
        
        core::matrix4 mWorldMatrix;
        core::matrix4 mViewMatrix;
        core::matrix4 mProjMatrix;

        u32 mTextureCoordIndex[GAME_MAX_TEXTURE_COORD_SETS];

        // Array of up to 8 lights, indexed as per API
        // Note that a null value indicates a free slot
        Light* mLights[GAME_MAX_SIMULTANEOUS_LIGHTS];

        // Saved manual color blends
        Color mManualBlendColors[GAME_MAX_TEXTURE_LAYERS][2];

        // Texture units from this upwards are disabled
        u32 mDisabledTexUnitsFrom;

        Shader* mCurrentVertexShader;
        Shader* mCurrentFragmentShader;
        Shader* mCurrentGeometryShader;
};

} // end namespace render

#endif