2021-07-05 20:51:08 -04:00
|
|
|
<!doctype html>
|
|
|
|
|
<html>
|
|
|
|
|
<head>
|
|
|
|
|
<style>
|
|
|
|
|
html, body
|
|
|
|
|
{
|
|
|
|
|
margin:0;
|
|
|
|
|
}
|
|
|
|
|
canvas
|
|
|
|
|
{
|
|
|
|
|
position:absolute;
|
|
|
|
|
top:0;
|
|
|
|
|
left:0;
|
|
|
|
|
display:block;
|
|
|
|
|
width:100%;
|
|
|
|
|
height:100%;
|
|
|
|
|
}
|
|
|
|
|
</style>
|
|
|
|
|
</head>
|
|
|
|
|
<body>
|
|
|
|
|
<canvas></canvas>
|
2021-07-10 11:27:44 -04:00
|
|
|
<script type="module">
|
2021-07-11 09:24:39 -04:00
|
|
|
import { Scene, THREE } from './scene.js';
|
2021-07-10 11:27:44 -04:00
|
|
|
import { Region } from "./region.js";
|
|
|
|
|
|
2021-07-11 09:24:39 -04:00
|
|
|
let surfaceTest = () =>
|
|
|
|
|
{
|
2021-07-12 10:40:31 -04:00
|
|
|
let limit = (x, y, z, ax, ay, az) =>
|
|
|
|
|
{
|
|
|
|
|
let centerX = Math.round(x);
|
|
|
|
|
let centerY = Math.round(y);
|
|
|
|
|
let centerZ = Math.round(z);
|
|
|
|
|
|
|
|
|
|
let deltaX = ax-centerX;
|
|
|
|
|
let deltaY = ay-centerY;
|
|
|
|
|
let deltaZ = az-centerZ;
|
|
|
|
|
|
|
|
|
|
let absDeltaX = Math.abs(deltaX);
|
|
|
|
|
let absDeltaY = Math.abs(deltaY);
|
|
|
|
|
let absDeltaZ = Math.abs(deltaZ);
|
|
|
|
|
|
|
|
|
|
let max = absDeltaX;
|
|
|
|
|
if(absDeltaY > max){ max = absDeltaY; }
|
|
|
|
|
if(absDeltaZ > max){ max = absDeltaZ; }
|
|
|
|
|
|
|
|
|
|
let lerp = 0.49/max;
|
|
|
|
|
|
|
|
|
|
if(lerp <= 1)
|
|
|
|
|
{
|
|
|
|
|
return [
|
|
|
|
|
centerX + deltaX*lerp,
|
|
|
|
|
centerY + deltaY*lerp,
|
|
|
|
|
centerZ + deltaZ*lerp
|
|
|
|
|
];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return [ax, ay, az];
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-07-12 09:05:15 -04:00
|
|
|
let average = (inArray, inPointInd, inOthersIndArray) =>
|
2021-07-05 20:51:08 -04:00
|
|
|
{
|
2021-07-07 15:12:39 -04:00
|
|
|
let sum = [0, 0, 0];
|
2021-07-12 09:05:15 -04:00
|
|
|
for(let i=0; i<inOthersIndArray.length; i++)
|
2021-07-07 07:00:50 -04:00
|
|
|
{
|
2021-07-12 09:05:15 -04:00
|
|
|
let otherInd = inOthersIndArray[i]*3;
|
2021-07-07 15:12:39 -04:00
|
|
|
sum[0] += inArray[otherInd+0];
|
|
|
|
|
sum[1] += inArray[otherInd+1];
|
|
|
|
|
sum[2] += inArray[otherInd+2];
|
2021-07-07 07:00:50 -04:00
|
|
|
}
|
|
|
|
|
|
2021-07-07 15:12:39 -04:00
|
|
|
let pointX = inPointInd*3 + 0;
|
|
|
|
|
let pointY = inPointInd*3 + 1;
|
|
|
|
|
let pointZ = inPointInd*3 + 2;
|
2021-07-12 09:05:15 -04:00
|
|
|
let reducer = inOthersIndArray.length;
|
2021-07-07 12:09:52 -04:00
|
|
|
|
2021-07-12 10:40:31 -04:00
|
|
|
let limited = limit(inArray[pointX], inArray[pointY], inArray[pointZ], sum[0]/reducer, sum[1]/reducer, sum[2]/reducer);
|
|
|
|
|
|
|
|
|
|
inArray[pointX] = limited[0];
|
|
|
|
|
inArray[pointY] = limited[1];
|
|
|
|
|
inArray[pointZ] = limited[2];
|
2021-07-07 07:00:50 -04:00
|
|
|
};
|
2021-07-12 09:05:15 -04:00
|
|
|
let smooth = (inVertsArray, inNeighborsArray, inTimes) =>
|
2021-07-07 07:26:21 -04:00
|
|
|
{
|
2021-07-12 09:05:15 -04:00
|
|
|
let count = inVertsArray.length/3;
|
2021-07-07 12:09:52 -04:00
|
|
|
for(let t=0; t<inTimes; t++)
|
2021-07-07 07:26:21 -04:00
|
|
|
{
|
2021-07-07 12:09:52 -04:00
|
|
|
for(let i=0; i<count; i++)
|
|
|
|
|
{
|
2021-07-12 09:05:15 -04:00
|
|
|
average(inVertsArray, i, inNeighborsArray[i]);
|
2021-07-07 12:09:52 -04:00
|
|
|
}
|
2021-07-07 07:26:21 -04:00
|
|
|
}
|
2021-07-12 09:05:15 -04:00
|
|
|
return inVertsArray;
|
2021-07-07 07:26:21 -04:00
|
|
|
}
|
2021-07-12 09:05:15 -04:00
|
|
|
|
|
|
|
|
let voxels = [];
|
|
|
|
|
voxels[Region.I(0, 0, 0)] = true;
|
|
|
|
|
voxels[Region.I(1, 0, 0)] = true;
|
|
|
|
|
voxels[Region.I(2, 0, 0)] = true;
|
|
|
|
|
voxels[Region.I(0, 1, 0)] = true;
|
|
|
|
|
voxels[Region.I(1, 1, 0)] = true;
|
|
|
|
|
voxels[Region.I(0, 2, 0)] = true;
|
|
|
|
|
|
2021-07-12 10:40:31 -04:00
|
|
|
/*
|
2021-07-12 09:05:15 -04:00
|
|
|
voxels[Region.I(0, 0, 1)] = true;
|
|
|
|
|
voxels[Region.I(1, 0, 1)] = true;
|
|
|
|
|
voxels[Region.I(2, 0, 1)] = true;
|
|
|
|
|
voxels[Region.I(0, 1, 1)] = true;
|
|
|
|
|
voxels[Region.I(1, 1, 1)] = true;
|
|
|
|
|
voxels[Region.I(0, 2, 1)] = true;
|
|
|
|
|
|
|
|
|
|
voxels[Region.I(0, 0, 2)] = true;
|
|
|
|
|
voxels[Region.I(1, 0, 2)] = true;
|
|
|
|
|
voxels[Region.I(2, 0, 2)] = true;
|
|
|
|
|
voxels[Region.I(0, 1, 2)] = true;
|
|
|
|
|
voxels[Region.I(1, 1, 2)] = true;
|
|
|
|
|
voxels[Region.I(0, 2, 2)] = true;
|
|
|
|
|
|
|
|
|
|
voxels[Region.I(0, 0, 3)] = true;
|
|
|
|
|
voxels[Region.I(1, 0, 3)] = true;
|
|
|
|
|
voxels[Region.I(2, 0, 3)] = true;
|
|
|
|
|
voxels[Region.I(0, 1, 3)] = true;
|
|
|
|
|
voxels[Region.I(1, 1, 3)] = true;
|
|
|
|
|
voxels[Region.I(0, 2, 3)] = true;
|
2021-07-12 10:40:31 -04:00
|
|
|
*/
|
2021-07-12 09:05:15 -04:00
|
|
|
|
|
|
|
|
|
2021-07-15 14:41:17 -04:00
|
|
|
/*
|
|
|
|
|
let testGeometry = new THREE.BufferGeometry();
|
|
|
|
|
let testAttribute = new THREE.BufferAttribute(new Float32Array(0));
|
|
|
|
|
testGeometry.setAttribute("position", testAttribute, 3);
|
|
|
|
|
|
|
|
|
|
console.log(testGeometry);
|
|
|
|
|
testAttribute.array = new Float32Array([1, 2, 3]);
|
|
|
|
|
testAttribute.needsUpdate = true;
|
|
|
|
|
console.log(testGeometry);
|
|
|
|
|
*/
|
|
|
|
|
|
2021-07-12 09:05:15 -04:00
|
|
|
let surfaceCubeGeometry = new THREE.BufferGeometry();
|
|
|
|
|
let surfaceCubeObject = new THREE.Mesh(
|
|
|
|
|
surfaceCubeGeometry,
|
2021-07-15 14:41:17 -04:00
|
|
|
new THREE.MeshPhongMaterial({color:0x666666, wireframe:false, flatShading:true, side:THREE.DoubleSide})
|
2021-07-12 09:05:15 -04:00
|
|
|
);
|
2021-07-15 14:41:17 -04:00
|
|
|
|
|
|
|
|
let rebuildSurface = inVoxels =>
|
|
|
|
|
{
|
|
|
|
|
let surface = Region.Surface(inVoxels);
|
|
|
|
|
let vertsCube = new Float32Array(surface.vertices.flat());
|
|
|
|
|
|
|
|
|
|
surfaceCubeGeometry.setAttribute("position", new THREE.BufferAttribute(vertsCube, 3));
|
|
|
|
|
surfaceCubeGeometry.setIndex(surface.triPointVert);
|
|
|
|
|
surfaceCubeGeometry.computeVertexNormals(true);
|
|
|
|
|
};
|
|
|
|
|
rebuildSurface(voxels);
|
2021-07-07 07:26:21 -04:00
|
|
|
|
2021-07-11 09:24:39 -04:00
|
|
|
return {
|
2021-07-07 07:00:50 -04:00
|
|
|
DOM:"canvas",
|
|
|
|
|
Init(inScene)
|
2021-07-12 09:05:15 -04:00
|
|
|
{
|
|
|
|
|
let light = new THREE.PointLight(0xffffff, 1, 100)
|
2021-07-12 10:40:31 -04:00
|
|
|
light.position.set(5, 5, -5);
|
2021-07-12 09:05:15 -04:00
|
|
|
inScene.add(light)
|
|
|
|
|
inScene.add(surfaceCubeObject);
|
2021-07-15 14:41:17 -04:00
|
|
|
//inScene.add(surfaceSmoothObject);
|
2021-07-12 09:05:15 -04:00
|
|
|
|
2021-07-12 10:40:31 -04:00
|
|
|
inScene.add(new THREE.GridHelper(10, 10));
|
|
|
|
|
inScene.add(new THREE.AxesHelper( 5 ));
|
2021-07-07 07:00:50 -04:00
|
|
|
},
|
2021-07-15 14:41:17 -04:00
|
|
|
Update(inScene, inScreen, inDelta)
|
|
|
|
|
{
|
|
|
|
|
var i, hits, hit, index;
|
|
|
|
|
if(inScreen.Drag > 0)
|
|
|
|
|
{
|
|
|
|
|
hits = inScreen.Ray.intersectObject(surfaceCubeObject);
|
|
|
|
|
if(hits.length)
|
|
|
|
|
{
|
|
|
|
|
hit = hits[0];
|
|
|
|
|
for(i=1; i<hits.length; i++)
|
|
|
|
|
{
|
|
|
|
|
if(hits[i].distance < hit.distance)
|
|
|
|
|
{
|
|
|
|
|
hit = hits[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
index = Region.I(Math.floor(hit.point.x), Math.floor(hit.point.y), Math.floor(hit.point.z));
|
|
|
|
|
voxels[index] = true;
|
|
|
|
|
rebuildSurface(voxels);
|
|
|
|
|
console.log(hit);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-07-12 09:05:15 -04:00
|
|
|
};
|
2021-07-07 07:00:50 -04:00
|
|
|
|
2021-07-12 09:05:15 -04:00
|
|
|
}
|
2021-07-11 09:24:39 -04:00
|
|
|
|
|
|
|
|
Scene(surfaceTest());
|
2021-07-05 20:51:08 -04:00
|
|
|
|
|
|
|
|
</script>
|
2021-07-06 16:50:26 -04:00
|
|
|
|
2021-07-05 20:51:08 -04:00
|
|
|
</body>
|
|
|
|
|
</html>
|
