SethTrowbridge/voxel
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: SethTrowbridge:averager
Branches Tags
SethTrowbridge:master
SethTrowbridge:refactor
SethTrowbridge:cube-gen
SethTrowbridge:orientation-groups
SethTrowbridge:surfacer
SethTrowbridge:averager
..
compare: SethTrowbridge:master
Branches Tags
SethTrowbridge:refactor
SethTrowbridge:cube-gen
SethTrowbridge:orientation-groups
SethTrowbridge:surfacer
SethTrowbridge:averager
SethTrowbridge:master

No commits in common. "averager" and "master" have entirely different histories.
averager ... master

2 changed files with 109 additions and 181 deletions
Show Stats Expand all files Collapse all files

215
index.html
View File

@ -19,137 +19,122 @@
</head> </head>
<body> <body>
<canvas></canvas> <canvas></canvas>
<script type="module"> <script type="module">
import { Scene, THREE } from './scene.js'; import * as T from 'http://esm.sh/three';
import { OrbitControls } from 'http://esm.sh/three/examples/jsm/controls/OrbitControls.js';
import { Region, Kernel } from "./region.js";
let average = (inArray, inPointInd, ...inOthersInd) => const renderer = new T.WebGLRenderer({canvas:document.querySelector("canvas")});
{ const scene = new T.Scene();
let sum = [0, 0, 0]; const camera = new T.PerspectiveCamera(80, 2, 0.1, 10);
for(let i=0; i<inOthersInd.length; i++) const light = new T.DirectionalLight(0xFFFFFF, 1);
{ const geometry = new T.BoxGeometry(0.8, 0.8, 0.8);
let otherInd = inOthersInd[i]*3; const shader = new T.MeshPhongMaterial({color:0xFFCC00});
sum[0] += inArray[otherInd+0]; const shaderBlue = new T.MeshPhongMaterial({color:0x0033FF});
sum[1] += inArray[otherInd+1]; const object = new T.Mesh(geometry, shader);
sum[2] += inArray[otherInd+2];
}
let pointX = inPointInd*3 + 0; const controls = new OrbitControls(camera, renderer.domElement);
let pointY = inPointInd*3 + 1; controls.update();
let pointZ = inPointInd*3 + 2;
let reducer = inOthersInd.length;
let limit = (inCenter, inPoint) =>
{
var limit;
limit = inCenter-0.49;
if(inPoint <= limit)
{
return limit;
}
limit = inCenter + 0.49;
if(inPoint >= limit)
{
return limit;
}
return inPoint; scene.add(light);
} scene.add(object);
inArray[pointX] = limit(Math.round(inArray[pointX]), sum[0]/reducer); scene.add(new T.GridHelper(10, 10));
inArray[pointY] = limit(Math.round(inArray[pointY]), sum[1]/reducer);
inArray[pointZ] = limit(Math.round(inArray[pointZ]), sum[2]/reducer);
}; const geoBuff = new T.BufferGeometry();
let smooth = (inArray, inTimes) => geoBuff.setAttribute("position", new T.BufferAttribute(new Float32Array(
{ [
let count = inArray.length/3; 0, 0, 0,
for(let t=0; t<inTimes; t++) 1, 0, 0,
{ 1, 1, 0,
for(let i=0; i<count; i++) 0, 1, 0,
{ 2, 0, 1,
if(i==0) 2, 1, 1
{ ]
average(inArray, i, count-1, i+1); ), 3));
}
else geoBuff.setIndex(
{ [
if(i==count-1) 0, 1, 2,
{ 2, 3, 0,
average(inArray, i, i-1, 0); 1, 4, 5,
} 5, 2, 1
else ]
{ );
average(inArray, i, i-1, i+1); geoBuff.computeVertexNormals();
} const geoObj = new T.Mesh(geoBuff, shader);
} shader.shading = T.FlatShading;
} scene.add(geoObj);
}
}
/* /*
let testPoints = let r = Region.Create();
[ let filler = (x, y, z) =>
0, 0, 0, {
0, 1, 0, r.Voxels[Region.CoordsToIndex(x, y, z)] = true;
1, 1, 0 };
]; filler(1, 1, 1);
console.log(testPoints); Kernel.Loop(Kernel.Corners, [1, 1, 1], filler);
average(testPoints, 1, 0, 2); Kernel.Loop(Kernel.Cardinal, [1, 1, 1], filler);
console.log(testPoints); Region.Update(r);
r.Filled.forEach((inIndexMap) =>
{
let coords = Region.IndexToCoords(inIndexMap);
let cube = new T.Mesh(geometry, shader);
cube.position.set(...coords);
scene.add(cube);
});
r.Surface.forEach((inIndexMap) =>
{
let coords = Region.IndexToCoords(inIndexMap);
let cube = new T.Mesh(geometry, shaderBlue);
cube.position.set(...coords);
scene.add(cube);
});
*/ */
let path = (inPoints, inSmoothing, inColor) => light.position.set(-1, 2, 4);
{ camera.position.set(0, 0, 2);
let clone = [...inPoints];
smooth(clone, inSmoothing);
const geometry = new THREE.BufferGeometry();
geometry.setAttribute('position', new THREE.Float32BufferAttribute( clone, 3 ));
const materialLine = new THREE.LineBasicMaterial( { color: inColor, linewidth: 3 } );
const materialPoint = new THREE.PointsMaterial( { color:inColor, size: 0.05 } );
const output = new THREE.Group();
output.add( new THREE.Line( geometry, materialLine ) ); let dirty = false;
output.add( new THREE.Points( geometry, materialPoint ) ); const update = inTime =>
return output; {
let timeNew = new Date();
let timeDelta = timeNew - inTime;
let delta = timeDelta * 0.001;
object.rotation.x += delta;
controls.update();
dirty = true;
setTimeout(()=>update(timeNew), 100);
} }
const points = const render = inTime =>
[
4, 0, 0,
3, 0, 0,
2, 0, 0,
1, 0, 0,
//
0, 0, 0,
0, 1, 0,
1, 1, 0,
2, 1, 0,
2, 2, 0,
3, 2, 0,
4, 2, 0,
4, 3, 0,
//
5, 3, 0,
5, 2, 0,
5, 1, 0,
5, 0, 0,
];
Scene(
{ {
DOM:"canvas", if(dirty)
Init(inScene)
{ {
inScene.add(path(points, 0, 0xFF0000)); renderer.render(scene, camera);
inScene.add(path(points, 10, 0x00ff00)); dirty = false;
},
Update(scene, delta)
{
} }
requestAnimationFrame(render);
} }
);
const resize = () =>
{
let canvas = renderer.domElement;
camera.aspect = canvas.clientWidth / canvas.clientHeight;
camera.updateProjectionMatrix();
renderer.setSize(canvas.clientWidth, canvas.clientHeight, false);
};
window.addEventListener("resize", resize);
resize();
render(0);
update(new Date());
</script> </script>
</body> </body>

