acidrainstudios/truereality

True Reality (TR) is an open source LGPL Game and Simulation Engine written entirely in Standard C++ and OpenGL. It runs on all Windows platforms and GNU/Linux. OpenSceneGraph is used as its graphics engine, along with many other open source projects for support of various features.

truereality's Issues

GUI System

Create GUI system to use for in-game menus, mini-maps, etc.

Level Editor

Create a level editor, like Delta3D's STAGE, to edit maps for the simulation.

Camera Centered World

The camera should be placed at (0,0,0) at all times to avoid positional miscalculation (rounding/machine error) from very far away objects placed near the camera.

Entity System Development

Simulation manager should use an actor, component and actor module based model to manage the system.

Create a messaging system for the True Reality Based off Delta3D's entity messaging system.

System should also support statistics for individual system elements.

Links: http://t-machine.org/index.php/2007/09/03/entity-systems-are-the-future-of-mmog-development-part-1/ http://scottbilas.com/files/2002/gdc_san_jose/game_objects_slides.pdf

Create TR Environmental Variables

Create TR Environmental variables and utilities to use them.

TR_ROOT = c:\blah_blah\TrueReality
TR_LIB = %TR_ROOT%\Lib;%TR_ROOT%\Ext\Lib
TR_BIN = %TR_ROOT%\Bin;%TR_ROOT%\Ext\Bin
TR_INC = %TR_ROOT%\Include;%TR_ROOT%\Ext\Include
TR_DATA = %TR_ROOT%\DataFolder --This is an optional Variable
TR_PATH = %TR_ROOT%;%TR_LIB%;%TR_BIN%;%TR_INC%

Make a CMake Version Script

We will have a version utility that should be used to generate versions automatically.

While we dont have a build server, CMAKE should make sure that this utility is executed on each successful build of a solution, in Linux and Windows.

Particle System

Visual Property Editor

Create a visual property editor for in-simulation use, similar to the limit theory system.

TR Scene Graph

Recreate a similar to D3D scene graph nodes and tree setup in TR

OpenSceneGraph should be wrapped in a trSG library, and from that scene graph classes should be created in trCore

Peripheral Input Support

Create an input system to handle joysticks, mice, controllers, gamepads, keyboards, etc.

Flat World Terrain System

Simulation should include the ability to use flat world projections system with a hull down effect.

Sound/Audio System

Create an audio/sound system for the simulation. Will use OpenAL and allow for surround sound.

Localized Fog Effects

Should be able to handle localized fog effects as well as "exponential" fog effects using pre-volumetric (noise generated density) or volumetric based models.

Shader Manager

Create a shader manager for the simulation. Shader manager should handle geometry, tessellation, pixel, vertex, and fragment. We should also support multi-texture ability in the shaders.

Networking System

Networking system that could handle AMQP, XMPP, HLA, native, DIS, zeroMQ and potentially other protocols.

Physically Based Rendering

Have shaders use the PBR model.

Some links on the topic:

https://www.marmoset.co/toolbag/learn/pbr-theory
https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/PhysicallyBased/index.html
https://jmonkeyengine.org/299803/physically-based-rendering-part-one/

-IR material Info
-Heat

Skeletal Animation

Create ability to have GPU skinned skeletal animation. Could use cal3d, or other open-source animation library.

Centralized Computing Capability

Create a system for the simulation to handle a majority of computations on a single machine and use other machines to render the scenes.

Volumetric Rendering

Create system that can render three dimensional objects using volumetric techniques, i.e. voxels.

Artificial Intelligence (AI) Decision Making System

Artificial Intelligence (AI) Decision Making System like in F.E.A.R. or other well known game engines.

Speed Tree Integration

Create a speedtree integration for the terrain system.

Multiscreen Capability

Allow the simulation to run on multiple screens.

Model Viewer

Create model viewer to perform spot testing on models. Should include the ability to add plugins, i.e. libraries, from our system into the model viewer.

Dead Reckoning Algorithm for networked entities.

Create a dead reckoning actor component for networked entities

Links: https://books.google.com/books?id=ujfOBQAAQBAJ&pg=PA307&lpg=PA307&dq=believable+dead+reckoning+for+networked+games&source=bl&ots=OB4QWrj953&sig=s-iBdCrZs8a7fkJrf9yU5rj120o&hl=en&sa=X&ved=0ahUKEwj1wIGNzZnMAhXDHT4KHSDADQ8Q6AEISDAH#v=onepage&q=believable%20dead%20reckoning%20for%20networked%20games&f=false

https://svn.code.sf.net/p/delta3d/code/trunk/delta3d/src/dtGame/deadreckoninghelper.cpp

CMake System

General CMake setup and project structure maintenance. Compilation should work on both Linux and Windows. Has not been tested or designed for other operating systems.

