@scenoco-three/core 0.1.0

package/dist/nodes/geometry/CylinderGeometry.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { CylinderGeometry } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { GEOMETRY_TARGETS } from '../targets.js';
+let CylinderGeometryNode = class CylinderGeometryNode extends Attachment {
+    radiusTop = 1;
+    radiusBottom = 1;
+    height = 1;
+    radialSegments = 32;
+    cached;
+    attach(ctx) {
+        ctx.node.geometry = (this.cached ??= new CylinderGeometry(this.radiusTop, this.radiusBottom, this.height, this.radialSegments));
+    }
+};
+__decorate([
+    property({ type: 'float', default: 1 })
+], CylinderGeometryNode.prototype, "radiusTop", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], CylinderGeometryNode.prototype, "radiusBottom", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], CylinderGeometryNode.prototype, "height", void 0);
+__decorate([
+    property({ type: 'int', default: 32 })
+], CylinderGeometryNode.prototype, "radialSegments", void 0);
+CylinderGeometryNode = __decorate([
+    attachment({ name: 'CylinderGeometry', target: GEOMETRY_TARGETS, group: 'geometry', required: true })
+], CylinderGeometryNode);
+export { CylinderGeometryNode };

package/dist/nodes/geometry/PlaneGeometry.d.ts

@@ -0,0 +1,11 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class PlaneGeometryNode extends Attachment<Mesh> {
+    width: number;
+    height: number;
+    widthSegments: number;
+    heightSegments: number;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/geometry/PlaneGeometry.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { PlaneGeometry } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { GEOMETRY_TARGETS } from '../targets.js';
+let PlaneGeometryNode = class PlaneGeometryNode extends Attachment {
+    width = 1;
+    height = 1;
+    widthSegments = 1;
+    heightSegments = 1;
+    cached;
+    attach(ctx) {
+        ctx.node.geometry = (this.cached ??= new PlaneGeometry(this.width, this.height, this.widthSegments, this.heightSegments));
+    }
+};
+__decorate([
+    property({ type: 'float', default: 1 })
+], PlaneGeometryNode.prototype, "width", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], PlaneGeometryNode.prototype, "height", void 0);
+__decorate([
+    property({ type: 'int', default: 1 })
+], PlaneGeometryNode.prototype, "widthSegments", void 0);
+__decorate([
+    property({ type: 'int', default: 1 })
+], PlaneGeometryNode.prototype, "heightSegments", void 0);
+PlaneGeometryNode = __decorate([
+    attachment({ name: 'PlaneGeometry', target: GEOMETRY_TARGETS, group: 'geometry', required: true })
+], PlaneGeometryNode);
+export { PlaneGeometryNode };

package/dist/nodes/geometry/SphereGeometry.d.ts