57
scene.js
View File

@ -1,57 +0,0 @@
import * as T from 'http://esm.sh/three';
import { OrbitControls } from 'http://esm.sh/three/examples/jsm/controls/OrbitControls.js';
export { T as THREE };
export function Scene(inSettings)
{
const renderer = new T.WebGLRenderer({canvas:document.querySelector(inSettings.DOM)});
const scene = new T.Scene();
const camera = new T.PerspectiveCamera(80, 2, 0.1, 10);
const light = new T.DirectionalLight(0xFFFFFF, 1);
const controls = new OrbitControls(camera, renderer.domElement);
let dirty = false;
const update = inTime =>
{
let timeNew = new Date();
let timeDelta = timeNew - inTime;
let delta = timeDelta * 0.001;
inSettings.Update(scene, delta);
controls.update();
dirty = true;
setTimeout(()=>update(timeNew), 50);
}
const render = inTime =>
{
if(dirty)
{
renderer.render(scene, camera);
dirty = false;
}
requestAnimationFrame(render);
}
const resize = () =>
{
let canvas = renderer.domElement;
camera.aspect = canvas.clientWidth / canvas.clientHeight;
camera.updateProjectionMatrix();
renderer.setSize(canvas.clientWidth, canvas.clientHeight, false);
};
scene.add(light);
//scene.add(new T.GridHelper(10, 10));
light.position.set(-1, 2, 4);
camera.position.set(0, 0, 2);
controls.update();
inSettings.Init(scene);
window.addEventListener("resize", resize);
resize();
render(0);
update(new Date());
};