Update Wiki

Need to update the Wiki with a Setup section and a contribution section.
Wiki needs to include a Coding Style guide.

Virtual Reality Headset Support

Support for VR systems such as HTC's Vive and Oculus' Rift. It will utilize the OpenVR library.

Plugin System

Ability to load libraries on the fly, using a configuration file or similar system.

Auto-LODs

Creates a system that will decimate the model mesh in real time on the fly and create lower level LODs according to pixel area.

Links:

https://wiki.jmonkeyengine.org/doku.php/jme3:advanced:level_of_detail https://github.com/worldforge/ember/tree/master/src/components/ogre/lod http://sajty.elementfx.com/progressivemesh/GSoC2012.pdf

Networked Splash Screen

Adds functionality to the splash screen to monitor progress of other network clients from any client.

Multithreaded Resource Loading

Simulation engine should use osgDB to load the models into scenes. This will reduce load hiccups and smooth rendering when loading new models.

Physics System

Create a physics system to handle all the physics calculations in the simulation. Will likely use bullet, PhysX, FleX, and other physics systems, plus handle calculations on both the CPU and off-loading onto GPU architecture.

Main physics Actor Module should use GPU enabled Bullet with additional Actor Modules for PhysX and FleX.

Lighting Effects System

Create lighting system that handles shadows, source lights, diffuse lighting, reflections, refraction, ray-tracing, particle generation etc. through shaders. Include aerial lighting and deferred rendering.

Links:
https://msdn.microsoft.com/en-us/library/windows/desktop/ee416307(v=vs.85).aspx
http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-16-shadow-mapping/
https://www.opengl.org/sdk/docs/tutorials/TyphoonLabs/Chapter_3.pdf
http://www.opengl-tutorial.org/intermediate-tutorials/billboards-particles/particles-instancing/
http://www.unilim.fr/pages_perso/frederic.mora/pdf/psv.pdf
https://developer.download.nvidia.com/SDK/10.5/opengl/src/cascaded_shadow_maps/doc/cascaded_shadow_maps.pdf

Shader Editor

Create a shader editor that utilizes the visual scripter system.

Geographic Information System (GIS) Coordinate System

Create a tool to convert between GL units and various Geographic Information System (GIS) coordinates on spherical worlds.

Splash Screen/Progress Bar

Create a splash screen that will indicate the progress of loading a map. Screen should be modular to include future enhancements.

Import VR-Sim

Import the VR-Sim project and restructure it into the new True Reality engine base.

VR-Sim is an engine @DieSlower built many years ago. Some modules of it were built for Stevens Institute of Technology and are partially owned by it.
The core VR-Sim engine is developed and owned by DieSlower and with his permission is going to be converted into an LGPL project and continue its development under a new name.

Parallel/Threaded Tasking

Create a thread pool manager to easily let TR use multiple cores to the max of the machine's ability. Delta3D already has thread pool manager which could be used as an example.

Create base motion model

Create a basic motion model for moving the player in the map. Will control the translation and rotation of the player.

Procedurally Generated Content

Create a system to procedurally generate certain content.

Server/Client Architecture

Create a server/client architecture for the simulation to run as either depending on configurations.

Visual Script Editor

Create a visual script editor like Unreals Kismet to program visually. Will be used for the shader editor and AI system.

Planetary-sized Terrain

Make the terrain system able to create and use planetary-sized terrains.
The system should have an ability to display a geocentric terrain system with gravity type clamping effects.
Should be an actor.

Artifical Intelligence (AI) Path Finding System

Create an AI system for actors to move around their environment. This system should be node based or mesh based.

This will be able to utilize the visual script editor.

Ocean System with Wakes

Simulation should have an ocean system that also includes wakes from models on the ocean.
-Transparent Ocean
-Lee Wakes

Logger System

TR needs a logging system for Log file creation, console output and exception catching. Similar to what D3D has.

Improve Repo ignore files

Update the .hgignore or .gitignore file to ignore certain files when checking the repository.

Issue has been opened for a while and will continue to be used for reference when committing updates related to the ignore file.

Create a version Info file, and Utilities to read it in.

Version Info file should be stored in the Data folder,
Utilities should be internal functions that can read the file, and a program trVersion that will print the version of the TR and any additional info that the user might want to see.

The format of the version number should be:

Maj.Min.YYMM.Commit# or Maj.Min.YYMM.Build# or

YY = Year MM = Month

Additional information could include the webpage where to get TR, and Author list.

Atlas Texture Editor

Create a tool that will take one or more models and unify their textures into a texture atlas. This atlas could have not only the diffuse texture, but bump, normal, specular maps and others in the same file.

Imposters

Simulation should use imposters when models are significantly far away from our cameras.
We need to have an Imposter node