@@ -0,0 +1,10 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class SphereGeometryNode extends Attachment<Mesh> {
+    radius: number;
+    widthSegments: number;
+    heightSegments: number;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/geometry/SphereGeometry.js

@@ -0,0 +1,32 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { SphereGeometry } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { GEOMETRY_TARGETS } from '../targets.js';
+let SphereGeometryNode = class SphereGeometryNode extends Attachment {
+    radius = 1;
+    widthSegments = 32;
+    heightSegments = 16;
+    cached;
+    attach(ctx) {
+        ctx.node.geometry = (this.cached ??= new SphereGeometry(this.radius, this.widthSegments, this.heightSegments));
+    }
+};
+__decorate([
+    property({ type: 'float', default: 1 })
+], SphereGeometryNode.prototype, "radius", void 0);
+__decorate([
+    property({ type: 'int', default: 32 })
+], SphereGeometryNode.prototype, "widthSegments", void 0);
+__decorate([
+    property({ type: 'int', default: 16 })
+], SphereGeometryNode.prototype, "heightSegments", void 0);
+SphereGeometryNode = __decorate([
+    attachment({ name: 'SphereGeometry', target: GEOMETRY_TARGETS, group: 'geometry', required: true })
+], SphereGeometryNode);
+export { SphereGeometryNode };

package/dist/nodes/geometry/TorusGeometry.d.ts

@@ -0,0 +1,11 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class TorusGeometryNode extends Attachment<Mesh> {
+    radius: number;
+    tube: number;
+    radialSegments: number;
+    tubularSegments: number;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/geometry/TorusGeometry.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { TorusGeometry } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { GEOMETRY_TARGETS } from '../targets.js';
+let TorusGeometryNode = class TorusGeometryNode extends Attachment {
+    radius = 1;
+    tube = 0.4;
+    radialSegments = 12;
+    tubularSegments = 48;
+    cached;
+    attach(ctx) {
+        ctx.node.geometry = (this.cached ??= new TorusGeometry(this.radius, this.tube, this.radialSegments, this.tubularSegments));
+    }
+};
+__decorate([
+    property({ type: 'float', default: 1 })
+], TorusGeometryNode.prototype, "radius", void 0);
+__decorate([
+    property({ type: 'float', default: 0.4 })
+], TorusGeometryNode.prototype, "tube", void 0);
+__decorate([
+    property({ type: 'int', default: 12 })
+], TorusGeometryNode.prototype, "radialSegments", void 0);
+__decorate([
+    property({ type: 'int', default: 48 })
+], TorusGeometryNode.prototype, "tubularSegments", void 0);
+TorusGeometryNode = __decorate([
+    attachment({ name: 'TorusGeometry', target: GEOMETRY_TARGETS, group: 'geometry', required: true })
+], TorusGeometryNode);
+export { TorusGeometryNode };

package/dist/nodes/index.d.ts

@@ -0,0 +1,36 @@
+import './object3d/Scene.js';
+import './object3d/Object3D.js';
+import './object3d/Group.js';
+import './object3d/Bone.js';
+import './object3d/LOD.js';
+import './object3d/Mesh.js';
+import './object3d/InstancedMesh.js';
+import './object3d/SkinnedMesh.js';
+import './object3d/BatchedMesh.js';
+import './object3d/Line.js';
+import './object3d/LineLoop.js';
+import './object3d/LineSegments.js';
+import './object3d/Points.js';
+import './object3d/Sprite.js';
+import './object3d/AmbientLight.js';
+import './object3d/DirectionalLight.js';
+import './object3d/HemisphereLight.js';
+import './object3d/PointLight.js';
+import './object3d/RectAreaLight.js';
+import './object3d/SpotLight.js';
+import './object3d/PerspectiveCamera.js';
+import './object3d/OrthographicCamera.js';
+import './object3d/ArrayCamera.js';
+import './geometry/BoxGeometry.js';
+import './geometry/SphereGeometry.js';
+import './geometry/CylinderGeometry.js';
+import './geometry/PlaneGeometry.js';
+import './geometry/TorusGeometry.js';
+import './material/MeshStandardMaterial.js';
+import './material/MeshBasicMaterial.js';
+import './material/LineBasicMaterial.js';
+import './material/PointsMaterial.js';
+import './material/SpriteMaterial.js';
+import './setting/Fog.js';
+import './setting/FogExp2.js';
+import './setting/Background.js';

package/dist/nodes/index.js

@@ -0,0 +1,46 @@
+// Built-in node tags. Importing this module registers every built-in into the
+// NodeRegistry (each file self-registers via a define* call). Add a new built-in
+// by dropping a file in the right folder and importing it here.
+// ---- Object3D family: structural --------------------------------------------
+import './object3d/Scene.js';
+import './object3d/Object3D.js';
+import './object3d/Group.js';
+import './object3d/Bone.js';
+import './object3d/LOD.js';
+// ---- Object3D family: renderables -------------------------------------------
+import './object3d/Mesh.js';
+import './object3d/InstancedMesh.js';
+import './object3d/SkinnedMesh.js';
+import './object3d/BatchedMesh.js';
+import './object3d/Line.js';
+import './object3d/LineLoop.js';
+import './object3d/LineSegments.js';
+import './object3d/Points.js';
+import './object3d/Sprite.js';
+// ---- Object3D family: lights ------------------------------------------------
+import './object3d/AmbientLight.js';
+import './object3d/DirectionalLight.js';
+import './object3d/HemisphereLight.js';
+import './object3d/PointLight.js';
+import './object3d/RectAreaLight.js';
+import './object3d/SpotLight.js';
+// ---- Object3D family: cameras -----------------------------------------------
+import './object3d/PerspectiveCamera.js';
+import './object3d/OrthographicCamera.js';
+import './object3d/ArrayCamera.js';
+// ---- Geometries -------------------------------------------------------------
+import './geometry/BoxGeometry.js';
+import './geometry/SphereGeometry.js';
+import './geometry/CylinderGeometry.js';
+import './geometry/PlaneGeometry.js';
+import './geometry/TorusGeometry.js';
+// ---- Materials --------------------------------------------------------------
+import './material/MeshStandardMaterial.js';
+import './material/MeshBasicMaterial.js';
+import './material/LineBasicMaterial.js';
+import './material/PointsMaterial.js';
+import './material/SpriteMaterial.js';
+// ---- Scene settings (config children of <Scene>) ----------------------------
+import './setting/Fog.js';
+import './setting/FogExp2.js';
+import './setting/Background.js';

package/dist/nodes/manifest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Maps each built-in node tag to the package subpath that registers it, so the
+ * build tooling (Vite plugin) can emit **usage-based imports** for built-ins —
+ * exactly the way it does for project `@component` files. A scene that uses only
+ * `<Mesh><BoxGeometry/>` ships `Mesh.js` + `BoxGeometry.js` (and just their three
+ * classes), not the whole node set.
+ *
+ * The runtime entry (`@scenoco-three/core`) deliberately does NOT import these,
+ * so `import { Engine } from '@scenoco-three/core'` pulls in zero node modules
+ * and the bundler tree-shakes everything unused. `@scenoco-three/core/nodes`
+ * (the barrel) registers them all, for Node tooling / tests / non-bundled use.
+ *
+ * Kept in sync with `nodes/index.ts` by `tests/treeshake.test.ts`, which fails
+ * if a registered built-in is missing here (or vice versa).
+ */
+export declare const builtinNodeModules: Record<string, string>;
+/** The package subpath that registers a built-in tag, or undefined if not a built-in. */
+export declare function builtinNodeModule(tag: string): string | undefined;

package/dist/nodes/manifest.js

@@ -0,0 +1,64 @@
+/**
+ * Maps each built-in node tag to the package subpath that registers it, so the
+ * build tooling (Vite plugin) can emit **usage-based imports** for built-ins —
+ * exactly the way it does for project `@component` files. A scene that uses only
+ * `<Mesh><BoxGeometry/>` ships `Mesh.js` + `BoxGeometry.js` (and just their three
+ * classes), not the whole node set.
+ *
+ * The runtime entry (`@scenoco-three/core`) deliberately does NOT import these,
+ * so `import { Engine } from '@scenoco-three/core'` pulls in zero node modules
+ * and the bundler tree-shakes everything unused. `@scenoco-three/core/nodes`
+ * (the barrel) registers them all, for Node tooling / tests / non-bundled use.
+ *
+ * Kept in sync with `nodes/index.ts` by `tests/treeshake.test.ts`, which fails
+ * if a registered built-in is missing here (or vice versa).
+ */
+export const builtinNodeModules = {
+    // object3d — structural
+    Scene: '@scenoco-three/core/nodes/object3d/Scene.js',
+    Object3D: '@scenoco-three/core/nodes/object3d/Object3D.js',
+    Group: '@scenoco-three/core/nodes/object3d/Group.js',
+    Bone: '@scenoco-three/core/nodes/object3d/Bone.js',
+    LOD: '@scenoco-three/core/nodes/object3d/LOD.js',
+    // object3d — renderables
+    Mesh: '@scenoco-three/core/nodes/object3d/Mesh.js',
+    InstancedMesh: '@scenoco-three/core/nodes/object3d/InstancedMesh.js',
+    SkinnedMesh: '@scenoco-three/core/nodes/object3d/SkinnedMesh.js',
+    BatchedMesh: '@scenoco-three/core/nodes/object3d/BatchedMesh.js',
+    Line: '@scenoco-three/core/nodes/object3d/Line.js',
+    LineLoop: '@scenoco-three/core/nodes/object3d/LineLoop.js',
+    LineSegments: '@scenoco-three/core/nodes/object3d/LineSegments.js',
+    Points: '@scenoco-three/core/nodes/object3d/Points.js',
+    Sprite: '@scenoco-three/core/nodes/object3d/Sprite.js',
+    // object3d — lights
+    AmbientLight: '@scenoco-three/core/nodes/object3d/AmbientLight.js',
+    DirectionalLight: '@scenoco-three/core/nodes/object3d/DirectionalLight.js',
+    HemisphereLight: '@scenoco-three/core/nodes/object3d/HemisphereLight.js',
+    PointLight: '@scenoco-three/core/nodes/object3d/PointLight.js',
+    RectAreaLight: '@scenoco-three/core/nodes/object3d/RectAreaLight.js',
+    SpotLight: '@scenoco-three/core/nodes/object3d/SpotLight.js',
+    // object3d — cameras
+    PerspectiveCamera: '@scenoco-three/core/nodes/object3d/PerspectiveCamera.js',
+    OrthographicCamera: '@scenoco-three/core/nodes/object3d/OrthographicCamera.js',
+    ArrayCamera: '@scenoco-three/core/nodes/object3d/ArrayCamera.js',
+    // geometries
+    BoxGeometry: '@scenoco-three/core/nodes/geometry/BoxGeometry.js',
+    SphereGeometry: '@scenoco-three/core/nodes/geometry/SphereGeometry.js',
+    CylinderGeometry: '@scenoco-three/core/nodes/geometry/CylinderGeometry.js',
+    PlaneGeometry: '@scenoco-three/core/nodes/geometry/PlaneGeometry.js',
+    TorusGeometry: '@scenoco-three/core/nodes/geometry/TorusGeometry.js',
+    // materials
+    MeshStandardMaterial: '@scenoco-three/core/nodes/material/MeshStandardMaterial.js',
+    MeshBasicMaterial: '@scenoco-three/core/nodes/material/MeshBasicMaterial.js',
+    LineBasicMaterial: '@scenoco-three/core/nodes/material/LineBasicMaterial.js',
+    PointsMaterial: '@scenoco-three/core/nodes/material/PointsMaterial.js',
+    SpriteMaterial: '@scenoco-three/core/nodes/material/SpriteMaterial.js',
+    // settings
+    Fog: '@scenoco-three/core/nodes/setting/Fog.js',
+    FogExp2: '@scenoco-three/core/nodes/setting/FogExp2.js',
+    Background: '@scenoco-three/core/nodes/setting/Background.js',
+};
+/** The package subpath that registers a built-in tag, or undefined if not a built-in. */
+export function builtinNodeModule(tag) {
+    return builtinNodeModules[tag];
+}

package/dist/nodes/material/LineBasicMaterial.d.ts

@@ -0,0 +1,11 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class LineBasicMaterialNode extends Attachment<Mesh> {
+    color: number;
+    linewidth: number;
+    opacity: number;
+    transparent: boolean;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/material/LineBasicMaterial.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LineBasicMaterial } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { MATERIAL_TARGETS } from '../targets.js';
+let LineBasicMaterialNode = class LineBasicMaterialNode extends Attachment {
+    color = 0xffffff;
+    linewidth = 1;
+    opacity = 1;
+    transparent = false;
+    cached;
+    attach(ctx) {
+        ctx.node.material = (this.cached ??= new LineBasicMaterial({
+            color: this.color,
+            linewidth: this.linewidth,
+            opacity: this.opacity,
+            transparent: this.transparent,
+        }));
+    }
+};
+__decorate([
+    property({ type: 'color', default: 0xffffff })
+], LineBasicMaterialNode.prototype, "color", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], LineBasicMaterialNode.prototype, "linewidth", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], LineBasicMaterialNode.prototype, "opacity", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], LineBasicMaterialNode.prototype, "transparent", void 0);
+LineBasicMaterialNode = __decorate([
+    attachment({ name: 'LineBasicMaterial', target: MATERIAL_TARGETS, group: 'material' })
+], LineBasicMaterialNode);
+export { LineBasicMaterialNode };

