239 lines
8.4 KiB
C++
239 lines
8.4 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
|
|
|
http://www.genesis-3d.com.cn
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
#ifndef RENDERSYSTEM_H_
|
|
#define RENDERSYSTEM_H_
|
|
#include "core/debug.h"
|
|
#include "core/refcounted.h"
|
|
#include "base/RenderDeviceTypes.h"
|
|
#include "base/PrimitiveGroup.h"
|
|
#include "base/RenderTarget.h"
|
|
#include "base/MultipleRenderTarget.h"
|
|
#include "base/RenderDevice.h"
|
|
#include "base/Texture.h"
|
|
#include "core/singleton.h"
|
|
#include "interface/interfacebase.h"
|
|
#include "util/guid.h"
|
|
#include "util/queue.h"
|
|
#include "util/stl.h"
|
|
#include "RenderSystemThreadHandler.h"
|
|
#include "base/GraphicCardCapability.h"
|
|
#include "base/RenderWindow.h"
|
|
|
|
namespace RenderBase
|
|
{
|
|
class RenderSystem : public Core::RefCounted
|
|
{
|
|
__DeclareSubClass(RenderSystem,Core::RefCounted);
|
|
__DeclareThreadSingleton(RenderSystem);
|
|
public:
|
|
/// constructor
|
|
RenderSystem();
|
|
/// destructor
|
|
virtual ~RenderSystem();
|
|
|
|
void ChangeSize(int width, int height);
|
|
|
|
/// open the interface object
|
|
virtual void Open(int width, int height);
|
|
/// close the interface object
|
|
virtual void Close();
|
|
|
|
void SetDeviceLostCallBack(deviceLostCallBackFunc func);
|
|
|
|
float GetHorizontalTexelOffset();
|
|
float GetVerticalTexelOffset();
|
|
float GetMinimumDepthInputValue();
|
|
float GetMaximumDepthInputValue();
|
|
|
|
void SetBlendState(const DeviceBlendState* state, float alphaRef);
|
|
void SetRasterState(const DeviceRasterizerState* state);
|
|
void SetDepthState(const DeviceDepthAndStencilState* state);
|
|
void SetSamplerState(const DeviceSamplerState* state, int stencilRef);
|
|
|
|
void SetVertexShaderConstantVectorF(const int& reg, float* val, const int& vec4count);
|
|
void SetPixelShaderConstantVectorF(const int& reg, float* val, const int& vec4count);
|
|
|
|
void SetVertexShaderConstantFloat(const int& reg, float* val);
|
|
void SetPixelShaderConstantFloat(const int& reg, float* val);
|
|
|
|
void SetVertexShaderConstantMatrixF(const int& reg, float* val, const int& matrixCount);
|
|
void SetPixelShaderConstantMatrixF(const int& reg, float* val, const int& matrixCount);
|
|
|
|
void BeginFrame();
|
|
void EndFrame();
|
|
bool IsBeginFrame() const;
|
|
|
|
void Clear();
|
|
|
|
GPUProgramHandle CreateShaderProgram(const GPtr<GPUProgram>& program);
|
|
void _SetShaderProgram(GPUProgramHandle handle);
|
|
|
|
PrimitiveGroup* GetPrimitiveGroup(const PrimitiveHandle& handle) const;
|
|
Texture* GetTexture(const TextureHandle& handle) const;
|
|
|
|
|
|
PrimitiveHandle CreatePrimitiveHandle(const VertexBufferData* vbd, const IndexBufferData* ibd = NULL);
|
|
void ChangePrimitiveHandle(RenderBase::PrimitiveHandle& handle, const RenderBase::VertexBufferData* vbd, const RenderBase::IndexBufferData* ibd = NULL);
|
|
void UpdateVertexBuffer(PrimitiveHandle& handle, const DataStream& data);
|
|
void UpdateIndexBuffer(PrimitiveHandle& handle, const DataStream& data);
|
|
|
|
void _DrawPrimitive(PrimitiveHandle handle,SizeT startVertice,SizeT endVertice,SizeT startIndice,SizeT endIndice);
|
|
void _DrawPrimitive(PrimitiveHandle handle);
|
|
void _DrawPrimitiveHWInstance(PrimitiveHandle handle);
|
|
|
|
|
|
RenderStateDescHandle CreateRenderStateObject( const GPtr<RenderStateDesc>& rsObject);
|
|
void _SetRenderState( GPtr<RenderStateDesc> rsObject, const uint& shaderMask);
|
|
|
|
RenderTargetHandle CreateRenderTarget( const GPtr<RenderTarget>& rt, TextureHandle& texhandle );
|
|
void _SetRenderTarget(RenderTargetHandle handle,SizeT index,uint clearflag);
|
|
void _SetRenderTargetClearColor(RenderTargetHandle handle,const Math::float4& clearColor);
|
|
void _ReSizeRenderTarget(RenderTargetHandle handle,const int& width,const int& height);
|
|
void CopyRenderTarget(RenderTargetHandle srcHandle, const Math::float4& srcRect, RenderTargetHandle desHandle, const Math::float4& desRect);
|
|
|
|
MultipleRenderTargetHandle CreateMultipleRenderTarget(const GPtr<MultipleRenderTarget>& mrt, Util::Array< RenderBase::RenderTargetHandle >& handles);
|
|
void _SetMultipleRenderTarget(MultipleRenderTargetHandle handle, bool resume = false);
|
|
void _ReSizeMultipleRenderTarget(MultipleRenderTargetHandle handle,const int& width,const int& height);
|
|
|
|
TextureHandle CreateTexture( const GPtr<Texture>& tex);
|
|
void _SetTexture(TextureHandle handle,SizeT index);
|
|
void UpdateTexture(TextureHandle texHandle, RenderBase::Texture::UpdateFunction texUpdateFunc, void* tag);
|
|
void UpdateTexture(TextureHandle texHandle, GPtr<RenderBase::Texture> texture);
|
|
void ChangeTexture(RenderBase::TextureHandle texHandle, GPtr<Texture> texture);
|
|
|
|
void _RemoveResouce(const RenderResourceHandle& handle);
|
|
|
|
void _SetDisplayMode(const DisplayMode& mode);
|
|
void _SetViewPort(const int& x,const int& y,const int& width,const int& height,const float& minZ,const float& maxZ);
|
|
|
|
//fixed pipeline functions
|
|
void _FXSetClipPlane(const int& index,const Math::float4& plane);
|
|
|
|
const GraphicCardCapability& GetGraphicCardCapability();
|
|
|
|
GPtr<RenderTarget> GetRenderTarget( RenderTargetHandle ) ;
|
|
bool OutPutRenderTarget( RenderTargetHandle , const Util::String& path ) ;
|
|
|
|
void _OnWindowChanged();
|
|
|
|
RenderWindow* CreateRenderWindow( WindHandle hWnd );
|
|
|
|
void DestroyRenderWindow( RenderWindow* rw );
|
|
|
|
void SetWireFrameMode(bool wireframe = false);
|
|
|
|
void OnDeviceLost();
|
|
|
|
bool CheckReset();
|
|
|
|
void OnDeviceReset();
|
|
|
|
protected:
|
|
bool _AddRenderHandle( const RenderBase::RenderResourceHandle& handle);
|
|
bool _RemoveRenderHandle( const RenderBase::RenderResourceHandle& handle);
|
|
bool _HasRenderHandle(const RenderBase::RenderResourceHandle& handle);
|
|
|
|
private:
|
|
friend class RenderSystemThreadHandler;
|
|
|
|
GPtr<RenderDevice> m_renderDevice;
|
|
GPtr<RenderDisplay> m_renderDisplay;
|
|
RenderBase::RenderTargetHandle m_dummyRenderTargetHandle;
|
|
|
|
typedef Util::STL_set<RenderResourceHandle> RenderResourceHandleSet;
|
|
RenderResourceHandleSet::type m_renderHandles;
|
|
|
|
void _OnDeviceLost();
|
|
void _OnDeviceReset();
|
|
private:
|
|
RenderResourceHandleSet::type& GetRenderResourceHandles();
|
|
|
|
WindHandle m_mainHWND;
|
|
#ifdef __WIN32__
|
|
|
|
public:
|
|
void SetMainWindowHandle(WindHandle hwnd);
|
|
WindHandle GetMainWindowHandle(void)const;
|
|
#endif
|
|
};
|
|
|
|
inline void RenderSystem::ChangeSize(int width, int height)
|
|
{
|
|
m_renderDevice->SetSize(width, height);
|
|
}
|
|
|
|
inline const GraphicCardCapability& RenderSystem::GetGraphicCardCapability()
|
|
{
|
|
n_assert(m_renderDevice);
|
|
return m_renderDevice->GetGraphicCardCapability();
|
|
}
|
|
|
|
#ifdef __WIN32__
|
|
inline void RenderSystem::SetMainWindowHandle(WindHandle hwnd)
|
|
{
|
|
m_mainHWND = hwnd;
|
|
}
|
|
inline WindHandle RenderSystem::GetMainWindowHandle(void)const
|
|
{
|
|
return m_mainHWND;
|
|
}
|
|
#endif
|
|
|
|
extern RenderSystem* rendersystem;
|
|
inline RenderSystem& GetRenderSystem()
|
|
{
|
|
n_assert( rendersystem );
|
|
return *rendersystem;
|
|
}
|
|
|
|
inline RenderSystem::RenderResourceHandleSet::type& RenderSystem::GetRenderResourceHandles()
|
|
{
|
|
return m_renderHandles;
|
|
}
|
|
|
|
inline void RenderSystem::SetWireFrameMode(bool wireframe /* = false */)
|
|
{
|
|
m_renderDevice->SetDrawWireFrame(wireframe);
|
|
}
|
|
|
|
inline float RenderSystem::GetHorizontalTexelOffset()
|
|
{
|
|
return m_renderDevice->GetHorizontalTexelOffset();
|
|
}
|
|
inline float RenderSystem::GetVerticalTexelOffset()
|
|
{
|
|
return m_renderDevice->GetVerticalTexelOffset();
|
|
}
|
|
inline float RenderSystem::GetMinimumDepthInputValue()
|
|
{
|
|
return m_renderDevice->GetMinimumDepthInputValue();
|
|
}
|
|
inline float RenderSystem::GetMaximumDepthInputValue()
|
|
{
|
|
return m_renderDevice->GetMinimumDepthInputValue();
|
|
}
|
|
}
|
|
|
|
#endif //RENDERSYSTEM_H_
|