Skip to content

naranyala/awesome-3d-modeling-math-physics

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

1 Commit
README.md
README.md
 
 

Repository files navigation

Awesome 3D Modeling: Blender Math & Physics

A curated list of Blender addons, tools, libraries, and resources for mathematical operations, physics simulations, precision modeling, computational design, and procedural workflows.

Blender Logo

Physics • Math • Geometry Nodes • CAD • Python API • Visualization • Learning

Table of Contents

Physics Simulations

Fluid Dynamics

  • Mantaflow - Built-in fluid simulation framework (Blender 2.82+). Grid-based solver for gas (smoke, fire) and liquid simulations. Object types: domain, flow, obstacle, effector, guide. Outputs OpenVDB volume grids (density, temperature, fuel, velocity, flame).
  • FLIP Fluids - FLIP (Fluid Implicit Particle) method addon. Particle-based liquid simulation with surface mesh reconstruction. Parameters: viscosity, surface tension, Whitewater foam/bubbles/spray, obstacle export, substeps control.
  • Jet Fluids - Addon integrating the Jet library for fluid simulation. Implements stable fluids (Jos Stam) and GPU-accelerated solvers.
  • EmberGen - Standalone real-time volumetric GPU simulation. Fire, smoke, explosions. Exports OpenVDB sequences for Blender import via Volume objects.

Cloth & Soft Body

  • Cloth Simulation - Built-in cloth solver. Vertex-based mass-spring system with collision detection. Parameters: structural stiffness, bending stiffness, shear stiffness, damping, mass, internal pressure (for inflatables), vertex group pinning, property weights.
  • Soft Body Simulation - Built-in deformable body physics. Spring-based edge and goal systems. Parameters: stiffness, damping, gravity, pull/push, collision, goal weights (vertex group), fuzz/curl (for hair-like behavior).
  • Modeling Cloth - Real-time cloth deformation in Edit Mode. Iterative relaxation of mesh topology based on gravity and neighbor distance. No bake required; interactive feedback during modeling.
  • AndoSim - Implements SIGGRAPH 2024 "Cubic Barrier with Elasticity-Inclusive Dynamic Stiffness" method. Cloth and shell physics with real-time viewport playback. Features: pin constraints, ground contact, strain limiting.
  • SimuSama - Material Point Method (MPM) engine. C++ core with Python bindings. Particle-grid coupled simulation for fluids and deformable solids.

Rigid Body & Fracture

  • Rigid Body Simulation - Built-in rigid body dynamics via Bullet Physics engine. Object types: Active (dynamic), Passive (kinematic/static), Ghost (no response). Constraint types: Fixed, Hinge, Slider, Piston, Cone Twist, Generic, Generic Spring, Point, Motor. Collision shapes: Box, Sphere, Cylinder, Cone, Capsule, Mesh, Convex Hull.
  • Cell Fracture - Built-in extension for Voronoi-based mesh fracture. Parameters: shard source (vertices/faces/particles), noise (cell randomness), recursion depth, material slot assignment, sharp edges.
  • Fracture Modifier (Custom Branch) - Custom Blender branch with integrated fracture modifier system. Non-destructive modifier workflow, constraint-based glue/break behavior, rigid body integration. Requires custom Blender build.
  • Fracture-Iterator - Iterative fracture addon. Recursive Cell Fracture with bake-to-keyframes workflow. Break-by-loose-parts, dynamic fragment generation, rigid body keyframe trigger.
  • RBDLab - Rigid body dynamics addon. Workflow: Voronoi fracturing → rigid body setup → constraint assignment → simulation → debris particle emission. Features: impact-based activation, collision shape optimization.
  • Kaboom - Destruction animation addon. Features: KRUMPLE (dynamic activation system), BLAST (radial/directional explosion force), debris particles, smoke emission, constraint clusters.
  • projectile (repo) - Ballistic trajectory calculator. Computes initial velocity vector for objects to reach target positions. Uses projectile motion equations: v = sqrt(g * d² / (2 * cos²(θ) * (tan(θ) * d - h))).
  • V-HACD - Volumetric Hierarchical Approximate Convex Decomposition. Generates convex hull sets from concave meshes for real-time physics collision shapes. Parameters: resolution, max convex hulls, concavity threshold, plane downsampling.

