} // namespace
+EglGraphicsController::EglGraphicsController()
+: mTextureDependencyChecker(*this),
+ mSyncPool(*this)
+{
+}
+
EglGraphicsController::~EglGraphicsController()
{
while(!mPresentationCommandBuffers.empty())
}
}
+void EglGraphicsController::PostRender()
+{
+ mTextureDependencyChecker.Reset();
+ mSyncPool.AgeSyncObjects();
+}
+
Integration::GlAbstraction& EglGraphicsController::GetGlAbstraction()
{
DALI_ASSERT_DEBUG(mGlAbstraction && "Graphics controller not initialized");
}
}
+TextureProperties EglGraphicsController::GetTextureProperties(const Texture& texture)
+{
+ const GLES::Texture* glesTexture = static_cast<const GLES::Texture*>(&texture);
+ auto createInfo = glesTexture->GetCreateInfo();
+
+ TextureProperties properties{};
+ properties.format = createInfo.format;
+ properties.compressed = glesTexture->IsCompressed();
+ properties.extent2D = createInfo.size;
+ properties.nativeHandle = glesTexture->GetGLTexture();
+ //TODO: Skip format1, emulated, packed, directWriteAccessEnabled of TextureProperties for now
+
+ return properties;
+}
+
const Graphics::Reflection& EglGraphicsController::GetProgramReflection(const Graphics::Program& program)
{
return static_cast<const Graphics::GLES::Program*>(&program)->GetReflection();
if(!mSharedContext)
{
auto eglGraphics = dynamic_cast<Dali::Internal::Adaptor::EglGraphics*>(mGraphics);
- mSharedContext = eglGraphics->GetEglImplementation().GetContext();
+ if(eglGraphics)
+ {
+ mSharedContext = eglGraphics->GetEglImplementation().GetContext();
+ }
}
}
}
case GLES::CommandType::DRAW:
{
- mCurrentContext->Flush(false, cmd.draw);
+ mCurrentContext->Flush(false, cmd.draw, mTextureDependencyChecker);
break;
}
case GLES::CommandType::DRAW_INDEXED:
{
- mCurrentContext->Flush(false, cmd.draw);
+ mCurrentContext->Flush(false, cmd.draw, mTextureDependencyChecker);
break;
}
case GLES::CommandType::DRAW_INDEXED_INDIRECT:
{
- mCurrentContext->Flush(false, cmd.draw);
+ mCurrentContext->Flush(false, cmd.draw, mTextureDependencyChecker);
break;
}
case GLES::CommandType::SET_SCISSOR: // @todo Consider correcting for orientation here?
}
mCurrentContext->BeginRenderPass(cmd.beginRenderPass);
+
break;
}
case GLES::CommandType::END_RENDERPASS:
{
- mCurrentContext->EndRenderPass();
+ mCurrentContext->EndRenderPass(mTextureDependencyChecker);
+ // This sync object is to enable cpu to wait for rendering to complete, not gpu.
+ // It's only needed for reading the framebuffer texture in the client.
auto syncObject = const_cast<GLES::SyncObject*>(static_cast<const GLES::SyncObject*>(cmd.endRenderPass.syncObject));
if(syncObject)
{
info.srcExtent2D.height != (createInfo.size.height / (1 << info.level)));
auto* sourceBuffer = reinterpret_cast<uint8_t*>(source.memorySource.memory);
+ auto sourceStride = info.srcStride;
std::vector<uint8_t> tempBuffer;
+
if(mGlAbstraction->TextureRequiresConverting(srcFormat, destFormat, isSubImage))
{
// Convert RGB to RGBA if necessary.
- texture->TryConvertPixelData(source.memorySource.memory, info.srcFormat, createInfo.format, info.srcSize, info.srcExtent2D.width, info.srcExtent2D.height, tempBuffer);
- sourceBuffer = &tempBuffer[0];
- srcFormat = destFormat;
- srcType = GLES::GLTextureFormatType(createInfo.format).type;
+ if(texture->TryConvertPixelData(source.memorySource.memory, info.srcFormat, createInfo.format, info.srcSize, info.srcStride, info.srcExtent2D.width, info.srcExtent2D.height, tempBuffer))
+ {
+ sourceBuffer = &tempBuffer[0];
+ sourceStride = 0u; // Converted buffer compacted. make stride as 0.
+ srcFormat = destFormat;
+ srcType = GLES::GLTextureFormatType(createInfo.format).type;
+ }
}
// Calculate the maximum mipmap level for the texture
}
mGlAbstraction->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
- mGlAbstraction->PixelStorei(GL_UNPACK_ROW_LENGTH, info.srcStride);
+ mGlAbstraction->PixelStorei(GL_UNPACK_ROW_LENGTH, sourceStride);
mCurrentContext->BindTexture(bindTarget, texture->GetTextureTypeId(), texture->GetGLTexture());
// TODO: using PBO with GLES3, this is just naive
// oldschool way
- char* stagingBuffer = reinterpret_cast<char*>(malloc(info.srcSize));
- std::copy(&reinterpret_cast<char*>(source.memorySource.memory)[info.srcOffset],
- reinterpret_cast<char*>(source.memorySource.memory) + info.srcSize,
- stagingBuffer);
+ uint8_t* stagingBuffer = reinterpret_cast<uint8_t*>(malloc(info.srcSize));
+
+ uint8_t* srcMemory = &reinterpret_cast<uint8_t*>(source.memorySource.memory)[info.srcOffset];
+
+ std::copy(srcMemory, srcMemory + info.srcSize, stagingBuffer);
mTextureUploadTotalCPUMemoryUsed += info.srcSize;
return *mPipelineCache;
}
+void EglGraphicsController::CaptureRenderingResult(Graphics::Framebuffer& framebuffer, CallbackBase* capturedCallback, uint8_t* capturedBuffer)
+{
+ static_cast<GLES::Framebuffer*>(&framebuffer)->CaptureRenderingResult(capturedCallback, capturedBuffer);
+}
+
} // namespace Dali::Graphics