/* * idea/realtime/idea_canvas_gpu.cpp * Idea System(TM) realtime canvas -- GPU compute backend (offscreen GL). * * Idea System(TM) / Idea(TM). From Author; distributive. * * The GPU path the VM offloads to when the CPU cannot sustain the 120 Hz * budget. It runs the SAME decay/diffusion step on the GPU and keeps the field * in device memory, reading back into the VM's native vertex block only when * asked. It uses an OFFSCREEN, windowless GL context so it works on a server: * * - EGL surfaceless (eglGetPlatformDisplay(EGL_PLATFORM_SURFACELESS_MESA) / * EGL_DEFAULT_DISPLAY + a pbuffer-less config) -> a real GPU context; or * - OSMesa fallback -> OpenGL executed entirely in CPU/native memory, no GPU * and no display at all (the most "native memory space" path). * * The field update is a fragment shader over a texture pair (ping-pong FBO): * intensity in a float texture, neighbour diffusion + decay in the shader, * colour-predictive RGBA written out. glReadPixels brings it back to the native * idea_vertex block on readback. * * BUILD: compiled with IDEA_CANVAS_WITH_GL (needs EGL+GL or OSMesa headers). * Without that define, this file provides stubs so idea_canvas_gpu_available() * returns 0 and the VM simply stays on the CPU. * * NOTE: like idea_canvas_gl.cpp, the GL/EGL code here is written against the * API but is NOT compiled or run in the Idea System sandbox (no GL/EGL/OSMesa, * no GPU, no display). Build and run it on a GPU/driver-equipped machine. */ #include "idea_canvas.h" #include "idea_canvas_internal.hpp" #include "idea_canvas_ctx.h" /* platform GL context (WGL/CGL/EGL/OSMesa) */ #if defined(IDEA_CANVAS_WITH_GL) /* Prefer EGL surfaceless; fall back to OSMesa if EGL is unavailable. Which of * these headers exist is decided by the build (define IDEA_CANVAS_USE_OSMESA * to force the software path). */ #if defined(IDEA_CANVAS_USE_OSMESA) # include # include #else # include # include # include #endif #include #include #include namespace { struct GpuState { #if defined(IDEA_CANVAS_USE_OSMESA) OSMesaContext ctx = nullptr; std::vector framebuffer; /* RGBA8, cols*rows*4 */ #else EGLDisplay dpy = EGL_NO_DISPLAY; EGLContext ctx = EGL_NO_CONTEXT; #endif GLuint prog = 0; GLuint texA = 0, texB = 0; /* ping-pong intensity textures */ GLuint fbo = 0; int cols = 0, rows = 0; bool ready = false; }; /* Compute-as-fragment shader: one texel per vertex, diffusion + decay. */ const char *kVert = "#version 300 es\n" "layout(location=0) in vec2 p; out vec2 uv;\n" "void main(){ uv = p*0.5+0.5; gl_Position = vec4(p,0.0,1.0); }\n"; const char *kFrag = "#version 300 es\n" "precision highp float;\n" "in vec2 uv; out vec4 o;\n" "uniform sampler2D field; uniform vec2 texel;\n" "uniform float keep; uniform float coupling;\n" "void main(){\n" " float c = texture(field, uv).r;\n" " float n = texture(field, uv+vec2(0.0, texel.y)).r;\n" " float s = texture(field, uv-vec2(0.0, texel.y)).r;\n" " float e = texture(field, uv+vec2(texel.x, 0.0)).r;\n" " float w = texture(field, uv-vec2(texel.x, 0.0)).r;\n" " float neigh = 0.25*(n+s+e+w);\n" " float inten = clamp(c*keep + coupling*(neigh-c), 0.0, 1.0);\n" " o = vec4(inten, 0.0, 0.0, 1.0);\n" "}\n"; GpuState *gs(idea_canvas *c) { return static_cast(c->gpu); } GLuint compile(GLenum t, const char *src) { GLuint s = glCreateShader(t); glShaderSource(s, 1, &src, nullptr); glCompileShader(s); return s; } bool make_context(GpuState *g) { #if defined(IDEA_CANVAS_USE_OSMESA) g->ctx = OSMesaCreateContextExt(OSMESA_RGBA, 24, 8, 0, nullptr); if (!g->ctx) return false; g->framebuffer.assign((size_t)g->cols * g->rows * 4, 0); return OSMesaMakeCurrent(g->ctx, g->framebuffer.data(), GL_UNSIGNED_BYTE, g->cols, g->rows) == GL_TRUE; #else g->dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (g->dpy == EGL_NO_DISPLAY) return false; if (!eglInitialize(g->dpy, nullptr, nullptr)) return false; eglBindAPI(EGL_OPENGL_ES_API); EGLConfig cfg; EGLint n = 0; const EGLint attrs[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_NONE }; if (!eglChooseConfig(g->dpy, attrs, &cfg, 1, &n) || n < 1) return false; const EGLint ctxattrs[] = { EGL_CONTEXT_MAJOR_VERSION, 3, EGL_NONE }; g->ctx = eglCreateContext(g->dpy, cfg, EGL_NO_CONTEXT, ctxattrs); if (g->ctx == EGL_NO_CONTEXT) return false; return eglMakeCurrent(g->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, g->ctx) == EGL_TRUE; #endif } } // namespace int idea_canvas_gpu_available(void) { /* A GPU backend is available iff the platform GL context layer can create a * context (WGL on Windows 10+, CGL on macOS, EGL/OSMesa on Linux). */ return idea_ctx_supported(); } int idea_canvas_gpu_init(idea_canvas *c) { if (!c) return -1; if (c->gpu) return 0; GpuState *g = new GpuState(); g->cols = c->cols; g->rows = c->rows; if (!make_context(g)) { delete g; return -1; } GLuint v = compile(GL_VERTEX_SHADER, kVert), f = compile(GL_FRAGMENT_SHADER, kFrag); g->prog = glCreateProgram(); glAttachShader(g->prog, v); glAttachShader(g->prog, f); glLinkProgram(g->prog); /* upload the current intensity field into texA (R32F). */ std::vector field((size_t)g->cols * g->rows); for (size_t i = 0; i < field.size(); ++i) field[i] = c->verts[i].intensity; glGenTextures(1, &g->texA); glGenTextures(1, &g->texB); for (GLuint t : {g->texA, g->texB}) { glBindTexture(GL_TEXTURE_2D, t); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, g->cols, g->rows, 0, GL_RED, GL_FLOAT, (t == g->texA) ? field.data() : nullptr); } glGenFramebuffers(1, &g->fbo); g->ready = true; c->gpu = g; return 0; } int idea_canvas_gpu_step(idea_canvas *c, const idea_sim_params *p, float dt) { GpuState *g = gs(c); if (!g || !g->ready) return -1; const float keep = (float)std::exp(-(p ? p->decay : 0.25f) * dt); const float coupling = p ? p->coupling : 0.06f; glBindFramebuffer(GL_FRAMEBUFFER, g->fbo); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g->texB, 0); glViewport(0, 0, g->cols, g->rows); glUseProgram(g->prog); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, g->texA); glUniform1i(glGetUniformLocation(g->prog, "field"), 0); glUniform2f(glGetUniformLocation(g->prog, "texel"), 1.0f/g->cols, 1.0f/g->rows); glUniform1f(glGetUniformLocation(g->prog, "keep"), keep); glUniform1f(glGetUniformLocation(g->prog, "coupling"), coupling); /* a full-screen triangle is drawn by the caller's VAO setup (omitted) */ glDrawArrays(GL_TRIANGLES, 0, 3); std::swap(g->texA, g->texB); /* ping-pong */ return 0; } int idea_canvas_gpu_readback(idea_canvas *c) { GpuState *g = gs(c); if (!g || !g->ready) return -1; std::vector field((size_t)g->cols * g->rows); glBindFramebuffer(GL_FRAMEBUFFER, g->fbo); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g->texA, 0); glReadPixels(0, 0, g->cols, g->rows, GL_RED, GL_FLOAT, field.data()); for (size_t i = 0; i < field.size(); ++i) c->verts[i].intensity = field[i]; return 0; } void idea_canvas_gpu_shutdown(idea_canvas *c) { GpuState *g = gs(c); if (!g) return; if (g->prog) glDeleteProgram(g->prog); if (g->texA) glDeleteTextures(1, &g->texA); if (g->texB) glDeleteTextures(1, &g->texB); if (g->fbo) glDeleteFramebuffers(1, &g->fbo); #if defined(IDEA_CANVAS_USE_OSMESA) if (g->ctx) OSMesaDestroyContext(g->ctx); #else if (g->ctx != EGL_NO_CONTEXT) eglDestroyContext(g->dpy, g->ctx); if (g->dpy != EGL_NO_DISPLAY) eglTerminate(g->dpy); #endif delete g; c->gpu = nullptr; } #else /* ---- no GL build: GPU backend unavailable ---- */ int idea_canvas_gpu_available(void) { return idea_ctx_supported(); } int idea_canvas_gpu_init(idea_canvas *c) { (void)c; return -1; } int idea_canvas_gpu_step(idea_canvas *c, const idea_sim_params *p, float dt) { (void)c; (void)p; (void)dt; return -1; } int idea_canvas_gpu_readback(idea_canvas *c) { (void)c; return -1; } void idea_canvas_gpu_shutdown(idea_canvas *c) { (void)c; } #endif