//----------------------------------------------------------------------------
void ShadowMaps::CreateScreenSpaceObjects ()
{
// Create a screen-space camera to use with the render target.
mScreenCamera = ScreenTarget::CreateCamera();
// Create a screen polygon to use with the render target.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mScreenTargetSize = 512;
mScreenPolygon = ScreenTarget::CreateRectangle(vformat, mScreenTargetSize,
mScreenTargetSize, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
// Create a render target for the shadow effect.
mShadowTarget = new0 RenderTarget(1, Texture::TF_A32B32G32R32F,
mScreenTargetSize, mScreenTargetSize, false, true);
// Create a render target for the unlit scene.
mUnlitTarget = new0 RenderTarget(1, Texture::TF_A32B32G32R32F, GetWidth(),
GetHeight(), false, true);
// Create a render target for the horizontally blurred scene.
mHBlurTarget = new0 RenderTarget(1, Texture::TF_A8R8G8B8, GetWidth(),
GetHeight(), false, false);
// Create a render target for the vertically blurred scene.
mVBlurTarget = new0 RenderTarget(1, Texture::TF_A8R8G8B8, GetWidth(),
GetHeight(), false, false);
mRenderer->Bind(mShadowTarget);
mRenderer->Bind(mUnlitTarget);
mRenderer->Bind(mHBlurTarget);
mRenderer->Bind(mVBlurTarget);
}
//-------------------------------------------------------------------------------------------------------
BloomPS::BloomPS()
{
vector2d size = IDriver::Instance().GetViewprot();
m_pDownSimple_1 = NEW RenderTarget(size / 4 , IDriver::FBO_texColor);
m_pDownSimple_2 = NEW RenderTarget(size / 4 , IDriver::FBO_texColor);
}
RenderTarget SimpleSurface::BeginRender (const Rect &inRect, bool inForHitTest) {
if (!mBase)
return RenderTarget ();
Rect r = inRect.Intersect (Rect (0, 0, mWidth, mHeight));
if (mTexture)
mTexture->Dirty (r);
mVersion++;
return RenderTarget (r, mPixelFormat, mBase, mStride);
}
int main(int argc, char** argv)
{
Magick::InitializeMagick(*argv);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowPosition(50, 50);
glutInitWindowSize(1024, 1024);
glutCreateWindow("James Engine");
if (glewInit() != GLEW_OK)
std::cout << "glewInit failed";
//Initialize Cuda prior to setting callbacks
initializeCuda();
glutDisplayFunc(&displayLoop);
glutKeyboardFunc(&keyboardFunction);
glutPassiveMotionFunc(&mouseNotClickedMotion);
glutReshapeFunc(&resizeLoop);
render_manager = RenderTarget(1024, 1024, argc, argv);
render_manager.dispatchVisitor();
const GLubyte* version_str = glGetString(GL_VERSION);
glutMainLoop();
}
void RendererGL::createRenderTarget(uint& idxOfRT, uint& idxOfTex/*shader resource, gl texture*/,uint format,uint w, uint h)
{
// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
GLuint FramebufferName = 0;
glGenFramebuffers(1, &FramebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
GLuint renderTargetTexture;
glGenTextures(1, &renderTargetTexture);
glBindTexture(GL_TEXTURE_2D, renderTargetTexture);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F, w, h, 0,format, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
/*
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);*/
//glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D, renderTargetTexture, 0);
// create a renderbuffer object to store depth info
GLuint rboId;
glGenRenderbuffers(1, &rboId);
glBindRenderbuffer(GL_RENDERBUFFER, rboId);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,w, h);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// attach the renderbuffer to depth attachment point
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboId);
/*
// Create the depth buffer
GLuint mDepth;
glGenTextures(1, &mDepth);
glBindTexture(GL_TEXTURE_2D, mDepth);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, w, h, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, mDepth, 0);
*/
// Always check that our framebuffer is ok
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
myassert(0);
m_texVec.push_back(renderTargetTexture);
idxOfTex = m_texVec.size()-1;
//m_texVec.push_back(mDepth);//depth
m_rtVec.push_back(RenderTarget(w,h, FramebufferName,m_texVec.size()-1));
idxOfRT = m_rtVec.size()-1;
}
bool DXDriver::CreateRenderTarget(const unsigned int _id, const RenderTargetInit& _rti, RenderTarget* _renderTargetPtr)
{
// Id already used
if (m_pRenderTargets[_id] != nullptr)
return false;
RenderTarget* temp = VNEW RenderTarget(std::to_string(_id).c_str());
// Failed to allocate mem
if (!temp)
return false;
// Failed to initialize, delete allocated mem
if (!temp->Init(_rti, m_device))
{
SAFE_DELETE(temp);
return false;
}
// all is good
m_pRenderTargets[_id] = temp;
_renderTargetPtr = temp;
return true;
}
void DeferredContainer::makeTarget() {
if(Window::getInstance()->getSize() == gBuffer.getSize()) return;
vec2ui size = Window::getInstance()->getSize();
GBDepth = Texture2D(size, TextureFormat::DEPTH_COMPONENT32F);
GBDepth.setFilter(GL_NEAREST, GL_NEAREST);
GBColor0 = Texture2D(size, TextureFormat::RGBA16F);
GBColor0.setFilter(GL_NEAREST, GL_NEAREST);
GBColor1 = Texture2D(size, TextureFormat::RGBA16F);
GBColor1.setFilter(GL_NEAREST, GL_NEAREST);
gBuffer = RenderTarget(size.x, size.y);
gBuffer.setTexture(RenderTargetBase::DEPTH, &GBDepth); //Z-BUFFER
gBuffer.setTexture(RenderTargetBase::COLOR0, &GBColor0); //COLOR
gBuffer.setTexture(RenderTargetBase::COLOR1, &GBColor1); //NORMAL, BRIGHTNESS, SPECULAR FACTOR
if(sunTarget.getSize() == vec2ui(0)) { //invalid (this is the first makeTarget() )
SDepth = Texture2DArray(vec3ui(4096,4096, NUM_SUN_CASCADES), TextureFormat::DEPTH_COMPONENT32F);
SDepth.setFilter(GL_LINEAR, GL_LINEAR);
SDepth.setComparison(GL_GREATER);
sunTarget = RenderTargetLayered(4096, 4096, NUM_SUN_CASCADES);
sunTarget.setTexture(RenderTargetBase::DEPTH, &SDepth); //Z-BUFFER
SDepthTrans = Texture2DArray(vec3ui(4096,4096, NUM_SUN_CASCADES), TextureFormat::DEPTH_COMPONENT32F);
SDepthTrans.setFilter(GL_LINEAR, GL_LINEAR);
SDepthTrans.setComparison(GL_GREATER);
sunTargetTrans = RenderTargetLayered(4096, 4096, NUM_SUN_CASCADES);
sunTargetTrans.setTexture(RenderTargetBase::DEPTH, &SDepthTrans); //Z-BUFFER
}
}
RenderTarget BeginRender(const Rect &inRect,bool inForHitTest)
{
mLockedForHitTest = inForHitTest;
if (SDL_MUSTLOCK(mSurf) && !mLockedForHitTest)
SDL_LockSurface(mSurf);
return RenderTarget(Rect(Width(),Height()), Format(),
(uint8 *)mSurf->pixels, mSurf->pitch);
}
void TypedRenderTargetCapability::setRenderTarget(
RenderTargetType type,
globjects::ref_ptr<globjects::Framebuffer> framebuffer,
gl::GLenum attachment,
gl::GLenum format)
{
m_renderTargets[type] = RenderTarget(framebuffer, attachment, format);
setChanged(true);
}
bool StateManager::Create ( )
{
assert( s_instance == nullptr );
s_instance = new StateManager;
s_instance->m_renderTargets.push_back( RenderTarget( 0, 0, 0, Window::Instance()->GetSize() ) );
s_instance->m_currentRenderTargetIndices.push( 0 );
return true;
}
//-------------------------------------------------------------------------------------------------------
SSAOPostEffect::SSAOPostEffect(void)
:IPostEffect( 300 )
{
Engine::Instance().GetPipeline()->NeedNoramlBuffer();
m_JitterTex = NEW Texture2D();
m_JitterTex->LoadTexture( Device::PF_R8G8B8, FILEPATH.TextureFolder() + "Jitter.tga");
m_JitterTex->SetWarp( Device::TW_REPEAT, Device::TW_REPEAT );
vector2d size = Engine::Instance().GetDevice()->GetResolutionSize();
m_pDownSimple_1 = NEW RenderTarget(size / 4, Device::FBO_TCOLOR);
m_pDownSimple_2 = NEW RenderTarget(size / 4, Device::FBO_TCOLOR);
{//初始化数值
GaussSpread = 2;
GaussRho = 1.1;
AOIntensity = 2.5f;
AOEdgeFinder = 0.01f;
JitterAmount = 0.05f;
GaussWeight.resize(4);
_MakeupGuassParam();
}
//engine::Instance().GetActionManage()->OnKeyDownEvent( MEMBER_FUNC_PTR( &SSAOPostEffect::OnKeyDown ) );
}
// Generates a render target that represents the screen.
RenderTarget RenderTarget::ScreenRenderTarget(Renderer& renderer) {
RenderTarget screen_render_target = RenderTarget();
screen_render_target.framebuffer_id_ = 0;
screen_render_target.rendered_texture_id_ = 0;
screen_render_target.depth_buffer_id_ = 0;
mathfu::vec2i window_size = renderer.window_size();
#ifdef FPL_BASE_RENDERER_BACKEND_SDL
#ifdef __ANDROID__
vec2i size = fplbase::AndroidGetScalerResolution();
if (size.x() && size.y()) {
window_size = size;
}
#endif
#endif
screen_render_target.dimensions_ = window_size;
screen_render_target.initialized_ = true;
return screen_render_target;
}
Arc::GraphicsSystem::GraphicsSystem( Program* pProgram, Size windowSize, string windowTitle, Color clearColor, bool fullscreen )
: SystemComponent(pProgram),
_clearColor(clearColor),
_pRenderTarget(nullptr),
_screenBPP(),
_windowSize(windowSize),
_windowTitle(windowTitle),
_fullscreen(fullscreen)
{
INFO(toString(), "Initializing");
addType(SYS_CMP_TYPE_GRAPHICS);
// Set SDL/OpenGL constants
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
setWindowTitle(_windowTitle);
resetVideoMode(); // Create the window
resetGL(); // Initialize OpenGL
_pRenderTarget = New RenderTarget(this);
if (TTF_Init() < 0) // Initialize the SDL TTF Addon for loading Fonts
{
ERROR(toString(), "Failed to initialize TTF Addon");
die();
}
INFO(toString(), "Complete");
}
void GamePanel::RenderFucn()
{
RenderTarget();
hge->Gfx_BeginScene();
//顯示背景
hge->Gfx_Clear(0);
if (Background.tex!=0)
hge->Gfx_RenderQuad(&Background);
else
ChFont->Print(100,100,"No Background.");
ill->Render(700,400);
//顯示遊戲畫面
PlayGroundTarget->Render(10,20);
//遊戲資訊
ChFont->Print(820,100,"ＰＯＩＮＴ：００００００００");
ChFont->Print(820,180,"ＬＩＦＥ：００００００００");
ChFont->Print(1100,900,"ＦＰＳ:%d",hge->Timer_GetFPS());
//ESC選單
if (stopFlag)
hge->Gfx_RenderQuad(&Mask);
gui->Render();
hge->Gfx_EndScene();
}
PPDefault::PPDefault(Engine* engine, IRenderTarget* backBuffer)
: PostProcess(engine), shaderShadow(0)
{
shaderDefault = engine->content->LoadShader(L"pp_default");
shaderDefault->AddRef();
shadowTarget = TIKI_NEW RenderTarget(engine);
shadowTarget->CreateScreenSize(false, PF_R8G8B8A8);
shadowTarget->Clear(Color::White);
shadowTarget->AddRef();
PostProcessPass* pass;
if (engine->GetShadowsEnabled())
{
shaderShadow = engine->content->LoadShader(L"pp_shadow");
shaderShadow->SetVector2("ScreenSize", engine->graphics->GetViewPort()->GetSize());
shaderShadow->AddRef();
pass = TIKI_NEW PostProcessPass(engine, shaderShadow);
pass->AddOutput(0, shadowTarget);
this->AddPass(pass);
}
pass = TIKI_NEW PostProcessPass(engine, shaderDefault);
pass->AddInput("rtDepth", engine->graphics->GetDepthTarget());
pass->AddInput("rtLight", engine->graphics->GetLightTarget());
pass->AddInput("rtScreen", engine->graphics->GetScreenTarget());
pass->AddInput("rtNormal", engine->graphics->GetNormalTarget());
pass->AddInput("rtInterface", engine->graphics->GetInterfaceTarget());
pass->AddInput("rtShadow", shadowTarget);
pass->AddOutput(0, backBuffer);
this->AddPass(pass);
engine->graphics->ScreenSizeChanged.AddHandler(this);
}
RenderTarget::RenderTarget( int width, int height, int numSamples, bool mipmaps ){
RenderTarget( width, height, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, numSamples, mipmaps );
}
//----------------------------------------------------------------------------
void RenderToTexture::CreateScene ()
{
// Create the root of the scene.
mScene = new0 Node();
mTrnNode = new0 Node();
mScene->AttachChild(mTrnNode);
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
// Create a screen-space camera to use with the render target.
mScreenCamera = ScreenTarget::CreateCamera();
// Create a screen polygon to use with the render target.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
const int rtWidth = 256, rtHeight = 256;
mScreenPolygon = ScreenTarget::CreateRectangle(vformat, rtWidth, rtHeight,
0.0f, 0.2f, 0.0f, 0.2f, 0.0f);
// Create the render target.
//Texture::Format tformat = Texture::TF_A8B8G8R8; // DX9 fails
Texture::Format tformat = Texture::TF_A8R8G8B8;
//Texture::Format tformat = Texture::TF_A16B16G16R16;
//Texture::Format tformat = Texture::TF_A16B16G16R16F;
//Texture::Format tformat = Texture::TF_A32B32G32R32F;
mRenderTarget = new0 RenderTarget(1, tformat, rtWidth, rtHeight, false,
false);
// Attach the render target texture to the screen polygon mesh.
mScreenPolygon->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(
mRenderTarget->GetColorTexture(0), Shader::SF_LINEAR,
Shader::SC_CLAMP_EDGE, Shader::SC_CLAMP_EDGE));
// Load the face model and use multitexturing.
#ifdef WM5_LITTLE_ENDIAN
std::string path = Environment::GetPathR("FacePN.wmof");
#else
std::string path = Environment::GetPathR("FacePN.be.wmof");
#endif
InStream inStream;
inStream.Load(path);
TriMeshPtr mesh = DynamicCast<TriMesh>(inStream.GetObjectAt(0));
// Create texture coordinates for the face. Based on knowledge of the
// mesh, the (x,z) values of the model-space vertices may be mapped to
// (s,t) in [0,1]^2.
VertexBufferAccessor vba0(mesh);
const int numVertices = vba0.GetNumVertices();
float xmin = Mathf::MAX_REAL, xmax = -Mathf::MAX_REAL;
float zmin = Mathf::MAX_REAL, zmax = -Mathf::MAX_REAL;
int i;
for (i = 1; i < numVertices; ++i)
{
Float3 position = vba0.Position<Float3>(i);
float x = position[0];
if (x < xmin)
{
xmin = x;
}
if (x > xmax)
{
xmax = x;
}
float z = position[2];
if (z < zmin)
{
zmin = z;
}
if (z > zmax)
{
zmax = z;
}
}
float invXRange = 1.0f/(xmax - xmin);
float invZRange = 1.0f/(zmax - zmin);
// Strip out the normal vectors, because there is no lighting in this
// sample. Add in two texture coordinate channels for a multiplicative
// texture effect.
vformat = VertexFormat::Create(3,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 1);
int vstride = vformat->GetStride();
VertexBuffer* vbuffer = new0 VertexBuffer(numVertices, vstride);
VertexBufferAccessor vba1(vformat, vbuffer);
for (i = 0; i < numVertices; ++i)
{
Float3 position = vba0.Position<Float3>(i);
Float2 tcoord(
(position[0] - xmin)*invXRange,
(position[2] - zmin)*invZRange);
vba1.Position<Float3>(i) = position;
vba1.TCoord<Float2>(0, i) = tcoord;
vba1.TCoord<Float2>(1, i) = tcoord;
}
mesh->SetVertexFormat(vformat);
mesh->SetVertexBuffer(vbuffer);
path = Environment::GetPathR("Leaf.wmtf");
Texture2D* texture0 = Texture2D::LoadWMTF(path);
path = Environment::GetPathR("Water.wmtf");
Texture2D* texture1 = Texture2D::LoadWMTF(path);
VisualEffectInstance* instance = Texture2AddEffect::CreateUniqueInstance(
texture0, Shader::SF_LINEAR, Shader::SC_CLAMP_EDGE,
Shader::SC_CLAMP_EDGE, texture1, Shader::SF_LINEAR,
Shader::SC_CLAMP_EDGE, Shader::SC_CLAMP_EDGE);
mesh->SetEffectInstance(instance);
mTrnNode->AttachChild(mesh);
}
/**
* Create a new RenderTarget instance
* @param target the framebuffer render target, commonly GL_FRAMEBUFFER
* @param framebuffer the framebuffer ID, 0 if it's not using already generated framebuffer
* @return the pointer to new render target
*/
ptr<RenderTarget> RenderTarget::create( GLenum target, GLuint framebuffer ){
return make_shared<RenderTarget>(RenderTarget(target, framebuffer));
}
void TypedRenderTargetCapability::resetRenderTarget(RenderTargetType type)
{
m_renderTargets[type] = RenderTarget();
setChanged(true);
}
bool DXDriver::Init(Resolution _res)
{
HRESULT result;
RenderTargetInit rti;
#ifdef _PERFTRACK
m_perfLib.Init(); // performance counter lib
#endif
D3D11_VIEWPORT viewport;
// Query DXGI about system
m_videoCardDescription = VNEW char[128];
result = QueryDXGI(_res, m_videoCardMemory, m_videoCardDescription);
if (FAILED(result))
return false;
// Create the swap chain, Direct3D device, and Direct3D device context.
DXGI_SWAP_CHAIN_DESC swapChainDesc = GetSwapChainDesc(_res, true, g_pCoreSystem->GetHwnd());
UINT deviceFlags = 0;
#ifdef _DEBUG
deviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL featureLevelsToTry[] = {
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0
};
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]);
D3D_DRIVER_TYPE driverType;
D3D_FEATURE_LEVEL initiatedFeatureLevel;
for (uint i = 0; i < numDriverTypes; ++i)
{
driverType = driverTypes[i];
result = D3D11CreateDeviceAndSwapChain(NULL, driverType, NULL, deviceFlags, featureLevelsToTry, ARRAYSIZE(featureLevelsToTry),
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, &initiatedFeatureLevel, &m_context);
if (SUCCEEDED(result))
{
D3D_FEATURE_LEVEL_11_1 == initiatedFeatureLevel ? printf("feature level: D3D_11_1\n") : printf("feature level: D3D_11_0\n");
0 == i ? printf("driver type: hardware\n") : printf("driver type: reference\n");
break;
}
}
if (FAILED(result))
{
_com_error err(result);
PrintError(AT, err.ErrorMessage());
return false;
}
// create backbuffer render target
m_pbackBufferRenderTarget = VNEW RenderTarget("BackBuffer");
// Get the pointer to the back buffer texture from the swapchain
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&m_pbackBufferRenderTarget->m_pTexture);
if (FAILED(result))
{
return false;
}
m_pbackBufferRenderTarget->m_pTexture->GetDesc(&rti.TexDesc);
rti.RTVDesc.Format = rti.TexDesc.Format;
rti.RTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rti.RTVDesc.Texture2D.MipSlice = 0;
rti.formats = RTFS_TEXTURE;
if (false == m_pbackBufferRenderTarget->Init(rti, m_device))
{
PrintError(AT, "failed to create backbuffer rendertarget");
return false;
}
// Create the texture for the depth buffer using the filled out description.
D3D11_TEXTURE2D_DESC depthBufferDesc = GetDepthBufferDesc(_res);
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
{
return false;
}
// Create the depth stencil state.
D3D11_DEPTH_STENCIL_DESC depthStencilDesc = GetDepthStencilDesc();
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(result))
{
return false;
}
depthStencilDesc.DepthEnable = false;
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_pDepthStateDisabled);
if (FAILED(result))
{
return false;
}
// Create the depth stencil view.
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc = GetDepthStencilViewDesc();
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
{
return false;
}
// Create the rasterizer state from the description we just filled out.
D3D11_RASTERIZER_DESC rasterDesc = GetRasterizerDesc();
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result))
{
return false;
}
// Set the rasterizer state.
m_context->RSSetState(m_rasterState);
D3D11_BLEND_DESC blendDesc = GetBlendDesc(RENDERTARGET_COUNT);
result = m_device->CreateBlendState(&blendDesc, &m_blendState);
if (FAILED(result))
{
return false;
}
// Setup the viewport for rendering.
viewport.Width = (float)_res.width;
viewport.Height = (float)_res.height;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
float fieldOfView = (float)M_PI / 4.0f;
float screenAspect = (float)_res.width / (float)_res.height;
m_context->RSSetViewports(1, &viewport);
#ifdef FDEBUG
printf("Driver: Ok\n");
#endif
return true;
}
