opengl_ffmpeg_script_driven_demo.dom — the script that produces the demo above — opens an OpenGL window, decodes a video stream with FFmpeg into a spinning textured cube, handles mouse input, and runs at 60 FPS. Every drawing decision lives in the source; there is no rendering engine hidden behind a high-level façade.
The excerpt below shows the spine: plugin declarations, the packed render state struct, the two callbacks the host dispatches into, and the main lifecycle. Geometry helpers, draw functions, and the per-frame renderer are omitted — see the full source for those (about 770 lines total).
/* The runtime knows almost nothing on its own. Each `plugin` line loads
a shared library that contributes a namespace (gl, ffmpeg, ...). */
plugin "builtin:os";
plugin "builtin:struct";
plugin "../plugins/worker/WorkerPlugin";
plugin "../plugins/opengl/GlPlugin";
plugin "../plugins/ffmpeg/FfmpegPlugin";
plugin "../plugins/image/ImagePlugin";
#define WINDOW_WIDTH 1280
#define WINDOW_HEIGHT 720
#define VIDEO_WIDTH 640
#define VIDEO_HEIGHT 360
#define AUTO_SPEED_X 0.23
#define AUTO_SPEED_Y 0.37
#define AUTO_SPEED_Z 0.11
/* Packed struct: byte-precise layout, no padding surprises. The runtime
can overlay this onto any blob with `$X assign RenderState;` and read
typed fields without copying. */
struct RenderState packet
{
i32 WindowWidth;
i32 WindowHeight;
i32 VideoSlot;
i32 LogoSlot;
double CameraDistance;
double ViewScale;
double AngleX;
double AngleY;
double AngleZ;
double SpeedX;
double SpeedY;
double SpeedZ;
/* ... edge color, cube gap, line width ... */
};
/* The interactive state lives in the callback world -- the thread the
mouse/resize and frame callbacks run on -- as a callback global. The
main thread never names it: once per frame it calls Tick, which
advances the rotation and writes a snapshot into the blob main lends. */
callback global blob $State[sizeof(RenderState)];
callback i32 Tick(ref blob $Snapshot)
{
$Snapshot assign RenderState;
$State assign RenderState;
/* ... advance AngleX/Y/Z by Speed * dt (clamped) ... */
$Snapshot.AngleX = $State.AngleX;
/* ... copy the remaining fields into the snapshot ... */
return 1;
}
/* =========== Callbacks the host dispatches into =================== */
/* Called by the ffmpeg plugin for each decoded video frame. The frame
bytes arrive in $FramePacket as a borrowed, mutable blob -- no
allocation, no memcpy. We hand them straight to the GL texture slot
and return; the plugin reclaims ownership the moment we exit. */
callback i32 OnVideoFrame(ref blob $FramePacket)
{
$State assign RenderState;
gl.UpdateTexture($State.VideoSlot, $FramePacket);
return 1;
}
/* The event packet the gl plugin hands to the callback: a packed
struct over the same bytes, so `$EventPacket assign GlEvent;` gives
typed fields with no copy. */
struct GlEvent packet
{
u8 magic0;
u8 magic1;
u8 magic2;
u8 magic3;
u8 version;
u8 type;
u8 button;
u8 pad0;
i16 x;
i16 y;
i16 dx;
i16 dy;
i16 wheel;
u16 width;
u16 height;
};
/* Called by the gl plugin for each pumped input event. We pull the
typed event view over the same packet bytes and update shared state. */
callback i32 OnOpenGlEvent(ref blob $EventPacket)
{
$State assign RenderState;
$EventPacket assign GlEvent;
if ($EventPacket.type == GL_EVENT_MOUSE_WHEEL)
{
$State.CameraDistance = $State.CameraDistance
- (0.25 * (double)$EventPacket.wheel);
$State.CameraDistance = ClampCameraDistance($State.CameraDistance);
}
/* ... mouse down / up / move handlers for left-drag rotation ... */
return 1;
}
/* =========== Entry point ========================================== */
i32 main()
{
i32 $Video = 0;
blob $LogoPacket[0];
/* Open the GL window. gl.Open returns 0 if no display is
available -- on a headless box the demo just exits cleanly. */
if (gl.Open(WINDOW_WIDTH, WINDOW_HEIGHT,
"Domin OpenGL FFmpeg demo") == 0)
{
return 0;
}
/* main's own copy of the state: seeded here, then refreshed by Tick
every frame. Configure carries it into the callback world once. */
blob $S[sizeof(RenderState)];
$S assign RenderState;
$S.WindowWidth = WINDOW_WIDTH;
$S.WindowHeight = WINDOW_HEIGHT;
$S.CameraDistance = 4.2;
$S.SpeedX = AUTO_SPEED_X;
$S.SpeedY = AUTO_SPEED_Y;
$S.SpeedZ = AUTO_SPEED_Z;
$S.VideoSlot = gl.CreateTextureSlot();
$S.LogoSlot = gl.CreateTextureSlot();
/* ... starting angles, edge colors, cube gap ... */
worker.Call("Configure", ref $S, 1000); /* seed the callback world */
/* Load the logo and bind it to its texture slot. */
$LogoPacket = image.Load("Assets/Images/domin_logo.png");
gl.UpdateTexture($S.LogoSlot, $LogoPacket);
/* Wire FFmpeg to deliver frames into OnVideoFrame at real-time pace. */
ffmpeg.SetOutputSize(VIDEO_WIDTH, VIDEO_HEIGHT);
ffmpeg.SetRealtime(1);
$Video = ffmpeg.Open("Assets/Videos/demo.mp4");
ffmpeg.StartAudio($Video);
/* Main loop: pump input -> decode frame -> draw. */
while (gl.IsOpen() != 0)
{
gl.PumpEvents("OnOpenGlEvent");
if (gl.IsOpen() == 0) { break; }
if (ffmpeg.DecodeNext($Video, "OnVideoFrame") == 0)
{
ffmpeg.Rewind($Video);
}
worker.Call("Tick", ref $S, 1000); /* advance + snapshot */
RenderScriptFrame(ref $S); /* draws the cube -- see full source */
}
ffmpeg.Close($Video);
gl.Close();
return 0;
}
