Application

Application Structure

All applications in Force holds by Force::Application class. Application is base class of Force Engine, it holds all user applications, initialize other engines, managers, load libraries defined by Force::ApplicationSpecification. To create a application we need create single executable file, in our case in will be ExampleApplication.cpp.

Any Application accept the ApplicationSpecification structure in their base constructor. About the specifications we will talk later.

// Defenition of Application constructor.
Application(const ApplicationSpecification& spec);

Modules

Each Force Core module is divided by different folders and stored in separate namespaces. Here list with all supported at this moment Force modules.

Module	Folder	Namespace
Core	Force/Core	Force::Core
IO	Force/IO	Force::IO
Graphics	Force/Graphics	Force::Graphics
Audio	Force/Audio	Force::Audio
Platform	Force/Platform	Force::Platform
Physics	Force/Physics	Force::Physics
Math	Force/Math	Force::Math
Animation	Force/Animation	Force::Animations
Assets	Force/Assets	Force::Assets
Project	Force/ProjectManagment	Force::ProjectManagment
Scene Managment	Force/SceneManagment	Force::SceneManagment
Scripting	Force/Scripting	Force::Scripting
Serialization	Force/Serialization	Force::Serialization
Networking	Force/Network	Force::Networking
Localization	Force/Localization	Force::Localization
UI	Force/UI	Force::UI
Utils	Force/Utils	Force::Utils

Entry point

Each application should have its entry point. Entry point is entry of any program in general. In Force entry point defined in Main.cpp file. Without it, you won't be able to compile and launch the application. This file need to be included once per application project.

So to quickly setup entry point, and other properties, lets define and setup Main.h, that you can copy from engine Force/Main.h with all description about each define.

#pragma once

/******************************************************************************************************/
/* [Requred]: This allows to custom implement some mono/C# functions on external application side.    */
/* For example it defined in Editor to send messages not to default Logger instead to editor Console. */
/*                                                                                                    */
/* Include default implementation:                                                                    */
   #include "Force/Scripting/External/MonoInternalCallsRaw.inl"                                        
/*                                                                                                    */
/* Include app implemenatation:                                                                       */
/* #include "ExternalApplication/Scripting/MonoInternalCallsAppName.h"                                */
/*                                                                                                    */
/******************************************************************************************************/

/******************************************************************************************************/
/* [Optional]: [ADVANCED] User implementation of Force::ManagedInitializeCore(). If this defined you  */
/* need implement it by yourself and setup core initialization modules, otherwise Force wiil use      */
/* default implementation of Force::ManagedInitializeCore().                                          */
/*                                                                                                    */
/*                                                                                                    */
   #define FE_CONFIG_MANAGED_CORE_INITIALIZATION                                                       
   #include "Force/Core/Types.h"                                                                       
   #include "Force/Core/Core.h"                                                                        
   namespace Force {                                                                                   
      CoreSpecification ManagedInitializeCore() { 
          CoreSpecification coreSpec;
          coreSpec.initScriptingEngine = FE_FALSE;
          return coreSpec; 
      }   
   }
/******************************************************************************************************/

/******************************************************************************************************/
/* [Requred]: This is entry point of each of Force application. It should be defined otherwise you    */
/* cannot compile Force Application.                                                                  */
/*                                                                                                    */
/*                                                                                                    */
  #include "Force/Main.cpp"
/******************************************************************************************************/

In this file we can choose witch runtime Force API's we should use, for example in ManagedInitializeCore() for CoreSpecification we can choose to disable executing of Scripting Engine, because for our application it not needed. But main include there is Force/Main.cpp, because it define application entry point and include Main() function to make our application executable.

Now how our ExampleApplication.cpp file should looks like:

#include "Main.h"

Before launching application we need to create implementation of Force::CreateApplication() function.

Force::Application* Force::CreateApplication(const Force::ApplicationBootSpecffication& bootSpec) noexcept {
    ApplicationSpecification applicationSpec;
    applicationSpec.name         = "Example Application";
    applicationSpec.workingPath  = Path(FE_DEV_LOCATION) / "Examples/ExampleApplication";
    applicationSpec.resourcesDir = "Resources";
    
    Force::Application* application = new Force::Application(applicationSpec);
    return application;
}

