scad-gltf 0.1.4 → 0.2.2

package/README.md

@@ -22,7 +22,8 @@ The C++ source code for this custom OpenSCAD version is included directly in thi
 - **CLI Converter:** Bundled `scad-convert` CLI utility for single file and batch compiling `.scad` files with smart dependency hashing.
 - **MCP Server for AI Agents:** Bundled `scad-mcp` server enables MCP clients to iteratively design, compile, and **visually inspect** 3D models via multi-angle headless rendering and animation frame evaluation.
 - **AI Studio Extension:** Chrome extension to natively preview, prompt, take chat snapshots, open in Scadify, and locally save AI-generated 3D models directly inside Google AI Studio.
-- **Godot 4 Integration & Web Demos:** Native Godot 4 importer addon for procedural `.scad` assets and prebuilt AI-generated [web game examples](https://iliagrigorevdev.github.io/scad-godot/).
+- **Godot 4, Rust Bevy & Web Integration:** Native Godot 4 importer addon, Rust Bevy compile-time `build.rs` integration, and prebuilt AI-generated game examples for Godot and Bevy.
+- **Automated AI Generation:** Pass an OpenAI-compatible base URL (and optional API key) to the `scad-godot`, `scad-bevy`, or `scad-web` CLI to automatically spawn a local MCP server, query the LLM via standard endpoints, allow it to visually iterate, and output a ready-to-run project generator script.
 
 ---
 
@@ -260,6 +261,7 @@ Instead of generating code blindly, the AI can compile its script, render the 3D
 
 - `get_scad_prompt`: Injects the custom OpenSCAD syntax rules (PBR, animations, baking) into the AI's context.
 - `render_scad_model`: Compiles the generated `.scad` code to GLB and returns base64 images from requested camera angles (front, back, left, right, top, bottom, isometric) and specific animation keyframes.
+- `compile_bevy_project` / `test_godot_project`: Tests the generated game projects for compilation and runtime errors.
 
 ### Setup
 
@@ -295,6 +297,53 @@ Try prebuilt AI-generated Godot games directly in your browser: [https://iliagri
 
 ---
 
+### Automated AI Generation (OpenAI-Compatible API)
+
+By default, `scad-godot`, `scad-bevy`, and `scad-web` copy a heavily engineered system prompt to your clipboard to paste into an LLM. However, if you provide a **Base URL** (and optional **API Key**), the CLI will fully automate this process. It will automatically spin up the `scad-mcp` server in the background, connect it to your LLM, and allow the AI to _visually evaluate and fix_ its 3D models in real-time before saving the final `generate_project.js` script to your disk.
+
+**Option 1: Using OpenAI (GPT-4o)**
+
+```bash
+export OPENAI_BASE_URL="https://api.openai.com/v1"
+export OPENAI_API_KEY="sk-..."
+export OPENAI_MODEL="gpt-4o"
+scad-bevy "A 3D spaceship shooter game"
+```
+
+**Option 2: Using Google Gemini (via OpenAI compatibility)**
+Because Gemini provides an official OpenAI-compatible endpoint, you can configure it using standard OpenAI variables:
+
+```bash
+export OPENAI_API_KEY="AIzaSy..."
+export OPENAI_BASE_URL="https://generativelanguage.googleapis.com/v1beta/openai/"
+export OPENAI_MODEL="gemini-3.8-flash"
+scad-godot "A fast-paced 3D hovercraft racing game"
+```
+
+**Option 3: Using Local Server**
+You can use completely local, uncensored, or fine-tuned vision models by overriding the OpenAI Base URL to point to a local inference server (like `llama.cpp`'s API server).
+
+```bash
+export OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
+export OPENAI_MODEL="llama-3" # Or whatever model name you've loaded
+scad-web "A 3D configurator app"
+```
+
+**Passing Parameters via JSON**
+You can also pass credentials inline as a JSON string argument instead of modifying environment variables:
+
+```bash
+scad-godot "A futuristic tank game" '{"openaiBaseUrl": "http://127.0.0.1:8080/v1", "openaiModel": "llama-3"}'
+```
+
+_Once the automated process completes, simply run the generated Node.js script to assemble your complete Godot, Bevy, or Vite project structure with all assets and code!_
+
+```bash
+node generate_godot_project.js
+```
+
+---
+
 ## Extended OpenSCAD Syntax
 
 This custom fork introduces new syntax not found in standard OpenSCAD.
@@ -421,8 +470,6 @@ const promptContext = generatePrompt(description, {
 console.log(promptContext);
 ```
 
----
-
 ### Workflow
 
 Once connected, an AI assistant can use the server to execute the following loop:

package/bevy/README.md

@@ -0,0 +1,46 @@
+# OpenSCAD GLTF Integration for Rust Bevy
+
+This folder contains resources and examples for integrating procedural OpenSCAD (`.scad`) 3D assets natively into the [Bevy](https://bevyengine.org/) game engine using the `scad-gltf` compiler.
+
+Unlike Godot (which uses a native editor plugin), Bevy integration is achieved programmatically at compile-time using a custom `build.rs` script. This script automatically watches your `.scad` files and compiles them into binary `.glb` meshes in your `assets/models` folder before the game compiles and runs.
+
+## 🛠️ How It Works
+
+To use OpenSCAD files in your Bevy project, ensure you have the CLI compiler installed globally on your machine:
+
+```bash
+npm install -g scad-gltf
+```
+
+Then, add a `build.rs` script to the root of your Bevy project (next to `Cargo.toml`):
+
+```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);
+    }
+}
+```
+
+Now, any `.scad` files placed in your `scad/` directory will automatically be converted to `.glb` when you run `cargo build` or `cargo run`. They can then be loaded natively in Bevy via the Asset Server:
+
+```rust
+let my_model = asset_server.load("models/my_model.glb#Scene0");
+```

package/bevy/examples/LICENSE

@@ -0,0 +1,21 @@
+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/bevy/examples/README.md

@@ -0,0 +1,58 @@
+# AI-Generated Bevy Examples
+
+This folder contains a collection of **all-in-one Node.js scripts**, each representing a complete, playable 3D Rust Bevy game generated entirely by AI using the `scad-bevy` 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, Rust source code (`main.rs`), and the required `build.rs` and `Cargo.toml` configurations.
+
+---
+
+## 🚀 How to Play the Examples
+
+To test out an example, you need to extract it and run it using Cargo.
+
+### Prerequisites
+
+- **Node.js** installed on your system.
+- **Rust and Cargo** installed on your system.
+- **scad-gltf** installed globally: `npm install -g scad-gltf`
+
+### Step 1: Extract the Project
+
+Open your terminal in this folder and execute the desired example script using Node.js:
+
+```bash
+node packman_3d.js
+```
+
+_The script will automatically create a new folder (e.g., `./packman_3d`) containing the full Bevy project directory structure, saving all the assets and Rust files to disk._
+
+---
+
+### Step 2: Compile & Play
+
+Navigate into the newly extracted project folder and use Cargo to run the game:
+
+```bash
+cd packman_3d
+cargo run
+```
+
+_The `build.rs` script will automatically invoke `scad-convert` to compile the OpenSCAD assets into `.glb` format before Bevy boots up._
+
+---
+
+## 🛠️ How were these generated?
+
+These files were created using this repository's built-in AI prompt pipeline. By running the `scad-bevy` 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-bevy "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 are licensed under the [MIT License](LICENSE).

package/bevy/examples/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "scad-bevy-examples",
+  "private": true,
+  "type": "commonjs"
+}