void LayerRenderer::destroyLayerDeferred(Layer* layer) { if (layer) { LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo()); Caches::getInstance().deleteLayerDeferred(layer); } }
void LayerRenderer::destroyLayerDeferred(Layer* layer) { if (layer) { LAYER_RENDERER_LOGD("Deferring layer destruction %p, fbo %d, texture %d, alpha %d", layer, layer->getFbo(), layer->getTexture(), layer->getAlpha()); Caches::getInstance().deleteLayerDeferred(layer); } }
void LayerRenderer::destroyLayer(Layer* layer) { if (layer) { LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d", layer->getWidth(), layer->getHeight(), layer->getFbo()); if (!Caches::getInstance().layerCache.put(layer)) { LAYER_RENDERER_LOGD(" Destroyed!"); Caches::getInstance().resourceCache.decrementRefcount(layer); } else { LAYER_RENDERER_LOGD(" Cached!"); #if DEBUG_LAYER_RENDERER Caches::getInstance().layerCache.dump(); #endif layer->removeFbo(); layer->region.clear(); } } }
void LayerRenderer::destroyLayer(Layer* layer) { if (layer) { ATRACE_FORMAT("Destroy %ux%u HW Layer", layer->getWidth(), layer->getHeight()); LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d", layer->getWidth(), layer->getHeight(), layer->getFbo()); if (!Caches::getInstance().layerCache.put(layer)) { LAYER_RENDERER_LOGD(" Destroyed!"); layer->decStrong(nullptr); } else { LAYER_RENDERER_LOGD(" Cached!"); #if DEBUG_LAYER_RENDERER Caches::getInstance().layerCache.dump(); #endif layer->removeFbo(); layer->region.clear(); } } }
void LayerRenderer::finish() { OpenGLRenderer::finish(); generateMesh(); LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo()); // No need to unbind our FBO, this will be taken care of by the caller // who will invoke OpenGLRenderer::resume() }
void LayerRenderer::destroyLayer(Layer* layer) { if (layer) { ATRACE_CALL(); LAYER_RENDERER_LOGD("Destroying or caching layer %p, %dx%d, fbo %d, texture %d, alpha %d", layer, layer->getWidth(), layer->getHeight(), layer->getFbo(), layer->getTexture(), layer->getAlpha()); if (!Caches::getInstance().layerCache.put(layer)) { LAYER_RENDERER_LOGD(" Destroyed!"); ResourceCache::getInstance().decrementRefcount(layer); } else { LAYER_RENDERER_LOGD(" Cached!"); layer->removeFbo(); layer->region.clear(); } #if DEBUG_LAYER_RENDERER if (g_HWUI_debug_layer_renderer) Caches::getInstance().layerCache.dump(); #endif } }
Layer* LayerRenderer::createTextureLayer(RenderState& renderState) { LAYER_RENDERER_LOGD("Creating new texture layer"); Layer* layer = new Layer(Layer::kType_Texture, renderState, 0, 0); layer->setCacheable(false); layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f); layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f); layer->region.clear(); layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer() Caches::getInstance().textureState().activateTexture(0); layer->generateTexture(); return layer; }
bool LayerRenderer::resizeLayer(Layer* layer, uint32_t width, uint32_t height) { if (layer) { LAYER_RENDERER_LOGD("Resizing layer fbo = %d to %dx%d", layer->getFbo(), width, height); if (layer->resize(width, height)) { layer->layer.set(0.0f, 0.0f, width, height); layer->texCoords.set(0.0f, height / float(layer->getHeight()), width / float(layer->getWidth()), 0.0f); } else { return false; } } return true; }
Layer* LayerRenderer::createTextureLayer(bool isOpaque) { LAYER_RENDERER_LOGD("Creating new texture layer"); Layer* layer = new Layer(0, 0); layer->setCacheable(false); layer->setTextureLayer(true); layer->setBlend(!isOpaque); layer->setEmpty(true); layer->setFbo(0); layer->setAlpha(255, SkXfermode::kSrcOver_Mode); layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f); layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f); layer->region.clear(); layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer() Caches::getInstance().activeTexture(0); layer->generateTexture(); return layer; }
void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height, bool isOpaque, bool forceFilter, GLenum renderTarget, float* textureTransform) { if (layer) { LAYER_RENDERER_LOGD("Updating texture layer %p, %dx%d, fbo %d, texture %d, renderTarget 0x%x, alpha %d", layer, width, height, layer->getFbo(), layer->getTexture(), renderTarget, layer->getAlpha()); layer->setBlend(!isOpaque); layer->setForceFilter(forceFilter); layer->setSize(width, height); layer->layer.set(0.0f, 0.0f, width, height); layer->region.set(width, height); layer->regionRect.set(0.0f, 0.0f, width, height); layer->getTexTransform().load(textureTransform); if (renderTarget != layer->getRenderTarget()) { layer->setRenderTarget(renderTarget); layer->bindTexture(); layer->setFilter(GL_NEAREST, false, true); layer->setWrap(GL_CLAMP_TO_EDGE, false, true); } } }
void LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) { LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo()); mRenderState.bindFramebuffer(mLayer->getFbo()); const float width = mLayer->layer.getWidth(); const float height = mLayer->layer.getHeight(); Rect dirty(left, top, right, bottom); if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 && dirty.right >= width && dirty.bottom >= height)) { mLayer->region.clear(); dirty.set(0.0f, 0.0f, width, height); } else { dirty.intersect(0.0f, 0.0f, width, height); android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom); mLayer->region.subtractSelf(r); } mLayer->clipRect.set(dirty); OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque); }
Layer* LayerRenderer::createRenderLayer(RenderState& renderState, uint32_t width, uint32_t height) { ATRACE_FORMAT("Allocate %ux%u HW Layer", width, height); LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height); Caches& caches = Caches::getInstance(); GLuint fbo = caches.fboCache.get(); if (!fbo) { ALOGW("Could not obtain an FBO"); return nullptr; } caches.textureState().activateTexture(0); Layer* layer = caches.layerCache.get(renderState, width, height); if (!layer) { ALOGW("Could not obtain a layer"); return nullptr; } // We first obtain a layer before comparing against the max texture size // because layers are not allocated at the exact desired size. They are // always created slighly larger to improve recycling const uint32_t maxTextureSize = caches.maxTextureSize; if (layer->getWidth() > maxTextureSize || layer->getHeight() > maxTextureSize) { ALOGW("Layer exceeds max. dimensions supported by the GPU (%dx%d, max=%dx%d)", width, height, maxTextureSize, maxTextureSize); // Creating a new layer always increment its refcount by 1, this allows // us to destroy the layer object if one was created for us layer->decStrong(nullptr); return nullptr; } layer->setFbo(fbo); layer->layer.set(0.0f, 0.0f, width, height); layer->texCoords.set(0.0f, height / float(layer->getHeight()), width / float(layer->getWidth()), 0.0f); layer->setAlpha(255, SkXfermode::kSrcOver_Mode); layer->setColorFilter(nullptr); layer->setDirty(true); layer->region.clear(); GLuint previousFbo = renderState.getFramebuffer(); renderState.bindFramebuffer(layer->getFbo()); layer->bindTexture(); // Initialize the texture if needed if (layer->isEmpty()) { layer->setEmpty(false); layer->allocateTexture(); // This should only happen if we run out of memory if (CC_UNLIKELY(GLUtils::dumpGLErrors())) { LOG_ALWAYS_FATAL("Could not allocate texture for layer (fbo=%d %dx%d)", fbo, width, height); renderState.bindFramebuffer(previousFbo); layer->decStrong(nullptr); return nullptr; } } glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, layer->getTextureId(), 0); renderState.bindFramebuffer(previousFbo); return layer; }
Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) { LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height); Caches& caches = Caches::getInstance(); GLuint fbo = caches.fboCache.get(); if (!fbo) { ALOGW("Could not obtain an FBO"); return NULL; } caches.activeTexture(0); Layer* layer = caches.layerCache.get(width, height); if (!layer) { ALOGW("Could not obtain a layer"); return NULL; } // We first obtain a layer before comparing against the max texture size // because layers are not allocated at the exact desired size. They are // always created slighly larger to improve recycling const uint32_t maxTextureSize = caches.maxTextureSize; if (layer->getWidth() > maxTextureSize || layer->getHeight() > maxTextureSize) { ALOGW("Layer exceeds max. dimensions supported by the GPU (%dx%d, max=%dx%d)", width, height, maxTextureSize, maxTextureSize); // Creating a new layer always increment its refcount by 1, this allows // us to destroy the layer object if one was created for us Caches::getInstance().resourceCache.decrementRefcount(layer); return NULL; } layer->setFbo(fbo); layer->layer.set(0.0f, 0.0f, width, height); layer->texCoords.set(0.0f, height / float(layer->getHeight()), width / float(layer->getWidth()), 0.0f); layer->setAlpha(255, SkXfermode::kSrcOver_Mode); layer->setBlend(!isOpaque); layer->setColorFilter(NULL); layer->setDirty(true); layer->region.clear(); GLuint previousFbo; glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo); glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo()); layer->bindTexture(); // Initialize the texture if needed if (layer->isEmpty()) { layer->setEmpty(false); layer->allocateTexture(); // This should only happen if we run out of memory if (glGetError() != GL_NO_ERROR) { ALOGE("Could not allocate texture for layer (fbo=%d %dx%d)", fbo, width, height); glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); caches.resourceCache.decrementRefcount(layer); return NULL; } } glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, layer->getTexture(), 0); glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); return layer; }