TextureResourceId TextureResourceManager::createTextureResourceByAssetId(AssetId assetId, Renderer::ITexture& texture) { // Texture resource is not allowed to exist, yet assert(isUninitialized(loadTextureResourceByAssetId(assetId))); // Create the texture resource instance TextureResource& textureResource = mTextureResources.addElement(); textureResource.setResourceManager(this); textureResource.setAssetId(assetId); textureResource.mTexture = &texture; // Done setResourceLoadingState(textureResource, IResource::LoadingState::LOADED); return textureResource.getId(); }
bool WebGLFramebuffer::initializeRenderbuffers(GraphicsContext3D* g3d) { ASSERT(object()); bool initColor = false, initDepth = false, initStencil = false; GC3Dbitfield mask = 0; if (isUninitialized(m_colorAttachment.get())) { initColor = true; mask |= GraphicsContext3D::COLOR_BUFFER_BIT; } if (isUninitialized(m_depthAttachment.get())) { initDepth = true; mask |= GraphicsContext3D::DEPTH_BUFFER_BIT; } if (isUninitialized(m_stencilAttachment.get())) { initStencil = true; mask |= GraphicsContext3D::STENCIL_BUFFER_BIT; } if (isUninitialized(m_depthStencilAttachment.get())) { initDepth = true; initStencil = true; mask |= (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT); } if (!initColor && !initDepth && !initStencil) return true; // We only clear un-initialized renderbuffers when they are ready to be // read, i.e., when the framebuffer is complete. if (g3d->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) return false; GC3Dfloat colorClearValue[] = {0, 0, 0, 0}, depthClearValue = 0; GC3Dint stencilClearValue = 0; GC3Dboolean colorMask[] = {0, 0, 0, 0}, depthMask = 0; GC3Duint stencilMask = 0xffffffff; GC3Dboolean isScissorEnabled = 0; GC3Dboolean isDitherEnabled = 0; if (initColor) { g3d->getFloatv(GraphicsContext3D::COLOR_CLEAR_VALUE, colorClearValue); g3d->getBooleanv(GraphicsContext3D::COLOR_WRITEMASK, colorMask); g3d->clearColor(0, 0, 0, 0); g3d->colorMask(true, true, true, true); } if (initDepth) { g3d->getFloatv(GraphicsContext3D::DEPTH_CLEAR_VALUE, &depthClearValue); g3d->getBooleanv(GraphicsContext3D::DEPTH_WRITEMASK, &depthMask); g3d->clearDepth(0); g3d->depthMask(true); } if (initStencil) { g3d->getIntegerv(GraphicsContext3D::STENCIL_CLEAR_VALUE, &stencilClearValue); g3d->getIntegerv(GraphicsContext3D::STENCIL_WRITEMASK, reinterpret_cast<GC3Dint*>(&stencilMask)); g3d->clearStencil(0); g3d->stencilMask(0xffffffff); } isScissorEnabled = g3d->isEnabled(GraphicsContext3D::SCISSOR_TEST); g3d->disable(GraphicsContext3D::SCISSOR_TEST); isDitherEnabled = g3d->isEnabled(GraphicsContext3D::DITHER); g3d->disable(GraphicsContext3D::DITHER); g3d->clear(mask); if (initColor) { g3d->clearColor(colorClearValue[0], colorClearValue[1], colorClearValue[2], colorClearValue[3]); g3d->colorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]); } if (initDepth) { g3d->clearDepth(depthClearValue); g3d->depthMask(depthMask); } if (initStencil) { g3d->clearStencil(stencilClearValue); g3d->stencilMask(stencilMask); } if (isScissorEnabled) g3d->enable(GraphicsContext3D::SCISSOR_TEST); else g3d->disable(GraphicsContext3D::SCISSOR_TEST); if (isDitherEnabled) g3d->enable(GraphicsContext3D::DITHER); else g3d->disable(GraphicsContext3D::DITHER); if (initColor) setInitialized(m_colorAttachment.get()); if (initDepth && initStencil && m_depthStencilAttachment) setInitialized(m_depthStencilAttachment.get()); else { if (initDepth) setInitialized(m_depthAttachment.get()); if (initStencil) setInitialized(m_stencilAttachment.get()); } return true; }
void WebGLFramebuffer::initializeRenderbuffers() { if (!object()) return; bool initColor = false, initDepth = false, initStencil = false; unsigned long mask = 0; if (isUninitialized(m_colorAttachment)) { initColor = true; mask |= GraphicsContext3D::COLOR_BUFFER_BIT; } if (isUninitialized(m_depthAttachment)) { initDepth = true; mask |= GraphicsContext3D::DEPTH_BUFFER_BIT; } if (isUninitialized(m_stencilAttachment)) { initStencil = true; mask |= GraphicsContext3D::STENCIL_BUFFER_BIT; } if (isUninitialized(m_depthStencilAttachment)) { initDepth = true; initStencil = true; mask |= (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT); } if (!initColor && !initDepth && !initStencil) return; // We only clear un-initialized renderbuffers when they are ready to be // read, i.e., when the framebuffer is complete. GraphicsContext3D* g3d = context()->graphicsContext3D(); if (g3d->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) return; float colorClearValue[] = {0, 0, 0, 0}, depthClearValue = 0; int stencilClearValue = 0; unsigned char colorMask[] = {1, 1, 1, 1}, depthMask = 1, stencilMask = 1; bool isScissorEnabled = false; bool isDitherEnabled = false; if (initColor) { g3d->getFloatv(GraphicsContext3D::COLOR_CLEAR_VALUE, colorClearValue); g3d->getBooleanv(GraphicsContext3D::COLOR_WRITEMASK, colorMask); g3d->clearColor(0, 0, 0, 0); g3d->colorMask(true, true, true, true); } if (initDepth) { g3d->getFloatv(GraphicsContext3D::DEPTH_CLEAR_VALUE, &depthClearValue); g3d->getBooleanv(GraphicsContext3D::DEPTH_WRITEMASK, &depthMask); g3d->clearDepth(0); g3d->depthMask(true); } if (initStencil) { g3d->getIntegerv(GraphicsContext3D::STENCIL_CLEAR_VALUE, &stencilClearValue); g3d->getBooleanv(GraphicsContext3D::STENCIL_WRITEMASK, &stencilMask); g3d->clearStencil(0); g3d->stencilMask(true); } isScissorEnabled = g3d->isEnabled(GraphicsContext3D::SCISSOR_TEST); g3d->disable(GraphicsContext3D::SCISSOR_TEST); isDitherEnabled = g3d->isEnabled(GraphicsContext3D::DITHER); g3d->disable(GraphicsContext3D::DITHER); g3d->clear(mask); if (initColor) { g3d->clearColor(colorClearValue[0], colorClearValue[1], colorClearValue[2], colorClearValue[3]); g3d->colorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]); } if (initDepth) { g3d->clearDepth(depthClearValue); g3d->depthMask(depthMask); } if (initStencil) { g3d->clearStencil(stencilClearValue); g3d->stencilMask(stencilMask); } if (isScissorEnabled) g3d->enable(GraphicsContext3D::SCISSOR_TEST); else g3d->disable(GraphicsContext3D::SCISSOR_TEST); if (isDitherEnabled) g3d->enable(GraphicsContext3D::DITHER); else g3d->disable(GraphicsContext3D::DITHER); if (initColor) setInitialized(m_colorAttachment); if (initDepth && initStencil && m_depthStencilAttachment) setInitialized(m_depthStencilAttachment); else { if (initDepth) setInitialized(m_depthAttachment); if (initStencil) setInitialized(m_stencilAttachment); } }
Renderer::ITexture* RenderTargetTextureManager::getTextureByAssetId(AssetId assetId, const Renderer::IRenderTarget& renderTarget, uint8_t numberOfMultisamples, float resolutionScale) { Renderer::ITexture* texture = nullptr; // Map asset ID to render target texture signature ID // TODO(co) The render target texture and framebuffer handling is still under construction regarding recycling renderer resources etc. - so for now, just add render target textures to have something to start with /* AssetIdToRenderTargetTextureSignatureId::const_iterator iterator = mAssetIdToRenderTargetTextureSignatureId.find(assetId); if (mAssetIdToRenderTargetTextureSignatureId.cend() != iterator) { // TODO(co) Is there need for a more efficient search? const RenderTargetTextureSignatureId renderTargetTextureSignatureId = iterator->second; for (RenderTargetTextureElement& renderTargetTextureElement : mSortedRenderTargetTextureVector) */ AssetIdToIndex::const_iterator iterator = mAssetIdToIndex.find(assetId); if (mAssetIdToIndex.cend() != iterator) { RenderTargetTextureElement& renderTargetTextureElement = mSortedRenderTargetTextureVector[iterator->second]; { const RenderTargetTextureSignature& renderTargetTextureSignature = renderTargetTextureElement.renderTargetTextureSignature; // if (renderTargetTextureSignature.getRenderTargetTextureSignatureId() == renderTargetTextureSignatureId) // TODO(co) The render target texture and framebuffer handling is still under construction regarding recycling renderer resources etc. - so for now, just add render target textures to have something to start with { // Do we need to create the renderer texture instance right now? if (nullptr == renderTargetTextureElement.texture) { // Get the texture width and height and apply resolution scale in case the main compositor workspace render target is used uint32_t width = renderTargetTextureSignature.getWidth(); uint32_t height = renderTargetTextureSignature.getHeight(); if (isUninitialized(width) || isUninitialized(height)) { uint32_t renderTargetWidth = 0; uint32_t renderTargetHeight = 0; renderTarget.getWidthAndHeight(renderTargetWidth, renderTargetHeight); if (!renderTargetTextureSignature.getAllowResolutionScale()) { resolutionScale = 1.0f; } if (isUninitialized(width)) { width = static_cast<uint32_t>(static_cast<float>(renderTargetWidth) * resolutionScale * renderTargetTextureSignature.getWidthScale()); } if (isUninitialized(height)) { height = static_cast<uint32_t>(static_cast<float>(renderTargetHeight) * resolutionScale * renderTargetTextureSignature.getHeightScale()); } } // Create the texture instance, but without providing texture data (we use the texture as render target) // -> Use the "Renderer::TextureFlag::RENDER_TARGET"-flag to mark this texture as a render target // -> Required for Direct3D 9, Direct3D 10, Direct3D 11 and Direct3D 12 // -> Not required for OpenGL and OpenGL ES 2 // -> The optimized texture clear value is a Direct3D 12 related option renderTargetTextureElement.texture = mRendererRuntime.getTextureManager().createTexture2D(width, height, renderTargetTextureSignature.getTextureFormat(), nullptr, Renderer::TextureFlag::RENDER_TARGET, Renderer::TextureUsage::DEFAULT, renderTargetTextureSignature.getAllowMultisample() ? numberOfMultisamples : 1u); renderTargetTextureElement.texture->addReference(); { // Tell the texture resource manager about our render target texture so it can be referenced inside e.g. compositor nodes TextureResourceManager& textureResourceManager = mRendererRuntime.getTextureResourceManager(); TextureResource* textureResource = textureResourceManager.getTextureResourceByAssetId(assetId); if (nullptr == textureResource) { // Create texture resource textureResourceManager.createTextureResourceByAssetId(assetId, *renderTargetTextureElement.texture); } else { // Update texture resource textureResource->setTexture(*renderTargetTextureElement.texture); } } } texture = renderTargetTextureElement.texture; // break; // TODO(co) The render target texture and framebuffer handling is still under construction regarding recycling renderer resources etc. - so for now, just add render target textures to have something to start with } } assert(nullptr != texture); } else { // Error! Unknown asset ID, this shouldn't have happened. assert(false); } // Done return texture; }