package/dist/nodes/material/MeshBasicMaterial.d.ts

@@ -0,0 +1,11 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class MeshBasicMaterialNode extends Attachment<Mesh> {
+    color: number;
+    opacity: number;
+    transparent: boolean;
+    wireframe: boolean;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/material/MeshBasicMaterial.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MeshBasicMaterial } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { MATERIAL_TARGETS } from '../targets.js';
+let MeshBasicMaterialNode = class MeshBasicMaterialNode extends Attachment {
+    color = 0xffffff;
+    opacity = 1;
+    transparent = false;
+    wireframe = false;
+    cached;
+    attach(ctx) {
+        ctx.node.material = (this.cached ??= new MeshBasicMaterial({
+            color: this.color,
+            opacity: this.opacity,
+            transparent: this.transparent,
+            wireframe: this.wireframe,
+        }));
+    }
+};
+__decorate([
+    property({ type: 'color', default: 0xffffff })
+], MeshBasicMaterialNode.prototype, "color", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], MeshBasicMaterialNode.prototype, "opacity", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], MeshBasicMaterialNode.prototype, "transparent", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], MeshBasicMaterialNode.prototype, "wireframe", void 0);
+MeshBasicMaterialNode = __decorate([
+    attachment({ name: 'MeshBasicMaterial', target: MATERIAL_TARGETS, group: 'material' })
+], MeshBasicMaterialNode);
+export { MeshBasicMaterialNode };