As you can see all information here that passed into Application via ApplicationSpecification is trivial, only one little new note that i wanna take of: FE_DEV_LOCATION macro is point to "C:/ForceDev", witch is default, constant location on drive where all Force Engine development branch are stored.

And that's it! Now you can just press F5 and build and run your own application written in Force.

If you have some problems with compiling or linking Force, please take a look on the latest two chapters below.

Application Specifications

Now Applications use the specifications like ApplicationSpecification, ApplicationUserSpecification, ApplicationWindowSpecification, and ApplicationBootSpecification instead old GetParam API.

When you first configure and run the engine you will have by default are the default settings of window and so on. If you want to add or change your app's settings you will need to use Force::ApplicationSpecification struct to configurate custom application. Its contains the bunch options that you can apply on application.

ApplicationSpecification

struct ApplicationSpecification {
		String                           name;                                        // Name of the application.
		String                           description;                                 // Description of the application.
		String                           autor;                                       // Autor/company of product/application.
		String                           version;                                     // Version of application. Defines in string as 0.0.1.
		uint                             versionMajor;                                // Seperate major version.
		uint                             versionMinor;                                // Seperate minor version.
		ApplicationVersionType           versionType         = (ApplicationVersionType)4;// Type of the application version. Usefull for developing.
		uint                             versionTypeIdx      = 1;                     // If version type is pre, alpha or beta this is pre-release index. E.g 0.1.0-beta1 -> versionTypePreIdx = 1.
		Path                             workingPath;                                 // Working directory of project.
		Path                             resourcesDir;                                // Directory of working resources.
		ApplicationBootSpecification     bootSpec;                                    // Additional create/command line specification.
		ApplicationWindowSpecification   windowSpec;                                  // Additional window specification.
		ApplicationUserSpecification     userSpec;                                    // Additional user specification.
		ApplicationPlatformSpecification platformSpec;                                // Platfrom application specification.
		ApplicationBuildSpecification*   buildSpec;                                   // Build specification. Used for retriving build scene list to output application.
		ApplicationHook                  hook;                                        // Application Hooks.
		bool                             consoleApp          = FE_FALSE;              // If true Force will create windowless application, with only console and force cut off: any main surface/window, LogoScreen, IO Engine, Render Engine, Language Manager, Scene Manager, Asset Manager, Drag Drop, VFS. This usefull for blank empty applications or audio applications, or servers. NOTE: If this was set you cannot undo in runtime on you client side (Application, Element, etc) this until application reloading.
		bool                             launchInIDE;                                 // Special flag for running app throw IDE or final excecutable.
		bool                             logoScreen          = FE_FALSE;              // [Beta]: If this true application during loading its resources will show the logo screen. NOTE: Modifying this after application creation is not allowed.
		bool                             useImGuiElement     = FE_FALSE;              // If true Force will create Dear's ImGui context and process it on their element. 
		bool                             useForceRenderer    = FE_TRUE;               // Enables the Force rendering engine. For all cases should be true, only for example if you want to render only throw custom render engine or Dear's ImGui shell. NOTE: Modifying this after application creation is not allowed.
		bool                             useForceRendererDoc = FE_FALSE;              // Enables the injecting RenderDoc runtime api into Force. Acceptable only if 'useForceRenderer' is true.
		bool                             useForceAudio       = FE_TRUE;               // Enables the Force audio engine. Should be false only if your never will use Audio Engine in your Application. NOTE: Modifying this after application creation is not allowed.
		bool                             useStdTerminate     = FE_TRUE;               // [Debug]: If this true will set global exception function handler (works outside VS only), or throw regular try..catch block.
		bool                             handleCloseByEngine = FE_TRUE;               // Sets the handle window close event by engine not user application or vise virsa. If close event will handle by engine and by user application its may cause a problems, because OS close event on engine side will excecute first and may broke the user close event. In general if handle close event on user side set this to false. If this true you should manially handle close event on user application side. Otherwise you cannot close OS window [if present on platform] by clicking on cross. 
	};

As you can see ApplicationSpecification contains basic, parameter as name or version of your application, but also contains other application sub-specifications.

ApplicationUserSpecification

User specification contains information about user per application. Some of options can be independent of each application, like startProjectPath or newUser.

