mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-09-10 13:18:31 +09:00
[Feat]: Making DiligentCore EGL init work
This commit is contained in:
@@ -0,0 +1,335 @@
|
||||
//
|
||||
// Created by Swung 0x48 on 2025-05-18.
|
||||
//
|
||||
|
||||
#include "EGL_impl.h"
|
||||
|
||||
typedef Diligent::IEngineFactoryOpenGL* (*Diligent_GetEngineFactoryOpenGL_t)();
|
||||
|
||||
using namespace Diligent;
|
||||
|
||||
namespace MG_EGL::Diligent {
|
||||
static const char *VSSource = R"(
|
||||
struct PSInput
|
||||
{
|
||||
float4 Pos : SV_POSITION;
|
||||
float3 Color : COLOR;
|
||||
};
|
||||
|
||||
void main(in uint VertId : SV_VertexID,
|
||||
out PSInput PSIn)
|
||||
{
|
||||
float4 Pos[3];
|
||||
Pos[0] = float4(-0.5, -0.5, 0.0, 1.0);
|
||||
Pos[1] = float4( 0.0, +0.5, 0.0, 1.0);
|
||||
Pos[2] = float4(+0.5, -0.5, 0.0, 1.0);
|
||||
|
||||
float3 Col[3];
|
||||
Col[0] = float3(1.0, 0.0, 0.0); // red
|
||||
Col[1] = float3(0.0, 1.0, 0.0); // green
|
||||
Col[2] = float3(0.0, 0.0, 1.0); // blue
|
||||
|
||||
PSIn.Pos = Pos[VertId];
|
||||
PSIn.Color = Col[VertId];
|
||||
}
|
||||
)";
|
||||
|
||||
// Pixel shader simply outputs interpolated vertex color
|
||||
static const char *PSSource = R"(
|
||||
struct PSInput
|
||||
{
|
||||
float4 Pos : SV_POSITION;
|
||||
float3 Color : COLOR;
|
||||
};
|
||||
|
||||
struct PSOutput
|
||||
{
|
||||
float4 Color : SV_TARGET;
|
||||
};
|
||||
|
||||
void main(in PSInput PSIn,
|
||||
out PSOutput PSOut)
|
||||
{
|
||||
PSOut.Color = float4(PSIn.Color.rgb, 1.0);
|
||||
}
|
||||
)";
|
||||
|
||||
EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
|
||||
const EGLint *attrib_list) {
|
||||
void *handle = dlopen("libGraphicsEngineOpenGL.so", RTLD_LAZY);
|
||||
auto Diligent_GetEngineFactoryOpenGL =
|
||||
(Diligent_GetEngineFactoryOpenGL_t) dlsym(handle,
|
||||
"Diligent_GetEngineFactoryOpenGL");
|
||||
|
||||
auto *pFactoryOpenGL = Diligent_GetEngineFactoryOpenGL();
|
||||
::Diligent::EngineGLCreateInfo EngineCI;
|
||||
auto *nativeWindow = static_cast<ANativeWindow *>(window);
|
||||
EngineCI.Window.pAWindow = nativeWindow;
|
||||
|
||||
::Diligent::SwapChainDesc SCDesc;
|
||||
|
||||
auto &ctx = MG_EGL::Diligent::DeviceContext::GetInstance();
|
||||
|
||||
pFactoryOpenGL->CreateDeviceAndSwapChainGL(
|
||||
EngineCI, &ctx.pDevice, &ctx.pContext, SCDesc, &ctx.pSwapChain);
|
||||
|
||||
// Pipeline state object encompasses configuration of all GPU stages
|
||||
|
||||
GraphicsPipelineStateCreateInfo PSOCreateInfo;
|
||||
|
||||
// Pipeline state name is used by the engine to report issues.
|
||||
// It is always a good idea to give objects descriptive names.
|
||||
PSOCreateInfo.PSODesc.Name = "Simple triangle PSO";
|
||||
|
||||
// This is a graphics pipeline
|
||||
PSOCreateInfo.PSODesc.PipelineType = PIPELINE_TYPE_GRAPHICS;
|
||||
|
||||
// clang-format off
|
||||
// This tutorial will render to a single render target
|
||||
PSOCreateInfo.GraphicsPipeline.NumRenderTargets = 1;
|
||||
// Set render target format which is the format of the swap chain's color buffer
|
||||
PSOCreateInfo.GraphicsPipeline.RTVFormats[0] = ctx.pSwapChain->GetDesc().ColorBufferFormat;
|
||||
// Use the depth buffer format from the swap chain
|
||||
PSOCreateInfo.GraphicsPipeline.DSVFormat = ctx.pSwapChain->GetDesc().DepthBufferFormat;
|
||||
// Primitive topology defines what kind of primitives will be rendered by this pipeline state
|
||||
PSOCreateInfo.GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
||||
// No back face culling for this tutorial
|
||||
PSOCreateInfo.GraphicsPipeline.RasterizerDesc.CullMode = CULL_MODE_NONE;
|
||||
// Disable depth testing
|
||||
PSOCreateInfo.GraphicsPipeline.DepthStencilDesc.DepthEnable = False;
|
||||
// clang-format on
|
||||
|
||||
ShaderCreateInfo ShaderCI;
|
||||
// Tell the system that the shader source code is in HLSL.
|
||||
// For OpenGL, the engine will convert this into GLSL under the hood.
|
||||
ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;
|
||||
// OpenGL backend requires emulated combined HLSL texture samplers (g_Texture + g_Texture_sampler combination)
|
||||
ShaderCI.Desc.UseCombinedTextureSamplers = true;
|
||||
// Create a vertex shader
|
||||
RefCntAutoPtr <IShader> pVS;
|
||||
{
|
||||
ShaderCI.Desc.ShaderType = SHADER_TYPE_VERTEX;
|
||||
ShaderCI.EntryPoint = "main";
|
||||
ShaderCI.Desc.Name = "Triangle vertex shader";
|
||||
ShaderCI.Source = VSSource;
|
||||
ctx.pDevice->CreateShader(ShaderCI, &pVS);
|
||||
}
|
||||
|
||||
// Create a pixel shader
|
||||
RefCntAutoPtr <IShader> pPS;
|
||||
{
|
||||
ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
|
||||
ShaderCI.EntryPoint = "main";
|
||||
ShaderCI.Desc.Name = "Triangle pixel shader";
|
||||
ShaderCI.Source = PSSource;
|
||||
ctx.pDevice->CreateShader(ShaderCI, &pPS);
|
||||
}
|
||||
|
||||
// Finally, create the pipeline state
|
||||
PSOCreateInfo.pVS = pVS;
|
||||
PSOCreateInfo.pPS = pPS;
|
||||
ctx.pDevice->CreateGraphicsPipelineState(PSOCreateInfo, &ctx.pPSO);
|
||||
|
||||
return (EGLSurface) 1;
|
||||
}
|
||||
|
||||
EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
|
||||
EGLint config_size, EGLint *num_config) {
|
||||
*num_config = 1;
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx,
|
||||
const EGLint *attrib_list) {
|
||||
return (EGLContext) 1;
|
||||
}
|
||||
|
||||
EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLDisplay eglGetDisplay(NativeDisplayType display) {
|
||||
return (EGLDisplay) 1;
|
||||
}
|
||||
|
||||
EGLint eglGetError() {
|
||||
return EGL_SUCCESS;
|
||||
}
|
||||
|
||||
EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglTerminate(EGLDisplay dpy) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglReleaseThread(void) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLContext eglGetCurrentContext(void) {
|
||||
return (EGLContext) 1;
|
||||
}
|
||||
|
||||
EGLBoolean
|
||||
eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) {
|
||||
if (attribute == EGL_NATIVE_VISUAL_ID)
|
||||
*value = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglBindAPI(EGLenum api) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLSurface eglGetCurrentSurface(EGLint readdraw) {
|
||||
return (EGLSurface) 1;
|
||||
}
|
||||
|
||||
EGLBoolean
|
||||
eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint *value) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) {
|
||||
auto &ctx = MG_EGL::Diligent::DeviceContext::GetInstance();
|
||||
|
||||
// Clear the back buffer
|
||||
const float ClearColor[] = {0.350f, 0.350f, 0.350f, 1.0f};
|
||||
// Let the engine perform required state transitions
|
||||
ITextureView *pRTV = ctx.pSwapChain->GetCurrentBackBufferRTV();
|
||||
ITextureView *pDSV = ctx.pSwapChain->GetDepthBufferDSV();
|
||||
ctx.pContext->ClearRenderTarget(pRTV, ClearColor,
|
||||
RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
|
||||
ctx.pContext->ClearDepthStencil(pDSV, CLEAR_DEPTH_FLAG, 1.f, 0,
|
||||
RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
|
||||
|
||||
// Set the pipeline state in the immediate context
|
||||
ctx.pContext->SetPipelineState(ctx.pPSO);
|
||||
|
||||
// Typically we should now call CommitShaderResources(), however shaders in this example don't
|
||||
// use any resources.
|
||||
|
||||
DrawAttribs drawAttrs;
|
||||
drawAttrs.NumVertices = 3; // We will render 3 vertices
|
||||
ctx.pContext->Draw(drawAttrs);
|
||||
|
||||
ctx.pSwapChain->Present();
|
||||
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
||||
EGLSurface
|
||||
eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) {
|
||||
return (EGLSurface) 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void *libGLES = nullptr, *libEGL = nullptr;
|
||||
|
||||
static const char *LibPathPrefixes[] = {
|
||||
"",
|
||||
"/opt/vc/lib/",
|
||||
"/usr/local/lib/",
|
||||
"/usr/lib/",
|
||||
nullptr
|
||||
};
|
||||
|
||||
static const char *LibExts[] = {
|
||||
"so",
|
||||
"so.1",
|
||||
"so.2",
|
||||
"dylib",
|
||||
"dll",
|
||||
nullptr
|
||||
};
|
||||
|
||||
static const char *GLES3Libs[] = {
|
||||
"libGLESv3_CM",
|
||||
"libGLESv3",
|
||||
nullptr
|
||||
};
|
||||
|
||||
static const char *EGLLibs[] = {
|
||||
"libEGL",
|
||||
nullptr
|
||||
};
|
||||
|
||||
void *OpenLib(const char **names, const char *override) {
|
||||
void *lib = nullptr;
|
||||
|
||||
char path_name[PATH_MAX + 1];
|
||||
int flags = RTLD_LOCAL | RTLD_NOW;
|
||||
if (override) {
|
||||
if ((lib = dlopen(override, flags))) {
|
||||
strncpy(path_name, override, PATH_MAX);
|
||||
return lib;
|
||||
} else {
|
||||
MG_Util::Debug::LogE("LIBGL_GLES override failed: %s\n", dlerror());
|
||||
}
|
||||
}
|
||||
for (int p = 0; LibPathPrefixes[p]; p++) {
|
||||
for (int i = 0; names[i]; i++) {
|
||||
for (int e = 0; LibExts[e]; e++) {
|
||||
snprintf(path_name, PATH_MAX, "%s%s.%s", LibPathPrefixes[p], names[i], LibExts[e]);
|
||||
if ((lib = dlopen(path_name, flags))) {
|
||||
return lib;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return lib;
|
||||
}
|
||||
|
||||
typedef __eglMustCastToProperFunctionPointerType (* eglGetProcAddress_t)(const char *procname);
|
||||
eglGetProcAddress_t real_eglGetProcAddress = nullptr;
|
||||
|
||||
__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) {
|
||||
if (strncmp(procname, "eglGetProcAddress", strlen("eglGetProcAddress")) == 0) {
|
||||
return (__eglMustCastToProperFunctionPointerType)(&eglGetProcAddress);
|
||||
}
|
||||
|
||||
MG_EGL_PROC_EXPORT(eglCreateWindowSurface);
|
||||
MG_EGL_PROC_EXPORT(eglChooseConfig);
|
||||
MG_EGL_PROC_EXPORT(eglCreateContext);
|
||||
MG_EGL_PROC_EXPORT(eglInitialize);
|
||||
MG_EGL_PROC_EXPORT(eglGetDisplay);
|
||||
MG_EGL_PROC_EXPORT(eglGetError);
|
||||
MG_EGL_PROC_EXPORT(eglMakeCurrent);
|
||||
MG_EGL_PROC_EXPORT(eglDestroyContext);
|
||||
MG_EGL_PROC_EXPORT(eglDestroySurface);
|
||||
MG_EGL_PROC_EXPORT(eglTerminate);
|
||||
MG_EGL_PROC_EXPORT(eglReleaseThread);
|
||||
MG_EGL_PROC_EXPORT(eglGetCurrentContext);
|
||||
MG_EGL_PROC_EXPORT(eglGetConfigAttrib);
|
||||
MG_EGL_PROC_EXPORT(eglBindAPI);
|
||||
MG_EGL_PROC_EXPORT(eglGetCurrentSurface);
|
||||
MG_EGL_PROC_EXPORT(eglQuerySurface);
|
||||
MG_EGL_PROC_EXPORT(eglSwapInterval);
|
||||
MG_EGL_PROC_EXPORT(eglSwapBuffers);
|
||||
MG_EGL_PROC_EXPORT(eglCreatePbufferSurface);
|
||||
|
||||
/* TODO: Call real eglGetProcAddress() to get the rest (should be real native GLES functions) */
|
||||
if (!libEGL) {
|
||||
libEGL = OpenLib(EGLLibs, nullptr);
|
||||
real_eglGetProcAddress = (eglGetProcAddress_t)dlsym(libEGL, "eglGetProcAddress");
|
||||
}
|
||||
if (real_eglGetProcAddress)
|
||||
return real_eglGetProcAddress(procname);
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
Reference in New Issue
Block a user