//---------------------------------------------------------------------------- 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,"POINT:00000000"); ChFont->Print(820,180,"LIFE:00000000"); ChFont->Print(1100,900,"FPS:%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; }