But other options is specific for each application.

struct ApplicationUserSpecification {
		Handle      ID;
		bool        newUser;
		bool        dist;                // Returns true if ForceEngine runs as Distrubution build, otherwise Dev build.
		Path        applicationPath;     // Path where Application.exe is stored.
		Path        lastApplicationPath; // Path where Application.exe was storing on disk from prev session.
		Path        startProjectPath;    // Path where last project is stored or start path or project.
		AssetHandle startScene = 0;      // Handle of startup scene, relative to startProjectPath Assets directory.
	};

ApplicationWindowSpecification

Window specification contains application window info.

struct ApplicationWindowSpecification {
  String name          = "My Window";                   // Name of the window not affected on its title.
  String title         = "My Window Title";             // Initial title of the window. Name != Title. Title can be modified by Name not.
  uint   xPos          = 0;                             // Initial X coordinate of the window relative to OS window coordinates. 
  uint   yPos          = 0;                             // Initial Y coordinate of the window relative to OS window coordinates.       
  uint   width         = 1280;                          // Initial width of the window.
  uint   height        = 720;                           // Initial height of the window.
  uint   minWidth      = 0;                             // Minimum width of the window, window X size cannot be below this width. 
  uint   minHeight     = 0;                             // Minimum height of the window, window Y size cannot be below this height. 
  bool   centered      = FE_TRUE;                       // Ignore the initial xPos, yPos, and centered window on creation.
  float  aspectRatio   = (float)width / (float)height;
  bool   resizeble     = FE_TRUE;                       // Has a maximize box, resize drip and can be resized?
  bool   maximized     = FE_FALSE;                      // Maximize window on creation. Window also can be Maximized the window by one of Show.
  bool   visible       = FE_TRUE;                       // Check if window visible of not.Initialy sets to FE_TRUE, but can be modified by WindowFlags_SetInitialVisible during creation.
  bool   topmost       = FE_FALSE;                      // Set the window on top of others. Initialy sets to FE_FALSE, but can be modified by WindowFlags_Topmost.
  bool   fullscreen    = FE_FALSE;
  bool   vSync         = FE_FALSE;
  Path   iconPath      = Path();                        // Path to window icon file. 
  Path   iconSmallPath = Path();                        // Path to small window icon file. 
  Path   iconLogoPath  = Path();                        // Path to logo window texture if application use logo window.
  bool   darkTheme     = FE_FALSE;                      // Change the title bar color to dark. Works only if that platfrom support it.
  bool   blank         = FE_FALSE;                      // [BETA API]: Make a blank window without title bar, maximize, minimized, close button. This style will block: decorated and resizeble settings.
  bool   decorated     = FE_TRUE;                       // Set the widnow decorated [with additional decorations or blank window]. Initialy sets to FE_TRUE, but can be modified by WindowFlags_NoDecorated.
};

ApplicationBootSpecification

Contains information about boot/start data that comes from Core and Entry Point.

struct ApplicationBootSpecification {
  ArrayList<String> cmdLineArgs;
  PlatformAPI       platfromAfterReset;
  RendererAPI       rendererAfterReset;
};

This Application specification you should implement in your CreateApplication function. For example:

Force::Application* Force::CreateApplication(const Force::ApplicationBootSpecification& bootSpec) noexcept {
  ApplicationSpecification applicationSpec;
  applicationSpec.name                     = "Example Application";
  applicationSpec.autor                    = "Danil Dukhovenko";
  applicationSpec.description              = "This is example app.";
  applicationSpec.version                  = "0.0.1";
  applicationSpec.versionMajor             = 0;
  applicationSpec.versionMinor             = 1;
  applicationSpec.workingPath              = "C:\\Force\\ExampleApplication";
  applicationSpec.resourcesDir             = "Resources\\ExampleApplication";
  applicationSpec.windowSpec.width         = 1280;
  applicationSpec.windowSpec.height        = 720;
  applicationSpec.windowSpec.minWidth      = 640;
  applicationSpec.windowSpec.minHeight     = 360;
  applicationSpec.windowSpec.fullscreen    = FE_TRUE;
  applicationSpec.windowSpec.vSync         = FE_TRUE;
  applicationSpec.windowSpec.resizeble     = FE_TRUE;
  applicationSpec.windowSpec.iconPath      = Path(applicationSpec.resourcesDir + "\\MyLogo.png");
  applicationSpec.windowSpec.iconSmallPath = Path(applicationSpec.resourcesDir + "\\MyLogo.png");
  applicationSpec.bootSpec = bootSpec;
  
  Force::Application* application = new Force::Application(applicationSpec);
  return application;
}