package/dist/nodes/material/MeshStandardMaterial.d.ts

@@ -0,0 +1,14 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class MeshStandardMaterialNode extends Attachment<Mesh> {
+    color: number;
+    roughness: number;
+    metalness: number;
+    emissive: number;
+    opacity: number;
+    transparent: boolean;
+    wireframe: boolean;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/material/MeshStandardMaterial.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MeshStandardMaterial } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { MATERIAL_TARGETS } from '../targets.js';
+let MeshStandardMaterialNode = class MeshStandardMaterialNode extends Attachment {
+    color = 0xffffff;
+    roughness = 1;
+    metalness = 0;
+    emissive = 0x000000;
+    opacity = 1;
+    transparent = false;
+    wireframe = false;
+    cached;
+    attach(ctx) {
+        ctx.node.material = (this.cached ??= new MeshStandardMaterial({
+            color: this.color,
+            roughness: this.roughness,
+            metalness: this.metalness,
+            emissive: this.emissive,
+            opacity: this.opacity,
+            transparent: this.transparent,
+            wireframe: this.wireframe,
+        }));
+    }
+};
+__decorate([
+    property({ type: 'color', default: 0xffffff })
+], MeshStandardMaterialNode.prototype, "color", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], MeshStandardMaterialNode.prototype, "roughness", void 0);
+__decorate([
+    property({ type: 'float', default: 0 })
+], MeshStandardMaterialNode.prototype, "metalness", void 0);
+__decorate([
+    property({ type: 'color', default: 0x000000 })
+], MeshStandardMaterialNode.prototype, "emissive", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], MeshStandardMaterialNode.prototype, "opacity", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], MeshStandardMaterialNode.prototype, "transparent", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], MeshStandardMaterialNode.prototype, "wireframe", void 0);
+MeshStandardMaterialNode = __decorate([
+    attachment({ name: 'MeshStandardMaterial', target: MATERIAL_TARGETS, group: 'material' })
+], MeshStandardMaterialNode);
+export { MeshStandardMaterialNode };

