Documentation - Introduction to Rendering

[RyanBurnside]

One of the things that would be of interest to people (especially in a GUI system) is a small demo of rendering a real time system.

My past approach to such things in other systems is keeping a rendering "loop" going while polling the keyboard.
I realize this is probably different in the Medley environment.

I think there is a lot of power in just putting rendering knowledge in peoples' hands.
For example, I'd very much like to make a little 4th of July fireworks simulation.

I would be happy to write a tutorial for review with the Medley pros once I understand how to keep the window updating without user input and also where to store the program so it's cleared when the window is closed. I had a hack in my last game where I stored the game instance in the window user data but that's probably not correct.

Thanks for all the work on Medley, I will be using it in the future!

[nbriggs]

It's about the same. You can look at, for example the LIFE package. You just loop, drawing what you want to draw, it's polite to put a (BLOCK) in the loop, or not much else will run, and you continue until, say, (KEYDOWNP 'X) or, another example, until (SHIFTDOWNP 'SHIFT)

[nbriggs]

(OPENWP window) will tell you if the window has not been closed. You can put a SHRINKFN and EXPANDFN property on the window (with WINDOWPROP) in order to get control, to, say, suspend/resume (vs. quit) when the user shrinks or expands the window you're running in. If you want to just run from an exec you don't need to worry about adding a process to handle it -- it will run until either it quits on its own (e.g., because you set it up to notice the window closed, or some key was touched) or it gets interrupted by control-E (or forced into a break to debug it, or ...). If you want, you can have the function that starts everything get a window from the user (CREATEW) and then (ADD.PROCESS '(form to be executed)) and just return.

[RyanBurnside]

Thank you for your response, it will give me a starting point.

[masinter]

@RyanBurnside I wonder if the Medley Primer https://interlisp.org/documentation/Medley-Primer.pdf was close as a better starting point?

[RyanBurnside]

@nbriggs
I've had some downtime to tackle this and learn a bit more.
I'm not quite sure how to gain more information on this PILOTBBT (record?).
I'm not sure if it needs to be imported or what. Happy to help out though and maybe write a small tutorial when finished.

[masinter]

We've reorganized the web site and cataloged some of the available documentation; have you looked in

https://interlisp.org/software/using-medley/

A lot of things need updating to 2024. In your screenshot try (FILESLOAD LIFE) (it's an Interilsp NLAMBDA function(from CL point of view, a macro). The (create PILOTBBT) is an indication (a) you're running Life interpreted, which is a lot slower than running compiled, and (b) you need to
(FILESLOAD (SOUCE) SYSEDIT) which will load in low-level system declarations.

[masinter]

perhaps this could be a later chapter for the primer.

[RyanBurnside]

Pardon the long delayed response!

It turns out that I'm needing to revisit this concept a bit. I have a bit more experience now and managed to implement a self running demo. (This is going to be for a Boids simulation so pardon the name). You can imagine that for the classic "Boids" they just flock around and so the program doesn't rely on any hooks or input to keep updating.

I'm working through this thread, and wanted to first start with the simple solution first offered by @nbriggs

Hmm that LET should probably be moved outside and just SETQ in the FOR to reuse symbols...
(I'll fix this and other suggestions in a minimal demo)

(LAMBDA (WINDOW NUM-BOIDS)
       (PROG* ((WIN (OR WINDOW (CREATEW)))
               (W (WINDOWPROP WINDOW 'WIDTH))
               (H (WINDOWPROP WINDOW 'HEIGHT))
               (BITMAP (BITMAPCREATE W H))
               (DSP (DSPCREATE BITMAP)))
              (for do (BLOCK)
                   (DSPRESET DSP)
                   (FRPTQ 10 (LET ((X (RAND 0 W))
                                   (Y (RAND 0 H))
                                   (RAD (RAND 16 32)))
                                  (DRAWCIRCLE X Y RAD NIL NIL DSP)))
                   (BITBLT BITMAP 0 0 WIN)
                   until
                   (SHIFTDOWNP 'SHIFT)
                   finally
                   (CLOSEW WIN))))

[pamoroso]

In your do iterative statement for is probably redundant.

[nbriggs]

I'd make that a (BLOCK 10) (10 ms) rather than just (BLOCK) because otherwise the display updates are unlikely to be visible.

[masinter]

it isnt clear what effect you're looking for in using a display stream on the BITMAP. If you want double buffering that's usually for some kind of continuity effect, but you're just drawing 10 random circles.

you make a variable WIN to handle the default WINDOW when NIL but then don't use it consistently.
and NUM-BOIDS isnt used at all.

the FOR is redundant but it would be more natural to write

(while (SHIFTDOWNP 'SHIFT) do (BLOCK))
(do (DSPRESET DSP)
(FRPTQ 10 (DRAWCIRCLE (RAND 0 W) (RAND 0 H) (RABD 16 32) NIL NIL DSP)))
(BItBLT BITMAP 0 0 WIN)
(BLOCK 250)
until (SHIFTDOWNP 'SHIFT))

[nbriggs]

Overlapping @masinter's suggestion -- I had rewritten it as

(LAMBDA (WINDOW NUM-BOIDS)
                                                             (* ; "Edited 20-May-2026 09:47 by nhb")
       (PROG* ((WINDOW (OR WINDOW (CREATEW)))
               (W (WINDOWPROP WINDOW 'WIDTH))
               (H (WINDOWPROP WINDOW 'HEIGHT))
               (NUM-BOIDS (OR NUM-BOIDS 10)))
              (until (SHIFTDOWNP 'SHIFT)
                     do
                     (BLOCK 10)
                     (DSPRESET WINDOW)
                     (FRPTQ NUM-BOIDS (LET ((X (RAND 0 W))
                                            (Y (RAND 0 H))
                                            (RAD (RAND 16 32)))
                                           (DRAWCIRCLE X Y RAD NIL NIL WINDOW)))
                     finally
                     (CLOSEW WINDOW))))

[RyanBurnside]

Edited:

@pamoroso thanks!

@masinter Ah, sorry for the confusion. This was not a finished demo, I wanted to make sure I had something that was properly updating on it's own without callbacks to start with. The circles were just a placeholder so I could see the updates for now. Yes, for the rest though I will want some kind of buffered display (I recall @hjellinek mentioning that rendering to an off screen bitmap then blitting that back reduces tearing and lag). Thanks for the catch on the inconsistent window usage. There was a bug.

@nbriggs Thanks for the fix. I need to un CL:LOOP my brain a bit. I've been using FOR a bit too much. CL's LOOP always starts with the same identifier (LOOP) and then the clauses come, so I thought (wrongly) that FOR was the mandatory identifier for Interlisp's "Iterative Statement" but I see the first clause is more flexible than a keyword that starts every loop. Implementing it in such a freeform way without a common identifier must have been some interesting Macro-ology.

[RyanBurnside]

I settled for some "snow" effects being far less intricate to make a demo for a newcomer.
I wanted to have a "small" demo function without much abstraction, implementing Boids with records would mean more verbosity and an additional resource.

I thought simple arrays might be OK, but the SETA/ELT combo proved for more verbosity.
I could provide some accessors functions, that makes things clearer but also drives up the line count for a single function demo...

The code below is too hackish.
I need more abstraction and will tinker more ... maybe making a Snowflake record removes a lot of verbosity and makes it cleaner ... yeah.

(It should run fine, but Github it butchering indentation...)

(LAMBDA (NUM-FLAKES)
       
       (* ;; "Provides a nice self updating snow simulator %"flakes%" are [x y radius]")

       (PROG* ((WIN (CREATEW))
               (NUM-FLAKES (OR NUM-FLAKES 100))
               (W (WINDOWPROP WIN 'WIDTH))
               (H (WINDOWPROP WIN 'HEIGHT))
               (BITMAP (BITMAPCREATE W H))
               (DSP (DSPCREATE BITMAP))
               (FLAKES (for to NUM-FLAKES collect (LET ((TEMP (ARRAY 3 'FLOATP 0 0)))
                                                       (SETA TEMP 0 (RAND 0 W))
                                                       (SETA TEMP 1 (RAND 0 H))
                                                       (SETA TEMP 2 (RAND 1 3))
                                                       TEMP))))
              
              (* ;; "Run demo until user presses shift ")

              (until (SHIFTDOWNP 'SHIFT)
                     do
                     (BLOCK 10)
                     (DSPRESET DSP)
                     
                     (* ;; "Update flakes keeping them onscreen")

                     (for F in FLAKES do (SETA F 0 (+ (ELT F 0)
                                                      (- (RAND 0 2)
                                                         1)))
                          (SETA F 1 (- (ELT F 1)
                                       (RAND 1 3)))
                          
                          (* ;; "Wrap around width")

                          (if (< (ELT F 0)
                                 0)
                              then
                              (SETA F 0 W)
                              elseif
                              (> (ELT F 0)
                                 W)
                              then
                              (SETA F 0 0))
                          
                          (* ;; " Wrap around height")

                          (if (< (ELT F 1)
                                 0)
                              then
                              (SETA F 1 H))
                          
                          (* ;; "Render to buffer")

                          (DRAWCIRCLE (ELT F 0)
                                 (ELT F 1)
                                 (ELT F 2)
                                 NIL NIL DSP))
                     
                     (* ;; "Blit buffer to screen")

                     (BITBLT BITMAP 0 0 WIN)
                     finally
                     (CLOSEW WIN))))

[MattHeffron]

When I read this discussion I was trying to figure out what "Boids" was.
Before I googled it, I saw this Hannah Fry video.
Perfect timing!

[RyanBurnside]

When I read this discussion I was trying to figure out what "Boids" was. Before I googled it, I saw this Hannah Fry video. Perfect timing!

I've enjoyed her content for a long time.

I think it's really cool that the original source is in Lisp. (What other language would you want to be doing exploratory thinking in!)

https://www.red3d.com/cwr/boids/

[RyanBurnside]

I think adding the record was the right move.
This is mostly complete now I think.
Trying to balance it to be short enough but also show something useful.
Maybe I'll attach the process as suggested. But you can load and try the code below.
Seems it can do 1000 snowflakes without choking on my computer. :)

I'll probably implement "Boids" at some point (separate project) but I need to fix a certain trig function that's currently wrong in Medley and then write a traditional 3D geometry vector library...

Critique and criticism welcome if you see something wrong in my implementation.
See attached code below.

SNOW.zip

[nbriggs]

Nothing wrong with the implementation.

You could use (RAND -1 1) directly rather than (- (RAND 0 2) 1) and likewise add (RAND -3 -1) to the Y value. I think you'll get the effect you want for wrapping with IMOD. Something like

(with FLAKE F 
      (* ;; "move and wrap coordinates")
      (SETQ X (IMOD (+ X (RAND -1 1)) W))
      (SETQ Y (IMOD (+ Y (RAND -3 -1)) H))
      (* ;; "Render to buffer")
      (DRAWCIRCLE X Y R NIL NIL DSP))

You could give it a little east-wind bias with (RAND -1 2) for the X ;-)

[RyanBurnside]

Thanks @nbriggs .
I was looking for something like modulus but didn't think to look in the integer specific part of the IRM. Works like a charm.

I think the code is now sufficiently (looks through New Hacker's Dictionary) bummed and tense for the newcomer.

So it's now hosted here.

I had a few cool ideas like your wind option but wanted to keep it short (I got comment heavy).
I may look into Medley's "generators" to see if I can implement a continuous random noise function which is the basis for a lot of procedurally generated effects. In this case that kind of continuous function could be used for flake rotation as well as varying wind speed. There are some exceptionally cool demos towards the bottom of that page ...

[masinter]

you can compile as-you-go by

• exit SEdit sessions with control-C rather than control-X.
• use cl:compile-file by setting the IL:FILETYPE property of ROOTFILENAME of your file to CL:COMPILE-FILE
• use (CLEANUP) rather than (MAKEFILES)

If you want to assert "bummed" then compiling is the very first thing to do.

[pamoroso]

As discussed in the May 27, 2026 external meeting I'll convert this issue to a discussion.