Element System

To access to engine main update loop and hold our code properly we use Elements.

Include the Force/Core/Element.h from Force::Core namespace. Next creates new file and class ExampleElement.h somewhere in folder Elements and inherent it from Element.

Element has pack events that called in some time by application and controls by Force::ElementEngine. This are basic from this list:

Element Events	Description
OnCreate()	Calls when all application engines was initialized. You can threat this event as Element constructor.
OnEvent()	Calls by application when any event inherited from Event is invokes.
OnUpdate()	Calls by application in engine main update loop every frame, with passing the delta time variable.
OnRender()	Calls by application in in engine main update loop every frame with purpose for rendering.
OnDestroy()	Calls when application exiting from main engine update loop. You can threat this event as Element destructor.

Also exist are few additional events that also can be called by application, order is matter here:

Element Events	Description
OnCreateWND()	Calls when application creates platform and window, but before the OnCreate(), and OnCreatePost(). Prefer using this for setting custom title. Not use rendering, audio, physics, scripting code here because contexts of it was not created at this point.
OnCreateGUI()	Calls right after OnCreate(), and OnCreateWND() during Dear's ImGui context creation, and before OnCreatePost(). This function will not be executed if application disable support ImGui. Main usage of this function is customize the ImGui global settings during creation for each application.
OnCreateGPU()	Calls every time when application is reloading all GPU descriptors and resources, such a Textures, Shaders, Framebuffers, VertexBuffers, IndexBuffers, and purpuse for its initialization. However this event will not be called automatically on the start, or at OnCreate() time, you need to call it manially. Reason for that sometimes, some Graphics APIs can detect GPU device as suspended, removed, ot hung due to driver/OS error or state change, and that way Force can reload all this resources automatically.
OnCreatePost()	Calls after OnCreate(), OnCreateGUI(), and OnCreateWND(). This event usally called after main window is full created, initialized and showed.
OnRenderGUI()	Calls after main rendering, when Dear's ImGui begin their rendering frame. This function will not be called if application disable support of Dear's ImGui.
OnDestroyGPU()	Calls every time when application is reloading all GPU descriptors and resources, such a Textures, Shaders, Framebuffers, VertexBuffers, IndexBuffers, and purpuse for its destruction. However this event will not be called on the end, or at OnDestroy() time, you need to call it manially. Reason for that sometimes, some Graphics APIs can detect GPU device as suspended, removed, ot hung due to driver/OS error or state change, and that way Force can reload all this resources automatically.
OnFrameOver()	Calls when current frame is over, usefull when need to Application::PresentFrame() immediatly. Nowdays using for processing operations, that should happen after frame is over, but before new frame.
OnNextFrame()	Calls on next frame, i.e after GPU redraws all drawable surface and application logic (execute SwapChain::Present()), and complete logic. You can skip few frames by passing 'frames' count and then execute. This function will be called right up when new frame is started, so here you cannot use renderers, only logic.

Rendering using Elements

This example will implement Element as basic test for Force Renderer.

#pragma once

#include "Force/Core/Element.h"
#include "Force/Math/Transform.h"
#include "Force/SceneManagment/SceneCamera.h"

using namespace Force;
using namespace Force::Core;
using namespace Force::SceneManagment;

class ExampleElement : public Element {
private:
	SceneCamera camera;
public:
	ExampleElement();
public:
	void OnCreate()            override;
	void OnCreateGPU()         override;
	void OnUpdate(Delta delta) override;
	void OnRender()            override;
	void OnDestroy()           override;
	void OnDestroyGPU()        override;
};

Next create the implementation file ExampleElement.cpp, and include ExampleElement.h.

#include "Elements/ExampleElement.h"
#include "Force/Graphics/Context.h"
#include "Force/Graphics/RenderPass.h"
#include "Force/Graphics/Renderer2D.h"
#include "Force/Graphics/Texture2D.h"

