tforgione
/
3d-interface
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Changed stuff

This commit is contained in:
Thomas FORGIONE 2015-06-18 16:30:37 +02:00
parent 9c9232d57b
commit fc77511d94
3 changed files with 123 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
geo/MeshStreamer.js
View File

@ -3,6 +3,38 @@ var mesh = require('./Mesh.js');
var geo = {};
function bisect(items, x, lo, hi) {
var mid;
if (typeof(lo) == 'undefined') lo = 0;
if (typeof(hi) == 'undefined') hi = items.length;
while (lo < hi) {
mid = Math.floor((lo + hi) / 2);
if (x < items[mid]) hi = mid;
else lo = mid + 1;
}
return lo;
}
function insort(items, x) {
items.splice(bisect(items, x), 0, x);
}
function partialSort(items, k, comparator) {
var smallest = items.slice(0, k).sort(),
max = smallest[k-1];
for (var i = k, len = items.length; i < len; ++i) {
var item = items[i];
var cond = comparator === undefined ? item < max : comparator(item, max) < 0;
if (cond) {
insort(smallest, item);
smallest.length = k;
max = smallest[k-1];
}
}
return smallest;
}
geo.MeshStreamer = function(path, callback) {
// Different parts of a obj (a mesh per material)
this.meshes = [];
@ -12,6 +44,7 @@ geo.MeshStreamer = function(path, callback) {
this.faces = [];
this.normals = [];
this.texCoords = [];
this.orderedFaces = [];
// Chunk size
this.chunk = 1000;
@ -26,6 +59,76 @@ geo.MeshStreamer = function(path, callback) {
}
}
// Returns the function that compares two faces
geo.MeshStreamer.prototype.faceComparator = function(camera) {
var direction = {
x: camera.target.x - camera.position.x,
y: camera.target.y - camera.position.y,
z: camera.target.z - camera.position.z
};
var norm = Math.sqrt(direction.x * direction.x + direction.y * direction.y + direction.z * direction.z);
direction.x /= norm;
direction.y /= norm;
direction.z /= norm;
return function(face1, face2) {
var center1 = {
x: (self.vertices[face1.a].x + self.vertices[face1.b].x + self.vertices[face1.b].x) / 3,
y: (self.vertices[face1.a].y + self.vertices[face1.b].y + self.vertices[face1.b].y) / 3,
z: (self.vertices[face1.a].z + self.vertices[face1.b].z + self.vertices[face1.b].z) / 3
};
var dir1 = {
x: center1.x - camera.position.x,
y: center1.y - camera.position.y,
z: center1.z - camera.position.z
};
var norm1 = Math.sqrt(dir1.x * dir1.x + dir1.y * dir1.y + dir1.z + dir1.z);
dir1.x /= norm1;
dir1.y /= norm1;
dir1.z /= norm1;
var dot1 = direction.x * dir1.x + direction.y * dir1.y + direction.z * dir1.z;
var center2 = {
x: (self.vertices[face2.a].x + self.vertices[face2.b].x + self.vertices[face2.b].x) / 3,
y: (self.vertices[face2.a].y + self.vertices[face2.b].y + self.vertices[face2.b].y) / 3,
z: (self.vertices[face2.a].z + self.vertices[face2.b].z + self.vertices[face2.b].z) / 3
}
var dir2 = {
x: center2.x - camera.position.x,
y: center2.y - camera.position.y,
z: center2.z - camera.position.z
};
var norm2 = Math.sqrt(dir2.x * dir2.x + dir2.y * dir2.y + dir2.z + dir2.z);
dir2.x /= norm2;
dir2.y /= norm2;
dir2.z /= norm2;
var dot2 = direction.x * dir2.x + direction.y * dir2.y + direction.z * dir2.z;
// Decreasing order
if (dot1 > dot2) {
return -1;
}
if (dot1 < dot2) {
return 1;
}
return 0;
}
}
geo.MeshStreamer.prototype.loadFromFile = function(path, callback) {
var self = this;
fs.readFile(path, function(err, data) {
@ -88,12 +191,14 @@ geo.MeshStreamer.prototype.loadFromFile = function(path, callback) {
faces[0].index = self.faces.length;
faces[0].meshIndex = self.meshes.length - 1;
self.faces.push(faces[0]);
self.orderedFaces.push(faces[0]);
if (faces.length === 2) {
faces[1].index = self.faces.length;
faces[1].meshIndex = self.meshes.length - 1;
self.faces.push(faces[1]);
self.orderedFaces.push(faces[1]);
}
@ -151,10 +256,6 @@ geo.MeshStreamer.prototype.start = function(socket) {
// Send next elements
var next = self.nextElements(camera);
// console.log(self.meshIndex);
// console.log(data);
// Emit self.chunk faces (and the corresponding vertices if not emitted)
socket.emit('elements', next.data);
if (next.finished) {

4
js/ProgressiveLoaderGeometry.js
View File

@ -111,9 +111,11 @@ ProgressiveLoaderGeometry.prototype.load = function() {
}
ProgressiveLoaderGeometry.prototype.getCamera = function() {
if (this.camera !== null)
return [this.camera.position.x, this.camera.position.y, this.camera.position.z,
this.camera.target.x, this.camera.target.y, this.camera.target.z];
else
return null;
}

28
js/prototype/initScene.js vendored
View File

@ -16,7 +16,7 @@ function initPeachCastle(scene, collidableObjects, loader, camera) {
var loader = new ProgressiveLoaderGeometry(
'/static/data/castle/princess peaches castle (outside).obj',
scene,
camera,
null,
function(object) {
object.raycastable = true;
if (object.material.name === 'Material.103_princess_peaches_cast') {
@ -38,10 +38,8 @@ function initPeachCastle(scene, collidableObjects, loader, camera) {
function resetPeachElements() {
return {
// position: new THREE.Vector3(0.24120226734236713,0.2009624547018851,-0.5998422840047036),
// target: new THREE.Vector3(0.24120226734232672,0.20096245470190008,-40.5998422840047)
position: new THREE.Vector3(1.4172594473140818,0.7422266244449804,-6.745110400697304),
target: new THREE.Vector3(1.217322777130804,-0.25766921214350846,-46.732111209008615)
position: new THREE.Vector3(0.24120226734236713,0.2009624547018851,-0.5998422840047036),
target: new THREE.Vector3(0.24120226734232672,0.20096245470190008,-40.5998422840047)
};
}
@ -337,16 +335,16 @@ function initWhompScene(scene, collidableObjects, loader, camera) {
loader.obj.rotation.z = Math.PI/2;
loader.obj.scale.set(0.1,0.1,0.1);
loader.getCamera = function() {
return [
loader.camera.position.z * 10,
loader.camera.position.x * 10,
loader.camera.position.y * 10,
loader.camera.target.z * 10,
loader.camera.target.x * 10,
loader.camera.target.y * 10
];
}
// loader.getCamera = function() {
// return [
// loader.camera.position.z * 10,
// loader.camera.position.x * 10,
// loader.camera.position.y * 10,
// loader.camera.target.z * 10,
// loader.camera.target.x * 10,
// loader.camera.target.y * 10
// ];
// }
collidableObjects.push(loader.obj);
loader.obj.raycastable = true;