package/dist/nodes/material/PointsMaterial.d.ts

@@ -0,0 +1,12 @@
+import { type Mesh } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class PointsMaterialNode extends Attachment<Mesh> {
+    color: number;
+    size: number;
+    sizeAttenuation: boolean;
+    opacity: number;
+    transparent: boolean;
+    private cached?;
+    attach(ctx: AttachContext<Mesh>): void;
+}

package/dist/nodes/material/PointsMaterial.js

@@ -0,0 +1,46 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { PointsMaterial } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { MATERIAL_TARGETS } from '../targets.js';
+let PointsMaterialNode = class PointsMaterialNode extends Attachment {
+    color = 0xffffff;
+    size = 1;
+    sizeAttenuation = true;
+    opacity = 1;
+    transparent = false;
+    cached;
+    attach(ctx) {
+        ctx.node.material = (this.cached ??= new PointsMaterial({
+            color: this.color,
+            size: this.size,
+            sizeAttenuation: this.sizeAttenuation,
+            opacity: this.opacity,
+            transparent: this.transparent,
+        }));
+    }
+};
+__decorate([
+    property({ type: 'color', default: 0xffffff })
+], PointsMaterialNode.prototype, "color", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], PointsMaterialNode.prototype, "size", void 0);
+__decorate([
+    property({ type: 'bool', default: true })
+], PointsMaterialNode.prototype, "sizeAttenuation", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], PointsMaterialNode.prototype, "opacity", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], PointsMaterialNode.prototype, "transparent", void 0);
+PointsMaterialNode = __decorate([
+    attachment({ name: 'PointsMaterial', target: MATERIAL_TARGETS, group: 'material' })
+], PointsMaterialNode);
+export { PointsMaterialNode };