static Ref<Texture2D> texture   = FE_NULLPTR;
static float          rotationZ = 0.0f;

ExampleElement::ExampleElement() 
    : Element("Example", ElementCategory_User) {
}

void ExampleElement::OnCreate() {

	// Create cameras and scenes here.
	camera = SceneCamera::CreatePerspective(16.0f / 9.0f, 70.0f, 0.1f, 1000.0f);
	OnCreateGPU();
}

void ExampleElement::OnCreateGPU() {

	// Create GPU resources: Textures, Shaders, Buffers here.
	texture = Texture2D::Create("Resources/IconBuild.png");
}

void ExampleElement::OnUpdate(Delta delta) {

	// Rotating the textured rectangle.
	float        rotateSpeed = 5.0f;
	rotationZ += rotateSpeed * delta;
	if (rotationZ > FE_FLOAT_MAX) 
		rotationZ = 0.0f;
	Transform transform;
	transform.SetLocalTranslation({ 0.0f, 0.0f, 5.0f });
	camera.SetViewMatrix(transform.GetViewMatrix());
}

void ExampleElement::OnRender() {

	// Draw to swap chain (main-screen).
	Vector4f    clearColor = { 0.4, 0.4, 0.4, 1.0f };
	const auto& swapChainPass = Context::GetActive()->GetSwapChainPass();
	swapChainPass->BeginRenderPass(&clearColor);
	Renderer2D::Begin(swapChainPass.get(), camera);
	{
		Renderer2D::RenderLine({ 2.0f, 1.5f }, { -2.0f, 1.5f }, { 1, 0, 1, 1 });
		Renderer2D::RenderQuad(Rect(-1.85f, 0.0f), { 1, 0, 0, 1 });
		Renderer2D::RenderQuad(Rect(1.85f, 0.0f), { 1, 0, 0, 1 });
		Renderer2D::RenderQuadTextured(Transform({ 0.0f, 2.5f }, rotationZ), { 1, 1, 1, 1 }, texture);
		Renderer2D::RenderCircle(Transform({ 0.0f, -2.5f }), { 0, 1, 1, 1 }, { 0, 1, 1, 1 }, Circle());
		Renderer2D::RenderSprite(Transform({ 0.0f, 1.0f }), Sprite(), { 1, 1, 0, 1 });
	}
	Renderer2D::End();
	swapChainPass->EndRenderPass();
}

void ExampleElement::OnDestroy() {
	OnDestroyGPU();
}

void ExampleElement::OnDestroyGPU() {
	texture->Free();
	texture.reset();
}

In OnCreate() event we setting up the perspective camera, and in OnCreateGPU() we create all GPU resources, for advanced usage you can create it everywhere, but for basic usage, to let Force reload all resources in case of driver lost/hung.

camera = SceneCamera::CreatePerspective(16.0f / 9.0f, 70.0f, 0.1f, 1000.0f);

In OnUpdate() event we implement basic every frame update logic, like camera movement or object transformations.

In OnRender() event we call commands from RenderPass from Force::Graphics to start main screen pass, which will perfom clearing main screen buffer with new color and clear depth/depth-stencil buffers which was defined in RenderPassSpecification or like in example dynamic clear property.

swapChainPass->BeginRenderPass();
swapChainPass->EndRenderPass();

Before we can render anything we need to call Begin() and End() from specified renderer which will begin renderer's pipeline, set to it Camera and RenderPass throw witch rendering happens.

Renderer2D::Begin(swapChainPass.get(), camera);
Renderer2D::RenderQuad(Rect(0.0f, 0.0f), { 1, 0, 0, 1 });
Renderer2D::End();

Today Force 2D Renderer support few types of primitive:

• Points

• Lines

• Quads

• Quads Textured

• Circles

• Sprites

• AABB's

If you want you can add few more example primitives:

Renderer2D::RenderLine({ 2.0f, 1.5f }, { -2.0f, 1.5f }, { 1, 0, 1, 1 });
Renderer2D::RenderQuad(Rect( -1.85f, 0.0f ), { 1, 0, 0, 1 });
Renderer2D::RenderQuad(Rect(  1.85f, 0.0f ), { 1, 0, 0, 1 });
Renderer2D::RenderQuadTextured(Transform({ 0.0f, 2.5f }, rotationZ ), { 1, 1, 1, 1 }, texture);
Renderer2D::RenderCircle(Transform({ 0.0f, -2.5f }), { 0, 1, 1, 1 }, { 0, 1, 1, 1 }, Circle());
Renderer2D::RenderSprite(Transform({ 0.0f, 1.0f }), Sprite(), { 1, 1, 0, 1 });

The RenderSprite() use the ECS components, one for Transform and another for Sprite. C++ API is almost identical to C#, so you can find more information in this section.

The RenderQuadTextured() accept the texture parameter. To create and load a texture use Texture2D from Force::Graphics namespace. Also its accepts Transform instead of Rect because we pass rotationZ value to have opportunity to rotate the rect.

texture = Texture2D::Create("Resources/MyTexture.png");

We have finished creating your own rendering element, now you just need to add element to application in Force::CreateApplication().

...
application->AddElement(new ExampleElement());
...
return application;

You can use two ways to do this by AddElementLast() to add element to end of container, and AddElement() to add scene to begin of container. And after that you can run your app with peace of mind.

Examples\ExampleApplication

Check Example\ExampleApplication for full example in ForceDev repository for details.

Console Applications

Force also allows to create a console applications, and cut off a lot of unnecessary API's, such a main window, rendering, assets, languages, IO, and display only console that you can write, read or test or maybe even create a server (even if Force not have this API yet.).

To create a console application all that you need to do is in you CreateApplication function set consoleApp to FE_TRUE:

...

applicationSpec.workingPath = "C:\\Force\\ConsoleApplication";
applicationSpec.resourcesDir = "Resources";
...

applicationSpec.consoleApp = FE_TRUE;

...
application->AddElement(new ConsoleElement());
...
return application;

Also you can disable debug logger that you Force and use specific release logger, that will log only your message to console. To do this set this in you config file inside ManagedInitializeCore function:

...

coreSpec.initLoggerInRelease  = FE_TRUE;   // Allow logger in release, because it console app.
coreSpec.initConsoleInRelease = FE_TRUE;   // Allow console in release for console apps.

...

Examples\ConsoleApplication

Check Example\ConsoleApplication for full example in ForceDev repository for details.

Solution and project configuration

Projects and solution we can configure using Premake that written on Lua. Lua is easy to learn scripting language, with minimum dependences and code. Each premake file stores on each of project directories. Main premake file is ForceEngine.lua stored in root of ForceDev. It contains utility functions to work with projects and solution itself. For reference you can check Lua and Premake documentation.

Force Linking

In the variable LinkForce we can specify how Force wil be linked and build: "Dynamic" to ".dll" or "Static to ".lib". Force from 23 commit (993651b) of dev using Static linking and to migrate to dynamic requested rewrite hole a bunch of code.

So for now Force supports only static linking and look like this:

LinkForce = LinkingType.Static

Force Projects

Projects in Force separates by few groups: Core, Examples and Libraries and in that order displays in Visual Studio. About libraries we talk about later. Force project list available at this moment is:

Projects.Core    ["Force"]              = true
Projects.Core    ["ForceCS"]            = true
Projects.Core    ["ForceEditor"]        = true
Projects.Core    ["ForceNave"]          = true
Projects.Core    ["ForceRuntime"]       = true
Projects.Examples["ExampleApplication"] = true
Projects.Examples["ConsoleApplication"] = true

If you dont need them to exist you can just turn it off by setting to false.

Each of this project and libraries defined as Libraries has its Project Directory ProjDir relative to ForceDir. Some of this projects - libraries that stored either relative to Force/Libraries or some of them relative to vckpg/packages .

All of this libraries has BinaryDir depending on build configuration (Debug, Release) where all binaries files stored for that library, then IncludeDir where all header files stored, and Library itself thats directly points to static library (.lib) witch you can link to Projects.Core.Force library.

Force Engine Solution

The code for solution looks like this:

workspace "ForceEngine"
	architecture   "x64"
	startproject   "ForceEditor"
	configurations ("Debug","Release")
	solution_items (".editorconfig" )
	flags          ("MultiProcessorCompile")

