stairsTest

Author: michaljaz

Terrain.png

@@ -106,14 +106,14 @@ <h3>Gra zatrzymana</h3>
     </div>
     <script src="js/jq.js?10210281028012"></script>
     <script type="module">
-import * as THREE from 'https://threejsfundamentals.org/threejs/resources/threejs/r115/build/three.module.js';
+import * as THREE from 'https://threejs.org/build/three.module.js';
 import {
   BufferGeometryUtils
-} from 'https://threejsfundamentals.org/threejs/resources/threejs/r115/examples/jsm/utils/BufferGeometryUtils.js';
-import Stats from 'https://threejsfundamentals.org/threejs/resources/threejs/r115/examples/jsm/libs/stats.module.js';
+} from 'https://threejs.org/examples/jsm/utils/BufferGeometryUtils.js';
+import Stats from 'https://threejs.org/examples/jsm/libs/stats.module.js';
 
 import {FirstPersonControls} from './js/fpc.module.js?123';
-import { FBXLoader } from 'https://threejsfundamentals.org/threejs/resources/threejs/r115/examples/jsm/loaders/FBXLoader.js';
+import { FBXLoader } from 'https://threejs.org/examples/jsm/loaders/FBXLoader.js';
 
 //Renderer
 var canvas = document.querySelector('#c');
@@ -127,15 +127,8 @@ <h3>Gra zatrzymana</h3>
 // scene.fog= new THREE.Fog(new THREE.Color('lightblue'),50, 64)
 scene.fog = new THREE.FogExp2(0xffffff, 0.00015);
 
-//clouds
-var loader = new FBXLoader();
-loader.load( 'objects/clouds.fbx', function ( object ) {
-  object.scale.x=0.1
-  object.scale.y=0.1
-  object.scale.z=0.1
-  object.position.y=100
-  scene.add( object );
-} );
+
+
 
 //Camera
 var camera = new THREE.PerspectiveCamera(75, 2, 0.1, 1000);
@@ -166,12 +159,40 @@ <h3>Gra zatrzymana</h3>
 
 
 //Textures
-var texture = new THREE.TextureLoader().load('Terrain.png');
+var texture = new THREE.TextureLoader().load('atla.png');
 texture.magFilter = THREE.NearestFilter;
 
 var gameState="menu";
 
 