package/dist/nodes/material/SpriteMaterial.d.ts

@@ -0,0 +1,11 @@
+import { type Sprite } from 'three';
+import { Attachment } from '../base.js';
+import type { AttachContext } from '../../core/NodeRegistry.js';
+export declare class SpriteMaterialNode extends Attachment<Sprite> {
+    color: number;
+    rotation: number;
+    opacity: number;
+    transparent: boolean;
+    private cached?;
+    attach(ctx: AttachContext<Sprite>): void;
+}

package/dist/nodes/material/SpriteMaterial.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { SpriteMaterial } from 'three';
+import { Attachment } from '../base.js';
+import { attachment, property } from '../../core/decorators.js';
+import { MATERIAL_TARGETS } from '../targets.js';
+let SpriteMaterialNode = class SpriteMaterialNode extends Attachment {
+    color = 0xffffff;
+    rotation = 0;
+    opacity = 1;
+    transparent = false;
+    cached;
+    attach(ctx) {
+        ctx.node.material = (this.cached ??= new SpriteMaterial({
+            color: this.color,
+            rotation: this.rotation,
+            opacity: this.opacity,
+            transparent: this.transparent,
+        }));
+    }
+};
+__decorate([
+    property({ type: 'color', default: 0xffffff })
+], SpriteMaterialNode.prototype, "color", void 0);
+__decorate([
+    property({ type: 'float', default: 0, description: 'Rotation of the sprite in radians' })
+], SpriteMaterialNode.prototype, "rotation", void 0);
+__decorate([
+    property({ type: 'float', default: 1 })
+], SpriteMaterialNode.prototype, "opacity", void 0);
+__decorate([
+    property({ type: 'bool', default: false })
+], SpriteMaterialNode.prototype, "transparent", void 0);
+SpriteMaterialNode = __decorate([
+    attachment({ name: 'SpriteMaterial', target: MATERIAL_TARGETS, group: 'material' })
+], SpriteMaterialNode);
+export { SpriteMaterialNode };