WickedEngine-Documentation.md

WickedEngine Documentation (work in progress)

High Level Interface

The high level interface consists of classes that allow for extending the engine with custom functionality. This is usually done by overriding the classes.

• MainComponent
  • This is the main runtime component that has the Run() function. It should be included in the application entry point while calling Run() in an infinite loop
  • It has a SetWindow function that expects a platform specific window handle. It is necessary to call SetWindow() before calling Run()
  • Once Run() is called in a loop, it will perform Initialize(), Update(), FixedUpdate(), Render(), Compose() functions.
  • ActivatePath() will activate a render path and optionally fade the screen to transition between them. Refer to RenderPath for additional details.
  • Refer to the order of execution diagram below for an overview:

Order of execution:
(Diagram generated with draw.io)

• RenderPath

  • This is an empty base class that can be activated with a MainComponent. It calls its Start(), Update(), FixedUpdate(), Render(), Compose(), Stop() functions as needed. Override this to perform custom gameplay or rendering logic.
  • It has several ready to use variants, such as RenderPath2D, RenderPath3D_Deferred, LoadingScreen, etc.

• RenderPath2D

  • Capable of handling 2D rendering to offscreen buffer in Render() function, or just the screen in Compose() function.
  • It has some functionality to render wiSprite and wiFont onto rendering layers

• RenderPath3D

  • By itself, it only does everything that RenderPath2D can do.
  • It must be specialized for a specific 3D rendering algorithm, such as RenderPath3D_Deferred, Forward, TiledForward, etc.

• RenderPath3D_Forward

  • Implements simple Forward rendering. It uses few render targets, but not very efficient with many lights

• RenderPath3D_Defered

  • Implements old school Deferred rendering. It uses many render target, capable of advanced post processing effects, and good to render many lights.

• RenderPath3D_TiledForward

  • Implements an advanced method of Forward rendering to be able to render many lights efficiently. It uses few render targets, so memory efficient.

• RenderPath3D_TiledDeferred

  • Implements and advanced method of Deferred rendering to be able to render many lights with reduced memory bandwidth requirements.

• RenderPath3D_PathTracing

  • Implements a compute shader based path tracing solution. In a static scene, the rendering will converge to ground truth.

System

You can find out more about the Entity-Component system and other engine-level systems under ENGINE/System filter in the solution.

• wiECS

  • This is the core entity-component relationship handler class: ComponentManager
  • Entity is a number, it can reference any number of different components through ComponentManager containers
  • Component is not defined, it can be any data, that is stored inside a ComponentManager along entities

• wiSceneSystem

  • This contains Scene, a class that is responsible of holding and managing everything in the world
  • There are also all of the Component types, like TransformComponent, MeshComponent, etc.

• wiJobSystem

  • Manages the execution of concurrent tasks
  • Execute() function will schedule a task for execution on a separate thread
  • Dispatch() function will schedule a task for execution on multiple parallel threads
  • Wait() function will block until all jobs have finished. All scheduling operations are put on hold too

• wiInitializer

  • Initializes all engine systems

• wiWindowRegistration

  • This is a platform specific utility to manage the native display window

Physics

You can find the physics system related functionality under ENGINE/Physics filter in the solution. It uses the entity-component system to perform updating all physics components in the world.

• wiPhysicsEngine_Bullet
  • Bullet physics engine library implementation of the physics update system

Graphics

You can find the Graphics related classes un der ENGINE/Graphics filter in the solution. The most notable classes are the folowing:

• wiRenderer

  • This is a collection of functions that facilitate an engine-level rendering logic, like DrawScene, DrawLights, etc...

• wiImage

  • This can render images to the screen

• wiFont

  • This can render fonts to the screen

• wiGraphicsDevice

  • This is the low-level rendering interface. It must implement either DirectX1, DirectX12 or Vulkan (at the moment)
  • See wiGraphicsDevice_DX11 for DirectX11 rendering interface
  • See wiGraphicsDevice_DX12 for DirectX12 rendering interface
  • See wiGraphicsDevice_Vulkan for Vulkan rendering interface

• There are many other classes that you can find here, such as wiEmittedParticle, to render emitter components.

You can see a quickstart guide on the following picture regarding the most common rendering resources:

Helpers

A collection of engine-level helper classes

• wiArchive
  • This is used for serializing binary data
• wiHelper
  • Many helper utility functions, like screenshot, readfile, messagebox, splitpath, sleep, etc...
• wiMath
  • Math related helper functions, like lerp, triangleArea, HueToRGB, etc...
• wiProfiler
  • A timer utility that can measure CPU and GPU timings and used across the engine
• wiRandom
  • random number generator
• ...

Input

The input interface can be found here

• wiInputManager
  • This manages all inputs
  • There are several functions, such as down(), press(), etc. to check button states.

Network

TODO: Rewrite the networking systems

Scripting

This is the place for the Lua scipt interface. The systems that are bound to Lua have the name of the system prefixed by _BindLua.

• wiLua
  • The Lua scripting interface

Tools

This is the place for tools that use engine-level systems

• wiBackLog
  • Used to log any messages by any system, from any thread. It can draw itself to the screen. It can execute Lua scripts.