Semantic search

Jump to: navigation, search
Search

Edit query Show embed code

The query [[Graphics::3d]] was answered by the SMWSQLStore3 in 0.0061 seconds.


Results 1 – 50    (Previous 50 | Next 50)   (20 | 50 | 100 | 250 | 500)   (JSON | CSV | RSS | RDF)


3D Pong
A one-or-two player "pong" (ball and paddles) game for X-Window, drawn using vectors (lines). Different view modes are available, including split red/blue mode for using 3D glasses. Two players supported by connecting to multiple X-Window displays.
3dldf Heckert gnu.tiny.png
3DLDF Three-dimensional drawing with MetaPost output. It is written in C++ using CWEB. It is intended, among other things, to provide a convenient way of including 3D graphics in TeX documents. This package includes an interactive program called `3dldf', which implements a language intended to resemble Donald Knuth's METAFONT language and John Hobby's MetaPost language, which is based on METAFONT.
AdaGate
A combination of Portal and Sokoban, AdaGate is a great example of OpenGL programming using the Ada language. It is F.O.S., of course. While exploring a remote south-seas island you make a startling historical discovery. But before you can report your findings, an operational stargate transports you into a curious sequence of dungeons. Your escape will require the logical rearrangement of weird power cells, called Zero Point Modules (ZPMs), that can roll in only two directions. You can shoot your portal guns at the dungeon walls to define a wormhole. But, in order to activate it, all of the ZPMs must be bumped into their sockets. Now, you can only PUSH the ZPMs. That means you will fail if you roll one into a corner or against a wall. Escape each level and find your way back to a beautiful lake on the surface. The degree of difficulty is now selectable. Each game resumes at the beach but progress from previous games is tracked. Complete all 4 levels to access the lake epilog and reset the game. Uses fully modern OpenGL methods in Ada using textures, shaders and uniforms that achieves version 3.3 core profile contexts in a way that is sufficiently mainstream that it easily compiles and runs on Windows, GNU/Linux and Mac OS-X systems. This project serves as a testbed for learning the complexities of modern OpenGL and GLSL. Absolutely no coding efforts or compromises have been made to accomodate proprietary operating systems except for learning how to compile on OS-X. It relies on a thin SDL2 binding from Dan Vazquez, a thin OpenGL binding from "Lumen", a PNG reader by Stephen Sanguine, and SFML-Audio. If one defines "modern" OpenGL to mean version 3.3 or beyond, then this may be the most functionally advanced demonstration of "modern" OpenGL using Ada to be found. The code itself is far from elegant, but serves as a working example, with focus on learning OpenGL. The Ada bindings used are thin, so the relationship to C++ methodology is quite transparent. Developers should note that these Ada bindings are usable as a standalone library for most any OpenGL project. Media Files Note: The particular choices of sound, image, and shader files (*.fs) delivered are not essential to the function of the game and are easily replaced. This software is primarily intended as a tutorial example of modern OpenGL game assembly methods. The only requirements are that sounds be in WAV format, images be in PNG format, and shaders be updated to GLSL 330 specifications.
AdaVenture
AdaVenture is a kid-friendly retro point & click game, essentially intended to be a minimal extension to 3D of the original 2D Atari game named "Adventure". Set in ancient Persia, it begins outside the castle of the young King Xerxes, who inherited a golden chalice from his father, Darius the Great. Coveted by Greek foes King Leonidas of Sparta and King Minos of Crete, the chalice has been stolen. Your quest is to seek and return the royal chalice to its pedestal within the castle of Xerxes...a stealth mission to avoid open hostilities. But, there will be obstacles to overcome. You must find the keys to various realms, defend yourself against dragons and the Minotaur, avoid snakes and pesky bats who steal things only to drop them in random locations, and survive the maze of the green mamba.
Algart
AlgART are free software Java libraries, supporting generalized smart arrays and matrices with elements of any types (1 bit, 8/16/32/64-bit integers, 32/64-bit floating point values and any other Java types), including a wide set of of 2D-, 3D- and multidimensional image processing and other algorithms, working with arrays and matrices.

Main Features

  • The libraries use 63-bit addressing of array elements (all indexes and length are represented by 64-bit long type). So, it's theoretically possible to create and process arrays and matrices containing up to 2^63-1 (~10^19) elements of any primitive or non-primitive types, if OS and hardware can provide necessary amount of memory or disk space.
  • Memory model concept allows storing AlgART arrays in different schemes, from simple Java arrays to mapped disk files; all necessary data transfers are performed automatically while every access to an element or a block of elements.
  • Most of algorithms are based on wide usage of lazy evaluations. Typical operations, like elementwise summing or geometrical matrix transformations, are implemented via lazy views of the source array or matrix.
    • For example, you can take a multidimensional matrix, rotate it (or perform any other affine or projective transform), and then extract a submatrix from the result. All these operations will be performed virtually (not requiring time), and actual calculations will be performed only at the moment of accessing elements, usually while copying the resulting matrix to a newly created one. Moreover, in many cases the libraries will "understand" itself, that the user wants to perform rotation or another transform, and will split the matrix into suitable rectangular blocks (fitting in RAM) and choose the best algorithm for this task at the moment of copying operation.
  • The libraries contain a wide set of image processing algorithms over matrices: linear filtering, mathematical morphology, rank operations, spectral transformation (FFT), etc.
  • There is also skeletonization and measuring of binary images.
Aqsis
Aqsis is a Renderman(tm) compliant 3D rendering toolkit. It is based on the Reyes rendering approach. Features include programmable shading, true displacements, NURBS, CSG, Motion Blur, and direct rendering of subdivision surfaces.
ArtofIllusion
Art of Illusion can be used as a 3D Modeller and can be used to create movies. It can currently import and export Alias .obj files and export VRML97 files (without animation). To create movies, Art of Illusion has a offline renderer and set of tools to create animations. Highlights include subdivision surface based modelling tools, skeleton based animation, and a graphical language for designing procedural textures and materials.
Asymptote
'Asymptote' is a script-based vector graphics language for technical drawing, inspired by MetaPost but with an improved C++-like syntax. It provides for figures the same high-quality level of typesetting that LaTeX does for scientific text. It is a programming language, not just a graphics program, so it can use the best features of both scripts and GUIs. High-level graphics commands are implemented in the language itself, so they can be tailored to specific applications. Labels and equations are typeset with LaTeX for high-quality PostScript output.
Ayam
Ayam is a free 3D modelling environment for the RenderMan interface. Ayam features at a glance:
  • RIB (RenderMan Interface Bytestream) export and import.
  • Support for NURB curves and (trimmed) NURB surfaces, Boxes, Quadrics (Sphere, Disk, Cylinder, Cone, Hyperboloid, Paraboloid, and Torus), CSG, MetaBalls, Polygonal and Subdivision Meshes.
  • NURBS modelling includes normal and interpolating curves as well as extrude, revolve, sweep, skin, gordon, and birail objects with caps, holes, and bevels.
  • Custom objects that may freely implement their representations (using OpenGL and RIB) and even small GUIs to edit their type specific parameters may be written by the user and dynamically loaded at runtime.
  • Scripting interface: Tcl.
  • Miscellaneous: instancing, arbitrary number of modeling views, object clipboard, independent property clipboard, console, n-level undo.
BRL-CAD
BRL-CAD includes an interactive geometry editor, parallel ray-tracing support for rendering and geometric analysis, path-tracing for realistic image synthesis, network distributed framebuffer support, image-processing and signal-processing tools.
Blender
Blender is an integrated 3D suite for modelling, animation, rendering, post-production, interactive creation and playback (games). Blender has its own particular user interface, which is implemented entirely in OpenGL and designed with speed in mind. Python bindings are available for scripting; import/export features for popular file formats like 3D Studio and Wavefront Obj are implemented as scripts by the community. Stills, animations, models for games or other third party engines and interactive content in the form of a standalone binary and/or a web plug-in are common products of Blender use.
CGAL
The goal of the CGAL Project is to provide easy access to efficient and reliable geometric algorithms in the form of a C++ library. CGAL is used in various areas needing geometric computation, such as: computer graphics, scientific visualization, computer aided design and modeling, geographic information systems, molecular biology, medical imaging, robotics and motion planning, mesh generation, numerical methods...
CGAL offers data structures and algorithms like triangulations (2D constrained triangulations and Delaunay triangulations in 2D and 3D), Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams), Boolean operations on polygons and polyhedra, arrangements of curves and their applications (2D and 3D envelopes, Minkowski sums) mesh generation (2D Delaunay mesh generation and 3D surface mesh generation, skin surfaces), geometry processing (surface mesh simplification, subdivision and parameterization, as well as estimation of local differential properties, and approximation of ridges and umbilics), alpha shapes, convex hull algorithms (in 2D, 3D and dD), operations on polygons (straight skeleton and offset polygon), search structures (kd trees for nearest neighbor search, and range and segment trees), interpolation (natural neighbor interpolation and placement of streamlines), shape analysis, fitting, and distances (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis), and kinetic data structures. All these data structures and algorithms operate on geometric objects like points and segments, and perform geometric tests on them. These objects and predicates are regrouped in CGAL Kernels.
CGKit (Python Computer Graphics Kit)
The Python Computer Graphics Kit is a collection of Python modules that contain the basic types and functions to be able to create 3D computer graphics images (focusing on Pixar's RenderMan interface).
Castle Game Engine
Castle Game Engine is a cross-platform 3D and 2D game engine for Object Pascal (FPC and Lazarus). - It supports many formats for game assets, including X3D, VRML, Collada, Spine JSON, MD3 and others. - Many graphic effects are possible, including bump mapping, shadows, shaders, mirrors, screen effects. - Animation, collision detection, 3D sound and more features are available. - An extensible system of 3D objects can be used, with out-of-the-box levels, items, intelligent creatures and more. - The engine is portable -- for desktop, mobile, web plugin. The engine is also used to develop view3dscene - a full-featured X3D / VRML browser and a viewer for many other 3D and 2D game formats.
Cl-ana
cl-ana is a library of modular utilities for reasonably high performance data analysis & visualization using Common Lisp. (Reasonably means I have to be able to use it for analyzing particle accelerator data). The library is made of various sublibraries and is designed in a very bottom-up way so that if you don't care about some feature you don't have to load it. The functionality support so far are
  • Tabular data analysis: Read-write of large datasets stored in HDF5 files are supported, along with ntuple datasets, CSVs, and in-memory data tables. Users can add their own table types by defining 4 methods and extending the table CLOS type.
  • Histograms: Binned data analysis is supported with both contiguous and sparse histogram types; functional interface is provided via map (which allows reduce/fold) and filter.
  • Plotting: Uses gnuplot for plotting dataset samples, plain-old lisp functions, histograms, strings-as-formulae, and anything else the user wishes to add via methods on a couple of generics.
  • Fitting: Uses GSL for non-linear least squares fitting. Uses plain-old lisp functions as the fit functions and can fit against dataset samples, histograms, and whatever the user adds.
  • Generic mathematics: CL doesn't provide extendable math functions, so cl-ana provides these as well as a convenient mechanism (a single function) for using these functions instead of the non-extendable versions. Already included are error propogation and quantities (values with units, e.g. 5 meters) as well as a GNU Octave-style handling of sequences (e.g. (+ (1 2) (3 4)) --> (4 6)).
Coin
Coin is a platform-independent retained-mode 3D graphics library that uses scene-graph data structures to render real-time graphics+suitable for mostly all kinds of scientific and engineering visualization applications. It is fully compatible with Open Inventor 2.1. Coin is built on the OpenGL immediate-mode rendering library, adds abstractions for higher-level primitives, provides 3D interactivity, increases programmer convenience and productivity, and contains optimization features for fast +rendering that are transparent for the application programmer.
Compiz
Compiz is the result of the re-unification of the Beryl-project and the community around the Compiz Window Manager. It seeks to provide an easy and fun-to-use windowing environment, allowing use of the graphics hardware to provide impressive effects, amazing speed and unrivalled usefulness. The first Compiz Fusion developer release was Compiz Fusion 0.5.2 on August 13th 2007.
Compiz Plugins- Extra
This is the Extra plugin package for Compiz.
Compiz Plugins- Main
This is the Main plugin package for Compiz.
Cpsed
'Cpsed' is a OpenGL 3D scene editor. It lets you import .3ds model files and position, rotate and scale each of them. It features open, save, and delete functions. The 3ds loader also loads the textures in JPG/BMP/TGA format. Support for DFF Renderware is planned. The scene file save format is pure ascii with comma separated values.
DrQueue
Drqueue is a distributed rendering queue. It manages jobs on a renderfarm. It supports Maya, Blender, and Bmrt (Renderman) out of the box, and can support any other renderer or computing task that can be handled via scripting. The package has three tools: master, slave and drqman. The master acts as a server where tasks are stored and where computers running slaves report success or failure in executing tasks. The slaves run on every node of the renderfarm. They report load average; if it is below a set level, they are available for rendering and take the first task assigned by the master server. drqman is a GUI for controlling jobs and computers.
Drishti
Drishti stands for vision or insight in Sanskrit, an Indian language. Drishti has been developed keeping in mind the end-use : visualizing tomography data, electron-microscopy data, etc. Understanding the data set is important and conveying that understanding to the research community or a lay person is equally important. Drishti is aiming for both. The central idea about Drishti is that the scientists should be able to use it for exploring volumetric datasets as well as use it in presentations.
EMAN
EMAN is a scientific image processing suite designed mainly to perform single-particle reconstructions of individual molecules. In this method, a transmission electron microscope is used to collect images of thousands of individual molecules. A complex series of algorithms then turns the individual 2D images into a high-resolution 3D structure of the molecule. The core of EMAN is a C++ based scientific image processing library.
Emerald- Compiz Theme Manager
Emerald controls the appearance of your window borders in Compiz. It allows you to install, edit and switch between various themes.
Equalizer
Equalizer is a framework for the development and deployment of parallel OpenGL applications. An Equalizer application can run unmodified on any visualization system, from a singlepipe workstation to large scale graphics clusters and multi-GPU workstations. Equalizer is built upon a scalable OpenGL-based programming interface solving problems that are common to any multipipe application. The API is minimally invasive, making application porting as easy as possible while delivering maximum performance.
Experimental Robotics Framework
The Experimental Robotics Framework is a framework for developing composable applications. The idea is to develop software components that interact with others previously developed in other applications and other components developed by other researchers. It is not a new concept in the field, it is very similar to IBM eclipse but in this case for 3d applications and based on C++ instead of Java.
Flames
"flam3' renders fractal flames as described on http://flam3.com. It is an advanced version of the Gimp plug-in. The package includes flam3-animate, which makes animations; flam3-render, which makes still images; and flam3-genome, which creates and manipulates genomes (parameter sets).
FreeCAD
FreeCAD is an CAx RAD based on OpenCasCade, Qt and Python. It features some key concepts like Macro recording, Workbenches, ability to run as a server and dynamically loadable Application extensions and it is designed to be platform independent.
FreeWRLDI
This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 02:32, 31 July 2018 (EDT) FreeWRLDI (FreeWRLduneInputDevice), together with FreeWRL, lets you "hover" through 3D data in the Web with 4 degree of freedom input devices. It is based on FreeWRL's "/tmp/inpdev" extern sensor input interface and white_dune's input device mechanism.
GTO
The GTO format's primary usage is storage of static geometric data. The types of data you might find in a GTO file are things like polygonal meshes, various types of subdivision surfaces, NURBS or UBS surfaces, coordinate systems, hierarchies of objects, material bindings, and even images. "GTO' is used at Tweak Films to streamline the modeling, animation, rendering, and 3-D paint processes. It includes source code for a Maya plug-in, various command line tools, a Wavefront .obj parser, and a Python module for reading and writing GTO files. There is also an emacs mode gto-mode.el for editing GTO text files.
Geomview
Geomview is interactive geometry software which is particularly appropriate for mathematics research and education. It can display objects in hyperbolic and spherical space as well as Euclidean space. Geomview allows multiple independently controllable objects and cameras. It provides interactive control for motion, appearances (including lighting, shading, and materials), picking on an object, edge or vertex level, snapshots in SGI image file or Renderman RIB format. Adding or deleting objects is provided through direct mouse manipulation, control panels, and keyboard shortcuts. External programs can control certain aspects of viewing (such as continually loading changing geometry or controlling the motion of certain objects) while allowing interactive control of everything else. It can be used as a standalone viewer for static objects or as a display engine for other programs. It can display objects described in a variety of file formats. It comes with a wide selection of example objects, and you can create your own objects too.
Gleem Heckert gnu.tiny.png
Gleem (OpenGL Extremely-Easy-to-use Manipulators) is a library for Java and C++ offering a set of 3D widgets that support direct user interaction with a 3D scene. These widgets are used to translate along a line, translate in a plane, and do three-dimensional translation and rotation.
Glv - OpenGL viewer command line tool
A generic openGL viewer for the prompt. The goal of this project is to make 3d rendering as accessible as text is, with well-known command-line tools (like grep, sed, gnuplot, etc.). The viewer is useable with pipes, and defines a simple input format.
Gmsh
'Gmsh' is an automatic 3D finite element mesh generator with build-in CAD and post-processing facilities. Its design goal is to provide a simple meshing tool for academic test cases with parametric input and up to date visualization capabilities. It can respect a characteristic length field for the generation of adapted meshes on lines, surfaces and volumes, and mix these meshes with simple structured grids. Gmsh is built around four modules: geometry, mesh, solver and post-processing. The specification of any input to these modules is done either interactively using the graphical user interface or in ASCII text files using Gmsh's own scripting language.
Gnu3dkit
GNU 3DKit is an object oriented graphics framework for creating 3D graphics applications in the Objective-C language. The last version (released in 2002) can no longer be downloaded. It has since been decommissioned and is no longer developed. 3DKit was officially part of the GNU project as an extension to GNUstep. Its main application was to render 3D graphics in real-time on commodity hardware, using a scene graph architecture. It was based on OpenGL graphics library to achieve this goal.
Gnubik Heckert gnu.tiny.png
GNUbik is an interactive, graphical, single player game. It renders an image of a Rubik cube and allows you to manipulate it and hopefully solve it. GNUbik supports cubes of any size; 3x3x3 is the default. It also has a guile interface by which you can create your own scripts to solve the cube.
Godot
Godot is a 2D and 3D game engine, featuring:
  • Use your eyes
    • Work inside a simple, yet flexible and feature rich editor, with tools popping up to aid you only when you need them.
  • Develop 2D games
    • Create complex 2D games with the fully dedicated 2D engine (no need for 3D over 2D), using pixel coordinates and a wide array of tools.
  • Develop 3D games
    • Create realistic looking 3D games with the dedicated 3D Engine, with full support for lights, shadows, occlusion, post processing, skeletal animation, etc.
  • Script
    • Add custom behaviors to any object by extending it with scripting, using the built-in editor with syntax highlighting and code completion.
  • Design
    • Create simple or complex user interfaces, or make your own custom tools to edit your game content.
  • Animate
    • Animate your games with full support for editing, blending, animation trees, realtime cutscenes, calling function, or animate just any property exported by any node.
  • Simulate
    • Add physics to your 2D and 3D scenes, through rigid and static bodies, characters, raycasts, vehicles and more.
  • Debug
    • Use the built-in debugger with breakpoints and stepping, or check the performance graphs for possible bottlenecks.
  • Deploy
    • One-click deploy to several platforms, such as GNU/Linux, OS X, Windows, Android, iOS, BB10 and HTML 5.
  • Extend
    • Extend the editor and your game by using plugins, which add extra functionality for both.
  • Work in a team
    • Develop projects in a team using any choice of VCS, as Godot integrates flawlessly with all of them.
Gphoton
Gphoton is a simple 3d modeller with integrated ray tracer. It lets you construct/manipulate/modify a 3d model while approximating the scene with OpenGL. It renders with either the software ray-tracer or OpenGL; screenshots can be saved to TIF. You move around in the scene interactively with keyboard/mouse combinations and/or dialog clicks. It's intended primarily for artistic use (as opposed, for example, to use as a 3D modeller for games). As a ray-tracer entirely implemented in software, the program is extremely slow compared to hardware 3d graphics. However, being software, it is extremely flexible and extensible, more hardware independent, and can produce images of outstanding quality and very high resolutions (ie ANSI-E size 300 dpi images).
Graphics3D
'Graphics3D' is a C++ library for game developers, researchers, and students. It is a base of robust and high performance code common to most 3D projects. It is not a standalone graphics or game engine--it is a set of pieces to jumpstart your own engine or graphics project. The library has two parts: G3D for pure math, and GLG3D for interacting with hardware acceleration via OpenGL. You can use G3D without GLG3D if you want to use another 3D API or don't like the OpenGL abstraction.
Guile-opengl Heckert gnu.tiny.png
Guile-OpenGL is a library providing access to the OpenGL graphics API from Guile.
JFreeChart
A free Java chart library. JFreeChart supports pie charts (2D and 3D), bar charts (horizontal and vertical, regular and stacked), line charts, scatter plots, time series charts, high-low-open-close charts, candlestick plots, Gantt charts, combined plots, thermometers, dials and more. JFreeChart can be used in applications, applets, servlets and JSP. JFreeChart's extensive feature set includes: - a consistent and well-documented API, supporting a wide range of chart types; - a flexible design that is easy to extend, and targets both server-side and client-side applications; - support for many output types, including Swing components, image files (including PNG and JPEG), and vector graphics file formats (including PDF, EPS and SVG); - JFreeChart is free software. It is distributed under the terms of the GNU Lesser General Public Licence (LGPL), which permits use in proprietary applications.
K-3D
K-3D is an advanced 3D modeling, animation, and rendering system that is extremely portable. It is designed from-the-ground-up to generate motion-picture-quality animation using RenderMan, the de facto industry standard for 3D graphics.
K3DSurf
K3DSurf is a program for visualizing and manipulating multidimensional surfaces by using Mathematical equations. It's also a "modeler" for POV-Ray in the area of parametric surfaces. It features 3D, 4D, 5D, and 6D HyperObjects visualization, full support for all functions (like the C language), support for mouse events in the drawing area, animation and morph effects, Povscript and mesh file generation, and support for VRML2 and OBJ files. More than 100 examples are provided.
KiCad
KiCad is electronic design automation (EDA) software made for designing schematics of electronic circuits and printed circuit boards (PCB). KiCad is developed by the KiCad Developers Team, and features an integrated environment with schematic capture, bill of materials list, PCB layout and much more. KiCad is cross-platform, written with WxWidgets and runs on FreeBSD, Linux, Microsoft Windows and Mac OS X. A lot of component libraries are available. Also migrating tools for components are available (from other EDA software tools). File formats are plain text and well documented, which is good for CVS or Subversion and to make automated component generation scripts. Multiple languages are supported, such as English, Portuguese, Spanish, Czech, Polish, French, German, and Russian. The 3D PCB viewer use 3D model from Wings3D CAD.
Lib3ds
Lib3ds is a free library for handling 3DS files. Its goal is to simplify the creation of 3DS import and export filters. It features support for little and big endian CPUs, modules for vector, quaternion, and matrix mathematics, simple data structures which are easy to manipulate, evaluation of all animation data, seamless integration with OpenGL, and the ability to load most 3DS chunks found in the material, camera, light, mesh, and keyframer sections.
LibL3D
L3D is a 3D library for developing OpenGL applications under GNU/Linux. The library has a mail event loop with callbacks and Camera And Path Classes exist to produce cinematic camera movement. FPS entities are under construction.
LibQGLViewer
'libQGLViewer' is an C++ library which lets you quickly start the development of a new 3D application. It is designed for 3D developers, who can display and move around a 3D scene by simply providing the openGL orders that define their 3D geometry. The viewer is designed to be as general as possible and is not designed for a specific 3D application. It provides some useful classical functionalities such as a camera trackball, screenshot saving, mouse manipulated frames, stereo display, keyFrames and more. 'libQGLViewer' is not a 3D viewer that can be used directly to view 3D scenes in various formats; it is more likely to be the starting point for the coding of such a viewer.
LibTAP
'libTAP' (The Architectural Playground) is a prototyping system for virtual reality and augmented reality applications. It runs on a variety of platforms. RAP (rapid application prototyping) is done through the Lua interface, which mirrors the C++ namespace as closely as possible. libTAP has a small but distinctive feature set, focused on prototyping of realtime 3D simulations.
  • Also known as 'Tacitpixel'.
Lightfeather
Lightfeather is a 3D engine for GNU/Linux. It is designed to be easy to use but still take advantage of the features of modern graphics hardware.
Mandelbulber
Mandelbulber is an experimental application that helps to make rendering 3D Mandelbrot fractals much more accessible. A few of the supported 3D fractals: Mandelbulb, Mandelbox, BulbBox, JuliaBulb, Menger Sponge, Quaternion, Trigonometric, Hypercomplex, and Iterated Function Systems. All of these can be combined into infinite variations with the ability to hybridize different formulas together.


Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.