+//clouds
+var loader = new FBXLoader();
+loader.load( 'assets/models/clouds.fbx', function ( object ) {
+  object.scale.x=0.1
+  object.scale.y=0.1
+  object.scale.z=0.1
+  object.position.y=100
+  scene.add( object );
+} );
+
+var stairsGeometry;
+loader.load( 'assets/models/stairso.fbx', function ( object ) {
+  stairsGeometry=object.children[0].geometry
+  stairsGeometry.scale(10,10,10)
+  // object.scale.set(0.01,0.01,0.01)
+  // object.children[0].material=new THREE.MeshLambertMaterial({
+  //   map: texture,
+  //   side: 2
+  // })
+  // // var mesh=new THREE.Mesh(object.geometry,object.material);
+  // object.children[0].index=null
+
+
+  // scene.add(object)
+  // object.position.set(26,26,26)
+});
+
+
 class Terrain {
   constructor(options) {
     this.textureAtlas = options.textureAtlas;
@@ -330,14 +351,23 @@ <h3>Gra zatrzymana</h3>
           var voxelGeometries = this.generateVoxelGeometry(x * cellSize + i, y * cellSize + j, z * cellSize + k);
           // console.log(voxelGeometries)
           for (var l = 0; l < voxelGeometries.length; l++) {
+            if(voxelGeometries[l].index!=null){
+              voxelGeometries[l]=voxelGeometries[l].toNonIndexed()
+            }else{
+              console.log("NON INDEXED")
+            }
             geometries.push(voxelGeometries[l]);
+
           }
         }
       }
     }
     // console.log(geometries)
     if (geometries.length != 0) {
+      // console.log(geometries)
+      console.log(geometries)
       var geometry = BufferGeometryUtils.mergeBufferGeometries(geometries);
+      // console.log(geometry)
       geometry.computeBoundingSphere();
     } else {
       var geometry = null;
@@ -349,36 +379,49 @@ <h3>Gra zatrzymana</h3>
     var voxel = this.getVoxel(x, y, z);
     var matrix = new THREE.Matrix4();
     matrix.makeTranslation(x, y, z);
-    if (this.blocks[voxel] != undefined) {
-      var geometries = [];
-      if (this.getVoxel(x - 1, y, z) == 0) {
-        var nxGeometry = this.generateFace("nx", voxel);
-        geometries.push(nxGeometry.applyMatrix4(matrix))
-      }
-      if (this.getVoxel(x + 1, y, z) == 0) {
-        var pxGeometry = this.generateFace("px", voxel);
-        geometries.push(pxGeometry.applyMatrix4(matrix))
-      }
-      if (this.getVoxel(x, y - 1, z) == 0) {
-        var nyGeometry = this.generateFace("ny", voxel);
-        geometries.push(nyGeometry.applyMatrix4(matrix))
-      }
-      if (this.getVoxel(x, y + 1, z) == 0) {
-        var pyGeometry = this.generateFace("py", voxel);
-        geometries.push(pyGeometry.applyMatrix4(matrix))
-      }
-      if (this.getVoxel(x, y, z - 1) == 0) {
-        var nzGeometry = this.generateFace("nz", voxel);
-        geometries.push(nzGeometry.applyMatrix4(matrix))
-      }
-      if (this.getVoxel(x, y, z + 1) == 0) {
-        var pzGeometry = this.generateFace("pz", voxel);
-        geometries.push(pzGeometry.applyMatrix4(matrix))
+    if(voxel==4){
+      // console.log(stairsGeometry)
+      var geo=stairsGeometry.clone()
+      geo=geo.applyMatrix4(matrix)
+      geo.translate(0,-0.25,0)
+      console.log(geo)
+      return [geo]
+
+
+      
+    }else{
+      if (this.blocks[voxel] != undefined) {
+        var geometries = [];
+        if (this.getVoxel(x - 1, y, z) == 0) {
+          var nxGeometry = this.generateFace("nx", voxel);
+          geometries.push(nxGeometry.applyMatrix4(matrix))
+        }
+        if (this.getVoxel(x + 1, y, z) == 0) {
+          var pxGeometry = this.generateFace("px", voxel);
+          geometries.push(pxGeometry.applyMatrix4(matrix))
+        }
+        if (this.getVoxel(x, y - 1, z) == 0) {
+          var nyGeometry = this.generateFace("ny", voxel);
+          geometries.push(nyGeometry.applyMatrix4(matrix))
+        }
+        if (this.getVoxel(x, y + 1, z) == 0) {
+          var pyGeometry = this.generateFace("py", voxel);
+          geometries.push(pyGeometry.applyMatrix4(matrix))
+        }
+        if (this.getVoxel(x, y, z - 1) == 0) {
+          var nzGeometry = this.generateFace("nz", voxel);
+          geometries.push(nzGeometry.applyMatrix4(matrix))
+        }
+        if (this.getVoxel(x, y, z + 1) == 0) {
+          var pzGeometry = this.generateFace("pz", voxel);
+          geometries.push(pzGeometry.applyMatrix4(matrix))
+        }
+        return geometries; 
+      } else {
+        return []
       }
-      return geometries;
-    } else {
-      return []
     }
+    
   }
   generateFace(type, voxel) {
     var geometry = new THREE.PlaneBufferGeometry(1, 1);
@@ -546,7 +589,7 @@ <h3>Gra zatrzymana</h3>
 //Setup inventory bar
 var inv_bar = new InventoryBar({
   boxSize: 60,
-  boxes: 3,
+  boxes: 4,
   padding: 4,
   div: ".inventoryBar",
   activeBox: 1
@@ -724,6 +767,7 @@ <h3>Gra zatrzymana</h3>
     } else {
       //Budowanie
       world.setVoxel(positionQ[0], positionQ[1], positionQ[2], inv_bar.activeBox)
+      // console.log(inv_bar.activeBox)
       // console.log(world.cells[world.computeCellId(...positionQ)])
     }
   }
@@ -737,6 +781,7 @@ <h3>Gra zatrzymana</h3>
 function animate() {
   stats.begin();
   render()
+  // console.log(renderer.info.render.calls)
   stats.end();
   requestAnimationFrame(animate)
 }

objects/clouds.fbx assets/models/clouds.fbxobjects/clouds.fbx renamed to assets/models/clouds.fbx

@@ -0,0 +1,106 @@
+/**
+ * Combine indexed and non-indexed BufferGeometry into a new indexed BufferGeometry. All missing uniforms are set to 0.
+ * @param {array} geometries Array of THREE.BufferGeometry instances
+ * @returns {BufferGeometry}
+ */
+function mergeBufferGeometries (geometries) {
+    var indexLength = 0,
+        verticesLength = 0,
+        attributesInfos = {},
+        geometriesInfos = [],
+        geometryInfo,
+        referenceAttributesKeys = [],
+        attributesKeys,
+        countVertices,
+        i,
+        j,
+        k;
+
+    // read the geometries and attributes information, calculate indexLength and verticesLength
+
+    for (i = 0; i < geometries.length; i++) {
+        attributesKeys = Object.keys(geometries[i].attributes);
+
+        geometryInfo = {
+            indexed: geometries[i].index !== null,
+            vertices: geometries[i].attributes[attributesKeys[0]].count
+        };
+
+        geometriesInfos.push(geometryInfo);
+
+        if (geometryInfo.indexed) {
+            indexLength += geometries[i].index.count;
+        } else {
+            indexLength += geometryInfo.vertices;
+        }
+
+        verticesLength += geometryInfo.vertices;
+
+        for (j = 0; j < attributesKeys.length; j++) {
+            if (referenceAttributesKeys.indexOf(attributesKeys[j]) === -1) {
+                referenceAttributesKeys.push(attributesKeys[j]);
+
+                attributesInfos[attributesKeys[j]] = {
+                    array: null,
+                    constructor: geometries[i].attributes[attributesKeys[j]].array.constructor,
+                    itemSize: geometries[i].attributes[attributesKeys[j]].itemSize
+                };
+            }
+        }
+    }
+
+    // prepare the new BufferGeometry and its attributes
+
+    var newGeometry = new THREE.BufferGeometry(),
+        indexArray = verticesLength > 0xFFFF ? new Uint32Array(indexLength) : new Uint16Array(indexLength);
+
+    for (i = 0; i < referenceAttributesKeys.length; i++) {
+        attributesInfos[referenceAttributesKeys[i]].array = new (attributesInfos[referenceAttributesKeys[i]].constructor)(
+            verticesLength * attributesInfos[referenceAttributesKeys[i]].itemSize
+        );
+
+        newGeometry.addAttribute(referenceAttributesKeys[i], new THREE.BufferAttribute(
+            attributesInfos[referenceAttributesKeys[i]].array,
+            attributesInfos[referenceAttributesKeys[i]].itemSize
+        ));
+    }
+
+    // copy all the data in the new BufferGeometry
+
+    var offsetIndices = 0,
+        offsetVertices = 0,
+        offsetAttribute;
+
+    for (i = 0; i < geometries.length; i++) {
+
+        geometryInfo = geometriesInfos[i];
+
+        if (geometryInfo.indexed) {
+            for (j = 0; j < geometries[i].index.count; j++) {
+                indexArray[offsetIndices + j] = offsetVertices + geometries[i].index.array[j];
+            }
+
+            offsetIndices += geometries[i].index.count;
+        } else {
+            for (j = 0; j < geometryInfo.vertices; j++) {
+                indexArray[offsetIndices + j] = offsetVertices + j;
+            }
+
+            offsetIndices += geometryInfo.vertices;
+        }
+
+        for (j = 0; j < referenceAttributesKeys.length; j++) {
+            offsetAttribute = offsetVertices * attributesInfos[referenceAttributesKeys[j]].itemSize;
+
+            if (geometries[i].attributes[referenceAttributesKeys[j]]) {
+                attributesInfos[referenceAttributesKeys[j]].array.set(geometries[i].attributes[referenceAttributesKeys[j]].array, offsetAttribute);
+            }
+        }
+
+        offsetVertices += geometryInfo.vertices;
+    }
+
+    newGeometry.setIndex(new THREE.BufferAttribute(indexArray, 1));
+
+    return newGeometry;
+}