konstantintomashevich / emergence Goto Github PK
View Code? Open in Web Editor NEWFlexible set of libraries for gameplay development. Currently under development.
License: Apache License 2.0
Flexible set of libraries for gameplay development. Currently under development.
License: Apache License 2.0
Celerity needs an input processing extension, that can be used both for device input (for now only keyboard) and for external input (for example from UI extension). SpaceShooterDemo already has an input system, we need to rework it in a more-Celerity-way and add proper support of external actions dispatch to it.
Recently I had to start adding comments like this:
// In fixed update, removal is usually done at the end of the frame after mortality feature,
// which is usually dependent on input processing, therefore we need to make these removers
// dependencies of hierarchy cleanup.
Which is awful, because it's just binding engine-level graph layout to gameplay-specific feature -- mortality.
One possible solution to avoid such complication is to create separate common slot for transform-related cascade removal and place all cascade removers there. The same thing can be done for all cascade removers including asset ones.
We need to work with assets and configs in "top level" world in order to save them while transitioning from one scene to another. To implement that we need some kind of "world inheritance" through partial sharing of world registries. For example, if parent world has storage for the type we need, we create query on parent world level instead of child world level.
But thinking of game as "multiple worlds" might be incorrect. We can think of one world with data views tree: this will provide the same multiple registries feature and the same registry sharing, but without exposing the problem of calling update multiple times.
We need a simple CPU profiling tool integration in order to be able to understand CPU usage.
Currently Celerity::Render2d works with predefined full-window viewport. We need to change that by adding viewports feature:
We need a basic resource cooking platform that:
Also, we need a game packaging script (at least for Windows) that packages game executables and cooked resources into one directory with appropriate mount lists.
We need to use VFS layer across the framework instead of plain file system access. Having VFS provides us with ability to:
Goals:
Proposed changes:
VECTOR
and PATCH
mapping archetypes in order to cover all use cases with StandardLayoutMapping
: any object should be mappable even if field projection is not possible.StandardLayoutMapping
: no more bundles or other special file formats. Everything should be covered by mapping after VECTOR
and PATCH
addition.JobDispatcher
jobs into foreground and background, then add ability to limit thread usage by background threads. Otherwise resource loading would be able to capture all threads and pause the application.ResourceRegistry
library for resource discovery and easier resource loading. The main principles are:
{ObjectTypeName}.{UniqueId}.{bin/yaml}
. Is {ObjectTypeName}
part of {UniqueId}
? To be decided.Data structures definitions are required everywhere, but not logic, connected to them. For example, cooking tool does not need to know about physics implementation, but still needs to convert physics configs and prefabs with physics components.
I'm not sure whether it is a real problem and whether it can be solved in a pretty way or not, but it might be worth to consider different solutions.
We cannot hide render backend, like BGFX, under the Celerity::Render2d extension, because other extensions may need to access render backend too. For example, UI needs to render its stuff directly without touching Render2d. In some cases we might want to have UI, Render2d and Render3d working all at once in one window. That means that all render-dependant extensions should be built upon one shared rendering service that will hide real render backend under the hood.
We need a UI extension for Celerity that is complete enough to make games with medium UI complexity or editors with limited UI complexity. ImGUI looks like a perfect backend for that task, but we need to hide it under service API.
Initial list of required features:
We need to create a simple 2d platformer in order to ensure that:
Also, it is needed to draft architecture for planned game creation framework.
Current version of Celerity::RenderFoundation
was made as an initial prototype and needs to be updated: we need a proper support for framebuffers, render to textures and other core rendering features.
Some stuff from Render2d, like textures, materials and material instances, is common for different render extensions. For example, UI may need to use the same texture mechanism as Render2d. We need to extract that common stuff into RenderCommon extension so it is usable for any render-related extension.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.