try points tommorrow

index.html

@@ -42,7 +42,6 @@
     <script src="js/GeometryUtils.js"></script>
     <script src="js/gpgpu/SimulationShader.js"></script>
     <script src="lib/OrbitControls.js"></script>
-
     <script src="js/leap-0.6.4.min.js"></script>
     <script src="js/leap-plugins-0.1.6.1.js"></script>
     <script src="js/leap.rigged-hand-0.1.3.min.js"></script>
@@ -259,8 +258,8 @@
           }
 
           mesh = new THREE.PointCloud(vbo_pos, material);
-          mesh.name = "clothParticles";
-          //mesh = new THREE.Mesh(vbo_pos, material);
+          //mesh = new THREE.Points(vbo_pos, material);
+
           window.addEventListener('start-simulation', onStartSimulation);
           window.addEventListener('step-simulation', onStepSimulation);
           window.addEventListener('mousemove', onMouseMove, false);
@@ -270,6 +269,7 @@
 
       function onMouseUp(event)
       {
+          if (moved) return;
           raycaster.setFromCamera(mouse, camera);
 
           // calculate objects intersecting the picking ray

js/gpgpu/SimulationShader.js

@@ -74,8 +74,8 @@ function simulationCommon() {
       ' vec4 texPrevPos = texture(u_texPrevPos,coord);',
       'vec3 F = vec3(0.0);',
       //'F.y = -9.8*mass;',
-      //'F.y = -9.8*pos.w;',
-      'F.y = -0.0*pos.w;',
+      'F.y = -9.8*pos.w;',
+      //'F.y = -0.0*pos.w;',
       ' vec3 vel = (texPos.xyz-texPrevPos.xyz)/timestep;',
       'F+=DAMPING*vel;',
       'F.x+=u_wind*0.3;',

lib/Points.js

@@ -0,0 +1,143 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Points = function (geometry, material) {
+
+    THREE.Object3D.call(this);
+
+    this.type = 'Points';
+
+    this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
+    this.material = material !== undefined ? material : new THREE.PointsMaterial({ color: Math.random() * 0xffffff });
+
+};
+
+THREE.Points.prototype = Object.create(THREE.Object3D.prototype);
+THREE.Points.prototype.constructor = THREE.Points;
+
+THREE.Points.prototype.raycast = (function () {
+
+    var inverseMatrix = new THREE.Matrix4();
+    var ray = new THREE.Ray();
+
+    return function raycast(raycaster, intersects) {
+
+        var object = this;
+        var geometry = object.geometry;
+        var threshold = raycaster.params.Points.threshold;
+
+        inverseMatrix.getInverse(this.matrixWorld);
+        ray.copy(raycaster.ray).applyMatrix4(inverseMatrix);
+
+        if (geometry.boundingBox !== null) {
+
+            if (ray.isIntersectionBox(geometry.boundingBox) === false) {
+
+                return;
+
+            }
+
+        }
+
+        var localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
+        var localThresholdSq = localThreshold * localThreshold;
+        var position = new THREE.Vector3();
+
+        function testPoint(point, index) {
+
+            var rayPointDistanceSq = ray.distanceSqToPoint(point);
+
+            if (rayPointDistanceSq < localThresholdSq) {
+
+                var intersectPoint = ray.closestPointToPoint(point);
+                intersectPoint.applyMatrix4(object.matrixWorld);
+
+                var distance = raycaster.ray.origin.distanceTo(intersectPoint);
+
+                if (distance < raycaster.near || distance > raycaster.far) return;
+
+                intersects.push({
+
+                    distance: distance,
+                    distanceToRay: Math.sqrt(rayPointDistanceSq),
+                    point: intersectPoint.clone(),
+                    index: index,
+                    face: null,
+                    object: object
+
+                });
+
+            }
+
+        }
+
+        if (geometry instanceof THREE.BufferGeometry) {
+
+            var index = geometry.index;
+            var attributes = geometry.attributes;
+            var positions = attributes.position.array;
+
+            if (index !== null) {
+
+                var indices = index.array;
+
+                for (var i = 0, il = indices.length; i < il; i++) {
+
+                    var a = indices[i];
+
+                    position.fromArray(positions, a * 3);
+
+                    testPoint(position, a);
+
+                }
+
+            } else {
+
+                for (var i = 0, l = positions.length / 3; i < l; i++) {
+
+                    position.fromArray(positions, i * 3);
+
+                    testPoint(position, i);
+
+                }
+
+            }
+
+        } else {
+
+            var vertices = geometry.vertices;
+
+            for (var i = 0, l = vertices.length; i < l; i++) {
+
+                testPoint(vertices[i], i);
+
+            }
+
+        }
+
+    };
+
+}());
+
+THREE.Points.prototype.clone = function () {
+
+    return new this.constructor(this.geometry, this.material).copy(this);
+
+};
+
+// Backwards compatibility
+
+THREE.PointCloud = function (geometry, material) {
+
+    console.warn('THREE.PointCloud has been renamed to THREE.Points.');
+    return new THREE.Points(geometry, material);
+
+};
+
+THREE.ParticleSystem = function (geometry, material) {
+
+    console.warn('THREE.ParticleSystem has been renamed to THREE.Points.');
+    return new THREE.Points(geometry, material);
+
+};