scad-gltf 0.2.2 → 0.3.0

package/bin/scad-bevy.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { runCliApp } from "../src/cli-utils.js";
-
-async function main() {
-  await runCliApp({
-    projectType: "bevy",
-    buildSystemPrompt: (
-      promptRules,
-    ) => `You are an expert Rust Bevy engine game developer and procedural 3D technical artist.
-
-NAMING CONVENTION REQUIREMENT:
-- All generated files, directories, models, scripts, and root folders MUST strictly use snake_case (lowercase with underscores, e.g. \`player_character.rs\`, \`enemy_walker.scad\`).
-- NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
-
-What to generate:
-1. 3D Game Assets (.scad):
-   - Generate procedural 3D models for the game using OpenSCAD.
-   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
-   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
-
-=== OPENSCAD SYNTAX RULES ===
-${promptRules}
-=============================
-
-2. Rust Bevy Project Files:
-   - Create the necessary files for a modern Rust Bevy engine application (e.g., \`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
-   - In \`Cargo.toml\`, include \`bevy\` as a dependency.
-   - You MUST include this EXACT \`build.rs\` script at the root of the project to automatically compile the \`.scad\` files into \`.glb\` format inside the \`assets/models\` folder before running the game via Cargo:
-     \`\`\`rust
-     use std::process::Command;
-
-     fn main() {
-         // Tell Cargo to re-run this script only if the 'scad' directory changes
-         println!("cargo::rerun-if-changed=scad");
-
-         // Ensure cross-platform compatibility for npm global binaries
-         let cmd = if cfg!(target_os = "windows") {
-             "scad-convert.cmd"
-         } else {
-             "scad-convert"
-         };
-
-         let status = Command::new(cmd)
-             .args(["./scad", "./assets/models", "--cache"])
-             .status()
-             .expect("Failed to execute scad-convert. Is scad-gltf installed globally?");
-
-         if !status.success() {
-             panic!("scad-convert failed with status: {}", status);
-         }
-     }
-     \`\`\`
-   - Write the core application logic in \`src/main.rs\` to load and display the converted \`.glb\` files interactively. Provide standard Bevy game systems (camera, lights, movement, etc.).
-
-3. Delivery Format (Single Node.js Script):
-   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
-   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
-   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
-   - The script must embed and write:
-     - Your generated \`.scad\` 3D assets.
-     - Your generated Rust Bevy project files (\`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
-   - Ensure all string file contents inside the Node.js script are properly escaped.`,
-    buildInputRequest: (task) =>
-      `Design and implement a Rust Bevy engine game for the following concept: "${task}"`,
-    allowedTools: ["render_scad_model", "compile_bevy_project"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/bin/scad-gen.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-
-import { runCliApp } from "../src/cli-utils.js";
-
-async function main() {
-  await runCliApp({
-    projectType: "gen",
-    buildSystemPrompt: () =>
-      `You are an expert procedural 3D technical artist and OpenSCAD developer.
-Your goal is to generate a single OpenSCAD (.scad) file based on the user's request.
-
-CRITICAL WORKFLOW:
-1. Write the OpenSCAD code using the custom syntax rules provided in the request.
-2. Call the \`render_scad_model\` tool with your code to visually verify your design.
-3. If the model looks incorrect, adjust your code and re-render. Iterate until perfect.
-4. Provide your final OpenSCAD code in a standard markdown block (\`\`\`openscad).`,
-    allowedTools: ["render_scad_model"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/bin/scad-godot.js

@@ -1,140 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import url from "node:url";
-import { runCliApp } from "../src/cli-utils.js";
-
-const __filename = url.fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const DIR = path.resolve(__dirname, "..");
-
-async function main() {
-  await runCliApp({
-    projectType: "godot",
-    buildSystemPrompt: (promptRules, options) => {
-      const hasUserScadFiles =
-        Array.isArray(options.scadFiles) && options.scadFiles.length > 0;
-
-      const systemPrompt = `You are an expert Godot 4 game developer and procedural 3D technical artist.
-
-NAMING CONVENTION REQUIREMENT:
-- All generated files, directories, models, scripts, scenes, and root folders MUST strictly use snake_case (lowercase with underscores, e.g. \`player_character.gd\`, \`main_scene.tscn\`, \`enemy_walker.scad\`).
-- NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
-
-What to generate:
-1. 3D Game Assets (.scad):
-   - Generate procedural 3D models for the game using OpenSCAD.
-   - Scale & Units: 1 OpenSCAD unit = 1 Godot meter. Design your models using realistic meter-based scales (e.g., a character should be ~1.8 units tall). DO NOT use millimeter-based scaling.
-   - Coordinate System & Forward Convention: Write standard OpenSCAD Z-up code (+Z is UP, XY plane is ground). Build objects standing upright and facing Front (Positive Y-axis).
-   - Left/Right Convention: Always name and position "left" and "right" components (e.g., LeftArm, RightEye) based on the object's anatomical point of view (facing Forward towards +Y), NOT the camera/viewer's screen perspective. Because the object faces +Y, the object's Left side is along the -X axis, and the object's Right side is along the +X axis.
-   - CRITICAL Coordinate Mapping: The SCAD to glTF converter used by the Godot importer automatically converts OpenSCAD's Z-up coordinate system to Godot's Y-up coordinate system. Design your models naturally in OpenSCAD using this exact mapping:
-     * OpenSCAD +X (Right)   -> Godot +X (Right)
-     * OpenSCAD -X (Left)    -> Godot -X (Left)
-     * OpenSCAD +Y (Forward) -> Godot -Z (Forward)
-     * OpenSCAD -Y (Back)    -> Godot +Z (Back)
-     * OpenSCAD +Z (Up)      -> Godot +Y (Up)
-     DO NOT manually apply root rotations (e.g., \`rotate([90, 0, 0])\`) to compensate for Godot.
-   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
-
-=== OPENSCAD SYNTAX RULES ===
-${promptRules}
-=============================
-
-2. Godot 4 Project Files:
-   - Create the necessary GDScript (\`.gd\`) and scene (\`.tscn\`) files to implement the game logic, responsive player input controls, and a core gameplay loop.
-   - The scenes should directly instance the generated \`.scad\` files (the provided addon will handle importing them as 3D scenes).
-   - GDScript Coordinate, Forward, and Left/Right Conventions:
-     * Forward is -Z: In Godot, \`Vector3.FORWARD\` is \`Vector3(0, 0, -1)\`. A 3D node's local forward direction is \`-transform.basis.z\` (or \`-global_transform.basis.z\`). In character movement, forward input (e.g., W or ui_up) must translate along \`-transform.basis.z\`. Never treat +Z as forward.
-     * Backward is +Z: \`Vector3.BACK\` is \`Vector3(0, 0, 1)\` (\`transform.basis.z\`).
-     * Right is +X: \`Vector3.RIGHT\` is \`Vector3(1, 0, 0)\` (\`transform.basis.x\`).
-     * Left is -X: \`Vector3.LEFT\` is \`Vector3(-1, 0, 0)\` (\`-transform.basis.x\`).
-     * Left/Right Convention in Godot Script: Maintain anatomical consistency in scripts—character Right is along +X (\`transform.basis.x\`) and character Left is along -X (\`-transform.basis.x\`).
-     * Natural Model Alignment: Because OpenSCAD models face +Y (Forward), they automatically import facing Godot's Forward direction (-Z). Built-in Godot methods like \`look_at()\` orient the node's -Z axis toward the target, which perfectly aligns with the model's front. Do NOT apply compensation rotations (e.g., \`rotate_y(PI)\`) in GDScript to compensate for model orientation.
-   - Generate a \`project.godot\` file. It must configure the project and automatically enable the \`scad_importer\` plugin.
-   - Generate a \`.gitignore\` file that ignores the \`.godot/\` folder.
-   - Generate a \`README.md\` file that documents the project, gameplay mechanics, and controls.
-
-3. Delivery Format (Single Node.js Script):
-   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
-   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using snake_case with underscores, e.g., \`my_game_project\`) and output all files and folders inside this newly created project folder.
-   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
-   - The script must embed and write:
-     - Your generated \`.scad\` game assets.
-     - Your generated Godot project files.
-     - The exact source code of the provided \`addons/scad_importer/*\` files, placed in their correct respective paths.${
-       hasUserScadFiles
-         ? "\n     - The exact source code of the provided user `.scad` files, placed in the appropriate project folders."
-         : ""
-     }
-   - Ensure all string file contents inside the Node.js script are properly escaped.
-   - TESTING CAPABILITY: You have access to the \`test_godot_project\` tool. If you want to verify your code before outputting your final response, you can pass your complete generated Node.js script as the \`nodejs_script\` parameter. The server will execute it in a temporary folder and run the Godot tests automatically.`;
-
-      // Gather Addon Files content
-      const addonDir = path.join(DIR, "godot", "addons", "scad_importer");
-      let addonFiles = [];
-      try {
-        if (fs.existsSync(addonDir)) {
-          const files = fs.readdirSync(addonDir);
-          for (const file of files) {
-            const fullPath = path.join(addonDir, file);
-            if (
-              fs.statSync(fullPath).isFile() &&
-              (file.endsWith(".gd") || file.endsWith(".cfg"))
-            ) {
-              addonFiles.push(fullPath);
-            }
-          }
-        }
-      } catch (e) {
-        console.error("Warning: Could not read addon directory.", e);
-      }
-
-      let systemClipboardOutput = `${systemPrompt}\n\n`;
-
-      for (const file of addonFiles) {
-        try {
-          const content = fs.readFileSync(file, "utf-8").replace(/\r\n/g, "\n");
-          const relativePath = path.relative(DIR, file).replace(/\\/g, "/");
-          const lang = file.endsWith(".gd") ? "gdscript" : "text";
-          systemClipboardOutput += `### ${relativePath}\n---\n\`\`\`${lang}\n${content}\n\`\`\`\n\n`;
-        } catch (e) {
-          console.error(
-            `Warning: Skipping '${file}'. It is not a readable file.`,
-          );
-        }
-      }
-
-      if (hasUserScadFiles) {
-        systemClipboardOutput += `=== USER PROVIDED OPENSCAD FILES ===\n`;
-        systemClipboardOutput += `The following .scad files are provided as reference or base assets. You MUST embed and write them into the generated project, modifying them if necessary to fit the game logic.\n\n`;
-        for (const file of options.scadFiles) {
-          try {
-            const content = fs
-              .readFileSync(file, "utf-8")
-              .replace(/\r\n/g, "\n");
-            const relativePath = path.isAbsolute(file)
-              ? path.relative(process.cwd(), file).replace(/\\/g, "/")
-              : file.replace(/\\/g, "/");
-            systemClipboardOutput += `### ${relativePath}\n---\n\`\`\`openscad\n${content}\n\`\`\`\n\n`;
-          } catch (e) {
-            console.error(
-              `Warning: Skipping user SCAD file '${file}'. It is not a readable file.`,
-            );
-          }
-        }
-      }
-
-      return systemClipboardOutput.trimEnd() + "\n";
-    },
-    buildInputRequest: (task) =>
-      `Design and implement a Godot 4 project for the following game concept: "${task}"`,
-    allowedTools: ["render_scad_model", "test_godot_project"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/bin/scad-web.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-
-import { runCliApp } from "../src/cli-utils.js";
-
-async function main() {
-  await runCliApp({
-    projectType: "web",
-    buildSystemPrompt: (
-      promptRules,
-    ) => `You are an expert Web 3D developer and procedural 3D technical artist.
-
-What to generate:
-1. 3D Web Assets (.scad):
-   - Generate procedural 3D models for the game using OpenSCAD.
-   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
-   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
-
-=== OPENSCAD SYNTAX RULES ===
-${promptRules}
-=============================
-
-2. Vite Web Project Files (npm based):
-   - Create the necessary files for a modern web application (e.g., \`package.json\`, \`index.html\`, \`main.js\`).
-   - You can use ANY web 3D library with glTF support (e.g., Three.js, Babylon.js, @google/model-viewer, PlayCanvas, A-Frame, etc.) that fits the game's requirements.
-   - In \`package.json\`, you MUST include the scad to gltf converter tool as a dev dependency:
-     \`"scad-gltf": "^0.1.0"\`
-   - In \`package.json\`, add npm scripts to automatically compile the \`.scad\` files into \`.glb\` format inside the \`public/\` folder before Vite runs its dev or build steps.
-     For example:
-     \`"predev": "scad-convert ./scad ./public/models --cache"\`
-     \`"prebuild": "scad-convert ./scad ./public/models --cache"\`
-   - Write the core game logic to load and display the converted \`.glb\` files interactively.
-
-3. Delivery Format (Single Node.js Script):
-   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
-   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
-   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
-   - The script must embed and write:
-     - Your generated \`.scad\` 3D assets.
-     - Your generated Vite web project files.
-   - Ensure all string file contents inside the Node.js script are properly escaped.`,
-    buildInputRequest: (task) =>
-      `Design and implement a web-based 3D glTF game using Vite for the following concept: "${task}"`,
-    allowedTools: ["render_scad_model"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/godot/examples/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Ilia Grigorev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/godot/examples/README.md

@@ -1,91 +0,0 @@
-# AI-Generated Godot Examples
-
-This folder contains a collection of **all-in-one Node.js scripts**, each representing a complete, playable 3D Godot 4 game generated entirely by AI using the `scad-godot` CLI tool.
-
-Instead of committing messy project folders, each example is bundled into a single, self-extracting JavaScript file. These scripts contain the generated OpenSCAD (`.scad`) 3D assets, Godot scripts (`.gd`), Godot scenes (`.tscn`), and the required `scad_importer` addon needed to parse the SCAD files directly in the engine.
-
-**🕹️ Play Online in Your Browser (No Installation Required):**
-👉 **[https://iliagrigorevdev.github.io/scad-godot/](https://iliagrigorevdev.github.io/scad-godot/)**
-
----
-
-## 🚀 How to Play the Examples
-
-To test out an example, you need to extract it and open it in Godot 4. The Godot importer relies on the `scad-gltf` tools to compile the 3D OpenSCAD scripts into binary meshes.
-
-Depending on your operating system and environment, there are two ways to handle this.
-
-### Prerequisites
-
-- **Node.js** installed on your system.
-- **Godot 4.x** installed on your system.
-
-### Step 1: Extract the Project
-
-Open your terminal in this folder and execute the desired example script using Node.js:
-
-```bash
-node my_example_game.js
-```
-
-_The script will automatically create a new folder (e.g., `./my-example-game`) containing the full Godot project directory structure, saving all the assets and addon files to disk._
-
----
-
-### Step 2: Compile Models & Open Godot
-
-Choose the method that best fits your environment:
-
-#### Option A: Standard Desktop (Global Install)
-
-If you are on a standard Windows, macOS, or Linux desktop, the easiest way is to have the CLI globally installed. The Godot plugin will automatically find and use the `scad-convert` command.
-
-1. Install the tool globally:
-   ```bash
-   npm install -g scad-gltf
-   ```
-2. Launch **Godot 4**.
-3. Click **Import** in the Project Manager, browse to the generated folder, and select the `project.godot` file.
-4. Click **Import & Edit**. The addon will automatically compile the `.scad` files in the background.
-
-#### Option B: Termux / Android / Restricted Environments (Backend Server)
-
-In some environments (like running Godot directly on an Android device via Termux), the Godot engine cannot easily execute globally installed NPM CLI binaries. To solve this, you can run `scad-serve` as a local backend server. The Godot importer will automatically detect it and use its REST API to convert the 3D models.
-
-1. Open your terminal and navigate into the newly extracted project folder:
-   ```bash
-   cd my-example-game
-   ```
-2. Start the local server:
-   ```bash
-   npx -p scad-gltf scad-serve
-   ```
-   _(This starts a local backend server on port 3000)._
-3. Leave the server running in the background.
-4. Launch **Godot 4**, import the project, and open it. The `scad_importer` addon will ping your local `scad-serve` backend to compile the `.scad` files over HTTP.
-
----
-
-### Step 3: Play the Game
-
-Once the Godot Editor opens and finishes importing the 3D scenes:
-
-- Press **F5** (or click the Play button in the top right) to run the game!
-
----
-
-## 🛠️ How were these generated?
-
-These files were created using this repository's built-in AI prompt pipeline. By running the `scad-godot` CLI command, the system instructs an LLM (like Claude, Gemini, or ChatGPT) to generate procedural OpenSCAD geometry, gameplay logic, and scene configurations, outputting them as a single JS extractor script.
-
-If you want to generate your own games, run:
-
-```bash
-scad-godot "A simple 3D platformer where you control a rolling ball collecting coins"
-```
-
-_(See the main repository documentation for full details on generating your own AI projects)._
-
-## 📜 License
-
-These examples and their generated Godot project assets are licensed under the [MIT License](LICENSE).