From befbcc5480f8f65e98b8f3f7a658d40639f16c7e Mon Sep 17 00:00:00 2001 From: Evert Prants Date: Tue, 26 Feb 2019 14:02:12 +0200 Subject: [PATCH] broken planet --- index.html | 2 +- package.json | 6 +- src/engine/camera.js | 4 +- src/engine/components/index.js | 68 +++++----- src/engine/components/planet/index.js | 124 ++++++++++++++++++ src/engine/components/terrain/experimental.js | 96 ++++++++++++++ src/engine/components/terrain/index.js | 6 +- src/engine/gui/index.js | 120 +++++++++++++++++ src/engine/gui/renderer.js | 0 src/engine/index.js | 2 + src/engine/mesh/index.js | 58 +++++--- src/engine/mesh/loader.js | 16 ++- src/engine/mesh/material.js | 2 +- src/engine/utility.js | 65 +++++++++ src/index.js | 14 +- 15 files changed, 514 insertions(+), 69 deletions(-) create mode 100644 src/engine/components/planet/index.js create mode 100644 src/engine/components/terrain/experimental.js create mode 100644 src/engine/gui/index.js create mode 100644 src/engine/gui/renderer.js create mode 100644 src/engine/utility.js diff --git a/index.html b/index.html index 15c7ac2..bafbd68 100644 --- a/index.html +++ b/index.html @@ -3,7 +3,7 @@ - Trotland + 3D Experiments diff --git a/package.json b/package.json index 42eaed1..6aebf3d 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { - "name": "trotland-game", + "name": "3dexperiments", "version": "0.0.1", - "description": "Trotland 3D MMORPG", + "description": "3D Experiments", "scripts": { "test": "echo \"Error: no test specified\" && exit 1", "serve": "node ./serve.js", @@ -9,7 +9,7 @@ "watch": "webpack -w --mode=development" }, "keywords": [ - "game", + "experiment", "webgl" ], "private": true, diff --git a/src/engine/camera.js b/src/engine/camera.js index 4895e0e..2d3e8e2 100644 --- a/src/engine/camera.js +++ b/src/engine/camera.js @@ -1,11 +1,11 @@ import { Node } from './components' import { glMatrix, mat4, vec2, vec3 } from 'gl-matrix' -const SPEED = 10.0 +const SPEED = 100.0 const SENSITIVTY = 100.0 const FOV = 45.0 const ZNEAR = 0.1 -const ZFAR = 1000.0 +const ZFAR = 10000.0 class Camera extends Node { constructor (pos, rotation) { diff --git a/src/engine/components/index.js b/src/engine/components/index.js index 7e154cb..6493e1e 100644 --- a/src/engine/components/index.js +++ b/src/engine/components/index.js @@ -47,6 +47,7 @@ class Node { this.rotation = rotation || [0.0, 0.0, 0.0] this.transform = mat4.create() + this.updateTransform() this.parent = null @@ -63,8 +64,8 @@ class Node { // Add local transform to the global transform, if present // Will be present in loaded models - if (this._rootTransform) { - mat4.mul(matrix, matrix, this._rootTransform) + if (this.worldTransform) { + mat4.mul(matrix, matrix, this.worldTransform) } // Add parent's transform to this @@ -158,13 +159,33 @@ class Node { // Draw base draw (gl, shader) { - // Set model transform matrix uniform - const transformLocation = shader.getUniformLocation(gl, 'uModelMatrix') - gl.uniformMatrix4fv(transformLocation, false, this.transform) + // Nothing to draw here, so just draw children + for (let i in this.children) { + let child = this.children[i] + if (!(child instanceof Node)) continue + child.draw(gl, shader) + } + } + + update (dt) { + // Update children + for (let i in this.children) { + let child = this.children[i] + if (!(child instanceof Node)) continue + child.update(dt) + } } addChild (ch) { + // Recursive add in case of table + if (ch && typeof ch === 'object' && ch.length) { + for (let i in ch) { + this.addChild(ch[i]) + } + } + if (!(ch instanceof Node)) return + ch.setParent(this) this.children.push(ch) this.updateTransform() } @@ -184,41 +205,18 @@ class MeshInstance extends Node { } draw (gl, shader) { - // Set model transform uniform - super.draw(gl, shader) + if (!this.mesh) return super.draw(gl, shader) + // Set model transform matrix uniform + const transformLocation = shader.getUniformLocation(gl, 'uModelMatrix') + gl.uniformMatrix4fv(transformLocation, false, this.transform) // Draw the mesh this.mesh.prepare(gl, shader) this.mesh.draw(gl, shader) - // Invoke children's draw methods - for (let i in this.children) { - let child = this.children[i] - if (!(child instanceof MeshInstance)) continue - child.draw(gl, shader) - } + // Draw children + super.draw(gl, shader) } } -// A node that contains multiple meshes -class MultiMeshInstance extends Node { - constructor (meshes, pos) { - super(pos) - - for (let i in meshes) { - meshes[i].parent = this - this.children.push(meshes[i]) - } - } - - draw (gl, shader) { - // Invoke children's draw methods - for (let i in this.children) { - let child = this.children[i] - if (!(child instanceof MeshInstance)) continue - child.draw(gl, shader) - } - } -} - -export { Node, MeshInstance, MultiMeshInstance } +export { Node, MeshInstance } diff --git a/src/engine/components/planet/index.js b/src/engine/components/planet/index.js new file mode 100644 index 0000000..6d0ae77 --- /dev/null +++ b/src/engine/components/planet/index.js @@ -0,0 +1,124 @@ +import { Mesh } from '../../mesh' +import { mat4 } from 'gl-matrix' +import { subv3, mulv3, addv3, normalv3, crossv3 } from '../../utility' + +class CubeFace { + constructor (parent, level, pos, normal, resolution, radius, generator) { + this.parent = parent + this.children = [] + + this.position = pos + this.normal = normal + this.resolution = resolution + this.radius = radius + + this.level = 0 + + this.generated = false + + // Calculate left and forward vectors from the normal + this.left = [normal[1], normal[2], normal[0]] + this.forward = crossv3(normal, this.left) + + this.transform = mat4.create() + mat4.fromTranslation(this.transform, this.position) + + this.generate() + } + + generate () { + if (this.generated) return + + let cpoint = subv3(this.position, mulv3(this.left, this.radius / 2)) + cpoint = subv3(cpoint, mulv3(this.forward, this.radius / 2)) + + let VERTICES = this.resolution + let count = VERTICES * VERTICES + let vertices = new Array(count * 3) + // let normals = new Array(count * 3) + let textureCoords = new Array(count * 2) + let indices = new Array(6 * (VERTICES - 1) * (VERTICES - 1)) + + for (let i = 0, vertexPointer = 0; i < VERTICES; i++) { + for (let j = 0; j < VERTICES; j++, vertexPointer++) { + let isize = i / VERTICES * this.radius + let jsize = j / VERTICES * this.radius + + // From the left and forward vectors, we can calculate an oriented vertex + let iv = mulv3(this.left, isize) + let jv = mulv3(this.forward, jsize) + + // Add the scaled left and forward to the centered origin + let vertex = addv3(cpoint.slice(0), addv3(iv, jv)) + + // Normalize and multiply by radius to create a spherical mesh + let pos = mulv3(normalv3(vertex), this.radius) + + vertices[vertexPointer * 3] = pos[0] + vertices[vertexPointer * 3 + 1] = pos[1] + vertices[vertexPointer * 3 + 2] = pos[2] + // normals[vertexPointer * 3] = normal[0] + // normals[vertexPointer * 3 + 1] = normal[1] + // normals[vertexPointer * 3 + 2] = normal[2] + textureCoords[vertexPointer * 2] = j / (VERTICES - 1) + textureCoords[vertexPointer * 2 + 1] = i / (VERTICES - 1) + } + } + + for (let gz = 0, pointer = 0; gz < VERTICES - 1; gz++) { + for (let gx = 0; gx < VERTICES - 1; gx++) { + let topLeft = (gz * VERTICES) + gx + let topRight = topLeft + 1 + let bottomLeft = ((gz + 1) * VERTICES) + gx + let bottomRight = bottomLeft + 1 + indices[pointer++] = topLeft + indices[pointer++] = bottomLeft + indices[pointer++] = topRight + indices[pointer++] = topRight + indices[pointer++] = bottomLeft + indices[pointer++] = bottomRight + } + } + + this.mesh = Mesh.construct(window.gl, vertices, indices, textureCoords) + this.generated = true + } + + draw (gl, shader) { + // Set model transform matrix uniform + const transformLocation = shader.getUniformLocation(gl, 'uModelMatrix') + gl.uniformMatrix4fv(transformLocation, false, this.transform) + + this.mesh.prepare(gl, shader) + this.mesh.draw(gl, shader) + } +} + +class CubePlanet { + constructor (origin, resolution, radius, generator) { + this.origin = origin + this.resolution = resolution + this.radius = radius + + let hs = resolution / 2 + + this.faces = [ + new CubeFace(this, 0, [0, 0, -hs], [0, 0, -1], resolution, radius, generator), // front + // new CubeFace(this, 0, [0, 0, hs], [0, 0, 1], resolution, radius, generator), // back + + new CubeFace(this, 0, [-hs, 0, 0], [-1, 0, 0], resolution, radius, generator), // left + // new CubeFace(this, 0, [hs, 0, 0], [1, 0, 0], resolution, radius, generator), // right + + // new CubeFace(this, 0, [0, hs, 0], [0, 1, 0], resolution, radius, generator), // top + // new CubeFace(this, 0, [0, -hs, 0], [0, -1, 0], resolution, radius, generator) // bottom + ] + } + + draw (gl, shader) { + for (let i in this.faces) { + this.faces[i].draw(gl, shader) + } + } +} + +export { CubePlanet, CubeFace } diff --git a/src/engine/components/terrain/experimental.js b/src/engine/components/terrain/experimental.js new file mode 100644 index 0000000..3f8ba37 --- /dev/null +++ b/src/engine/components/terrain/experimental.js @@ -0,0 +1,96 @@ +import { Node } from '../' +import { Mesh } from '../../mesh' +import { vec3 } from 'gl-matrix' +import { subv3, mulv3, addv3, normalv3 } from '../../utility' + +class Terrain extends Node { + constructor (pos, sWidth, sHeight, face = [0.0, -1.0, 0.0]) { + super(pos) + + this.width = sWidth + this.height = sHeight + + this.mesh = null + + // Calculate left and forward vectors + this.left = [face[1], face[2], face[0]] || [1.0, 0.0, 0.0] + this.forward = [0.0, 0.0, -1.0] + vec3.cross(this.forward, face, this.left) + } + + createMesh (gl, heightMap) { + // Center the mesh + let cpoint = [0.0, 0.0, 0.0] + cpoint = subv3(cpoint, mulv3(this.left, heightMap.size / 2)) + cpoint = subv3(cpoint, mulv3(this.forward, heightMap.size / 2)) + + let VERTICES = heightMap.size + let count = VERTICES * VERTICES + let vertices = new Array(count * 3) + let normals = new Array(count * 3) + let textureCoords = new Array(count * 2) + let indices = new Array(6 * (VERTICES - 1) * (VERTICES - 1)) + let vertexPointer = 0 + + for (let i = 0; i < VERTICES; i++) { + for (let j = 0; j < VERTICES; j++) { + let isize = j / (VERTICES - 1) * this.width / 2 + let jsize = i / (VERTICES - 1) * this.height / 2 + + // From the left and forward vectors, we can calculate an oriented vertex + let iv = mulv3(this.left, isize) + let jv = mulv3(this.forward, jsize) + + // Add the scaled left and forward to the centered origin + let pos = addv3(cpoint.slice(0), addv3(iv, jv)) + + vertices[vertexPointer * 3] = pos[0] + vertices[vertexPointer * 3 + 1] = pos[1] + vertices[vertexPointer * 3 + 2] = pos[2] + let normal = [0.0, 1.0, 0.0] // heightMap.getNormal(j, i) + normals[vertexPointer * 3] = normal[0] + normals[vertexPointer * 3 + 1] = normal[1] + normals[vertexPointer * 3 + 2] = normal[2] + textureCoords[vertexPointer * 2] = j / (VERTICES - 1) + textureCoords[vertexPointer * 2 + 1] = i / (VERTICES - 1) + vertexPointer++ + } + } + + let pointer = 0 + for (let gz = 0; gz < VERTICES - 1; gz++) { + for (let gx = 0; gx < VERTICES - 1; gx++) { + let topLeft = (gz * VERTICES) + gx + let topRight = topLeft + 1 + let bottomLeft = ((gz + 1) * VERTICES) + gx + let bottomRight = bottomLeft + 1 + indices[pointer++] = topLeft + indices[pointer++] = bottomLeft + indices[pointer++] = topRight + indices[pointer++] = topRight + indices[pointer++] = bottomLeft + indices[pointer++] = bottomRight + } + } + + this.mesh = Mesh.construct(gl, vertices, indices, textureCoords, normals) + } + + setMaterial (mat) { + this.mesh.material = mat + } + + draw (gl, shader) { + if (!this.mesh) return + // Set model transform matrix uniform + const transformLocation = shader.getUniformLocation(gl, 'uModelMatrix') + gl.uniformMatrix4fv(transformLocation, false, this.transform) + + this.mesh.prepare(gl, shader) + this.mesh.draw(gl, shader) + + super.draw(gl, shader) + } +} + +export { Terrain } diff --git a/src/engine/components/terrain/index.js b/src/engine/components/terrain/index.js index 2cc9346..04765ba 100644 --- a/src/engine/components/terrain/index.js +++ b/src/engine/components/terrain/index.js @@ -60,10 +60,14 @@ class Terrain extends Node { draw (gl, shader) { if (!this.mesh) return - super.draw(gl, shader) + // Set model transform matrix uniform + const transformLocation = shader.getUniformLocation(gl, 'uModelMatrix') + gl.uniformMatrix4fv(transformLocation, false, this.transform) this.mesh.prepare(gl, shader) this.mesh.draw(gl, shader) + + super.draw(gl, shader) } } diff --git a/src/engine/gui/index.js b/src/engine/gui/index.js new file mode 100644 index 0000000..190b801 --- /dev/null +++ b/src/engine/gui/index.js @@ -0,0 +1,120 @@ +import { clamp } from '../utility' + +class Dim4 { + constructor (scX, ofX, scY, ofY) { + this.scX = scX + this.ofX = ofX + this.scY = scY + this.ofY = ofY + this._update() + } + + static fromTable (tbl) { + let sx = 0.0 + let ox = 0.0 + let sy = 0.0 + let oy = 0.0 + if (tbl.length === 2) { + let x = tbl[0] + let y = tbl[1] + + if (typeof x === 'object' && x.length === 2) { + sx = x[0] + ox = x[1] + } else if (typeof x === 'number') { + sx = x + } + + if (typeof y === 'object' && y.length === 2) { + sx = y[0] + ox = y[1] + } else if (typeof y === 'number') { + sx = y + } + } else if (tbl.length === 4) { + sx = tbl[0] + ox = tbl[1] + sy = tbl[2] + oy = tbl[3] + } + return new Dim4(sx, ox, sy, oy) + } + + toTable () { + return [this.scX, this.ofX, this.scY, this.ofY] + } + + _update () { + this[0] = this.scX + this[1] = this.ofX + this[2] = this.scY + this[3] = this.ofY + } +} + +class Node2D { + constructor (pos, size, rotation) { + // Translation + this.gpos = [0.0, 0.0] + this.pos = pos || new Dim4(0.0, 0.0, 0.0, 0.0) + + // Scaling + this.gscale = [1.0, 1.0] + this.size = size || new Dim4(0.0, 0.0, 0.0, 0.0) + + // Rotation in degrees + this.rotation = rotation || 0.0 + + this.parent = null + this.children = [] + } + + updateTransform () { + + } + + // Getters + get position () { + return this.pos + } + + get translation () { + return this.pos + } + + // Draw base + draw (gl) { + // Nothing to draw here, so just draw children + for (let i in this.children) { + let child = this.children[i] + if (!(child instanceof Node2D)) continue + child.draw(gl) + } + } + + update (dt) { + // Update children + for (let i in this.children) { + let child = this.children[i] + if (!(child instanceof Node2D)) continue + child.update(dt) + } + } + + addChild (ch) { + // Recursive add in case of table + if (ch && typeof ch === 'object' && ch.length) { + for (let i in ch) { + this.addChild(ch[i]) + } + } + + if (!(ch instanceof Node2D)) return + this.children.push(ch) + } + + setParent (p) { + if (!(p instanceof Node2D)) return + this.parent = p + } +} diff --git a/src/engine/gui/renderer.js b/src/engine/gui/renderer.js new file mode 100644 index 0000000..e69de29 diff --git a/src/engine/index.js b/src/engine/index.js index 8eb59e7..1729b51 100644 --- a/src/engine/index.js +++ b/src/engine/index.js @@ -17,6 +17,8 @@ class Engine { this.frameTime = 0 this.frameCount = 0 this.fps = 0 + + window.gl = this.screen.gl } get gl () { diff --git a/src/engine/mesh/index.js b/src/engine/mesh/index.js index 6e898bf..573eed5 100644 --- a/src/engine/mesh/index.js +++ b/src/engine/mesh/index.js @@ -1,35 +1,36 @@ class Mesh { + static loadToBuffer (gl, type, data, drawtype = gl.STATIC_DRAW) { + let id = gl.createBuffer() + gl.bindBuffer(type, id) + gl.bufferData(type, data, drawtype) + return id + } + static construct (gl, vertices, indices, uvs, normals) { // VBO for model vertices - let pos = gl.createBuffer() - gl.bindBuffer(gl.ARRAY_BUFFER, pos) - gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW) + let pos = Mesh.loadToBuffer(gl, gl.ARRAY_BUFFER, new Float32Array(vertices)) // Indices Buffer - let ebo = gl.createBuffer() - gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo) - gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW) + let ebo = Mesh.loadToBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices)) + // Create the mesh, as we have the most important data already buffered let mesh = new Mesh() mesh.posBuffer = pos mesh.ebo = ebo - mesh.indices = indices.length + mesh.vertices = vertices + mesh.indices = indices // VBO for model UVs if (uvs) { - let uv = gl.createBuffer() - gl.bindBuffer(gl.ARRAY_BUFFER, uv) - gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(uvs), gl.STATIC_DRAW) - mesh.uvs = uv + mesh.uv = uvs + mesh.uvs = Mesh.loadToBuffer(gl, gl.ARRAY_BUFFER, new Float32Array(uvs)) } // Normals buffer if (normals) { - let nms = gl.createBuffer() - gl.bindBuffer(gl.ARRAY_BUFFER, nms) - gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(normals), gl.STATIC_DRAW) - mesh.nms = nms + mesh.normals = normals + mesh.nms = Mesh.loadToBuffer(gl, gl.ARRAY_BUFFER, new Float32Array(normals)) } gl.bindBuffer(gl.ARRAY_BUFFER, null) @@ -64,8 +65,31 @@ class Mesh { } } - draw (gl, shader) { - gl.drawElements(gl.TRIANGLES, this.indices, gl.UNSIGNED_SHORT, 0) + draw (gl, shader, mode = gl.TRIANGLES) { + if (this.indices) { + gl.drawElements(mode, this.indices.length, gl.UNSIGNED_SHORT, 0) + } else { + gl.drawArrays(mode, 0, this.vertices.length) + } + } + + // Make sure no data floats around in memory + dispose (gl) { + gl.deleteBuffer(this.posBuffer) + gl.deleteBuffer(this.ebo) + this.uvs && gl.deleteBuffer(this.uvs) + this.nms && gl.deleteBuffer(this.nms) + this.vertices = null + this.indices = null + this.uv = null + this.normals = null + } + + recreate (gl) { + let msh = Mesh.construct(gl, this.vertices, this.indices, this.uv, this.normals) + if (!msh) return null + this.dispose(gl) + return msh } } diff --git a/src/engine/mesh/loader.js b/src/engine/mesh/loader.js index 59bb35a..bf6755a 100644 --- a/src/engine/mesh/loader.js +++ b/src/engine/mesh/loader.js @@ -1,5 +1,5 @@ import { Mesh } from './' -import { MeshInstance, MultiMeshInstance } from '../components' +import { Node, MeshInstance } from '../components' import { Material } from './material' import { mat4 } from 'gl-matrix' @@ -122,7 +122,7 @@ async function assimp2json (gl, file, dat) { } mat4.transpose(transform, transform) - meshInstance._rootTransform = transform + meshInstance.worldTransform = transform meshInstance.updateTransform() } @@ -135,9 +135,10 @@ async function assimp2json (gl, file, dat) { let returnType if (finished.length > 1) { - returnType = new MultiMeshInstance(finished) + returnType = new Node() + returnType.addChild(finished) mat4.transpose(lastTransform, lastTransform) - returnType._rootTransform = lastTransform + returnType.worldTransform = lastTransform returnType.updateTransform() } else { returnType = finished[0] @@ -155,7 +156,12 @@ async function loadMesh (gl, file) { file = '/assets/models/' + file + '.json' // Ensure each mesh file is loaded only once - if (meshCache[file]) return meshCache[file].length > 1 ? new MultiMeshInstance(meshCache[file]) : meshCache[file][0] + if (meshCache[file]) { + if (meshCache[file].length <= 1) return meshCache[file][0] + let cached = new Node() + cached.addChild(meshCache[file]) + return cached + } let dat = await Resource.GET({ type: 'json', url: file }) diff --git a/src/engine/mesh/material.js b/src/engine/mesh/material.js index 2a6271e..22a6cbb 100644 --- a/src/engine/mesh/material.js +++ b/src/engine/mesh/material.js @@ -40,8 +40,8 @@ class Material { for (let i in this.textures) { let tex = this.textures[i] if (tex && tex instanceof Texture) { - gl.bindTexture(tex.type, tex.id) gl.activeTexture(gl.TEXTURE0 + parseInt(i)) + gl.bindTexture(tex.type, tex.id) } } } diff --git a/src/engine/utility.js b/src/engine/utility.js new file mode 100644 index 0000000..ab6081a --- /dev/null +++ b/src/engine/utility.js @@ -0,0 +1,65 @@ +import { vec3 } from 'gl-matrix' + +export function clamp (num, min, max) { + return Math.min(Math.max(num, min), max) +} + +export function addv3 (one, two) { + if (one.length !== 3) return null + if (typeof two !== 'object') { + return [ + one[0] + two, one[1] + two, one[2] + two + ] + } + return [ + one[0] + two[0], one[1] + two[1], one[2] + two[2] + ] +} + +export function subv3 (one, two) { + if (one.length !== 3) return null + if (typeof two !== 'object') { + return [ + one[0] - two, one[1] - two, one[2] - two + ] + } + return [ + one[0] - two[0], one[1] - two[1], one[2] - two[2] + ] +} + +export function mulv3 (one, two) { + if (one.length !== 3) return null + if (typeof two !== 'object') { + return [ + one[0] * two, one[1] * two, one[2] * two + ] + } + return [ + one[0] * two[0], one[1] * two[1], one[2] * two[2] + ] +} + +export function divv3 (one, two) { + if (one.length !== 3) return null + if (typeof two !== 'object') { + return [ + one[0] / two, one[1] / two, one[2] / two + ] + } + return [ + one[0] / two[0], one[1] / two[1], one[2] / two[2] + ] +} + +export function normalv3 (vec) { + let res = [] + vec3.normalize(res, vec) + return res +} + +export function crossv3 (vec1, vec2) { + let res = [] + vec3.cross(res, vec1, vec2) + return res +} diff --git a/src/index.js b/src/index.js index c5c148a..6b4836f 100644 --- a/src/index.js +++ b/src/index.js @@ -7,10 +7,12 @@ import { Terrain } from './engine/components/terrain' import { SimplexHeightMap } from './engine/components/terrain/heightmap' import { Material } from './engine/mesh/material' +import { CubePlanet } from './engine/components/planet' + let game = new Engine() let env = new Environment() -let t = 0 +// let t = 0 async function pipeline () { let entity = await loadMesh(game.gl, 'test') let shader = await game.shaders.createShaderFromFiles(game.gl, 'basic', false) @@ -32,9 +34,12 @@ async function pipeline () { terrain.setMaterial(material) // Create and initialize the camera - let cam = new Camera([0.0, 1.0, 2.0]) + let cam = new Camera([-100.0, 1.0, 0.0]) cam.updateProjection(game.gl) + // Planet test + let planet = new CubePlanet([0.0, 0.0, 0.0], 16, 32) + // Update function for camera game.addUpdateFunction(function (dt) { if (game.input.isDown('w')) { @@ -54,8 +59,8 @@ async function pipeline () { } // TESTING: Move model forward - t = t + 0.1 - entity.setPosition([t, 0.0, 0.0]) + // t = t + 0.1 + // entity.setPosition([t, 0.0, 0.0]) }) // Render function for the triangle @@ -63,6 +68,7 @@ async function pipeline () { shader.use(gl) cam.draw(gl, shader) entity.draw(gl, shader) + planet.draw(gl, shader) // Use terrain shader terrainShader.use(gl)