Funktionale Animation. Teil 2.

Bevor ich mit der Behavior-Monade aus Teil 1 fortfahre, brauche ich erstmal die Windows-Form, auf der die Animation stattfinden soll.

//Animation.fsx
module Demo.Animations
#load @"C:\Temp\Behavior.fsx"
open System
open System.Drawing
open System.Drawing.Imaging
open System.Windows.Forms
open Demo.Behavior

type AnimationForm() as x =
  inherit Form()
  let mutable startTime = DateTime.Now
  let anim = singelton //hier wird die Behavior-Animation zugewiesen.

  do
    x.SetStyle(ControlStyles.AllPaintingInWmPaint  ControlStyles.OptimizedDoubleBuffer, true)
    let tmr = new Timers.Timer(Interval = 25.0)
    tmr.Elapsed.Add(fun _ -> x.Invalidate() )
    tmr.Start()
 
  // Gets or sets the currently displayed animation
  member x.Animation
    with get() = anim
  override x.OnPaint(e) = 
      let wid, hgt = x.ClientSize.Width, x.ClientSize.Height
      e.Graphics.FillRectangle(Brushes.White, 0, 0, wid, hgt)
      e.Graphics.TranslateTransform(float32 wid/2.0f, float32 hgt/2.0f) 
      let elapsed = (DateTime.Now - startTime).TotalSeconds
      //Hier wird die Animation ausgeführt.
      let drawing = runBehavior anim {Time=float32 elapsed}
      drawing.Draw(e.Graphics) startTime).TotalSeconds

Zurück zur Behavior-Monade. Nun ist es möglich verschiedene Behavior-Funktionen zu definieren. Zuerst die wichtigste Zeitfunktion, die direkt über den Behavior-Typkonstruktor erstellt wird.

//Behavior.fsx
...
let behavior = new BehaviorBuilder()

let time = Behavior(fun context -> context.Time)

Spaßeshalber definiere ich die Funktion auch "monadisch".

let time = behavior{
    let! t = Behavior(fun context -> context.Time)
    return t}

und weitere Funktionen.

let wait (delay:float32) a = behavior{
    let! t = a
    return delay + t}

let faster (speed:float32) a = behavior{
    let! t = a
    return speed * t}

let wiggle b = behavior{
    let! t = b
    return sin (t * float32 Math.PI)}

let rotate= behavior{
  let! posx = wiggle time
  let! posy = time|>wait 0.5f|>wiggle
  return posx * 100.0f, posy * 100.0f}

Die Funktionen für die Animation.

module BehaviorDrawing  =
    open Demo.DrawingFunctions
    open System.Drawing
    let animation = 
        let moon  = circle Brushes.DimGray 20.0f 20.0f "moon"
        behavior{
            let! x,y = rotate
            return translate x y moon
            }
    let singelton=
        let one = behavior{
              let! a = animation
              return a
              }
        one

Zuletzt Main().

//main.fs
#load @"C:\Temp\Animation.fsx"
open Demo.Animations
open System
open System.Drawing
open System.Windows.Forms

let test =
    let af = new AnimationForm(ClientSize = Size(1000, 1000), Visible=true)
    af
let main() =
    test |> ignore
[]
    do main()

Hier der Beweis.

Alle Dateien zum Download:
Drawing.fs
Behavior.fsx
Animation.fsx
main.fs