3DWorld Blog: https://3dworldgen.blogspot.com

3DWorld is a cross-platform OpenGL-based 3D Game Engine that I've been working on since I took the CS184 computer graphics course at UC Berkeley in 2001. It has the following features:

• 3D graphics functions, classes, and wrappers around OpenGL
• Shader generator/processor with hot reload
• Procedural content generation for terrain, vegetation, cities, building interiors and exteriors, etc.
• Procedural universe generator with galaxies, stars, planets, moons, etc.
• Procedural voxel 3D terrain generation with realtime user editing
• Terrain generator including various noise functions, erosion, realtime user editing, heightmap read/write
• Procedural building (interior and exterior), road, and city generation
• NPC AI behaviors for people, cars, and animals with target selection and path finding/navigation
• Physics simulation for primitive object types and others (> 10K dynamic objects)
• Realtime day/night cycle with weather (rain, snow, hail, wind, lightning)
• Physically based materials with reflection and refraction
• Dynamic shadows, ambient occlusion, up to 1024 dynamic light sources, postprocessing effects
• Skeletal animation and procedural animation
• Built-in first person shooter game "smiley killer"
• Build-in spaceship + planet colonization game
• Building open world item collection and zombie gameplay mode
• Computer AI for players in the FPS game, building gameplay, and ships in the universe game
• Importer for Lightwave object file, 3DS formats, and Assimp for other file formats
• Reading support for textures: JPEG, PNG, BMP, TIFF, TGA, DDS
• Optimized for fast load and realtime rendering of large models (> 1GB of vertex/texture data)

I converted the project from svn to git at commit 6607. Most of the code is written in C++, with GLSL for shaders. This is intended to be a cross-platform project. Microsoft Visual Studio Insiders 2026 Community project files are included. A linux/gcc makefile is also included, but is more experimental. See README.linux for more details. The project should build under gcc on linux with some work, but may not run with all graphics drivers.

Be warned, this is a large repository, currently about 1GB. I've included source code, config files, textures, sounds, small models, lighting files, scene data, heightmaps, and project files. This repo does not contain the large model files used in some scenes, you'll have to download these separately. This means that some of the scene config files won't fully work because they can't find their referenced data. The current list of dependencies is:

