M2 - Test on-line

MODULE RotatingCube

(*
** Wireframe representation of a rotating cube.
** We use the library "m3d" to do rotations and translations.
** The graphical screen is simulated with a matrix of characters.
*)

IMPORT m2, str, m3d

CONST
    perspective = TRUE
    (* Set to FALSE if you want a parallel projection *)

CONST
    WIDTH = 40  # screen width
    HEIGHT = 20  # screen height

VAR

(* Current position of the drawing pen: *)
    curr_h, curr_v: INTEGER

(* "Color" of the pen: *)
    curr_color: STRING

(* Screen buffer: *)
    S: ARRAY OF ARRAY OF STRING

FUNCTION ClearScreen()
VAR
    h,v: INTEGER
BEGIN
    curr_h = 0
    curr_v = 0
    curr_color = "*"
    FOR v=0 TO HEIGHT-1 DO
        FOR h=0 TO WIDTH-1 DO
            S[v][h] = " "
        END
    END
END

FUNCTION Pixel(h: INTEGER, v: INTEGER)
BEGIN
    IF (h < 0) OR (h >= WIDTH) OR (v < 0) OR (v >= HEIGHT) THEN
        RETURN
    END
    S[v][h] = curr_color
END

FUNCTION SetColor(color: STRING)
BEGIN
    IF length(color) <> 1 THEN
        RETURN
    END
    curr_color = color
END

FUNCTION MoveTo(h: INTEGER, v: INTEGER)
BEGIN
    curr_h = h
    curr_v = v
END

FUNCTION LineTo(h: INTEGER, v: INTEGER)
VAR
    x, y, dx, dy, xChange, yChange, err, i: INTEGER
BEGIN
    (* Bresenham algorithm. *)
    x = curr_h
    y = curr_v
    dx = h - x
    dy = v - y

IF dx < 0 THEN
        xChange = -1
        dx = -dx
    ELSE
        xChange = 1
    END
    IF dy < 0 THEN
        yChange = -1
        dy = -dy
    ELSE
        yChange = 1
    END

err = 0

IF dx < dy THEN
        FOR i=0 TO dy DO
            Pixel(x, y)
            y = y + yChange
            err = err + dx
            IF err >= dy THEN
                x = x + xChange
                err = err - dy
            END
        END
    ELSE
        FOR i=0 TO dx DO
            Pixel(x, y)
            x = x + xChange
            err = err + dy
            IF err >= dx THEN
                y = y + yChange
                err = err - dx
            END
        END
    END

curr_h = h
    curr_v = v
END

FUNCTION PrintScreen()
VAR h,v: INTEGER
BEGIN
    print("+" + repeat("-", WIDTH) + "+\n")
    FOR v=HEIGHT-1 TO 0 BY -1 DO
        print("|")
        FOR h=0 TO WIDTH-1 DO
            print( S[v][h] )
        END
        print("|\n")
    END
    print("+" + repeat("-", WIDTH) + "+\n")
END

FUNCTION Line3D(a: POINT, b: POINT)
CONST vScale = 0.5 (* square pixel correction *)
BEGIN
    (* FIXME: clip to the available screen *)
    MoveTo(WIDTH DIV 2 + rtoi(a[x]), HEIGHT DIV 2 + rtoi(vScale * a[y]))
    LineTo(WIDTH DIV 2 + rtoi(b[x]), HEIGHT DIV 2 + rtoi(vScale * b[y]))
END

FUNCTION Projection(p: POINT): POINT
CONST ez = 70.0  (* eye z position *)
VAR q: POINT
BEGIN
    (* FIXME: clip to the front plan *)
    IF perspective THEN
        (* project over the plan xy: *)
        q[x] = ez * p[x] / (ez - p[z])
        q[y] = ez * p[y] / (ez - p[z])
        q[z] = p[z]
        RETURN q
    ELSE
        (* parallel projection: *)
        RETURN p
    END
END

FUNCTION DrawCube(t: RT, l: REAL)
(*
    2*l = size of the cube
    t = roto-translation to be applied
*)
VAR p1, p2, p3, p4, p5, p6, p7, p8: POINT
BEGIN
    (* Cube vertex: *)
    p1 = {l, l, -l}
    p2 = {-l, l, -l}
    p3 = {-l, -l, -l}
    p4 = {l, -l, -l}
    p5 = {l, l, l}
    p6 = {-l, l, l}
    p7 = {-l, -l, l}
    p8 = {l, -l, l}
    (* Do the roto-translation: *)
    p1 = Projection( Transform(t, p1) )
    p2 = Projection( Transform(t, p2) )
    p3 = Projection( Transform(t, p3) )
    p4 = Projection( Transform(t, p4) )
    p5 = Projection( Transform(t, p5) )
    p6 = Projection( Transform(t, p6) )
    p7 = Projection( Transform(t, p7) )
    p8 = Projection( Transform(t, p8) )
    (* Draw over the xy plan: *)
    Line3D(p1, p2)
    Line3D(p2, p3)
    Line3D(p3, p4)
    Line3D(p4, p1)
    Line3D(p5, p6)
    Line3D(p6, p7)
    Line3D(p7, p8)
    Line3D(p8, p5)
    Line3D(p1, p5)
    Line3D(p2, p6)
    Line3D(p3, p7)
    Line3D(p4, p8)
END

CONST degree = 0.017453292 (* convertion factor from degrees to radiants *)

VAR
    t: RT
    i: INTEGER

BEGIN
    (* Initialize roto-translation: *)
    t = Unit()
    (* Draw 10 photograms: *)
    FOR i=1 TO 10 DO
        print("\nPhotogram no. " + i + ":\n")
        ClearScreen()
        SetColor("#")
        DrawCube(t, 12.0)
        PrintScreen()
        (* Rotate 5 degrees around the x axis: *)
        t = Product( Rotation_x(-5.0*degree), t )
        (* Rotate 10 degrees around the y axis: *)
        t = Product( Rotation_y(-10.0*degree), t )
    END
END

Limitations: you may use only these library modules:


buffer
date
digest
encode
encrypt
fixed
fmt
gcry_ac
gcry_cipher
gcry_common
gcry_md
gcry_mpi
iconv
img
m2
m2runtime
m3d
math
serialize
str
time

. See the report of the language for details about the correct syntax. See the examples gallery for more examples.