void PassForward_Indicators::draw() { //return; if(!atmGetGame()) { return; } i3d::DeviceContext *dc = atmGetGLDeviceContext(); VertexArray *va_grid = atmGetVertexArray(VA_FIELD_GRID); AtomicShader *sh_grid = atmGetShader(SH_FILL3D); RenderTarget *rt = atmGetBackRenderTarget(); rt->setDepthStencilBuffer(atmGetRenderTarget(RT_GBUFFER)->getDepthStencilBuffer()); dc->setBlendState(atmGetBlendState(BS_BLEND_ALPHA)); dc->setDepthStencilState(atmGetDepthStencilState(DS_DEPTH_ENABLED)); dc->setRenderTarget(rt); sh_grid->bind(); dc->setVertexArray(va_grid); dc->draw(I3D_LINES, 0, 6*6*2); dc->setVertexArray(nullptr); sh_grid->unbind(); dc->setDepthStencilState(atmGetDepthStencilState(DS_NO_DEPTH_NO_STENCIL)); dc->setBlendState(atmGetBlendState(BS_NO_BLEND)); rt->setDepthStencilBuffer(nullptr); }
void CCPlus::go(const std::string& path, int fps) { RenderTarget target; target.inputPath = path; target.fps = fps; go(target); target.waitFinish(); }
void MainWindow::newRenderTarget(SceneController* scene, char* name) { char buf[256]; bool ret; RenderTarget* renderTarget = new RenderTarget(); renderTarget->setScene(scene); scene->setSceneRect(0, 0, ui->tabWidget->size().width(), ui->tabWidget->size().height()); scene->setBackgroundBrush(QBrush(QColor(0, 0, 0))); renderTarget->setFixedSize(ui->tabWidget->size().width(), ui->tabWidget->size().height()); renderTarget->setAlignment(Qt::AlignTop); renderTarget->setViewportUpdateMode(QGraphicsView::FullViewportUpdate); if (m_connectedSender) { ret = disconnect(m_connectedSender, SIGNAL(statusChanged()), this, SLOT(statusChanged())); assert(ret == true); } ret = connect(scene, SIGNAL(statusChanged()), this, SLOT(statusChanged()), Qt::UniqueConnection); assert(ret == true); m_connectedSender = scene; int idx = ui->tabWidget->addTab(renderTarget, name); ui->tabWidget->setCurrentIndex(idx); sprintf(buf, "New surface pool: %s", name); ui->label->setText(buf); }
void ObjectInterface::drawObjects(RenderTarget &target) { if (cb->mapInterface->getTileMap() == 0 && firstFloorObject == 0 && firstObject == 0) { // No objects to be drawn return; } target.setAsCurrent(); //al_hold_bitmap_drawing(true); //Little speed up // All objects are drawn at world coordinates. target.useWorldCoords(true); // Draw floor objects, including map back layer CBObject *currentObject = firstFloorObject; while (currentObject != 0) { currentObject->render(target); currentObject = currentObject->afterObj; } // Draw normal objects currentObject = firstObject; while (currentObject != 0) { currentObject->render(target); currentObject = currentObject->afterObj; } // Draw map over layer if (cb->mapInterface->getTileMap()) { cb->mapInterface->getTileMap()->drawLayer(1, target); } //al_hold_bitmap_drawing(false); // Reset drawing to screen target.useWorldCoords(false); }
void Graphics::Initialize() { WickedSick::Window* window = core_->GetSystem<WickedSick::Window>(ST_Window); std::lock_guard<std::mutex> lk(window->GetWindowHandleMutex()); graphicsAPI->Initialize(options_, window); // Setup the projection matrix. float fieldOfView = (float)PI / 2.0f;//90 degrees float screenAspect = (float)window->GetWindowSize().x / (float)window->GetWindowSize().y; // Create the projection matrix for 3D rendering. projection_matrix_.DoPerspective(90.0 * PI/180.0, 0.1f, 100000.0f, screenAspect); orthographic_matrix_.DoOrthographic(window->GetWindowSize().x, window->GetWindowSize().y, 0.1f, 100000.0f); camera_->SetPosition(0.0f, 0.0f, 0.0f); mat_stack_->Push(projection_matrix_); RenderTargetDesc desc; desc.size = window->GetWindowSize(); RenderTarget* reflectionTarget = nullptr; for(int i = 0; i < ReflectionDirections::Count; ++i) { reflectionTarget = graphicsAPI->MakeRenderTarget(desc); reflectionTarget->Initialize(); render_targets_.push_back(reflectionTarget); } }
DeferredShadingSystem::~DeferredShadingSystem() { // Delete mini lights for(std::set<MLight*>::iterator i=mLights.begin(); i!=mLights.end(); ++i) { delete (*i); } // Delete the ambient light delete mAmbientLight; if (mCurrentMode==DSM_SHOWLIT && mInstance[mCurrentMode]->getEnabled()) { RenderTarget* renderTarget = mInstance[mCurrentMode]->getRenderTarget("mrt_output"); assert(renderTarget); LogManager::getSingleton().logMessage("Removing Listener from:"); LogManager::getSingleton().logMessage(renderTarget->getName()); renderTarget->removeListener(this); } CompositorChain *chain = CompositorManager::getSingleton().getCompositorChain(mViewport); for(int i=0; i<DSM_COUNT; ++i) chain->_removeInstance(mInstance[i]); delete mLightMaterialGenerator; }
void CarReflection::Update() { // update only if we created if ( pSet->refl_mode == "single" && iIndex != 0 ) return; // static: only 1st frame if ( pSet->refl_mode == "static" && bFirstFrame == false ) return; // skip frames if (++iCounter >= pSet->refl_skip || bFirstFrame) { iCounter = 0; // cube faces at once int fc = bFirstFrame ? 6 : pSet->refl_faces; for (int i=0; i < fc; ++i) { ++iCam; if (iCam > 5) iCam = 0; // next Camera* cam = pCams[iCam]; RenderTarget* rt = pRTs[iCam]; if (cam) cam->setPosition ( camPosition ); //else LogO("upd cam 0"); if (rt) rt->update(); //else LogO("upd rt 0"); } } //Image im; //cubetex->convertToImage(im); //im.save("cube.dds"); bFirstFrame = false; }
// All threads start execution here. int main() { void *frameBuffer; if (get_current_thread_id() != 0) worker_thread(); // Set up render context frameBuffer = init_vga(VGA_MODE_640x480); start_all_threads(); RenderContext *context = new RenderContext(); RenderTarget *renderTarget = new RenderTarget(); Surface *colorBuffer = new Surface(kFbWidth, kFbHeight, Surface::RGBA8888, frameBuffer); renderTarget->setColorBuffer(colorBuffer); context->bindTarget(renderTarget); context->bindShader(new ColorShader()); const RenderBuffer kVertices(kSquareVertices, 4, 3 * sizeof(float)); const RenderBuffer kIndices(kSquareIndices, 6, sizeof(int)); context->bindVertexAttrs(&kVertices); context->drawElements(&kIndices); context->finish(); return 0; }
void WaterRTT::create() { if (!mSceneMgr) return; mCamera = mSceneMgr->createCamera("PlaneReflectionRefraction"); if (mViewerCamera) { mCamera->setFarClipDistance(mViewerCamera->getFarClipDistance()); mCamera->setNearClipDistance(mViewerCamera->getNearClipDistance()); mCamera->setAspectRatio(mViewerCamera->getAspectRatio()); } for (unsigned int i = 0; i < 2; ++i) { if (i==0 && !mReflect) continue; if (i==1 && !mRefract) continue; TexturePtr tex = TextureManager::getSingleton().createManual(i == 0 ? "PlaneReflection" : "PlaneRefraction", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, mRTTSize, mRTTSize, 0, PF_R8G8B8, TU_RENDERTARGET); RenderTarget* rtt = tex->getBuffer()->getRenderTarget(); Viewport* vp = rtt->addViewport(mCamera); vp->setOverlaysEnabled(false); vp->setBackgroundColour(ColourValue(0.8f, 0.9f, 1.0f)); vp->setShadowsEnabled(false); vp->setMaterialScheme ("reflection"); vp->setVisibilityMask( i == 0 ? RV_WaterReflect : RV_WaterRefract); rtt->addListener(this); if (i == 0) mReflectionTarget = rtt; else mRefractionTarget = rtt; } sh::Factory::getInstance ().setTextureAlias ("WaterReflection", "PlaneReflection"); sh::Factory::getInstance ().setTextureAlias ("WaterRefraction", "PlaneRefraction"); }
void CompositorRenderPass::Commit(CommitContext& context) { if (context.rsys->GetTicket() != this->renderSystemTicket) { if (numTextureToResolve == 1) { TextureUnit tu; RenderTarget* target = context.GetTargetByName(_rtJustOne.name); if (target && target->GetRenderTargetType() == RenderTargetType::TEXTURE) { tu.texture = static_cast<RenderTexture*>(target); parameters.SetData(&tu, _rtJustOne.offset); } } else { for (uint32 i = 0; i < numTextureToResolve; ++i) { TextureUnit tu; RenderTarget* target = context.GetTargetByName(_rtBunchOf[i].name); if (target && target->GetRenderTargetType() == RenderTargetType::TEXTURE) { tu.texture = static_cast<RenderTexture*>(target); parameters.SetData(&tu, _rtBunchOf[i].offset); } } } this->renderSystemTicket = context.rsys->GetTicket(); } BeginRender(context); RenderPrimitive(context, (uint32)(ptrdiff_t)this, &primitive); EndRender(context); }
// All threads start execution here. int main() { if (__builtin_nyuzi_read_control_reg(0) != 0) workerThread(); // Start worker threads __builtin_nyuzi_write_control_reg(30, 0xffffffff); RenderContext *context = new RenderContext(); RenderTarget *renderTarget = new RenderTarget(); Surface *colorBuffer = new Surface(kFbWidth, kFbHeight, (void*) 0x200000); Surface *depthBuffer = new Surface(kFbWidth, kFbHeight); renderTarget->setColorBuffer(colorBuffer); renderTarget->setDepthBuffer(depthBuffer); context->bindTarget(renderTarget); context->enableDepthBuffer(true); context->bindShader(new ColorShader()); const RenderBuffer kVertices(kTriangleVertices, 6, 7 * sizeof(float)); const RenderBuffer kIndices(kTriangleIndices, 6, sizeof(int)); context->bindGeometry(&kVertices, &kIndices); context->submitDrawCommand(); context->finish(); exit(1); // Stop worker threads return 0; }
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 Renderer::_renderCamera(Camera* cam) { RenderTarget* rt = cam->GetRenderTarget(); if (!rt) return; cameraRendering = cam; rt->Bind(); _setZWrite(true); _setZTest(true); glClearColor(0, 0, 0, 1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); std::vector<Renderable*> sorted(renderables.begin(), renderables.end()); std::sort(sorted.begin(), sorted.end(), renderableCompare()); std::vector<Renderable*>::iterator rIt; for (rIt = sorted.begin(); rIt != sorted.end(); rIt++) { (*rIt)->Update(); //_render(cam, (*rIt)); (*rIt)->Render(cam); } //Go through post-processes _renderPostProcess(rt->GetPostProcess()); }
void SimpleSurface::applyFilter (Surface *inSrc, const Rect &inRect, ImagePoint inOffset, Filter *inFilter) { if (!mBase) return; FilterList f; f.push_back (inFilter); Rect src_rect (inRect.w, inRect.h); Rect dest = GetFilteredObjectRect (f, src_rect); inSrc->IncRef (); Surface *result = FilterBitmap (f, inSrc, src_rect, dest, false, ImagePoint (inRect.x, inRect.y)); dest.Translate (inOffset.x, inOffset.y); src_rect = Rect (0, 0, result->Width (), result->Height ()); int dx = dest.x; int dy = dest.y; dest = dest.Intersect (Rect (0, 0, mWidth, mHeight)); dest.Translate (-dx, -dy); dest = dest.Intersect (src_rect); dest.Translate (dx, dy); int bpp = BytesPP (); RenderTarget t = BeginRender (dest, false); //printf("Copy back @ %d,%d %dx%d + (%d,%d)\n", dest.x, dest.y, t.Width(), t.Height(), dx, dy); for (int y = 0; y < t.Height (); y++) memcpy ((void *)(t.Row (y + dest.y) + ((dest.x) * bpp)), result->Row (y - dy) - (dx * bpp), dest.w * bpp); EndRender (); result->DecRef (); }
void render(float delta){ float ClearColor[4] = { 0.5f, 0.5f, 0.5f, 1.0f }; // red,green,blue,alpha float ClearColor2[4] = { 0.1f, 0.2f, 0.3f, 1.0f }; // red,green,blue,alpha clearTargetColor(m_pRenderTargetView,ClearColor); clearTargetColor(*backTarget->getTarget(),ClearColor2); clearTargetDepth(m_depthStencilView,1); static float t=0; t+=delta; m_World = XMMatrixRotationY(t); ConstantBuffer cb; cb.mWorld = XMMatrixTranspose( m_World ); cb.mView = XMMatrixTranspose( m_View ); cb.mProjection = XMMatrixTranspose( m_Projection); people->updateConstantbuffer(m_pImmediateContext,0,&cb); m_pImmediateContext->OMSetRenderTargets(1,backTarget->getTarget(),m_depthStencilView); people->draw(m_pImmediateContext); clearTargetDepth(m_depthStencilView,1); m_pImmediateContext->OMSetRenderTargets(1,&m_pRenderTargetView,m_depthStencilView); people->draw(m_pImmediateContext); view_shader->use(m_pImmediateContext); m_pImmediateContext->PSSetShaderResources(0,1,backTarget->getShaderResource()); view_shader->setConstantBuffer(m_pImmediateContext,0,&quard->s_Matrix); //quard->draw(m_pImmediateContext); controller->visite(m_pImmediateContext); //MyLuaManager::getInstance()->doFile("lua/lua_script/render.lua"); presentDraw(); }
//--------------------------------------------------------------------------------------------- void RenderSystem::attachRenderTarget( RenderTarget &target ) { assert( target.getPriority() < OGRE_NUM_RENDERTARGET_GROUPS ); mRenderTargets.insert( RenderTargetMap::value_type( target.getName(), &target ) ); mPrioritisedRenderTargets.insert( RenderTargetPriorityMap::value_type(target.getPriority(), &target )); }
void CarReflection::Create() { //bFirstFrame = true; if (pSet->refl_mode == 1) cubetexName = "ReflectionCube"; // single: use 1st cubemap else if (pSet->refl_mode == 2) { cubetexName = "ReflectionCube" + toStr(iIndex); // first cubemap: no index if (cubetexName == "ReflectionCube0") cubetexName = "ReflectionCube"; } else /* static */ cubetexName = "ReflectionCube"; TextureManager* tm = TextureManager::getSingletonPtr(); int size = ciShadowSizesA[pSet->refl_size]; // /2 ? // create cube render texture if ( !(pSet->refl_mode == 1 && iIndex != 0) ) { cubetex = tm->createManual(cubetexName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_CUBE_MAP, size,size, 0/*mips*/, PF_R8G8B8, TU_RENDERTARGET); //LogO("created rt cube"); for (int face = 0; face < 6; face++) { Camera* mCam = pSceneMgr->createCamera("Reflect_" + toStr(iIndex) + "_" + toStr(face)); mCam->setAspectRatio(1.0f); mCam->setFOVy(Degree(90)); mCam->setNearClipDistance(0.1); mCam->setFarClipDistance(pSet->refl_dist * 1.1f); RenderTarget* mRT = cubetex->getBuffer(face)->getRenderTarget(); //LogO( "rt face Name: " + mRT->getName() ); mRT->removeAllViewports(); Viewport* vp = mRT->addViewport(mCam); vp->setOverlaysEnabled(false); vp->setVisibilityMask(RV_MaskReflect); vp->setShadowsEnabled(false); vp->setMaterialScheme ("reflection"); mRT->setAutoUpdated(false); //mRT->addListener(this); //- mCam->setPosition(Vector3::ZERO); Vector3 lookAt(0,0,0), up(0,0,0), right(0,0,0); switch(face) { case 0: lookAt.x =-1; up.y = 1; right.z = 1; break; // +X case 1: lookAt.x = 1; up.y = 1; right.z =-1; break; // -X case 2: lookAt.y =-1; up.z = 1; right.x = 1; break; // +Y case 3: lookAt.y = 1; up.z =-1; right.x = 1; break; // -Y case 4: lookAt.z = 1; up.y = 1; right.x =-1; break; // +Z case 5: lookAt.z =-1; up.y = 1; right.x =-1; break; // -Z } Quaternion orient( right, up, lookAt ); mCam->setOrientation( orient ); pCams[face] = mCam; pRTs[face] = mRT; } } }
// 视口更新 void AxisGridPlugin::postViewportUpdate(const RenderTargetViewportEvent& evt) { RenderTarget *target = evt.source->getTarget(); char text[255]; const RenderTarget::FrameStats& stats = target->getStatistics(); sprintf(text , "FPS:%.2f TRI:%d BATCH:%d" , stats.avgFPS , stats.triangleCount , stats.batchCount); m_statElement->setCaption(text); }
void HUD::draw(RenderTarget& target, RenderStates states) const // Draws all UI { target.draw(m_RPMSprite); target.draw(m_needle); target.draw(m_GearText); target.draw(m_TimerText); target.draw(m_BestTimeText); }
bool OpenGLRenderer::renderModel3DWireframe(Model3D &model3D, const glm::vec4 &color, Camera &camera, RenderTarget &renderTarget) { __(glDepthRangef(camera.getNear(), camera.getFar())); /* Enable wireframe mode */ __(glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)); __(glEnable(GL_LINE_SMOOTH)); __(glDisable(GL_CULL_FACE)); /* Calculate MVP matrix */ glm::mat4 MVP = camera.getPerspectiveMatrix() * camera.getViewMatrix() * model3D.getModelMatrix(); /* Cast the model into an internal type */ OpenGLAsset3D *glObject = static_cast<OpenGLAsset3D *>(model3D.getAsset3D()); /* Set the color for the wireframe shader */ _wireframeShader->setColor(color); /* Bind the render target */ renderTarget.bind(); { __(glEnable(GL_MULTISAMPLE)); __(glEnable(GL_DEPTH_TEST)); __(glDepthFunc(GL_LEQUAL)); __(glBlendEquation(GL_FUNC_ADD)); __(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); __(glEnable(GL_BLEND)); /* Bind program to upload the uniform */ _wireframeShader->attach(); /* Send our transformation to the currently bound shader, in the "MVP" uniform */ _wireframeShader->setUniformMat4("u_MVPMatrix", &MVP); /* Set the shader custom parameters */ _wireframeShader->setCustomParams(); /* Draw the model */ __(glBindVertexArray(glObject->getVertexArrayID())); { std::vector<uint32_t> offset = glObject->getIndicesOffsets(); std::vector<uint32_t> count = glObject->getIndicesCount(); for (size_t i = 0; i < offset.size(); ++i) { __(glDrawElements(GL_TRIANGLES, count[i], GL_UNSIGNED_INT, (void *)(offset[i] * sizeof(GLuint)))); } } __(glBindVertexArray(0)); /* Unbind */ _wireframeShader->detach(); } renderTarget.unbind(); return true; }
bool OpenGLRenderer::renderBoundingSphere(const BoundingSphere &sphere, const glm::vec3 ¢er, const glm::vec3 &color, Camera &camera, RenderTarget &renderTarget) { /* Calculate MVP matrix, bounding box coordinates are already in world coordinates */ glm::mat4 MVP = camera.getPerspectiveMatrix() * camera.getViewMatrix(); /* Bind the render target */ renderTarget.bind(); { GLuint boxPosVAO, boxPosVBO; __(glEnable(GL_DEPTH_TEST)); //__(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)); //__(glEnable(GL_CULL_FACE)); /* Bind program to upload the uniform */ _renderBoundingSphere.attach(); /* Send our transformation to the currently bound _renderBoundingSpheres, in the "MVP" uniform */ _renderBoundingSphere.setUniformMat4("u_MVPMatrix", &MVP); _renderBoundingSphere.setUniformMat4("u_projectionMatrix", &camera.getPerspectiveMatrix()); _renderBoundingSphere.setUniformVec3("u_boxColor", const_cast<glm::vec3 &>(color)); _renderBoundingSphere.setUniformFloat("u_radius", sphere.getRadius()); __(glGenVertexArrays(1, &boxPosVAO)); __(glBindVertexArray(boxPosVAO)); __(glGenBuffers(1, &boxPosVBO)); __(glBindBuffer(GL_ARRAY_BUFFER, boxPosVBO)); __(glBufferData(GL_ARRAY_BUFFER, sizeof center, ¢er[0], GL_STATIC_DRAW)); __(glEnableVertexAttribArray(0)); __(glVertexAttribPointer(0, // attribute. No particular reason for 0, but must match the layout in the _renderBoundingSpheres. 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void *)0 // array buffer offset )); __(glDrawArrays(GL_POINTS, 0, 1)); __(glBindVertexArray(0)); __(glDeleteBuffers(1, &boxPosVBO)); __(glDeleteVertexArrays(1, &boxPosVAO)); /* Unbind */ _renderBoundingSphere.detach(); } renderTarget.unbind(); return true; }
void CarReflection::Update(bool first) { if (!first) { // update only if we created if (pSet->refl_mode == 1 && iIndex != 0) return; // static: only 1st frame if (pSet->refl_mode == 0) return; } // skip frames if (++iCounter >= pSet->refl_skip || first) { iCounter = 0; // all cube faces at once int fc = first ? 6 : pSet->refl_faces; for (int i=0; i < fc; ++i) { ++iCam; if (iCam > 5) iCam = 0; // next Camera* cam = pCams[iCam]; RenderTarget* rt = pRTs[iCam]; Vector3 origScale, origPos; if (cam) { cam->setPosition( camPosition ); // Set skydome position to camera if (pApp->ndSky) { origScale = pApp->ndSky->getScale(); origPos = pApp->ndSky->getPosition(); pApp->ndSky->setScale(pSet->refl_dist * Vector3::UNIT_SCALE); pApp->ndSky->setPosition(camPosition); } } //else LogO("upd cam 0"); if (rt) rt->update(); //else LogO("upd rt 0"); // restore previous skydome position if (pApp->ndSky) { pApp->ndSky->setScale(origScale); pApp->ndSky->setPosition(origPos); } } } //Image im; //cubetex->convertToImage(im); //im.save("cube.dds"); }
int GL_initializeFrameBuffers() { debug_rendertarget.Create(client_rect.w, client_rect.h, false); rt_temp0.Create(client_rect.w, client_rect.h, false); rt_temp1.Create(client_rect.w, client_rect.h, false); rt_scene.Create(scene_rect.w,scene_rect.h, false); rt_back.fbo = 0; return 1; }
void Cero::draw(RenderTarget& target, RenderStates states) const { states.transform *= getTransform(); for(int i = 0; i < spirals; i++) { target.draw(particles[i], (activeSegemnts - 1) * 6, PrimitiveType::Triangles, states); } target.draw(centerCircle, centerSides + 2, PrimitiveType::TrianglesFan, states); }
//----------------------------------------------------------------------- void RenderSystem::_notifyCameraRemoved(const Camera* cam) { RenderTargetMap::iterator i, iend; iend = mRenderTargets.end(); for (i = mRenderTargets.begin(); i != iend; ++i) { RenderTarget* target = i->second; target->_notifyCameraRemoved(cam); } }
void GameWorld::draw(RenderTarget& target, RenderStates states) const { //draw the tiles for (auto chunk : Chunks) { target.draw(*chunk); } target.draw(*DebugDraw::GetInstance()); DebugDraw::GetInstance()->clearArray(); }
void P_cleanup() { debug_rendertarget.Delete(); rt_temp0.Delete(); rt_temp1.Delete(); rt_scene.Delete(); glDeleteTextures(1, &texture_sprite); glDeleteTextures(1, &texture_tile); glDeleteTextures(1, &texture_bg); }
void PostProcessWater::Process(RenderTarget &destinationTarget, LPDIRECT3DBASETEXTURE9 sourceTexture) { // Implement your own solution for the Post-process lab //return ProcessSolution(destinationTarget, sourceTexture); elapsedTime += timer.GetElapsedTime(); destinationTarget.ActivateTarget(0); IDirect3DDevice9 *pDevice = Renderer::theDevicePtr; Renderer::theDevicePtr->Clear(0,0, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1, 0); // Set the vertex and index source and declarion pDevice->SetVertexDeclaration(VertexBufferManager::GetReference().GetPositionTexBuffer().GetVertexDeclaration()); pDevice->SetStreamSource(0, VertexBufferManager::GetReference().GetPositionTexBuffer().GetVertexBuffer(), 0, sizeof(VERTEX_POSTEX)); pDevice->SetIndices(IndexBuffer::GetReference().GetIndices()); effectPtr->SetTexture(textureHandle, sourceTexture); effectPtr->SetFloat(elapsedTimeHandle, elapsedTime); // RTT_Ambient, RTT_Diffuse, RTT_Specular, RTT_Emmisive, RTT_Normal effectPtr->SetTexture(reflectionMapTextureHandle, renderMaterialHandle.GetContent()->GetRTCubeMapHandle().GetContent()->GetHandle()); effectPtr->SetTexture(heightMapTextueHandle, renderMaterialHandle.GetContent()->GetRTHandles()[RTT_Diffuse].GetContent()->GetHandle()); effectPtr->SetTexture(noiseTextureHandle, renderMaterialHandle.GetContent()->GetRTHandles()[RTT_Normal].GetContent()->GetHandle()); effectPtr->SetTexture(foamTextureHandle, renderMaterialHandle.GetContent()->GetRTHandles()[RTT_Ambient].GetContent()->GetHandle()); effectPtr->SetTexture(causticTextureHandle, renderMaterialHandle.GetContent()->GetRTHandles()[RTT_Specular].GetContent()->GetHandle()); effectPtr->SetValue(surfaceColorHandle, &renderMaterialHandle.GetContent()->GetRenderColors()[RTT_Diffuse], sizeof(RenderColor)); effectPtr->SetValue(ambientColorHandle, &renderMaterialHandle.GetContent()->GetRenderColors()[RTT_Ambient], sizeof(RenderColor)); pDevice->SetVertexDeclaration(VertexBufferManager::GetReference().GetPositionTexBuffer().GetVertexDeclaration()); pDevice->SetStreamSource(0, VertexBufferManager::GetReference().GetPositionTexBuffer().GetVertexBuffer(), 0, sizeof(VERTEX_POSTEX)); pDevice->SetIndices(IndexBuffer::GetReference().GetIndices()); // Begin the post-process effect UINT passes = 0; effectPtr->Begin(&passes, 0); // Iterate through the post-process passes for(UINT pass = 0; pass < passes; ++pass) { effectPtr->BeginPass(pass); Renderer::theDevicePtr->DrawIndexedPrimitive(meshPtr->GetPrimitiveType(), meshPtr->GetStartVertex(), 0, meshPtr->GetVertCount(), meshPtr->GetStartIndex(), meshPtr->GetPrimitiveCount()); effectPtr->EndPass(); } effectPtr->End(); destinationTarget.RevertTarget(); timer.Reset(); }
RenderTarget InventoryScreenState::GetRenderTarget() const { assert(mPlayer.IsValid()); static const int kWindowWidth = ScreenConstants::EViewPortWidth; static const int kWindowHeight = ScreenConstants::EViewPortHeight; static const int kWindowMargin = 2; static const int kCellLeftOffset = 2; static const int kCellWidth = (ScreenConstants::EViewPortWidth - (2 * (kWindowMargin + kCellLeftOffset)) - 2) / 2; static const int kCellHeight = 2; static const int kVerticalSpacingBetweenCells = 1; static const Fragment kCursor((char) 26, ETextWhite); auto armedItem0 = mGameData->mPlayerData.GetItemInSlot( Player::EItemSlot_Slot0 ); auto armedItem1 = mGameData->mPlayerData.GetItemInSlot( Player::EItemSlot_Slot1 ); auto& items = mGameData->mPlayerData.mInventory.GetAllItems(); auto renderItemCell = [&] (ItemBase* inItem) { RenderTarget target(kCellWidth, kCellHeight); std::string itemName = inItem->GetName(); itemName += (inItem == armedItem0) ? " (Spc)" : ""; itemName += (inItem == armedItem1) ? " (E)" : ""; target.Write(itemName, ETextWhite, 0, 0); target.Write(inItem->GetHUDIcon(), 0, 1); return target; }; RenderTarget window = BorderedFrame(kWindowWidth, kWindowHeight).Render(); window.Write( " Inventory ", 3, 0 ); for (size_t i = 0; i < items.size(); ++i) { RenderTarget renderedCell = renderItemCell( items[i] ); int col = ((i % 2) == 0) ? (kWindowMargin + kCellLeftOffset) : (kWindowWidth - kWindowMargin - kCellWidth); int row = kWindowMargin + ((i / 2) * (kCellHeight + kVerticalSpacingBetweenCells)); window.Write(renderedCell, col, row); if ((int) i == mHighlightedItem) { window.Write(kCursor, col - kCellLeftOffset, row); } } return window; }
void UIPanel::Render( RenderTarget& target ) const { if (!visibled_) return; if (!enabled_ && hasDisabledAnim_) target.Draw(anims_[DISABLED_ANIM_]); else if (hasNormalAnim_) target.Draw(anims_[NORMAL_ANIM_]); __super::Render(target); }