Its basic premake script workspace with two configurations and some flags. Basically here all what you need for solution so dont recommended it to change.

Force Project

Go to Force and open Force.lua premake file. This is file that contains definition of the main project, basically all other projects are structured this way.

project "Force"
	kind          "StaticLib"
	language      "C++"
	cppdialect    "C++20"
	staticruntime "on"
	targetdir     ("%{ForceDir.Bin}/" .. BuildDir .. "/%{prj.name}/Lib")
	objdir        ("%{ForceDir.Bin}/" .. BuildDir .. "/%{prj.name}/Obj")
	pchheader     "ForcePCH.h"
	pchsource     "Sources/ForcePCH.cpp"
	
	-- Files to include
	files { ... }
	
	-- Directories to include
	includedirs { ... }
	
	-- Links and defines
	links   (GetLinkedLibraries("Any"))
	defines (GetLinkedLibrariesDefines())

	-- Windows specific
	filter "system:windows"
		systemversion "latest"
		defines (GetWindowsDefines())
		files { ... }
	
	-- Linux specific
	filter "system:linux"
		systemversion "latest"
		defines (GetLinuxDefines())
		files { ... }
	
	-- Debug only
	filter "configurations:Debug"
		runtime "Debug"
		symbols "on"
		links   (GetLinkedLibraries("Debug"))
		defines (GetConfigurationDefines("Debug"))
		
	-- Release only
	filter "configurations:Release"
		runtime  "Release"
		optimize "on"
		links    (GetLinkedLibraries("Release"))
		defines  (GetConfigurationDefines("Release"))
	

The most important here is targetdir and objdir where project will store when build project. By default it will be Bin/*BuildDir/*ProjectName/Lib and Bin/*BuildDir/*ProjectName/Obj

Then goes files and include directories (includedir) witch project will be included and use, and links list and already configured for each library of libraries that will be linked to Force.

Defines (defines) that contains list of predefined FE_LIBRARY_* macross and other platform libraries.

And the goes that same for each platform and configuration.

Application and Libraries

Enable and disable libraries

When you write applications, you can disable some libraries and especially its linking if you dont use them to decrease size of the your executable. Now it totally achievable. To do that please go to ForceEngine.lua and find libraries list:

Libraries = {}
Libraries["Vulkan"]       = false
Libraries["DirectX12"]    = false
Libraries["Mono"]         = true
Libraries["Curl"]         = true
Libraries["LibSndFile"]   = true
Libraries["OpenAL"]       = true
Libraries["Assimp"]       = true
Libraries["OpenGL"]       = true
Libraries["Glm"]          = true
Libraries["Glfw"]         = true
Libraries["DxErr"]        = true
Libraries["DxTK"]         = true
Libraries["Yaml"]         = true
Libraries["HwInfo"]       = true
Libraries["Box2D"]        = true
Libraries["MsdfAtlasGen"] = true
Libraries["MsdfGen"]      = true
Libraries["FreeType"]     = true
Libraries["Stb"]          = true
Libraries["EnTT"]         = true
Libraries["ImGui"]        = true
Libraries["ImGuizmo"]     = true
Libraries["LibZip"]       = true
Libraries["SpdLog"]       = true

Just set you library to false and you ready to go. Its disable library linking for static libraries, for dynamic libraries its disable copying its .dll file in to executable directory, and sets it proper macros FE_LIBRARY_XXX to 0. After this you need to fully rebuild the solution for Debug and Release configuration.

Libraries that now can be disables:

OpenGL
Vulkan
DirectX12
Glfw
Mono
LibSndFile (including):
 - flac
 - mpg123
 - mp3lame
 - ogg
 - opus
Assimp (including):
 - zlib
 - minizip
 - pugixml  

For other libraries its not tested, and basically other libraries its tiny and all static linked so you dont have any .dll file requested and dont need to disable.

Missing Mono .NET Framework

When you linked Mono and Mono Runtime in to Force you can not have Mono folder with all Runtime .Net Framework. If that happens means you forgot copy proper version of you .Net Framework from MonoSDK. To do that please go to C:\_YourMonoSDKPath_\lib\mono and select you version of .NET Framework and copy it Mono folder to you working or executable directory or just download this archive.