threedimensions 0.1.0__tar.gz

threedimensions-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,48 @@
+name: Build and Publish ThreeDimensions
+
+on:
+  workflow_dispatch:   # manual only (no auto spam)
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Checkout repo
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      # Setup Python
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      # Install build tools
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build cibuildwheel pybind11
+
+      # Clean old builds (IMPORTANT)
+      - name: Clean old builds
+        run: |
+          rm -rf dist
+          rm -rf build
+          rm -rf *.egg-info
+
+      # Build wheel ONCE using cibuildwheel
+      - name: Build wheel
+        run: cibuildwheel --output-dir dist
+
+      # Build source distribution ONCE
+      - name: Build sdist
+        run: python -m build --sdist
+
+      # Publish to PyPI
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

threedimensions-0.1.0/CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.15)
+project(ThreeDimensions LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Optimization flags
+if(MSVC)
+    add_compile_options(/O2 /arch:AVX2 /fp:fast)
+else()
+    add_compile_options(-O3 -march=native -ffast-math -pthread)
+endif()
+
+# Fetch pybind11
+include(FetchContent)
+FetchContent_Declare(
+  pybind11
+  GIT_REPOSITORY https://github.com/pybind/pybind11.git
+  GIT_TAG        v2.11.1
+)
+FetchContent_MakeAvailable(pybind11)
+
+# Include directories
+include_directories(
+    cpp_core/math
+    cpp_core/geometry
+    cpp_core/mesh
+    cpp_core/topology
+    cpp_core/modifiers
+    cpp_core/sculpt
+    cpp_core/curves
+)
+
+# Core library sources
+file(GLOB_RECURSE SOURCES
+    "cpp_core/math/*.cpp"
+    "cpp_core/geometry/*.cpp"
+    "cpp_core/mesh/*.cpp"
+    "cpp_core/topology/*.cpp"
+    "cpp_core/modifiers/*.cpp"
+    "cpp_core/sculpt/*.cpp"
+    "cpp_core/curves/*.cpp"
+    "cpp_core/bindings.cpp"
+)
+
+# Create the python extension module
+pybind11_add_module(_threedimensions_core ${SOURCES})
+
+# Link libraries
+target_link_libraries(_threedimensions_core PRIVATE pybind11::module)
+
+# Install rules
+install(TARGETS _threedimensions_core DESTINATION python/threedimensions)

threedimensions-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LEGEND'S DaD
+
+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.

threedimensions-0.1.0/Manual.md

@@ -0,0 +1,164 @@
+# ThreeDimensions Documentation
+
+Welcome to the official documentation for **ThreeDimensions**, a professional 3D modeling engine and SDK.
+
+## Table of Contents
+
+1. [Installation](#install)
+2. [Quick Start](#start)
+3. [User Guide](#guide)
+    - [Creating Objects](#create)
+    - [Transforming Objects](#transform)
+    - [Combining Objects](#combine)
+    - [Saving and Exporting](#save)
+4. [API Reference](#api)
+5. [Examples](#examples)
+
+<a name="install"></a>
+## 1. Installation
+
+ThreeDimensions is a hybrid C++/Python library.
+
+### Prerequisites
+- Python 3.11+
+- C++20 Compiler (Optional, but recommended for performance)
+- CMake 3.15+ (Optional)
+
+### Installing via pip
+
+```bash
+pip install .
+```
+
+If you do not have a C++ compiler, the library will automatically fallback to a pure Python implementation.
+
+<a name="start"></a>
+## 2. Quick Start
+
+Here is a simple example to create a Cube and save it.
+
+```python
+import threedimensions as td
+
+# Create a Cube of size 2.0
+cube = td.Mesh.create_cube(size=2.0)
+
+# Move it up by 1 unit
+cube.translate(0, 1, 0)
+
+# Save to OBJ file
+cube.save("my_cube.obj")
+```
+
+<a name="guide"></a>
+## 3. User Guide
+
+### <a name="create"></a> Creating Objects
+
+You can create various geometric primitives.
+
+**Cube**
+```python
+# Create a 1x1x1 cube
+box = td.Mesh.create_cube(size=1.0)
+```
+
+**Sphere**
+```python
+# Create a sphere with radius 1.0
+ball = td.Mesh.create_sphere(radius=1.0, segments=32, rings=16)
+```
+
+**Cylinder**
+```python
+# Create a cylinder (radius=0.5, height=2.0)
+pole = td.Mesh.create_cylinder(radius=0.5, height=2.0, segments=16)
+```
+
+**Other Primitives**
+- `create_cone(radius, height, segments)`
+- `create_torus(main_radius, tube_radius, main_segments, tube_segments)`
+- `create_plane(size, subdivisions)`
+
+### <a name="transform"></a> Transforming Objects
+
+You can move, rotate, and scale your meshes.
+
+**Translation (Move)**
+```python
+# Move x=1, y=2, z=0
+mesh.translate(1.0, 2.0, 0.0)
+```
+
+**Scaling (Resize)**
+```python
+# Scale x=2 (double width), y=0.5 (half height), z=1 (same depth)
+mesh.scale(2.0, 0.5, 1.0)
+```
+
+**Rotation**
+```python
+import math
+# Rotate 90 degrees around Y axis
+mesh.rotate_y(math.pi / 2)
+```
+
+### <a name="combine"></a> Combining Objects
+
+To build complex objects (like furniture), you can join multiple meshes together.
+
+```python
+# Create a seat
+seat = td.Mesh.create_cube(size=1.0)
+seat.scale(1.0, 0.1, 1.0)
+
+# Create a leg
+leg = td.Mesh.create_cube(size=1.0)
+leg.scale(0.1, 1.0, 0.1)
+
+# Attach leg to seat at specific offset
+# This merges the leg geometry INTO the seat mesh
+seat.join(leg, offset_x=0.4, offset_y=-0.5, offset_z=0.4)
+```
+
+### <a name="save"></a> Saving and Exporting
+
+The library supports `.obj` and `.stl` formats.
+
+```python
+# Save as OBJ (Wavefront) - Good for rendering
+mesh.save("model.obj")
+
+# Save as STL (Stereolithography) - Good for 3D Printing
+mesh.save("model.stl")
+```
+
+<a name="api"></a>
+## 4. API Reference
+
+### `threedimensions.Mesh`
+
+The core class representing a 3D object.
+
+#### Properties
+- `vertex_count`: Number of vertices.
+- `face_count`: Number of faces.
+
+#### Methods
+- `add_vertex(x, y, z)`: Add a single vertex manually.
+- `add_face(indices)`: Add a face manually using vertex indices.
+- `translate(x, y, z)`: Move the entire mesh.
+- `scale(x, y, z)`: Scale the entire mesh.
+- `rotate_x(angle)`: Rotate around X axis (radians).
+- `rotate_y(angle)`: Rotate around Y axis (radians).
+- `rotate_z(angle)`: Rotate around Z axis (radians).
+- `extrude_face(index, distance)`: Extrude a specific face along its normal.
+- `join(other_mesh, offset_x, offset_y, offset_z)`: Merge another mesh into this one.
+- `save(filepath)`: Auto-detects format from extension and saves file.
+
+<a name="examples"></a>
+## 5. Examples
+
+Check the `examples/` directory for full scripts:
+- `baseball_bat.py`: Demonstrates extrusion and scaling to model a bat.
+- `chair.py`: Demonstrates `join()` to compose a complex object from primitives.

threedimensions-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.2
+Name: threedimensions
+Version: 0.1.0
+Summary: Professional 3D Modeling Engine & SDK
+Author-Email: LegedsDaD <legendsdad001@gmail.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: C++
+Requires-Python: >=3.11
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# ThreeDimensions
+<img width="1024" height="1024" alt="ChatGPT Image Mar 1, 2026, 09_40_22 AM" src="https://github.com/user-attachments/assets/f07c4899-ef07-43af-b00b-03e90cc3af77" />
+
+**Professional 3D Modeling Engine & SDK**
+
+ThreeDimensions is a high-performance, hybrid C++20/Python 3D modeling library designed to provide a complete toolset comparable to Blender's modeling capabilities. It features a modern C++ core for heavy lifting and a flexible Python SDK for scripting and tool development.
+
+## Features
+
+- **Hybrid Architecture**: 
+  - **C++20 Core**: High-performance mesh kernel, geometry processing, and math engine.
+  - **Python SDK**: Object-oriented API, scene graph, and modifier system.
+- **Mesh Engine**: Efficient topology, support for N-gons, and large mesh optimization.
+- **Modeling Tools**: 
+  - Primitives: Cube, Sphere, Cylinder, Cone, Torus, Plane.
+  - Edit Mode: Vertex/Edge/Face operations (Extrude, Bevel, Inset, etc.).
+  - Advanced: Booleans, Subdivision Surface, Decimate, Remesh.
+- **Non-Destructive Workflow**: Modifier stack system (Subdivision, Mirror, Array, Boolean).
+- **Scene System**: Hierarchical scene graph, object instancing, and collections.
+- **Export**: OBJ, STL support.
+
+## Project Structure
+
+```
+ThreeDimensions/
+├── cpp_core/           # C++20 Core Engine
+├── python/             # Python SDK
+├── examples/           # Usage examples (chair.py, baseball_bat.py)
+├── LICENSE
+├── Manual.md
+├── CMakeLists.txt
+├── README.md
+├── pyproject.toml
+```
+
+## Build Instructions
+
+### Prerequisites
+
+- CMake 3.15+
+- C++20 compliant compiler (GCC 10+, Clang 10+, MSVC 2019+)
+- Python 3.11+
+- pip
+
+### Building from Source
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/LegendsDaD/ThreeDimensions.git
+   cd ThreeDimensions
+   ```
+
+2. Install dependencies and build the Python extension:
+   ```bash
+   pip install .
+   ```
+   
+   If a C++ compiler is not found, the library will fallback to a pure Python implementation automatically.
+
+## Usage
+
+See [manual.md](https://github.com/LegedsDaD/ThreeDimensions/blob/main/Manual.md) for detailed documentation.
+
+```python
+import threedimensions as td
+
+# Create a scene
+bat = td.Mesh.create_cylinder(radius=0.15, height=1.0)
+bat.save("bat.obj")
+```
+
+## Authors
+
+- **LegedsDaD** (legendsdad001@gmail.com)
+
+## License
+
+MIT License

threedimensions-0.1.0/README.md

@@ -0,0 +1,78 @@
+# ThreeDimensions
+<img width="1024" height="1024" alt="ChatGPT Image Mar 1, 2026, 09_40_22 AM" src="https://github.com/user-attachments/assets/f07c4899-ef07-43af-b00b-03e90cc3af77" />
+
+**Professional 3D Modeling Engine & SDK**
+
+ThreeDimensions is a high-performance, hybrid C++20/Python 3D modeling library designed to provide a complete toolset comparable to Blender's modeling capabilities. It features a modern C++ core for heavy lifting and a flexible Python SDK for scripting and tool development.
+
+## Features
+
+- **Hybrid Architecture**: 
+  - **C++20 Core**: High-performance mesh kernel, geometry processing, and math engine.
+  - **Python SDK**: Object-oriented API, scene graph, and modifier system.
+- **Mesh Engine**: Efficient topology, support for N-gons, and large mesh optimization.
+- **Modeling Tools**: 
+  - Primitives: Cube, Sphere, Cylinder, Cone, Torus, Plane.
+  - Edit Mode: Vertex/Edge/Face operations (Extrude, Bevel, Inset, etc.).
+  - Advanced: Booleans, Subdivision Surface, Decimate, Remesh.
+- **Non-Destructive Workflow**: Modifier stack system (Subdivision, Mirror, Array, Boolean).
+- **Scene System**: Hierarchical scene graph, object instancing, and collections.
+- **Export**: OBJ, STL support.
+
+## Project Structure
+
+```
+ThreeDimensions/
+├── cpp_core/           # C++20 Core Engine
+├── python/             # Python SDK
+├── examples/           # Usage examples (chair.py, baseball_bat.py)
+├── LICENSE
+├── Manual.md
+├── CMakeLists.txt
+├── README.md
+├── pyproject.toml
+```
+
+## Build Instructions
+
+### Prerequisites
+
+- CMake 3.15+
+- C++20 compliant compiler (GCC 10+, Clang 10+, MSVC 2019+)
+- Python 3.11+
+- pip
+
+### Building from Source
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/LegendsDaD/ThreeDimensions.git
+   cd ThreeDimensions
+   ```
+
+2. Install dependencies and build the Python extension:
+   ```bash
+   pip install .
+   ```
+   
+   If a C++ compiler is not found, the library will fallback to a pure Python implementation automatically.
+
+## Usage
+
+See [manual.md](https://github.com/LegedsDaD/ThreeDimensions/blob/main/Manual.md) for detailed documentation.
+
+```python
+import threedimensions as td
+
+# Create a scene
+bat = td.Mesh.create_cylinder(radius=0.15, height=1.0)
+bat.save("bat.obj")
+```
+
+## Authors
+
+- **LegedsDaD** (legendsdad001@gmail.com)
+
+## License
+
+MIT License

threedimensions-0.1.0/cpp_core/bindings.cpp

@@ -0,0 +1,70 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "math/Vector3.h"
+#include "mesh/Mesh.h"
+#include "geometry/Primitives.h"
+
+namespace py = pybind11;
+using namespace ThreeDimensions;
+
+PYBIND11_MODULE(_threedimensions_core, m) {
+    m.doc() = "ThreeDimensions Core C++ Module";
+
+    // Math
+    py::class_<Math::Vec3>(m, "Vector3")
+        .def(py::init<float, float, float>())
+        .def_readwrite("x", &Math::Vec3::x)
+        .def_readwrite("y", &Math::Vec3::y)
+        .def_readwrite("z", &Math::Vec3::z)
+        .def("length", &Math::Vec3::length)
+        .def("normalize", &Math::Vec3::normalize)
+        .def("__add__", &Math::Vec3::operator+)
+        .def("__sub__", &Math::Vec3::operator-)
+        .def("__mul__", &Math::Vec3::operator*)
+        .def("__repr__", [](const Math::Vec3& v) {
+            return "<Vector3 (" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")>";
+        });
+
+    // Mesh
+    py::class_<Core::Vertex>(m, "Vertex")
+        .def_readwrite("position", &Core::Vertex::position)
+        .def_readwrite("normal", &Core::Vertex::normal)
+        .def_readwrite("uv", &Core::Vertex::uv)
+        .def_readwrite("index", &Core::Vertex::index);
+
+    py::class_<Core::Face>(m, "Face")
+        .def_readwrite("indices", &Core::Face::indices)
+        .def_readwrite("normal", &Core::Face::normal);
+
+    py::class_<Core::Mesh>(m, "Mesh")
+        .def(py::init<std::string>())
+        .def_readwrite("name", &Core::Mesh::name)
+        .def("add_vertex", &Core::Mesh::addVertex)
+        .def("add_face", &Core::Mesh::addFace)
+        .def("calculate_normals", &Core::Mesh::calculateNormals)
+        .def("clear", &Core::Mesh::clear)
+        // Transforms
+        .def("translate", &Core::Mesh::translate)
+        .def("scale", &Core::Mesh::scale)
+        .def("rotate_x", &Core::Mesh::rotateX)
+        .def("rotate_y", &Core::Mesh::rotateY)
+        .def("rotate_z", &Core::Mesh::rotateZ)
+        // Editing
+        .def("extrude_face", &Core::Mesh::extrudeFace)
+        .def("scale_face", &Core::Mesh::scaleFace)
+        .def("translate_face", &Core::Mesh::translateFace)
+        .def("join", &Core::Mesh::join)
+        // Properties
+        .def_property_readonly("vertex_count", &Core::Mesh::vertexCount)
+        .def_property_readonly("face_count", &Core::Mesh::faceCount)
+        .def_readonly("vertices", &Core::Mesh::vertices)
+        .def_readonly("faces", &Core::Mesh::faces);
+
+    // Geometry Primitives
+    m.def("create_cube", &Geometry::Primitives::CreateCube, "Create a cube mesh", py::arg("size") = 1.0f);
+    m.def("create_sphere", &Geometry::Primitives::CreateSphere, "Create a sphere mesh", py::arg("radius") = 1.0f, py::arg("segments") = 16, py::arg("rings") = 16);
+    m.def("create_cylinder", &Geometry::Primitives::CreateCylinder, "Create a cylinder mesh", py::arg("radius") = 1.0f, py::arg("height") = 2.0f, py::arg("segments") = 16);
+    m.def("create_cone", &Geometry::Primitives::CreateCone, "Create a cone mesh", py::arg("radius") = 1.0f, py::arg("height") = 2.0f, py::arg("segments") = 16);
+    m.def("create_torus", &Geometry::Primitives::CreateTorus, "Create a torus mesh", py::arg("main_radius") = 1.0f, py::arg("tube_radius") = 0.4f, py::arg("main_segments") = 32, py::arg("tube_segments") = 16);
+    m.def("create_plane", &Geometry::Primitives::CreatePlane, "Create a plane mesh", py::arg("size") = 2.0f, py::arg("subdivisions") = 1);
+}