const { occt } = bitbybit;
enum cameraAnimationEnum {
ellipse,
spiral,
line,
};
let activeAnimation = cameraAnimationEnum.spiral;
const start = async () => {
const asset = await bitbybit.asset.getFile({ fileName: "plant.splat" });
const objectUrl = bitbybit.asset.createObjectURL({ file: asset });
const gs = await bitbybit.babylon.gaussianSplatting.create({
url: objectUrl
});
createVase();
setupCameraAndAnimations();
}
async function createVase() {
const shapesToDelete = [];
const cylinder = await occt.shapes.solid.createCylinder({
center: [0, 0, 0],
direction: [0, 1, 0],
height: 0.2,
radius: 0.7,
});
shapesToDelete.push(cylinder);
const ngon = await occt.shapes.wire.createNGonWire({
nrCorners: 6,
direction: [0, 1, 0],
radius: 1,
center: [0, 0, 0],
});
shapesToDelete.push(ngon);
const rotatedExtrude = await occt.operations.rotatedExtrude({
shape: ngon,
angle: 90,
height: 0.5,
});
shapesToDelete.push(rotatedExtrude);
const translatedExtrude = await occt.transforms.translate({
shape: rotatedExtrude,
translation: [0, -0.4, 0],
});
shapesToDelete.push(translatedExtrude);
const vaseBase = await occt.booleans.difference({
shape: translatedExtrude,
shapes: [cylinder],
keepEdges: false,
});
shapesToDelete.push(vaseBase);
const vase = await occt.fillets.filletEdges({
shape: vaseBase,
radius: 0.03,
});
bitbybit.occt.deleteShapes({ shapes: shapesToDelete });
const drawOptions = new Bit.Inputs.Draw.DrawOcctShapeOptions();
drawOptions.edgeColour = "#000000";
drawOptions.edgeWidth = 0.1;
drawOptions.faceColour = "#404040";
drawOptions.precision = 0.001;
bitbybit.draw.drawAnyAsync({
entity: vase,
options: drawOptions,
});
}
async function setupCameraAndAnimations() {
let wire;
if (activeAnimation === cameraAnimationEnum.ellipse) {
wire = await occt.shapes.wire.createEllipseWire({
center: [0, 2, 0],
radiusMinor: 4,
radiusMajor: 5,
direction: [1, 1, 0]
});
} else if (activeAnimation === cameraAnimationEnum.line) {
wire = await occt.shapes.wire.createLineWire({
start: [6, 2, 3],
end: [-6, 2, 3],
});
} else if (activeAnimation === cameraAnimationEnum.spiral) {
const radius = 4;
const step = 0.2;
const ptsSpiralBase: Bit.Inputs.Base.Point3[] = [
[radius, 0, 0],
[0, step * 1, radius],
[-radius, step * 2, 0],
[0, step * 3, -radius],
[radius, step * 4, 0],
[0, step * 5, radius],
[-radius, step * 6, 0],
[0, step * 7, -radius],
[radius, step * 8, 0],
[0, step * 9, radius],
[-radius, step * 10, 0],
[0, step * 11, -radius],
];
wire = await occt.shapes.wire.interpolatePoints({ points: ptsSpiralBase, periodic: false, tolerance: 0.01 });
}
const points = await occt.shapes.wire.divideWireByEqualDistanceToPoints({ shape: wire, nrOfDivisions: 10000, removeStartPoint: false, removeEndPoint: true });
const ptsLooped = [...points, ...points.reverse()]
const camera = bitbybit.babylon.scene.getActiveCamera() as BABYLON.ArcRotateCamera;
camera.target = new BABYLON.Vector3(0, 0.5, 0);
let index = 0;
bitbybit.time.registerRenderFunction(() => {
if (index < ptsLooped.length) {
const pt = ptsLooped[index];
camera.setPosition(new BABYLON.Vector3(pt[0], pt[1], pt[2]))
index++;
} else {
index = 0;
}
});
}
start();