When I tried this F# Interactive, no problem. When I tried this F# Compile, I get an errors:

Error 1 Type mismatch. Expecting a Device -> 'a -> (Device -> scene -> unit) -> 'b but given a Device -> unit. The type ''a -> (Device -> scene -> unit) -> 'b' does not match the type 'unit'.

Error 2 The value or constructor 'scene' is not defined.

Error 3 The value or constructor 'device' is not defined.

#light

open System

open System.Drawing

open System.Windows.Forms

open Microsoft.DirectX

open Microsoft.DirectX.Direct3D

let presentParams() =

let p = new PresentParameters()

p.Windowed <- true

p.SwapEffect <- SwapEffect.Discard

p.EnableAutoDepthStencil <- true

p.AutoDepthStencilFormat <- DepthFormat.D24S8

[| p |]

let makeDevice (form : #Form) =

let dtype = DeviceType.Hardware

let flags = CreateFlags.SoftwareVertexProcessing

new Device(0, dtype, form, flags, presentParams())

type Viewer() = class

inherit Form()

override form.OnPaintBackground _ = ()

end

let paint (form : #Form) render (device : Device) _ =

try

device.TestCooperativeLevel()

device.BeginScene()

render device

device.EndScene()

device.Present()

form.Invalidate()

with

| :? DeviceLostException -> ()

| :? DeviceNotResetException -> device.Reset(presentParams())

let makeViewer title render =

let form = new Viewer(StartPosition=FormStartPosition.CenterScreen,

Text=title, Visible=true)

form.MinimumSize <- form.Size

let device = makeDevice form

form.Paint.Add(paint form render device)

form.Resize.Add(fun _ -> form.Invalidate())

form.KeyDown.Add(fun e -> if e.KeyCode = Keys.Escape then form.Close())

form.Invalidate()

form

let render (device: Device) =

let target = ClearFlags.Target

device.Clear(target, Color.Coral, 1.0f, 0)

//let form = makeViewer "Blank" render

let allBuffers =

ClearFlags.Target ||| ClearFlags.ZBuffer ||| ClearFlags.Stencil

let vec(x, y, z) =

let f = Float32.of_float

new Vector3(f x, f y, f z)

type Vertex = CustomVertex.PositionNormalColored

let vertex (c : Color) (nx, ny, nz) (x, y, z) =

let c = c.ToArgb()

let f = Float32.of_float

new Vertex(f x, f y, f z, f nx, f ny, f nz, c)

let vertex2 color (x, y) =

vertex color (0.0, 0.0, -1.0) (x, y, 0.0)

let show2D render (device : Device) =

let near, far = -1.0f, 1.0f

let vp = device.Viewport

let w, h = float32 vp.Width, float32 vp.Height

device.Transform.Projection <- Matrix.OrthoLH(w, h, near, far)

device.Clear(allBuffers, Color.White, far, 0)

device.RenderState.Lighting <- false

device.RenderState.CullMode <- Cull.None

device.RenderState.ZBufferEnable <- false

render device

let drawTriangles (device : Device) (vertex : Vertex array) =

if vertex <> [||] then

device.VertexFormat <- Vertex.Format

let prim = PrimitiveType.TriangleList

let n = Array.length vertex / 3

device.DrawUserPrimitives(prim, n, vertex)

//let form =

// let render device =

// [| -100.0, -100.0; 0.0, 100.0; 100.0, -100.0; |]

// |> Array.map (vertex2 Color.BurlyWood)

// |> drawTriangles device

// show2D render

// |> makeViewer "Triangle"

let aspect (device : Device) =

let vp = device.Viewport

float32 vp.Width / float32 vp.Height

type perspective =

{ fov : float32;

aspect : float32;

near : float32;

far : float32;

camera : Vector3;

target : Vector3;

up : Vector3 }

let perspectiveDefault =

{ fov = 0.8f;

aspect = 0.0f;

near = 0.01f;

far = 100.0f;

camera = vec(-1.0, 2.0, -4.0);

target = vec(0.0, 0.0, 0.0);

up = vec(0.0, 1.0, 0.0) }

let perspective p (t : Transforms) =

t.Projection <- Matrix.PerspectiveFovLH(p.fov, p.aspect, p.near, p.far)

t.View <- Matrix.LookAtLH(p.camera, p.target, p.up)

let show3D render (device : Device) =

let p = { perspectiveDefault with aspect = aspect device }

perspective p device.Transform

device.Clear(allBuffers, Color.White, p.far, 0)

device.Lights.[0].Direction <- vec(1.0, -1.0, 2.0)

device.Lights.[0].Enabled <- true

render device

let vertices =

let r, y = sin(Math.PI / 3.0), cos(Math.PI / 3.0)

let f g x = r * g(float x * Math.PI / 5.0)

let aux n y i = vec(f sin (2 * i + n), y, f cos (2 * i + n))

Array.concat

[ [| vec(0.0, 1.0, 0.0) |]

Array.init 5 (aux 0 y)

Array.init 5 (aux 0 (-y))

[| vec(0.0, -1.0, 0.0) |] ]

let faces =

let r1 i = 1 + (1 + i) % 5

let r2 i = 6 + (1 + i) % 5

[ for i in 0 .. 4 -> 0, r1 i, r1(i + 1) ] @

[ for i in 0 .. 4 -> r1(i + 1), r1 i, r2 i ] @

[ for i in 0 .. 4 -> r1(i + 1), r2 i, r2(i + 1) ] @

[ for i in 0 .. 4 -> r2(i + 1), r2 i, 11 ]

let triOfFace (c: Color) (v: Vector3 array) (i, j, k) =

let i, j, k = v.[i], v.[j], v.[k]

let n = Vector3.Normalize(i + j + k)

let v r = new Vertex(r, n, c.ToArgb())

[| v i; v j; v k |]

let triangles =

faces |> List.map (triOfFace Color.BurlyWood vertices)

|> Array.concat

let timer = new System.Diagnostics.Stopwatch()

timer.Start()

let renderIcosahedron (device : Device) =

let t = float32 timer.ElapsedMilliseconds / 1e3f

device.Transform.World <- Matrix.RotationY t

drawTriangles device triangles

//let form =

// show3D renderIcosahedron

// |> makeViewer "Icosahedron"

type scene =

| Triangles of (Vector3 * Vector3 * Vector3) list

| Color of Color * scene

| Transform of Matrix * scene

| Group of scene list

let Triangles = [ vec(-1.0, -1.0, 0.0),

vec(0.0, 1.0, -1.0),

vec(1.0, -1.0, 0.0) ]

let triangle (c : Color) (p0: Vector3, p1: Vector3, p2: Vector3) =

let p01 = p1 - p0

let p02 = p2 - p0

let n = Vector3.Normalize(Vector3.Cross(p01, p02))

Array.map (vertex c (float n.X, float n.Y, float n.Z))

( [| float p0.X, float p0.Y, float p0.Z;

float p01.X, float p01.Y, float p01.Z;

float p02.X, float p02.Y, float p02.Z |] )

let transform (device : Device) color m k scene =

let world = device.Transform.World

device.Transform.World <- Matrix.Multiply(world, m)

try k device color scene finally

device.Transform.World <- world

let rec draw (device : Device) color = function

| Triangles tris ->

Array.concat (List.map (triangle color) tris)

|> drawTriangles device

| Color(color, scene) -> draw device color scene

| Transform(m, scene) -> transform device color m draw scene

| Group ts -> List.iter (draw device color) ts

let form = (fun device -> draw device Color.Black)

|> show3D render scene device // ERROR

|> makeViewer "F# Visualization"

[<STAThread>]

do Application.Run(form)