Particles & Dynamics

  • Particle System - Built-in particle emitter. Types: Hair (strand-based), Emitter (point-based). Physics types: Newtonian (standard forces), Boids (flocking AI), Fluid (fluid-guided), Keyed (target-linked). Integrator: Euler with adaptive substeps.
  • Boids - Flocking behavior system. Rules: Goal (seek targets), Avoid (flee), Avoid Collision (deflect), Separate (spacing), Flock (cohesion), Follow Leader, Average Speed, Fight. Parameters: air speed, acceleration, banking, health, aggression. Based on Craig Reynolds (1986) distributed behavioral models.
  • Molecular Script - Particle collision and linking addon. Creates particle-to-particle bonds forming molecular/chain structures. Collision-based interaction, distance thresholds, bond strength.
  • Dynamic Paint - Surface interaction system. Canvas types: Paint (vertex color), Displace (vertex offset), Weight (vertex group intensity), Wetmap (wetness/dryness tracking). Brush types: paint, proximity, velocity-based.
  • Cake Particles - Bakes particle simulations to keyframed objects. Supports: meshes, Grease Pencil, metaballs, cameras. Features: bake-step interval, collection management, FBX export with animation.
  • Fluid Particles - Fluid-like behavior via particle system with custom forces. Multi-sim support, emission parameters, custom material assignment.