• OpenGL 4.5 (Should come with Windows 8/10/11 latest graphics drivers)
• OpenAL 1.1 (optional) (System Install: https://www.openal.org/downloads/ or you can try the newer openal-soft: https://github.com/kcat/openal-soft)
• freeglut-2.8.1 (Current 3.0 version probably works: https://sourceforge.net/projects/freeglut/)
• freealut-1.1.0 (optional) (One version is here: https://github.com/vancegroup/freealut)
• zlib-1.2.11 (You can download a newer version from here: https://zlib.net/)
• glew-2.0.0 (2.1.0 probably works as well: http://glew.sourceforge.net/)
• gli (Latest version: https://github.com/g-truc/gli / header only, included in dependencies directory)
• glm-0.9.9.0 (Latest version: https://glm.g-truc.net/0.9.9/index.html or https://github.com/g-truc/glm / header only, included in dependencies directory)
• libpng-1.2.20 (optional) (My version is very old; Latest version: https://libpng.sourceforge.io/index.html); Can be replaced with stb_image in most cases, except for map image export.)
• libtiff-4.3.0 (optional) (Latest version: http://www.simplesystems.org/libtiff/)
• Assimp (optional) (See build instructions at https://github.com/assimp/assimp/blob/master/Build.md ; The vcpkg build instructions are probably the easiest.)
• libtarga (source included)
• STB headers: stb_image, stb_image_write, stb_dxt (source included)

I've included stripped down versions of most of these libraries in the dependencies directory. I removed all large files that aren't required by 3DWorld, in some cases even examples/tests/documentation. These have been built with MS Visual Studio Insiders 2026 Community on Windows 11. If you want to use these, you'll need to copy the directories to the root directory and rebuild any libraries needed for other versions of Windows or Visual Studio. If you clone/install vcpkg it should be at the same level as the 3DWorld directory.

Note that many of these dependencies are old and could be replaced with newer libraries. I've been concentrating on adding content and I'm not too interested in this. Freeglut should probably be replaced with SDL, and the image libraries with STB. (STB is used as a fallback but doesn't support all of the images used.)

If you want to build 3DWorld, you can use the projects in the dependencies/ folder, or download and build them yourself and change the project settings to use them. I currently use the x64 MS Visual Studio Insiders 2026 Community build target for 3DWorld, but the win32 build target also works. It should compile and run in either 32 or 64-bit mode if you copy the DLLs from the lib64/ folder into the root of the repo and make some other project settings changes.

If you have linux, you can try to build using the provided makefile. The file README.linux should be helpful. I've gotten 3DWorld to build and mostly run on Ubuntu 20.04 with gcc 9.

3DWorld takes a config filename on the command line. If not found, it reads defaults.txt and uses any config file(s) listed there. Some of these congig files include models such as the Sponza Atrium, Stanford Dragon, sportscar, etc. These files are too large to store in the git repo. I've attempted to have 3DWorld generate nonfatal errors if the models can't be found. Many of the larger models can be found on Sketchfab or at the McGuire Computer Graphics Archive: http://casual-effects.com/data/ Also see image_and_model_credits.txt in the root of the repo.

I've packaged up the 3D models that are too large for the GitHub repo and put them on Google Drive. The current version is v10 and can be found here: https://drive.google.com/file/d/1X_Do9Mzyj7bl1N4W-Kh0Rb7N5lNTIfa1/view?usp=drive_link

Some of these models are stored in 3DWorld's internal format and should not be reused in other projects. Others come from websites such as Mixamo. There is also a textures directory with additional textures used with building interiors that can be merged with the project textures directory.

System requirements:

• Windows 10/11; Linux when using the makefile with gcc.
• Microsoft Visual Studio 2026. The professional or community version is needed for OpenMP support. You can also try to use gcc on linux.
• A relatively new generation of Nvidia or AMD GPU (Runs on my laptop with integrated graphics, but at 12-20 FPS)
• At least 16GB system memory for the larger scenes
• At least 8GB GPU memory for the larger scenes; My GPU has 12GB of memory

Troubleshooting: It seems like some systems (AMD cards in particular) require an OpenGL core context. This can be selected by adding "use_core_context 1" in the config file. This can also be enabled in scene_config/config_post.txt, which is a file that applies after reading all other top-level config files. In some situations (some Nvidia cards), using a core context can be slower, which is why I don't have it enabled by default in all scenes.

Useful Keys (see readme-keys.txt for more key bindings):

• a,s,d,w: Movement
• q,e: Change weapon (gameplay mode)
• 'space': Jump/fire
• 'esc': Quit
• 'tab': Onscreen menu (navigate with arrow keys and 'X' to switch menus)
• b: Enable objects/physics/AI (for ground mode and universe mode gameplay)
• F1: Switch between ground/universe/tiled terrain modes
• F2: Toggle gameplay mode
• m: Toggle fullscreen mode
• h: Toggle flight move
• v: Change camera mode (crystal ball/orbit vs. first person)
• V: Toggle mouse look
• K: Toggle overhead map mode
• x: Pause
• Mouse Left: Turn/Action
• Mouse Right: Fire

I currently have this repo up for educational purposes under the GPLv3 license. Some sub-modules are available with other licenses compatible with commercial use in my GitHub account. It's not meant as a commercial tool and I'm not trying to make money here. That's also why I don't spend money on software, models, or textures. I'm also not looking for others to work on the project at this stage, though I'm accepting feedback, bug reports, and suggestions. Maybe things will change if I decide to make a real game out of this. If you would like to use something here for your project, please let me know.

There is no further documentation for 3DWorld. However, I do have a blog that includes descriptions of the algorithms and lots of screenshots: https://3dworldgen.blogspot.com And my YouTube channel: https://www.youtube.com/@FrankGennari

Please do not send me bot/AI generated pull requests. Please do not make suggestions related to the dependencies directory. This is included as a reference and the user is expected to update and/or build these libraries themselves.

Here are some screenshots linked from my blog:

This is a procedurally generated factory interior with machines, tanks, catwalks, ladders, and pipes. (config_heightmap.txt)

This is the interior of a 7 level procedurally generated mall interior. (config_heightmap.txt)

Here is a procedurally generated mall food court with tables and chairs, and stores to the sides. (config_heightmap.txt)

Here is a retail area of a building with racks of shelves. Buildings can contain tens of thousands of interactive objects the player can take and carry around. (config_heightmap.txt)

Cameras placed in other rooms show realtime video feeds on security monitors. (config_heightmap.txt)

Zombies (with path finding and other AI behaviors) walking around and falling into an indoor pool. The water water surface has ripples, splashes, reflections, and refractions. (config_heightmap.txt)

Parking garage with parked cars and sprinkler pipes routed on the ceiling. (config_heightmap.txt)

Procedural building basement with people, indirect lighting, and pipes routed along the ceiling. (config_heightmap.txt)

Procedural residential neighborhood with office buildings in the background. There are cars and people both on the sidewalks and inside buildings. (config_heightmap.txt)

Procedural building interior - a library with procedurally generated books. (config_heightmap.txt)

Procedurally generated houses and office buildings with full interiors. (config_heightmap.txt)

Reflective (metal), refractive (glass), emissive, and translucent spheres in night time scene with indirect lighting. Drawn in realtime; spheres can be moved interactively. (config_white_plane.txt)

Procedural city with buildings, roads, cars, and pedestrians. (config_heightmap.txt)

Procedural city at night with bridge in the foreground. (config_heightmap.txt)

Early procedural city with pine trees.

Early procedural city.

Terrain using domain warp noise with hydraulic erosion simulation before city has been placed. (config_heightmap.txt)

Tiled terrain mode with river, trees, grass, etc. (config_t.txt)

Realtime interactive destructive fire/smoke simulation involving trees, plants, and grass. (config_trees.txt)

Procedural universe solar system with asteroid belt. (universe/config_universe.txt)

Crytek Sponza atrium scene with dynamic shadow casting light source and indirect lighting. (sponza/config_sponza2.txt)

10,000 instances of a highly detailed museum model placed in tiled terrain mode (Puget Sound heightmap) and drawn in realtime with shadows and indirect lighting. (config_museum_tt_model.txt)

Crytek Sponza atrium with reflective floors and 200 dynamic point light sources in realtime. (sponza/config_sponza2.txt)

Many reflective/refractive spheres and cubes with density-based light attenuation in the office building courtyard. (mapx/config_mapx.txt)

San Miguel scene with dynamic snowfall and path traced snow coverage map rendered with a custom shader. (config_san_miguel.txt)

San Miguel scene rendered in realtime with path traced precomputed indirect lighting, normal maps, and cube mapped reflective surfaces. (config_san_miguel.txt)

2M procedurally generated + placed pine trees (500K visible) drawn in realtime in tiled terrain mode using instanced billboards. (config_t.txt)

Interactive stacking of 10,000 dynamic boxes in mapx scene. Stacks can be moved and knocked over, and scene can be saved/reloaded/edited. (mapx/config_mapx.txt)

Procedurally generated planet with rings containing small asteroids. (universe/config_universe.txt)

Asteroid belt with 10,000 dynamic (rotating and orbiting) asteroids, 100,000 point sprite particles, and volume billboard clouds for dust. (universe/config_universe.txt)

Tiled terrain mode, showing various forms of procedurally generated vegetation, including grass, flowers, pine trees, palm trees, and deciduous trees. These are actually polygon models that cast shadows. (config_t.txt)

Realtime, dynamic light shafts through noise-based volumetric smoke in the Crytek Sponza scene. (sponza/config_sponza2.txt)

Reflective, metallic floors in the Crytek Sponza scene, with indirect sun + sky lighting. (sponza/config_sponza2.txt)

Reflective spheres, torus, and cube drawn in realtime in a dynamic scene using cube map reflection textures in the office building lobby. Materials are a mix of metals and dielectrics using physically-based models. (mapx/config_mapx.txt)

Museum scene with indirect lighting, reflective surfaces, and shadow mapping. This model is procedurally textured. (config_museum.txt)

Snowy house scene generated by dropping a billion snow particles and accumulating snow. Snow is precomputed but can be rendered in realtime. (house/config_house_winter.txt)

Rain simulation and rendering, including collision detection for each raindrop and wet/reflective surfaces. (house/config_house.txt)

Indirect lighting and shadows from overlapping spotlights applied to dynamic objects. (mapx/config_mapx.txt)

Water simulation with waves using hardware tessellation in tiled terrain mode. (config_t.txt)

Procedurally generated 3D voxel ice caves with indirect lighting. This terrain can be edited in realtime with brushes and weapon fire. (config_ice_caves.txt)

Procedurally generated planet drawn entirely in the fragment shader with no textures. This includes terrain generation (ice, snow, rock, forest, desert, dirt), water, clouds, and atmosphere. (universe/config_universe.txt)