├── public
    ├── fable.ico
    └── index.html
├── package.json
├── Nuget.Config
├── src
    ├── App.fsproj
    ├── App.fs
    └── ThreeJsTypes.fs
├── README.md
├── webpack.config.js
├── LICENSE
└── .gitignore


/public/fable.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/w0lya/fable-three/HEAD/public/fable.ico


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "private": true,
 3 |   "dependencies": {
 4 |     "@babel/core": "^7.1.2",
 5 |     "fable-compiler": "^2.1.6",
 6 |     "fable-loader": "^2.1.0",
 7 |     "react": "^16.6.0",
 8 |     "react-dom": "^16.6.0",
 9 |     "three": "^0.99.0",
10 |     "webpack": "^4.25.1",
11 |     "webpack-cli": "^3.1.2",
12 |     "webpack-dev-server": "^3.1.10"
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/Nuget.Config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <configuration>
 3 |   <!-- This clears Nuget configuration in the machine to avoid conflicts -->
 4 |   <packageSources>
 5 |     <clear />
 6 |     <add key="NuGet.org" value="https://api.nuget.org/v3/index.json" />
 7 |   </packageSources>
 8 |   <disabledPackageSources>
 9 |      <clear />
10 |   </disabledPackageSources>
11 | </configuration>
12 | 


--------------------------------------------------------------------------------
/src/App.fsproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>netstandard2.0</TargetFramework>
 4 |   </PropertyGroup>
 5 |   <ItemGroup>
 6 |     <Compile Include="ThreeJsTypes.fs" />
 7 |     <Compile Include="App.fs" />
 8 |   </ItemGroup>
 9 |   <ItemGroup>
10 |     <PackageReference Include="Fable.Core" Version="2.0.1" />
11 |     <PackageReference Include="Fable.Elmish.React" Version="2.0.0" />
12 |   </ItemGroup>
13 | </Project>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Three.js sample project based on Fable 2 Minimal App
 2 | 
 3 | ## Requirements
 4 | 
 5 | * [dotnet SDK](https://www.microsoft.com/net/download/core) 2.1 or higher
 6 | * [node.js](https://nodejs.org) with [npm](https://www.npmjs.com/)
 7 | 
 8 | ## Building and running the app
 9 | 
10 | * Install JS dependencies: `npm install`
11 | * Start Webpack dev server: `npx webpack-dev-server`
12 | * After the first compilation is finished, in your browser open: http://localhost:8080/
13 | 
14 | Any modification you do to the F# code will be reflected in the web page after saving.
15 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
 1 | // Note this only includes basic configuration for development mode.
 2 | // For a more comprehensive configuration check:
 3 | // https://github.com/fable-compiler/webpack-config-template
 4 | 
 5 | var path = require("path");
 6 | 
 7 | module.exports = {
 8 |     mode: "development",
 9 |     entry: "./src/App.fsproj",
10 |     output: {
11 |         path: path.join(__dirname, "./public"),
12 |         filename: "bundle.js",
13 |     },
14 |     devServer: {
15 |         contentBase: "./public",
16 |         port: 8080,
17 |     },
18 |     module: {
19 |         rules: [{
20 |             test: /\.fs(x|proj)?$/,
21 |             use: "fable-loader"
22 |         }]
23 |     }
24 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Volha Samusik
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | bin/
 2 | obj/
 3 | 
 4 | # Logs
 5 | logs
 6 | *.log
 7 | npm-debug.log*
 8 | yarn-debug.log*
 9 | yarn-error.log*
10 | 
11 | # Runtime data
12 | pids
13 | *.pid
14 | *.seed
15 | *.pid.lock
16 | 
17 | # Directory for instrumented libs generated by jscoverage/JSCover
18 | lib-cov
19 | 
20 | # Coverage directory used by tools like istanbul
21 | coverage
22 | 
23 | # nyc test coverage
24 | .nyc_output
25 | 
26 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
27 | .grunt
28 | 
29 | # Bower dependency directory (https://bower.io/)
30 | bower_components
31 | 
32 | # node-waf configuration
33 | .lock-wscript
34 | 
35 | # Compiled binary addons (https://nodejs.org/api/addons.html)
36 | build/Release
37 | 
38 | # Dependency directories
39 | node_modules/
40 | jspm_packages/
41 | 
42 | # TypeScript v1 declaration files
43 | typings/
44 | 
45 | # Optional npm cache directory
46 | .npm
47 | 
48 | # Optional eslint cache
49 | .eslintcache
50 | 
51 | # Optional REPL history
52 | .node_repl_history
53 | 
54 | # Output of 'npm pack'
55 | *.tgz
56 | 
57 | # Yarn Integrity file
58 | .yarn-integrity
59 | 
60 | # dotenv environment variables file
61 | .env
62 | 
63 | # next.js build output
64 | .next
65 | 


--------------------------------------------------------------------------------
/src/App.fs:
--------------------------------------------------------------------------------
  1 | module App
  2 | 
  3 | open System.Collections.Generic
  4 | open Fable.Core
  5 | open Fable.Import
  6 | open Fable.Import.Browser
  7 | open ThreeJs.ThreeJsTypes
  8 | 
  9 | // There's a bug in Fable that doesn't allow global values that are both mutable
 10 | // and public, we can solve it by making them private (latest version throws error):
 11 | // let [<Global>] mutable private globalCamera: ArrayCamera = jsNative
 12 | 
 13 | // However, in this case we do want to declare the variables ourselves
 14 | // so we can just do it in F# and initialize them to null
 15 | let mutable globalCamera: ArrayCamera = null
 16 | let mutable globalScene: Scene = null
 17 | let mutable globalRenderer: WebGLRenderer = null
 18 | let mutable globalMesh: Mesh = null
 19 | 
 20 | let onWindowResize(e:Browser.UIEvent) =
 21 |    globalCamera.aspect <- window.innerWidth / window.innerHeight
 22 |    globalCamera.updateProjectionMatrix()
 23 |    globalRenderer.setSize( window.innerWidth, window.innerHeight)
 24 | 
 25 | let init() =
 26 | 
 27 |   let amount = 5.
 28 |   let size = 1. / amount
 29 |   let aspectRatio = window.innerWidth / window.innerHeight
 30 |   let cameras = new List<PerspectiveCamera>()
 31 | 
 32 |   for y = 0 to (int)amount do
 33 |     for x = 0 to (int)amount do
 34 | 
 35 |       let subcamera = Globals.PerspectiveCamera.Create( 40, aspectRatio, 0.1, 10 )
 36 | 
 37 |       subcamera.bounds <- Globals.Vector4.Create( (float)x / amount, (float)y / amount, size, size )
 38 | 
 39 |       subcamera.position.x <- ( (float)x / amount ) - 0.5
 40 |       subcamera.position.y <- 0.5 - ( (float)y / amount )
 41 |       subcamera.position.z <- 1.5
 42 |       subcamera.position.multiplyScalar( 2.) |> ignore
 43 |       subcamera.lookAt( 0., 0., 0. )
 44 |       subcamera.updateMatrixWorld()
 45 | 
 46 |       cameras.Add(subcamera)
 47 | 
 48 |   // Camera at a higher level (ArrayCamera)
 49 |   let camera = Globals.ArrayCamera.Create(cameras)
 50 | 
 51 |   camera.position.z <- 3.
 52 | 
 53 |   globalCamera <- camera
 54 | 
 55 |   let scene = Globals.Scene.Create()
 56 |   let ambientLight = Globals.AmbientLight.Create(Globals.Color.Create(0xFF8080))
 57 | 
 58 |   scene.add(ambientLight) |> ignore
 59 | 
 60 |   let dirLight = Globals.DirectionalLight.Create()
 61 |   dirLight.position.set( 0.5, 0.5, 1. ) |> ignore
 62 |   dirLight.castShadow <- true
 63 |   dirLight.shadow.camera.zoom <- 4.
 64 |   scene.add( dirLight ) |> ignore
 65 | 
 66 |   let geometry = Globals.PlaneBufferGeometry.Create(100,100)
 67 |   let material = Globals.MeshPhongMaterial.Create(color=Globals.Color.Create(0x006600))
 68 |   let background = Globals.Mesh.Create(geometry, material)
 69 |   background.receiveShadow <- true
 70 |   background.position.set( 0., 0., -1. ) |> ignore
 71 |   scene.add( background ) |> ignore
 72 | 
 73 |   let cbGeometry = Globals.CylinderBufferGeometry.Create(0.5, 0., 1, 45)
 74 |   cbGeometry.parameters.radiusTop <- 0.5
 75 |   let cbMaterial = Globals.MeshPhongMaterial.Create(color=Globals.Color.Create(0xFFAA00))
 76 |   let mesh = Globals.Mesh.Create(cbGeometry, cbMaterial)
 77 | 
 78 |   mesh.castShadow <- true
 79 |   mesh.receiveShadow <- true
 80 |   scene.add(mesh) |> ignore
 81 | 
 82 |   globalScene <- scene
 83 |   globalMesh <- mesh
 84 | 
 85 |   let renderer = Globals.WebGLRenderer.Create()
 86 |   renderer.setPixelRatio( window.devicePixelRatio )
 87 |   renderer.setSize( window.innerWidth, window.innerHeight )
 88 |   renderer.shadowMap.enabled <- true
 89 |   document.body.appendChild( renderer.domElement ) |> ignore
 90 | 
 91 |   globalRenderer <- renderer
 92 | 
 93 |   Browser.window.addEventListener_resize(onWindowResize, false )
 94 | 
 95 | 
 96 | let rec animate _: unit =
 97 |    globalMesh.rotation.x <- globalMesh.rotation.x + 0.005
 98 |    globalMesh.rotation.z <-  globalMesh.rotation.z + 0.01
 99 |    globalRenderer.render( globalScene, globalCamera )
100 | 
101 |    Browser.window.requestAnimationFrame(animate) |> ignore
102 | 
103 | init()
104 | 
105 | animate 0.
106 | 


--------------------------------------------------------------------------------
/public/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 | <head>
  4 |   <title>three.js webgl - arraycamera</title>
  5 |   <meta http-equiv='Content-Type' content='text/html; charset=utf-8'>
  6 |   <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
  7 |   <link rel="shortcut icon" href="fable.ico" />
  8 |   <style>
  9 |     body {
 10 |       margin: 0px;
 11 |       background-color: #000000;
 12 |       overflow: hidden;
 13 |     }
 14 |   </style>
 15 | </head>
 16 | <body>
 17 |     <!-- <div id="elmish-app" class="elmish-app">   
 18 | 
 19 | 
 20 |     </div> -->
 21 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/99/three.js"></script> <!---cdn-->
 22 |      <script src="bundle.js"></script>   
 23 |     
 24 | <!-- <script>
 25 |  
 26 | var camera, scene, renderer, mesh;
 27 | 
 28 | function onWindowResize(e) {
 29 |   camera.aspect = window.innerWidth / window.innerHeight;
 30 |   camera.updateProjectionMatrix();
 31 |   renderer.setSize(window.innerWidth, window.innerHeight);
 32 |   return null;
 33 | }
 34 | function init() {
 35 | 
 36 |    camera = new THREE.ArrayCamera();
 37 |    scene = new THREE.Scene();
 38 |    renderer = new THREE.WebGLRenderer();
 39 |    //mesh = new THREE.Mesh();
 40 | 
 41 |   const amount = 7;
 42 |   const size = 1 / amount;
 43 |   const aspectRatio = window.innerWidth / window.innerHeight;
 44 |   const cameras = [];
 45 | 
 46 |   for (let y = 1; y <= ~~amount; y++) {
 47 |     for (let x = 1; x <= ~~amount; x++) {
 48 |       // var subcamera = new THREE.PerspectiveCamera();
 49 |       // subcamera.fov = 40;
 50 |       // subcamera.aspect = aspectRatio;
 51 |       // subcamera.near = 0.1;
 52 |       // subcamera.far = 10;
 53 |       const subcamera = new THREE.PerspectiveCamera( 40, aspectRatio, 0.1, 10 );
 54 |       // var boundsVector = new THREE.Vector4();
 55 |       // boundsVector.x = x / amount;
 56 |       // boundsVector.y = y / amount;
 57 |       // boundsVector.x = size;
 58 |       // boundsVector.w = size;
 59 |       // subcamera.bounds = boundsVector;
 60 |       subcamera.bounds = new THREE.Vector4( x / amount, y / amount, size, size );
 61 | 
 62 | 
 63 |       subcamera.position.x = x / amount - 0.5;
 64 |       subcamera.position.y = 0.5 - y / amount;
 65 |       subcamera.position.z = 1.5;
 66 |       subcamera.position.multiplyScalar(2);
 67 |       subcamera.lookAt( 0, 0, 0 );
 68 |       // const lookAVector = new THREE.Vector3();
 69 |       // lookAVector.x = 0;
 70 |       // lookAVector.y = 0;
 71 |       // lookAVector.z = 0;
 72 |       // subcamera.lookAt(lookAVector);
 73 |       subcamera.updateMatrixWorld();
 74 |       cameras.push(subcamera);
 75 |      
 76 |     }
 77 |   }
 78 | 
 79 |   camera.cameras = cameras;
 80 |   camera.position.z = 3;
 81 |   
 82 |   scene.add( new THREE.AmbientLight( 0x222266 ));
 83 |   // const ambientLight = new THREE.AmbientLight();
 84 |   // const lightColor = new THREE.Color();
 85 |   // lightColor.r = 0.133;
 86 |   // lightColor.g = 0.133;
 87 |   // lightColor.b = 0.4;
 88 |   // ambientLight.color = lightColor;
 89 |   // scene.add(ambientLight);
 90 |   const dirLight = new THREE.DirectionalLight();
 91 |   dirLight.position.set(0.5, 0.5, 1);
 92 |   dirLight.castShadow = true;
 93 |   dirLight.shadow.camera.zoom = 4;
 94 |   scene.add(dirLight);
 95 |   
 96 | 
 97 |   const geometry = new THREE.PlaneBufferGeometry( 100, 100 );
 98 |   const material = new THREE.MeshPhongMaterial( { color: 0x000066 } );
 99 |   const background = new THREE.Mesh( geometry, material );
100 |   // const geometry = new THREE.PlaneBufferGeometry();
101 |   // geometry.parameters.width = 100;
102 |   // geometry.parameters.height = 100;
103 |   
104 |   // const material = new THREE.MeshPhongMaterial();
105 |   // const pbColor = new THREE.Color();
106 |   // pbColor.r = 0;
107 |   // pbColor.g = 0;
108 |   // pbColor.b = 0.4;
109 |   // material.color = pbColor;
110 |   // const background = new THREE.Mesh();
111 |   // background.geometry = geometry;
112 |   // background.material = material;
113 |   background.receiveShadow = true;
114 |   background.position.set(0, 0, -1);
115 |   scene.add(background);
116 |   
117 |   const cbGeometry = new THREE.CylinderBufferGeometry( 0.5, 0.5, 1, 32 );
118 |   const cbMaterial = new THREE.MeshPhongMaterial( { color: 0xff0000 } );
119 |   mesh = new THREE.Mesh( cbGeometry, cbMaterial );
120 | 
121 |   // const cbGeometry = new THREE.CylinderBufferGeometry();
122 |   // cbGeometry.parameters.radiusTop = 0.5;
123 |   // cbGeometry.parameters.radiusBottom = 0.5;
124 |   // cbGeometry.parameters.height = 1;
125 |   // cbGeometry.parameters.radialSegments = 32;
126 |   // const cbMaterial = new THREE.MeshPhongMaterial();
127 |   // const cbColor = new THREE.Color();
128 |   // cbColor.r = 1;
129 |   // cbColor.g = 0;
130 |   // cbColor.b = 0;
131 |   // cbMaterial.color = cbColor;
132 |   // mesh.geometry = cbGeometry;
133 |   // mesh.material = cbMaterial;
134 |   mesh.castShadow = true;
135 |   mesh.receiveShadow = true;
136 |   scene.add(mesh);
137 | 
138 |   renderer.setPixelRatio(window.devicePixelRatio);
139 |   renderer.setSize(window.innerWidth, window.innerHeight);
140 |   renderer.shadowMap.enabled = true;
141 |   document.body.appendChild(renderer.domElement);
142 |   //renderer.render(scene, camera);
143 |   window.addEventListener("resize", onWindowResize, false);
144 | }
145 | function animate() {
146 |   mesh.rotation.x = mesh.rotation.x + 0.005;
147 |   mesh.rotation.z = mesh.rotation.z + 0.01;
148 |   renderer.render(scene, camera);
149 |   requestAnimationFrame(animate);
150 | }
151 | init();
152 | animate();
153 | 
154 | </script>  -->
155 | 
156 |       
157 |            <!-- <script>
158 |             var camera, scene, renderer;
159 |             var mesh;
160 |             init();
161 |             animate();
162 |             function init() {
163 |               var AMOUNT = 7;
164 |               var SIZE = 1 / AMOUNT;
165 |               var ASPECT_RATIO = window.innerWidth / window.innerHeight;
166 |               var cameras = [];
167 |               for ( var y = 0; y < AMOUNT; y ++ ) {
168 |                 for ( var x = 0; x < AMOUNT; x ++ ) {
169 |                   var subcamera = new THREE.PerspectiveCamera( 40, ASPECT_RATIO, 0.1, 10 );
170 |                   subcamera.bounds = new THREE.Vector4( x / AMOUNT, y / AMOUNT, SIZE, SIZE );
171 |                   subcamera.position.x = ( x / AMOUNT ) - 0.5;
172 |                   subcamera.position.y = 0.5 - ( y / AMOUNT );
173 |                   subcamera.position.z = 1.5;
174 |                   subcamera.position.multiplyScalar( 2 );
175 |                   subcamera.lookAt( 0, 0, 0 );
176 |                   subcamera.updateMatrixWorld();
177 |                   cameras.push( subcamera );
178 |                 }
179 |               }
180 |               camera = new THREE.ArrayCamera( cameras );
181 |               camera.position.z = 3;
182 |               
183 |               scene = new THREE.Scene();
184 |               scene.add( new THREE.AmbientLight( 0x222266 ) );
185 |               
186 |               var light = new THREE.DirectionalLight();
187 |               light.position.set( 0.5, 0.5, 1 );
188 |               light.castShadow = true;
189 |               light.shadow.camera.zoom = 4; // tighter shadow map
190 |               scene.add( light );
191 |               
192 |               var geometry = new THREE.PlaneBufferGeometry( 100, 100 );
193 |               var material = new THREE.MeshPhongMaterial( { color: "0x000066" } );
194 |               var background = new THREE.Mesh( geometry, material );
195 |               background.receiveShadow = true;
196 |               background.position.set( 0, 0, - 1 );
197 |               scene.add( background );
198 |               
199 |               var geometry = new THREE.CylinderBufferGeometry( 0.5, 0.5, 1, 32 );
200 |               var material = new THREE.MeshPhongMaterial( { color: 0xff0000 } );
201 |               mesh = new THREE.Mesh( geometry, material );
202 |               mesh.castShadow = true;
203 |               mesh.receiveShadow = true;
204 |               scene.add( mesh );
205 |               
206 |               renderer = new THREE.WebGLRenderer();
207 |               renderer.setPixelRatio( window.devicePixelRatio );
208 |               renderer.setSize( window.innerWidth, window.innerHeight );
209 |               renderer.shadowMap.enabled = true;
210 |               document.body.appendChild( renderer.domElement );
211 |               //
212 |               window.addEventListener( 'resize', onWindowResize, false );
213 |             }
214 |             function onWindowResize() {
215 |               camera.aspect = window.innerWidth / window.innerHeight;
216 |               camera.updateProjectionMatrix();
217 |               renderer.setSize( window.innerWidth, window.innerHeight);
218 |             }
219 |             function animate() {
220 |               mesh.rotation.x += 0.005;
221 |               mesh.rotation.z += 0.01;
222 |               renderer.render( scene, camera );
223 |               requestAnimationFrame( animate );
224 |             }
225 |           </script>  -->
226 | </body>
227 | </html>


--------------------------------------------------------------------------------
/src/ThreeJsTypes.fs:
--------------------------------------------------------------------------------
  1 | namespace ThreeJs
  2 | 
  3 | module ThreeJsTypes =
  4 | 
  5 |     
  6 |     open Fable.Core
  7 |     open Fable.Import.Browser   
  8 |        
  9 |         type [<AllowNullLiteral>] Matrix4 =
 10 |             interface end      
 11 | 
 12 |         type [<AllowNullLiteral>] Euler =
 13 |             abstract x : float with get,set                
 14 |             abstract y : float with get, set
 15 |             abstract z  : float with get, set
 16 | 
 17 |         type [<AllowNullLiteral>] Vector3 = 
 18 |             abstract x : float with get,set                
 19 |             abstract y : float with get, set
 20 |             abstract z  : float with get, set 
 21 |             // Sets value of this vector.
 22 |             abstract set: x: float * y: float * z: float -> Vector3
 23 |            /// Multiplies this vector by scalar s.
 24 |             abstract multiplyScalar: s: float -> Vector3
 25 |         and [<AllowNullLiteral>] Vector3Type =
 26 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: unit -> Vector3       
 27 | 
 28 | 
 29 |        type [<AllowNullLiteral>] Vector4 =
 30 |             abstract x : float with get,set                
 31 |             abstract y : float with get, set
 32 |             abstract z  : float with get, set  
 33 |             abstract w  : float with get, set 
 34 |        and [<AllowNullLiteral>] Vector4Type =
 35 |                 [<Emit("new THREE.$0($1...)")>] abstract Create:  ?p1:obj * ?p2:obj * ?p3:obj * ?p4:obj -> Vector4       
 36 | 
 37 | 
 38 |        type [<AllowNullLiteral>] Color =
 39 |              /// Red channel value between 0 and 1. Default is 1.
 40 |             abstract r: float with get, set
 41 |             /// Green channel value between 0 and 1. Default is 1.
 42 |             abstract g: float with get, set
 43 |             /// Blue channel value between 0 and 1. Default is 1.
 44 |             abstract b: float with get, set
 45 |             abstract setHex: hex: float -> Color
 46 |             abstract set: color: string -> Color
 47 |             abstract setRGB: r: float * g: float * b: float -> Color
 48 |        and [<AllowNullLiteral>] ColorType =
 49 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj -> Color       
 50 | 
 51 | 
 52 | 
 53 |        type [<AllowNullLiteral>] Object3D =
 54 |             abstract position: Vector3 with get, set        
 55 |             abstract add: param : obj -> obj //ResizeArray<Object3D> -> Object3D        
 56 |             abstract castShadow: bool with get, set
 57 |             abstract receiveShadow: bool with get, set
 58 |             abstract rotation: Euler with get, set   
 59 | 
 60 |        type [<AllowNullLiteral>] Camera = 
 61 |             inherit Object3D
 62 | 
 63 |        type [<AllowNullLiteral>] OrthographicCamera =
 64 |             inherit Camera
 65 |             abstract zoom: float with get, set
 66 | 
 67 |         
 68 |        type [<AllowNullLiteral>] PerspectiveCamera =                    
 69 |             inherit Camera
 70 |             
 71 |             /// Camera frustum vertical field of view, from bottom to top of view, in degrees.
 72 |             abstract fov: float with get, set
 73 |             
 74 |             /// Camera frustum aspect ratio, window width divided by window height.
 75 |             abstract aspect: float with get, set
 76 |             
 77 |             /// Camera frustum near plane.
 78 |             abstract near: float with get, set
 79 |             
 80 |             /// Camera frustum far plane.
 81 |             abstract far: float with get, set            
 82 |             abstract bounds : Vector4 with get, set // not found in TS
 83 |             abstract lookAt: p1:float * p2:float * p3:float -> unit
 84 |             abstract updateMatrixWorld: ?force: bool -> unit
 85 |             abstract updateProjectionMatrix: unit -> unit      
 86 | 
 87 |         and [<AllowNullLiteral>] PerspectiveCameraType =
 88 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj * ?p2:obj * ?p3:obj * ?p4:obj -> PerspectiveCamera       
 89 | 
 90 |         
 91 |         type [<AllowNullLiteral>] ArrayCamera =            
 92 |                 inherit PerspectiveCamera
 93 |                 abstract cameras: ResizeArray<PerspectiveCamera> with get, set
 94 |                 abstract isArrayCamera: obj with get, set
 95 |         
 96 |         and [<AllowNullLiteral>] ArrayCameraType =
 97 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj -> ArrayCamera
 98 | 
 99 | 
100 |         type [<AllowNullLiteral>] Scene =
101 |             inherit Object3D  
102 |         and [<AllowNullLiteral>] SceneType =
103 |             [<Emit("new THREE.$0($1...)")>] abstract Create: unit -> Scene        
104 | 
105 |         type [<AllowNullLiteral>] LightShadow =
106 |             abstract camera: Camera with get, set        
107 | 
108 |         type [<AllowNullLiteral>] DirectionalLightShadow =
109 |             interface
110 |                 inherit LightShadow
111 |                 abstract camera: OrthographicCamera with get, set
112 |             end  
113 | 
114 |         type [<AllowNullLiteral>] Light  =
115 |             inherit Object3D      
116 |             abstract color: Color with get, set
117 | 
118 |         type [<AllowNullLiteral>] AmbientLight =            
119 |             inherit Light
120 |             abstract castShadow: bool with get, set
121 |          and [<AllowNullLiteral>] AmbientLightType =
122 |             [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj -> AmbientLight        
123 | 
124 | 
125 |         type [<AllowNullLiteral>] DirectionalLight =            
126 |             inherit Light
127 |             /// Target used for shadow camera orientation.
128 |             abstract target: Object3D with get, set
129 |             abstract shadow: DirectionalLightShadow with get, set
130 |          and [<AllowNullLiteral>] DirectionalLightType =
131 |             [<Emit("new THREE.$0($1...)")>] abstract Create: unit -> DirectionalLight        
132 | 
133 |            
134 | 
135 |         type [<AllowNullLiteral>] EventDispatcher = 
136 |             interface end        
137 | 
138 |         // Type to resolve parameters for Geometries.
139 |         type [<AllowNullLiteral>] GeometryParameters = 
140 |             abstract width : int with get, set
141 |             abstract height : int with get, set
142 |             abstract radiusTop : float with get, set
143 |             abstract radiusBottom : float with get, set
144 |             abstract radialSegments : int with get, set
145 | 
146 |         type [<AllowNullLiteral>] Geometry =
147 |             inherit EventDispatcher
148 | 
149 |         type [<AllowNullLiteral>] BufferGeometry =
150 |             inherit Geometry
151 |             
152 | 
153 |         type [<AllowNullLiteral>] CylinderBufferGeometry =
154 |             inherit BufferGeometry        
155 |             abstract parameters: GeometryParameters with get, set
156 |         and [<AllowNullLiteral>] CylinderBufferGeometryType =
157 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj * ?p2:obj * ?p3:obj * ?p4:obj -> CylinderBufferGeometry
158 | 
159 | 
160 | 
161 |         type [<AllowNullLiteral>] PlaneBufferGeometry =   
162 |             inherit BufferGeometry
163 |             abstract parameters: GeometryParameters with get, set
164 |         and [<AllowNullLiteral>] PlaneBufferGeometryType =
165 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj * ?p:obj -> PlaneBufferGeometry
166 |    
167 | 
168 |         type [<AllowNullLiteral>] Material =
169 |             inherit EventDispatcher
170 | 
171 |         type [<AllowNullLiteral>] MeshPhongMaterial =
172 |             inherit Material
173 |             abstract color: Color with get, set
174 |         and [<AllowNullLiteral>] MeshPhongMaterialType =
175 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1:obj -> MeshPhongMaterial
176 | 
177 | 
178 |         type [<AllowNullLiteral>] Mesh =
179 |            inherit Object3D
180 |            abstract geometry: obj with get, set 
181 |            abstract material: obj with get, set 
182 |          and [<AllowNullLiteral>] MeshType =
183 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: ?p1 :obj * ?p2:obj -> Mesh
184 | 
185 | 
186 |         type [<AllowNullLiteral>] Renderer =        
187 |             abstract domElement: HTMLCanvasElement with get, set
188 |             abstract render: scene: Scene * camera: Camera -> unit
189 |             abstract setSize: width: float * height: float * ?updateStyle: bool -> unit
190 |            
191 |         type [<AllowNullLiteral>] WebGLShadowMap =
192 |             abstract enabled: bool with get, set
193 | 
194 |         type [<AllowNullLiteral>] WebGLRenderer =            
195 |                 inherit Renderer
196 |                 abstract shadowMap: WebGLShadowMap with get, set
197 |                 abstract getPixelRatio: unit -> float
198 |                 abstract setPixelRatio: value: float -> unit
199 |         and [<AllowNullLiteral>] WebGLRendererType =
200 |                 [<Emit("new THREE.$0($1...)")>] abstract Create: unit -> WebGLRenderer
201 | 
202 |         type [<Erase>] Globals =
203 |             [<Global>] static member PerspectiveCamera with get(): PerspectiveCameraType = jsNative and set(v: PerspectiveCameraType): unit = jsNative
204 |             [<Global>] static member ArrayCamera with get(): ArrayCameraType = jsNative and set(v: ArrayCameraType): unit = jsNative
205 |             [<Global>] static member Scene with get(): SceneType = jsNative and set(v: SceneType): unit = jsNative
206 |             [<Global>] static member WebGLRenderer with get(): WebGLRendererType = jsNative and set(v: WebGLRendererType): unit = jsNative
207 |             [<Global>] static member Mesh with get(): MeshType = jsNative and set(v: MeshType): unit = jsNative
208 |             [<Global>] static member Vector4 with get(): Vector4Type = jsNative and set(v: Vector4Type): unit = jsNative
209 |             [<Global>] static member Vector3 with get(): Vector3Type = jsNative and set(v: Vector3Type): unit = jsNative
210 |             [<Global>] static member AmbientLight with get(): AmbientLightType = jsNative and set(v: AmbientLightType): unit = jsNative
211 |             [<Global>] static member Color with get(): ColorType = jsNative and set(v: ColorType): unit = jsNative
212 |             [<Global>] static member DirectionalLight with get(): DirectionalLightType = jsNative and set(v: DirectionalLightType): unit = jsNative
213 |             [<Global>] static member PlaneBufferGeometry with get(): PlaneBufferGeometryType = jsNative and set(v: PlaneBufferGeometryType): unit = jsNative
214 |             [<Global>] static member MeshPhongMaterial with get(): MeshPhongMaterialType = jsNative and set(v: MeshPhongMaterialType): unit = jsNative
215 |             [<Global>] static member CylinderBufferGeometry with get(): CylinderBufferGeometryType = jsNative and set(v: CylinderBufferGeometryType): unit = jsNative
216 | 
217 |     
218 |     
219 | 


--------------------------------------------------------------------------------