A scripting language for serious work.

/* 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/blob/BlobPlugin";
plugin "../plugins/script_state/ScriptStatePlugin";
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 ... */
}

/* =========== 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)
{
    ref blob &$S = blob.RefFromPointer(script_state.GetPointer(),
                                       script_state.GetSize());
    $S assign RenderState;
    gl.UpdateTexture($S.VideoSlot, $FramePacket);
    return 1;
}

/* 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)
{
    ref blob &$S = blob.RefFromPointer(script_state.GetPointer(),
                                       script_state.GetSize());
    $S assign RenderState;
    $EventPacket assign GlEvent;

    if ($EventPacket.type == GL_EVENT_MOUSE_WHEEL)
    {
        $S.CameraDistance = $S.CameraDistance
            - (0.25 * (double)$EventPacket.wheel);
        $S.CameraDistance = ClampCameraDistance($S.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;
    }

    /* Allocate the shared render state and initialize. Every callback
       and the main loop will bind a ref-blob view over these bytes --
       no globals, no duplication; every caller sees the same data. */
    script_state.Allocate(sizeof(RenderState));
    {
        ref blob &$S = blob.RefFromPointer(script_state.GetPointer(),
                                           script_state.GetSize());
        $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 ... */
    }

    /* Load the logo and bind it to its texture slot. */
    $LogoPacket = image.Load("Assets/Images/domin_logo.png");
    /* ... bind $S, opengl.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);
        }
        RenderScriptFrame();  /* draws the cube -- see full source */
    }

    ffmpeg.Close($Video);
    gl.Close();
    script_state.Free();
    return 0;
}