Force Fields

  • Force Fields - Built-in force field objects. Each applies a specific physical force model:
    • Force: Constant direction attraction/repulsion. F = strength * falloff(distance).
    • Vortex: Spiral force around Z-axis. F_tangential = strength * falloff.
    • Wind: Area-based directional force with noise. F = strength * direction * noise_factor.
    • Turbulence: Noise-driven chaotic force. F = strength * noise(position * frequency * scale).
    • Drag: Velocity-dependent resistance. F = -linear_drag * v - quadratic_drag * |v| * v.
    • Magnetic: Monopole/dipole attraction. F = (pole_strength₁ * pole_strength₂) / distance².
    • Harmonic: Spring force (Hooke's law). F = -stiffness * (distance - rest_length).
    • Charge: Coulomb interaction. F = k * q₁ * q₂ / distance².
    • Lennard-Jones: Molecular potential. V(r) = 4ε[(σ/r)¹² - (σ/r)⁶].
    • Texture: Texture intensity drives force magnitude.
    • Curve Guide: Path-following along curve tangent.
    • Boid: Flocking AI field (goal/predator behavior).
  • Field Weights - Per-physics-type influence multipliers. Controls: rigid body, particle, soft body, cloth, fluid force reception per field type.

Baked Simulation Workflows

  • Simulations to Keyframes/Shapekeys - Converts simulation cache data to keyframed animation or shape keys. Enables export of baked physics to formats that don't support live simulation data.
  • Collider Tools - Simplifies collision shape creation. Auto-generates convex hulls, box/cylinder/sphere approximations, collection-based collider setup.
  • Interactive Physics Editor - Viewport-based physics property editing. Direct manipulation of collision shapes, rigid body parameters, constraint settings.

Math & Computation

Math Expression Evaluators

  • Math Controller - Evaluates mathematical expressions within Geometry Nodes. Supports: variables, functions, constants (π, e), nested formulas. Text input → numerical output for node-driven calculations.
  • Math Formula - Creates node chains by typing formulas. Auto-selects appropriate node type (Vector Math, Math). Functions: sin, cos, tan, sqrt, log, abs, min, max, round, floor, ceil, fraction, modulo, wrap, pingpong. Shortcut: Ctrl+Enter.
  • Node Quick Maths - Dialog-based math node chain generator. Operators: + - * / ** < > %. Functions: log, sqrt, abs, exp, min, max, cmp, smin, smax, round, floor, ceil, trunc, frac, sin, cos, tan, asin, acos, atan, atan2, sinh, cosh, tanh, rad, deg. Shortcut: Ctrl+M.
  • Node Expressions - Parses mathematical expressions into Geometry Node groups. Operations: + - * / **. Functions: sin, cos, tan, asin, acos, atan, abs, round, max, min, mod, log. Comparators: == != < > <= >=. GPU-compatible (standard nodes only). Multiple outputs.

Function Plotting

  • fEq - Formula Equation - Plots explicit mathematical functions as curves or meshes. Input: formula string. Supports 2D (y = f(x)) and 3D (z = f(x,y)) function visualization.
  • Add Mesh: Math Function - Built-in addon (Mesh: Extra Objects). Generates: Z Math Surface (z = f(x,y)), XY Grid function, polar coordinate plots. Parameters: function string, resolution, range.
  • Maze Generator - Procedural maze generation via recursive backtracking/Prim's algorithm. Parameters: width, height, seed, cell size. Output: mesh geometry.

Mathematical Animation

  • Math Anim - Scientific animation addon (GPL-3.0). Architecture:
    • Function plotting: explicit, parametric, polar, implicit functions; first-order ODEs
    • Formula typesetting: Typst, LaTeX (via Optex), or PDF input; character-by-character animation via Geometry Nodes
    • Morph animations: transitions between functions, formulas, freehand drawings
    • ODE solvers: pydiffsol for explicit and linearly implicit first-order ODEs; conditional stop/reset states
    • Dependencies: asteval (explicit/parametric/polar), numexpr (implicit), meval (ODEs)
    • Visual effects: Bloom, Glow, Rim lighting, Shadow
  • Curve To Rope Simulation - Converts curve geometry into rope/cable physics simulation. Creates vertex pin groups, applies cable/chain physics along curve path. Parameters: tension, gravity, slack.

Scientific Computing Libraries

  • NumPy - Python array computation library (bundled with Blender). Use cases: vertex attribute manipulation, matrix batch operations, Fourier transforms on image data, statistical analysis of simulation results.
  • SciPy - Python scientific computing. Use cases: numerical integration (ODE solvers), optimization (curve fitting), interpolation (spline, grid), linear algebra (eigenvalue, SVD), signal processing (FFT), spatial algorithms (KD-tree, Delaunay).

Geometry Nodes

Simulation Nodes & Custom Physics

  • Simulation Nodes - Built-in frame-to-frame feedback system (Blender 3.3+). Architecture:
    • Simulation Zone: Node tree region where geometry state persists across frames
    • Iterative time-stepping: Output of frame N feeds into frame N+1
    • Caching: Automatic viewport cache; manual bake to disk for sequential rendering
    • Built-in nodes: Simulation Input/Output, Store Named Attribute, Sample Index, Repeat Zone
  • XPBD Solver (Geometry Nodes, In Development) - Extended Position-Based Dynamics solver for Geometry Nodes. Declarative system: users define force fields, colliders, constraints; solver computes resulting physics. Initial focus: hair simulation (Cosserat rod model). Bundle architecture for simulation world state. Planned: third-party solver exposure (Bullet, Jolt, Box2D). Collision: BVH tree (precision-favored over SDF). Rest shape initialization via reverse solve.
  • Custom Particle Systems in Geometry Nodes - Particle physics built entirely within Geometry Nodes simulation zones. Collision detection, gravity, inter-particle forces, spatial hashing.
  • Particle & Collision Simulations in Geometry Nodes - Physically accurate particle collision using Geometry Nodes 3.5+ simulation nodes. Spatial partitioning, velocity reflection, energy loss.

Fields & Attributes

  • Fields System - Data evaluation context system (Blender 3.0+). Evaluation domains: Point, Edge, Face, Face Corner, Curve, Spline, Instance. Field contexts: position, normal, tangent, ID, index, material, attribute. Used by: all Geometry Nodes, force fields, particle systems, simulation nodes.
  • Attributes Reference - Built-in geometry attributes accessible in Geometry Nodes. Position (vector), Normal (vector), ID (int), Index (int), Material (int), UV (vector), Color (vector), Crease (float), Bump (vector). Custom attributes via Spreadsheet editor.
  • Attribute Vector Math - Per-element vector operations on geometry attributes. Operations: dot product, cross product, addition, subtraction, normalization. Used for: normal manipulation, directional effects, procedural alignment.

Node Programming

  • Pynodes - Python library for programmatic node tree generation. Chain-call API on data sockets: curve.set_position(pos).trim_factor(end=e). 1:1 mapping to Geometry Nodes, Shader Nodes, Compositor Nodes. Decorator-based tree definition: @tree compiles Python functions to Blender Node Groups. Supports Simulation Zones and Repeat Zones via context managers.
  • NodeToPython - Converts node groups (Geometry, Shader, Compositor) to Python addon files. Outputs: node creation, connection, default value assignment, frame grouping. Enables version control and distribution of node setups as installable addons.

Node Reference & Libraries

  • Math Node Reference - Complete operation list: Add, Subtract, Multiply, Divide, Multiply Add, Power, Logarithm, Sine, Cosine, Tangent, Arcsin, Arccos, Arctan, Arctan2, Sinh, Cosh, Tanh, Sqrt, Inverse Sqrt, Absolute, Minimum, Maximum, Less Than, Greater Than, Sign, Compare, Snap, Floor, Ceil, Fraction, Modulo, Wrap, Pingpong, Smooth Min, Smooth Max, Linear Slope, Remap.
  • Vector Math Node Reference - Operations: Add, Subtract, Multiply, Divide, Cross Product, Dot Product, Project, Reflect, Refract, Faceforward, Length, Distance, Scale, Normalize, Average, Sum, Math (per-component).
  • Vector Math Nodes (Shader) - Same operations as Geometry Nodes vector math, available in Shader Editor: Math, Vector Math, Map Range, Float Curve, Clamp, Compare, Mix, Float to Integer, Boolean Math.
  • Bit Math Node - Bitwise operations: AND, OR, XOR, NOT, Left Shift, Right Shift. Integer input/output. Use cases: flag systems, procedural ID encoding, binary logic in node trees.
  • Hash Value Node - Hash function for data types. Input: Value, Integer, Vector, Color, Object, String, Collection. Output: deterministic hash. Use cases: randomization by ID, procedural variation, seed-based generation.
  • Integer Math Node - Integer-specific operations: Add, Subtract, Multiply, Divide, Multiply Add, Power, Logarithm, Square Root, Absolute, Minimum, Maximum, Sign, Compare, Snap, Floor, Ceil, Fraction, Modulo, Wrap, Pingpong.
  • Mapping Node - Coordinate transformation: Translation, Rotation, Scale. Types: Point, Texture, Vector, Normal. Use cases: UV offset, texture rotation, normal space transformation.
  • Float Curve - User-defined 1D function mapping. Input: float value → curve lookup → output float. Use cases: custom falloff, non-linear remapping, animation curve definition.

CAD & Precision

Constraint-Based Modeling

  • CAD Sketcher (repo) - Constraint-based 2D sketching. Geometric constraints: coincident, parallel, perpendicular, tangent, concentric, equal, horizontal, vertical, symmetry, midpoint, collinear. Dimensional constraints: distance, angle, radius, diameter. Solver: adjusts geometry to satisfy all constraints. Parametric: dimension changes propagate to 3D operations.

Measurement & Analysis

  • MeasureIt - Measurement and annotation. Capabilities: linear dimensions, angles, areas, coordinates, origin indicators. Output: viewport overlay, rendered annotations, SVG export. (Bundled addon in Blender ≤4.1, now standalone extension.)
  • Pro 3D Dimension Tool - Dimensioning tool. Features: X/Y/Z axis measurement, aligned dimensions, custom text styles, unit formatting, arrow styles, constraint locking (Shift+X/Y/Z).
  • Analysis Toolkit - Analysis and measurement suite:
    • UV SS Resolution: Calculates on-screen texture coverage, recommends texture sizes, computes UDIM tile counts
    • Illuminance Meter: Measures lux at scene points (Cycles), calculates average/min/max, adjusts light strength to target lux, exports CSV
    • EV Lux Converter: Bidirectional conversion EV100 = log2(Lux / 2.5)
    • EV Calculator: Solves camera exposure parameters (aperture, shutter, ISO, ND filter)
    • Horizon Distance: Calculates geometric horizon from camera Z-height, spherical Earth model
    • Parallax Distance: Computes distance where parallax shift ≤ pixel threshold between camera positions
    • Speedometer: Measures velocity of animated objects (instantaneous or range analysis), unit conversion (m/s, km/h, mph, Mach)
    • Unit Converter: Imperial ↔ Metric conversion in real-time
    • Shooting Distance: Camera-to-target distance calculation

Precision Modeling

  • PDT (Precision Drawing Tools) - CAD-style precision modeling. Command-line input for coordinates, distance, angle. Relative/absolute positioning. Intersection calculations (line-line, line-plane). Construction geometry (helper lines, points). View-based alignment.
  • Construction Lines - Reference geometry system. Infinite lines, circles, arcs. Snapping: endpoint, midpoint, intersection, perpendicular, tangent.
  • Bezier Utility - Bézier curve tools. Curve analysis (length, curvature). Boolean operations on curves (union, difference, intersection). Mathematical curve manipulation (control point editing, degree elevation).
  • LoopTools - Built-in mesh utilities. Operations: Relax (Laplacian vertex smoothing), Circle (least-squares circular projection), Curve (Bézier interpolation), Flatten (planar projection), Space (arc-length equalization), Bridge (loft surface), Gsphere (spherical projection).
  • Bool Tool - Boolean operations. Types: Union (mesh merge), Difference (subtract), Intersect (common volume), Slice (cut without removal). Solver options: Fast (BMesh), Exact (Carve). Non-destructive modifier mode.

Deformation & Lattice

  • Lattice Modifier - Free-Form Deformation (FFD) via 3rd-degree Bézier hyper-surface interpolation. Lattice resolution: U/V/W subdivisions. Interpolation: trilinear/triquadratic. Use cases: organic deformation, animation-driven shape changes.
  • Lattice Magic - Lattice-based deformation tools. Features: automatic lattice fitting to selection, multi-lattice management, symmetry options, quick setup operators.

Mesh Analysis & Topology

  • Mesh Analysis (Native) - Built-in mesh analysis in Edit Mode. Displays: Overhang (angle threshold), Thickness (ray cast), Intersections, Distortion (n-gon flatness), Sharp Edges. Red = high value, blue = low value. Target: 3D printing workflows.
  • Topology Doctor - One-click topology analysis and repair assistant. Inspects mesh, identifies flaws, selects and zooms to problem areas.
  • Analyze Mesh - Free extension for mesh topology checking. Reports: vertex, edge, face, tri, quad, n-gon counts. E-pole (5-edge), N-pole (3-edge), multi-pole detection. Highlight overlays.
  • Meshstats - Displays topological statistics. Tris, quads, n-gons, e-poles, n-poles, multi-poles. Polygon budget tracking, overlay highlighting in viewport.
  • Mesh Analysis Overlay - Edit mode overlays. Face overlays: degenerate, non-planar, n-gons, quads, tris. Edge overlays: boundary, seam, sharp, non-manifold. Vertex overlays: high poles, e-poles, n-poles, non-manifold. Selection tools.
  • E Topology Smooth - Advanced mesh topology smoothing. Features: arc-length parameterization, outlier detection, corner defect detection, G0-G4 continuity analysis, multi-algorithm curve fitting.
  • Edge Length Measure - Measures mesh edge lengths in Object Mode. Supports modifier-deformed geometry. Individual edge lengths, total edge length per object. Unit-aware formatting.

Python API & Scripting

Math Types (mathutils)

  • mathutils Module - Built-in Python module for 3D math types:
    • Vector (2D-4D): dot(), cross(), normalize(), lerp(), slerp(), reflect(), length, angle(), rotation_difference(), project(), ortho(), lerp(), slerp(), dot(), cross(), reflect(), rescale()
    • Matrix (2x2-4x4): decompose() → (translation, rotation, scale), invert(), transpose(), determinant(), lerp(), to_euler(), to_quaternion(). Constructors: Translation(vec), Rotation(angle, size, axis), Scale(factor, size, axis), Shear(plane, size, factor), OrthoProjection(axis, size)
    • Euler: rotate_axis(axis, angle), to_matrix(), to_quaternion(), make_compatible() (gimbal lock prevention). Orders: XYZ, XZY, YXZ, YZX, ZXY, ZYX
    • Quaternion (4D): rotate(vec), to_matrix(), to_euler(), slerp(), normalize(), rotation_difference(), dot(), cross(). Gimbal-lock-free rotation.
    • Color: RGB/RGBA vector operations
    • BoundingBox: Spatial bounding volume with min/max, center, volume, intersection
    • Geometry: intersects_ray_triangle(), barycentric_transform(), intersect_line_line(), intersect_line_plane(), intersect_line_sphere(), intersect_ray_sphere()
    • ID Properties: Custom property attachment to data blocks

Scripting Resources

  • Blender Python API Documentation - Complete reference: bpy, mathutils, bmesh, gpu, aud, all modules.
  • njanakiev/blender-scripting - Progressive examples: operators, mesh generation, modifier application, UI panels, custom tools, data access.
  • BMesh Module - Low-level mesh data access. Direct vertex/edge/face/loop manipulation. Operations: vertex split, edge collapse, face subdivision, normal recalculation, boundary detection. Use cases: custom subdivision algorithms, topology analysis, procedural mesh generators.
  • GPU Module - GPU buffer and shader API. Custom viewport drawing, compute shaders, geometry buffer manipulation.

F-Curve & Animation Math

  • F-Curve Modifiers - Mathematical functions applied to animation curves:
    • Noise: Adds Perlin noise. f'(t) = f(t) + noise(t) * strength. Integration modes: Replace, Add, Subtract, Multiply.
    • Function Generator: Analytical functions: Sine, Cosine, Tanh. Parameters: amplitude, phase multiplier, value offset, cyclic count.
    • Built-in: Limits (min/max clamping), Stepped (frame interval snapping), Envelope (amplitude modulation), Generator (polynomial: y = c0 + c1*x + c2*x² + c3*x³), Extrapolation (extended/constant), Eased (smooth interpolation).
  • Drivers - Python expression-driven properties. Expression types: scripted expression, maximum/minimum value, average. Variables: transform channel, rotation difference, distance, single property, transform scale. Name space: sin, cos, tan, sqrt, abs, radians, degrees, noise, random, frame (current frame variable).
  • NLA (Non-Linear Animation) - Animation clip blending. Operations: add, blend, replace, combine strips. Use cases: animation state machines, procedural animation layering, math-driven animation blending.

Visualization & Data

Data Visualization

  • Data-FX - CSV import and 3D visualization. Node-based data mapping to geometry properties (position, scale, color, emission). Use cases: bar charts, scatter plots, heatmaps, data-driven modeling.
  • Blender Data Vis - External dataset import (JSON, CSV). Creates: 3D bar charts, scatter plots, surface plots, geographic map projections.

Scientific Illustration

  • Mathematical Illustration in Blender - Tutorial series for publication-quality math diagrams. Workflow: 3D model → Line Art modifier → SVG export → Inkscape post-processing → PDF/LaTeX. Topics: curve construction, Python-scripted geometry, knot diagrams.
  • Line Art Modifier - Edge extraction from 3D geometry. Edge types: contour (silhouette), crease (angle threshold), intersection (object overlap), material boundary, occluding (hidden lines), external (outer boundary). Output: curve object or stroke material.
  • Freestyle Rendering - Non-photorealistic line rendering. Edge detection: silhouette, border, crease, suggestive contour, ridge, valley. Parameterization: distance from camera, material, geometry, random. Stroke shaders: thickness, color, texture, calligraphic.

Math Visualization

  • Math Vis (Console) - Visualizes mathutils type variables from Python console in 3D viewport. Supported types: Vector (arrow), Matrix (axes), Quaternion (rotation gizmo), Euler (rotation). Updates on variable change in console.
  • Spreadsheet Editor - Tabular view of geometry attributes. Columns: position, normal, UV, custom attributes, simulation state. Domains: Point, Edge, Face, Face Corner, Curve, Spline, Instance. Use cases: attribute debugging, numerical verification, data inspection.
  • Animation Graph Editor - F-Curve visualization and editing. Mathematical function representation of keyframe interpolation. Editing: control points, Bézier handles, extrapolation modes, modifier stack.

Computational Design

  • Sverchok (repo) - Visual programming for parametric design. Data tree architecture (path-based data organization). Node categories: List, Math, Vector, Matrix, Generator, Analyzer, Transform, Script. Alternatives/complements to Geometry Nodes for complex algorithmic workflows. Similar to Grasshopper (Rhinoceros 3D).
  • Tissue - Computational design addon. Operations: tessellation (surface pattern projection), dual mesh, lattice deformation, weave patterns, hyperbolic surfaces, topology optimization, thickness analysis, curvature-based coloring.
  • Animation Nodes (repo) - Visual scripting system (pre-dates Geometry Nodes). Node-based procedural animation. Data types: objects, vectors, matrices, text, collections, particles. Execution: per-frame evaluation, event-driven triggers, loop subprograms.
  • Commotion - Motion graphics addon built on Animation Nodes. Procedural animation node groups: text animation, shape morphing, particle effects.
  • BY-GEN (repo) - Non-destructive procedural modeling via Geometry Nodes and modifiers. Styles: mechanical, crystalline, paneling, displacement.
  • Infinigen (repo) - Procedural scene generator (Princeton VL). Mathematical scene grammars, procedural rules, real-world statistics. Output: geometry, materials, lighting, segmentation masks.

Terrain & Erosion

  • ANT Landscape - Built-in addon for procedural terrain generation. Perlin/Simplex noise-based heightmaps. Parameters: terrain size, resolution, subdivisions, noise scale, height, falloff, water level.
  • Erosion Add-On - Industry-level erosion simulation. Features: hydraulic erosion (particle-based), thermal erosion, flow maps, river/lake mesh generation, vertex colors for shading, vegetation particle systems. Non-destructive workflow with modifier stack.
  • Hydra - GPU erosion addon using OpenGL. Erosion types: hydraulic (particle-based, pipe-based), thermal, snow simulation. Parameters: resolution, iterations, erosion rate, sediment capacity, drag. Output: images, Geometry Nodes groups, Displace modifiers.
  • Terrain Mixer - Multi-heightmap terrain blending. Shader-based (Cycles) and Geometry Nodes versions. Erosion Mixer GN for erosion pack integration. 8K-16K heightmap support.
  • True Terrain - Terrain system with erosion simulation. Hydraulic erosion (erosion rate, deposition rate, evaporation), thermal erosion. Animated erosion parameters. Geometry Nodes compatible.
  • ErosionR - Erosion simulation based on ANT Landscape. Hydraulic erosion with vertex group generation for water/capacity.
  • Terrain Eroder - Bachelor thesis terrain erosion plugin. Features: noise-based terrain generation, thermal erosion, hydraulic erosion, rainfall area selection via vertex groups.

Animation & Rigging Physics

  • Rigid Body Bones - Applies rigid body physics to armature bones. Bones respond to gravity, collisions, forces. Constraint system for bone-to-bone joints. Use cases: ragdoll simulation, mechanical rig testing.
  • Spring Bones - Spring constraint system for bone chains. Parameters: stiffness, damping, rest length. Hooke's law: F = -k * (x - x₀) - c * v. Use cases: hair, tails, antennae, secondary motion.
  • Wiggle Bones 2 - Jiggle physics for bone chains. Secondary motion based on parent bone velocity. Controls: stiffness, damping, gravity, influence per bone.
  • Spring Constraint (Native) - Built-in spring constraint for rigid bodies and object constraints. Hooke's law implementation. Parameters: stiffness, damping, rest length.
  • Soft Wrap - Retopology dynamics addon. Wrapping mesh around target geometry with physics-based relaxation.

Export & Interchange

Simulation Data Formats

  • OpenVDB - Sparse volume data format. Industry standard for fluid/smoke simulation. Blender: native VDB import as Volume object. Grid types: density (float), temperature (float), fuel (float), velocity (vector), flame (float), heat (float). Tools: vdb_print (metadata), vdb_render (visualization), vdb_convert (format), vdb_merge (combine).
  • Alembic (.abc) - Animation cache format. Stores baked simulation geometry per frame. Use cases: fluid mesh export, cloth animation transfer, rigid body animation. Import options: set camera, validate mesh, sequence time. Export options: selected objects, visible layers, frame range, compression.
  • USD / USDZ - Universal Scene Description. Stage-based scene composition. Physics Schema: rigid body, collision, material binding. Import options: Prim paths, time codes. Export options: selection, animation, materials.

Robotics & Engineering

  • Phobos - Robot modeling toolchain. Export: URDF (Unified Robot Description Format), SDF (Simulation Description Format), SMURF. Integration targets: Gazebo, MuJoCo, Bullet, ODE. Features: link/joint hierarchy, collision geometry, sensor definition, inertia tensor calculation, mass property assignment.
  • 3D Print Toolbox - Built-in mesh analysis for physical fabrication. Checks: non-manifold edges, intersecting faces, overhangs (angle threshold), thickness (ray cast). Statistics: volume, surface area, bounding box dimensions. Units: metric/imperial conversion.

Shader & Texture Math

  • Math Node (Shader) - Scalar math operations in Shader Editor: Add, Subtract, Multiply, Divide, Multiply Add, Power, Logarithm, Sine, Cosine, Tangent, Arcsin, Arccos, Arctan, Arctan2, Sinh, Cosh, Tanh, Sqrt, Inverse Sqrt, Absolute, Minimum, Maximum, Less Than, Greater Than, Sign, Compare, Snap, Floor, Ceil, Fraction, Modulo, Wrap, Pingpong, Smooth Min, Smooth Max, Round.
  • Color Ramp - Maps scalar input to color/alpha via gradient. Interpolation modes: Linear, Ease, Cardinal, Spline, B-Spline, Constant, Near, Mix. Use cases: height-to-color mapping, normal-based gradients, procedural material variation.
  • Color Mix - Blending operations for two colors/factors. Modes: Mix, Add, Multiply, Screen, Overlay, Soft Light, Linear Light, Difference, Subtract, Divide, Darken, Lighten, Dodge, Burn. Factor-driven interpolation.
  • Separate/Combine XYZ - Vector component extraction and reconstruction. Separate: Vector → X, Y, Z (float). Combine: X, Y, Z → Vector. Use cases: per-axis manipulation, UV-driven displacement, channel-swizzling.
  • RGB Curves - Per-channel curve mapping. Independent R, G, B, A curve editing. Use cases: color correction, contrast adjustment, channel-specific remapping.

Learning Resources

Physics Simulations

Geometry Nodes & Math

Mathematics for 3D

  • Pixar in a Box (Khan Academy) - Free course: parabolas, Bézier curves, polygon subdivision, color mathematics, animation curves, ray tracing.
  • Computer Graphics from Scratch - Free online book by Gabriel Gambetta. Topics: ray tracing, rasterization, perspective projection, transformation matrices, visibility, Phong shading.
  • tinyrenderer - Software renderer from scratch (~500 lines C++). Teaches: rasterization, triangle filling, hidden face removal, texture mapping, flat/Gouraud shading, shadow mapping.
  • tinyraytracer - Minimal raytracer (~200 lines C++). Teaches: ray-object intersection, reflection, refraction, point lights, shadows.
  • Foundations of Physically Based Modelling and Animation - SIGGRAPH course notes (Baraff & Witkin). Topics: particle dynamics, rigid body dynamics, collision response, constrained dynamics, ODE integration, friction.
  • The Nature of Code - Daniel Shiffman. Simulating natural systems: vectors, forces, oscillation, particles, cellular automata, genetic algorithms, neural networks.
  • Blender's Link with Linear Algebra - Linear algebra concepts in Blender: transformation matrices, vector operations, coordinate spaces (local, world, view, clip).
  • Mathematical Illustration in Blender (UO) - Tutorial series for math publication diagrams: line art generation, Python-scripted precision modeling, knot construction.
  • Practicing Math in Blender (YouTube) - Shader node trigonometry: sine, cosine, wave interference, polar coordinate mapping.

Official Documentation

Communities

  • Blender Artists Forum - Community forum. Sections: Python Support, Geometry Nodes, Physics & Simulations, Game Assets.
  • BlenderNation - Daily Blender news and tutorials. Submissions from community.
  • r/blender - Blender subreddit. Tutorial sharing, work showcase, troubleshooting.
  • r/blenderhelp - Q&A subreddit. Technical support.
  • Blender Discord - Real-time chat. Channels: geometry-nodes, python-scripting, physics-simulation, support.
  • Blender Developer Talk - Development discussions, feature proposals, release planning.
  • Blender Stack Exchange - Q&A site. Tags: geometry-nodes, python, physics, modifiers, math.
  • Blender Addons Directory - Physics addon catalog. Lists addons by type: Physics, Simulations.

Books & Academic Resources

Books

Title Author(s) Topic Link
Computer Graphics from Scratch Gabriel Gambetta Ray tracing, rasterization, projection, transformation matrices Online
Foundations of Physically Based Modelling and Animation David Baraff, Andrew Witkin Particle/rigid body dynamics, collision, constraints, ODE PDF
The Nature of Code Daniel Shiffman Vectors, forces, oscillation, particles, automata Online
Physically Based Rendering: From Theory to Implementation Matt Pharr, Wenzel Jakob, Greg Humphreys Light transport, materials, sampling, volume scattering Online (4th ed.)
Real-Time Collision Detection Christer Ericson Bounding volumes, spatial partitioning, collision algorithms Book
Essential Mathematics for Games and Interactive Applications James M. Van Verth, Lars M. Bishop Vectors, matrices, quaternions, interpolation Book

Academic Papers & Courses

Related Lists

About

A curated list of Blender addons, tools, libraries, and resources for mathematical operations, physics simulations, precision modeling, computational design, and procedural workflows.

Topics

math blender physics

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors