-
(https://nero-games.com/resource/artwork/github/github_readme_engine_v2.png)
Hi everyone, In this topic, I want to present you Project Nero
The goal of the project is to build a Game Engine using SFML and Box2D. I decided to focus on the development of platform games. Build a Game Engine with a lot of features is really tough. The first step in building my engine was to integrate Box2D with SFML, I've thought of a lot of way to do that, and then I've discovered the Box2D TestBed, The Box2D TestBed offers many features, but it uses GLUI and FreeGlUT instead of SFML. So, I've decided to replicate it, suppress all the GLUI, FreeGlUT and OpenGL code and then get only some SFML and SFGUI code : This gave me the "Nero Game Engine 0.1"
For the moment the engine is split into two parts, a Render_Engine and a Dev_Engine
The goal of the Render Engine is to test a game scene: you create a new Scene (a new class that inherits from nero::Scene), set the scene to the engine, and run the engine. The Render Engine offers to reset and pause the scene.
Here is a screenshot that run the "Tumbler" example from the Box2D TestBed
(http://s-media-cache-ak0.pinimg.com/originals/bf/71/28/bf7128041c725a42c0f4fe574aa5255c.png)
The goal of the Dev_Engine is to help in a Scene building, at this stage of development it's a complete replication of the Box2D Testbed. The features it offers are :
- Automatic drawing : when you create a box2d object, it draws automatically no need to create an SFML shape
- Move objects with the mouse
- See object center of mass, bounding rectangle, etc
- See statistic (number of body in the scene etc)
Here is a Screen shoot with the "Conveyor Belt" example from Box2D Testbed
(http://s-media-cache-ak0.pinimg.com/originals/9d/a7/42/9da74271f904d7687b4e4d3284f4b795.png)
When you create a Scene by inheriting from (nero::Scene or nero::DevScene), you get access to the camera and some functions to process keyboard and mouse input
-
Nice!
Do you have your code up somewhere accessible?
-
Hi " ratzlaff ", thanks for your interest :), the code is not on a repository yet, i'll made that this week.
Also, i'm already working in some new features. the step 2 in building my engine is the map editor. It will be possible to load sprites and map them on the physic scene build with Box2D. I'll present those new features by the end of this month, so, stay tuned 8).
-
Hi everyone ! I'm going to present the new features in the Nero Dev_Engine :).
I've added the possibility to add and manipulate sprites on the Scene. And when all it's done, the physics (Box2D stuff) and the graphics (sprites) can be saved separately in two files in a JSON format. Before I explain, here is a video
http://www.youtube.com/watch?v=segLJa93ujs
Now let's see the new features in more detail.
Feature 1 : Texture loading and sprite recognition
For each texture, we need a ".txt" file with the same name. The ".txt" file describes all the sprites we want to extract from that texture.
the format of the ".txt" file is " Sprite_Id - BoundRect_Left - BoundRect_Top - BoundRect_Width - BoundRect_Height ". After that, the Engine just needs the path to the folder where textures are located.
(http://s-media-cache-ak0.pinimg.com/originals/59/71/1f/59711f5cd1fda02ffb62fe2b2faff2c2.png)
Feature 2 : Sprite preview
When textures have been loaded and sprites detected, The engine offers a preview of each sprite. During the preview, it's possible to zoom in and out.
Feature 3 : Sprite manipulation
Here are manipulations we can apply on sprites, there will be more later!
- add/remove sprite in/from the canvas
- select sprite one by one
- move sprites with the mouse
- rotate and scale sprites
Feature 4 : Working directory and saving
When several scenes are added to the Dev_Engine, the engine creates a directory for each scene. The physics and the graphics are saved in the directory of each scene. This allows us to work on several scenes at the same time.
Physics and Graphics are in JSON format and can be easily loaded in a Nero Render_Engine.
That's all for now, if anyone has feedback, please let me know, your critics will help to improve the engine
-
Hi! everyone
The code of the Engine is now on Github, here is a link : https://github.com/NeroGames/Nero-Game-Engine
The Engine is a API, but there is no way to compile it currently. I will need some help to write a CmakeMake file.
The Engine use c++11 and some shared libraries
- SFML
- SFGUI
- Box2D
- Boost (system, filesystem)
-
Great progress, the GUI is very intuitive.
The engine is focus mostly on physics?
-
Great progress, the GUI is very intuitive.
The engine is focus mostly on physics?
you're right, i expect games to be built using box2d features, the graphics are just there to give a more pleasant view
-
Hi everyone !, I'm back, let me present you Nero Game Engine 0.3.0
I've added many new features, the most important are Sprite_Layers and some news Sprites Manipulations
Here is a video
http://www.youtube.com/watch?v=e7msdIuvBmA
The new features are presented below, but I want to say now what I'm going to do for the next.
I will work mostly on Box2d, I first thought to build a Box2d editor, but I think it will build a scripting system instead. Box2d stuff will be described in a Lua script and the engine will build every using the script.
(http://s-media-cache-ak0.pinimg.com/originals/1f/c5/d9/1fc5d9db27b98caebcc087d4f882660f.jpg)
Now let's see the new features in more detail.
Sprite_Layers
there are now layers in the engine with some classic functions
- add/delete layer
- move layer up/down
- show/hide layer
- change the color of all sprites in a layer
- move the entire layer horizontally/vertically
- each layer is saved in a different JSON file and can be recovered as a std::vector<sf::sprite>
the system I've built allows to add an infinite number of layer, but I've restricted the number to 10, I think it's enough, and there is always at least one layer
Sprite Manipulations
there are new sprite manipulations that allow to build scenes quickly and with intuitiveness
- copy a selected sprite (the copy can be made in any direction : left, right, up, down, diagonal), it useful for tilemap scene
- precision move (move sprite pixel by pixel, more accurate than using the mouse)
- change color
- flip horizontally/vertically
- delete by mouse click
Canvas Color
the canvas color can be changed using some pre-configure buttons or the RGB system
Log
there is now a log that describes what's happening, the log is saved in a .txt file at the same time than graphics and physics
Auto_Save
the auto-saving saves everything every 30 seconds, I don't know if it's a good interval of time.
Load
to load something, the files just need to be in the working directory of the Scene. When Engine the startup, it tries to load Layers(graphics) and physics. So it's possible to begin a work, save it, close the engine and come back to continue
I think it's all, the last thing to remark is that the mouse position on the canvas and in the world appears on top on the Canvas.
-
Looks like you've got a lot of work done on this! Looking good so far. Your GitHub link is broken though, did you move the repo somewhere?
-
Your GitHub link is broken though, did you move the repo somewhere?
Hi!, i've deleted the repo, the code was published with no license and no author name, i was in hurry and i've forgotten all those stuffs :-[, i will recreate the repo soon 8)
-
8) Hi every one! 8)
I have been busy those last couple of months, so the project has fallen behind. But But, it keep going ;D.
Code repository
The github repository has been reactivated : https://github.com/NeroGames/Nero-Game-Engine
At the moment of this post, there is not any code on repository.
Licence
The project will be under the MIT Licence
Updates
The shape of the engine has changed a bit,
The most interresting new feature is the Mesh Editor, the engine let you edit Physical Object in a flexible way.
I will talk more about that later, you can look at the video bellow to get an idea
http://www.youtube.com/watch?v=cQfgAfqybpI
-
Good job. Really good job!
-
This looks awesome! :)
-
This looks awesome! :)
Good job. Really good job!
hi! guys, it took a long time to say it, but thank you for your support 8) 8), i realy appreciate.
I have been busy those last couple of months, i know i've already said that, but let's say it again.
The great new, it's now i get some time to work on project, i plan to finish the first working version of my engine/framework within two months.
-
Wow, the GUI looks so crisp! Just kidding, your project looks nice. ;-)
-
Wow, the GUI looks so crisp! Just kidding, your project looks nice. ;-)
Thanks for the comment but also for the SFGUI library. When i started the project i asked myself, should i use QT or SFGUI, i wanted an engine that is simple and that focus on the essential, i think SFGUI suits the best to that philosophy. The library is great, i've used it on two others projects, one call MyFinances which is not related to game and another one called TheGame, i will show case them one day.
-
Engine Update
Object Node
I've implemented a Tree structure to hold all objects in a given scene. When i started the engine i was handling only Sprites, things were simple, each Layer of Sprites was represented by a std::vector. Now that the number of different objects begin to increase, i need a more flexible data structure. Starting from now everything in a scene will be encapsulated in a ObjectNode and attached to a parent.
The Different Objects
There are two main categories of objects, primary objects, and logical objects
Primary objects are represented by a Class in the engine. By exemple for Sprites, there is a Class called SpriteObject that encapsulate a sf::sprite.
List of primary objects : LayerObject, SpriteObject, MeshObject, PhysicObject (encapsulate a Box2d body)
Logical objects are built by combining two or more primary objects. Even if the engine recognize them, there are not explicit Classes that represent them.
List of logical objects : MeshedObject(a MeshObject attached to a Spriteobject), SolidObject (a SpriteObject attached to a PhysicObject)
I plan to make the concept of logical object a key concept of the engine. Complex objects like a Player could be build using that concept.
Also in the future (not for the first release), there will be more primary objects like : AnimationObject, LightObject, SoundObject, MusicOject, ParticleObject, ShaderObject etc.
Smart Layers
Now that each scene is based on a Tree structure, looking for a object could be more complex. To reduce the time of processing over the tree, objects are stored in Layers and each Layer always contain the same type of object. Also the engine can create automatically some Layers in order to prevent mixing different types of objects in the same layer.
Video Time 8)
The video present three types of objects : SpriteObject, MeshObject and MeshedObject
We can see that the engine automatically create layers. Also each layer has a Color that indicate the type of object it is holding.
http://www.youtube.com/watch?v=LCrg_UZl1Es
Next Time
The next time i'll talk in detail about Mesh Objects and the Mesh Editor
-
Mesh, Mesh Object and Mesh Editor
Hi! everyone, how are you doing. Let's talk about Meshes this time.
The Engine Modes and SubModes
Before talking about Meshes, it would be helpfull to talk about the Engine Modes and SubModes.
The Engine has been built to work in several Modes. Currently the Engine has only one Mode, the Scene Edition Mode. This mode allows to build a scene.
Each Mode has several SubModes. Our Scene Edition Mode has three SubModes : Object, Mesh, Play.
- Object SubMode : This SubMode allows to handle any type of Object. The following actions can be perform : Add, Delete, Move, Rotate, Scale, Duplicate (copy the Object in any direction)
- Mesh SubMode : This SubMode allows the edition of any Mesh present in the Scene.
- Play SubMode : This SubMode allows to test the game in real time.
A Box2d Editor or a Mesh Editor ?
My first idea was to build a Box2d Editor. The Nero Game Engine, is built with the idea to be Simple, Intuitive and Efficient. I did not want users to struggle with Box2d stuff. So, a Box2d Editor was the perfect solution. But let's say thing clearly, build a Box2d Editor is realy tough, months ago i would just say, it's impossible.
When you create a Box2d Body, you can't modify it later, more, it's difficult to store the Box2d Body somewhere in order to play with it later because its constructor is private. It was the first time i've seen a private constructor. :-\
With all those difficulties, i've just given up and begin to think to alternative solutions.
But, But, one day i woke up, and the solution came to my mind ;D
I've forgotten the Idea to build a Box2d Editor and decided to build a Mesh Editor instead. (I've stolen the name "Mesh" from Blender 8))
The Idea is that i don't need to Edit Box2d Body, instead, i can create Meshes and then generate Box2d Bodies from those Meshes. Meshes are pure SFML and C++, they don't contain any Box2d stuff, and the cool thing, it's that they are really, really simple to Edit.
Mesh
Meshes are just a powerfull tool. There are four types of Mesh
The four types of Meshes are handled by the same Class. This allows to switch from one type to another very easly. By example, a Line is made of two vertex (vertices), when you add one more vertex, the Mesh become automatically a Chain, and when you remove that vertex you come back to a Line.
MeshObject
A MeshObject encapsulates a Mesh. When a user is in the Engine Object SubMode, he can handle the MeshObject, this SubMode does not allow to fully edit the Mesh.
MeshEditor
When a user switches to the Engine Mesh SubMode, there comes the magic. Going in that mode, activate the MeshEditor and the user can now get access directly to the Meshes encapsulated in MeshObjects. In that mode the following actions can be perform
- Add vertex
- Remove vetex
- Move vertex
- Move Edge
- Edge Extrusion
Next Time
I will post a Cool Video in the next hours 8)
The video will show the outcome of my work and the power of the Nero Game Engine.
-
Nero Game Engine 0.5 / Enjoy Box2D Physics !
For this post, i'm not going to talk alot, just checkout the following video. I'm sure that many people who wish to make games with SFML and Box2D have dream of something like that.
http://www.youtube.com/watch?v=IPGP1OmZ19w
-
Solid Object
(http://i.pinimg.com/564x/20/d2/5c/20d25c0b679614b2082e72371e1f580b.jpg)
As you may saw in the previous video, it's easy to add physics to sprites or more exactly to create Solid Objects. The following picture shows the process.
(http://i.pinimg.com/564x/55/98/93/559893d2ec7922878adbe176083378bf.jpg)
Things begin in the Engine Object Mode. First add a sprite, then select the sprite and add a Mesh. Et voila ! you just created a Meshed Object. The Mesh can take any Type (dynamic, static, kinematic) and any Shape (line, chain, polygon, circle).
By cliking on the Play button, the Engine goes to the Play Mode, it generates a Physic Object from the Mesh and attaches the previous sprite to it, what give us a Solid Object.
Physic Object
When you simply add a MeshObject (without selecting a sprite), the MeshObject becomes a simple Physic Object. This is good to create grounds, delimit areas or build the scene base shape. here is a resume of all objects.
(http://s-media-cache-ak0.pinimg.com/564x/4d/f7/ef/4df7ef35700e87651207b230fe280814.jpg)
A Versatile Engine
The way the Engine as been built, allows it to create any type of 2d games. When i've started the project, i've specified that i will focus on platformers, but even if you don't want to use Box2d physics or make platformers, The engine will suit to you as well. The Engine may be used to create RPGs, Top Down games, or Puzzle games like TicTacToe. We may notice three types of users.
- Users 1 : I want to use all Box2d features
That is the default behavior of the engine, you can use Bodies, Fixtures, Joints, Collisions, everything from Box2D
- Users 2 : I don't want to use Box2d at all
You just have to destroy all Box2d Bodies and Joints and then nullify the b2_world (m_World = nullptr). Of corse you won't have to do it yourself, i will add a Macro to handle that.
- Users 3 : I want to use Box2D collisions but, I don't want Box2D Physics simulation
You just have to make all Bodies as sensors, by doing that you will have a functionnal collision system without any physics simulation. I will add a box you can check somewhere, so all bodies will be automatically in sensor mode.
The Engine Logo
I've tried differents designs for the Engine Logo, and finally comes up with this one. Let me know what you think !
(https://i.pinimg.com/564x/f2/51/8e/f2518ef9856318bdb9001e84438104c2.jpg)
(http://i.pinimg.com/564x/a0/d9/d5/a0d9d57876493f1d032758242977a20e.jpg)
-
Neat progress on the Nero, Keep up the good work!
Concerning logo, IMHO the font is not suitable for a logo at all. The graphic is so-so, I wouldn't use it for sure. It is apparent you're not a logo designer (nor am I. It takes a lot of time and skill to become good at designing logos). If you want to get inspired, however, I recommend looking at dribbble posts. https://dribbble.com/search?q=logo&s=latest
-
This engine looks quite impressive. I noticed that your repository is empty again...
the font is not suitable for a logo at all
I recommend looking at dribbble posts. https://dribbble.com/search?q=logo&s=latest
I clicked the link to look at what was there and there was a logo right there using literally the same font! ;D
It actually looked okay; it was "serious".
However, I actually agree with you; it doesn't work here. It's a boring font and I doubt anyone would want to associate something boring with their 'sparkly, awesome game engine!'
I don't mind the actual shape of the logo but it makes no connection with me as it seemingly has nothing to do with what it represents (the product or its name). What is it? ???
Consider where the name Nero came from and why you think it's appropriate for this engine and maybe come up with a logo that represents that.
Or... just represent something linked to games :P
-
Hi! guys, thanks for the replies, it helps me improve my work.
It seems i still have a lot to do on the logo :P. I'll make more researches on logo creation, and also ask a friend to help me with that.
From the end of this month i'll be a little busy with other stuff, so the development of the engine will slow down a bit.
In my next post, i'll discuss the remaining tasks before the first release, and also when i plan this release to be done.
-
What next for the Nero Game Engine ?
Hi! Everyone how are you doing :D
It's almost one year that I’ve started the project. I've got into the habit of making a post only when I actually make some progresses in the development. I know, that, in this way it's difficult for you to understand where I am going with the Engine. So in this post I will describe the work that need to be done in order to complete the Project.
The First Release
The first release will be the version 0.6.x, the Engine will be released as a precompiled library/API and games will be developed in C++
In order to make this release many tasks need to be done.
- Task 1: Rebuild the "Saving and Loading" feature
When I’ve implemented the Object’s Tree data structure, I’ve completely modified the engine heart. By doing that I’ve destroyed totally or partially some features like: the way things are added or removed in the canvas, the way things get selected, the way the layers work, etc. I've already re-implemented most of those features. The remaining one is the way Scenes are Saved and Loaded.
Good news, I’ve already solved that in Pseudo code, I just need to make the implementation.
- Task 2: Add a window that let edit Physic_Objects properties
As you may saw, the Engine use Meshes in order to generate Physic_Objects. So all Physic_Objects properties are carried by Meshes. Currently only the type (Dynamic, Kinematic, Static) of the mesh can be choosed. But for those you know Box2D, Box2D bodies are made of one Body (b2Body) and somes Fixtures (b2Fixture). Bodies and Fixtures have properties like density, velocity, fix rotation etc. that can be customized. So there will be a window to handle that.
- Task 3: Add a way to give a "Name" and a "Category" to each Object
The Name of a object will be the primarily way to retrieve it in the code. In the code it'll be possible to write something like: Object o = engine.findObject(“ojbect_name”)
The Object Categories will serve primarily to build the game collision logic. In simple word you will be able to specify which category of object can collide with which other category. In the code it'll be possible to write something like:
- can_collide (Player, Enemy);
- can_collide (Player_Bullet, Enemy);
- can_collide (Player, Enemy_Bullet);
Internally the engine will configure Box2D Collision Filtering for you.
- Task 4: Process Box2D Collisions
Build a game will consist mainly to retrieve collisions and give response to them. Box2D gives four functions to handle collisions: - BeginContact(b2Contact* contact)
- EndContact(b2Contact* contact)
- PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
- PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
As I don't want users to struggle with Box2D stuff (It really gives some headaches), the Engine will process collisions for you in order to simplify things. For each of those four functions you'll be able write something like
- nero::Collision c = engine.process(b2Contact) or
- nero::Collision c = engine.process(b2Contact, b2Manifold) or
- nero::Collision c = engine.process(b2Contact, b2ContactImpulse
That way you will only have to deal with nero::Collision, the nero::Collision will give you the two nero::Object that are colliding and all other information concerning the collision.
- Task 5: Build a game prototype
To ensure that the Engine is ready for a first release I will build a game prototype. The prototype will be entirely made with physics, that means no graphics (Sprite), no sound, no music. The goal will be to have a fluid game.
It’ll be a platformer, the Player will be a simple Cube or Circle that can move right/left, jump, double jump and dash.
This prototype will be used to test the engine fluidity but also its limits.
The Second Release
After the first release, we will have an Engine that work fine, with most bugs fixed. Now in order to show the power and the potential of the Engine I will build a small adventure game (only one scene) with high quality graphics. In this game, Box2D physics will be completely transparent and the following features will be added
- Animation Object
- Sound Object
- Music Object
When this game will be completed the Engine will be ready for a second release (The Official one with a full tutorial). And again the engine will be release as a precompiled library/API and games will be developed in C++
The Third Release
The third release will concern the version 0.7.x to 1.0.0
In those versions Lua will be added as a scripting language, therefore the default language to build games with the Nero Game Engine will be Lua. And the Engine will no longer be a Library/API, You will be able to install the engine as any other software on Windows, Linux and MacOS and start build games in your prefer IDE (Notepad++, Sublime etc).
The End
After adding Lua as a scripting language, my work will be completed. Of course I’ll continue to maintain the Engine and fix bugs but I will no longer add some features.
But, you should know that many features could still be added to the Engine, features like Particle Object, Soft Light Object, Shader Object, Artificial Intelligence etc. Also ones could think to carry the Engine on QT in order to benefit from more advance feature like color wheel, MVC structure, file management etc.
The Engine will be open source, so if any one wish to add features to the Engine it'll be up to him, also I know there are others great projects on this forum, those projects could be combined with the Nero project in order to build a real big and robust framework for SFML users.
It's all for this post, have a good day 8)
-
Nero Game Engine Happy Release :)
Hi! everyone, in a previous post, i've said that i will be busy on the next days, so i'll need to slow down the development, but guess what, i suddenly get some days off! what allows me to make a great progress on the Engine. Therefore i'm pretty happy now ;D. Instead of making a post on the new features or make a video, i've thought, it would be better if you can try the engine yourself.
There is the download link, it is a 32 bit version, it should work on any Windows
Nero Game Engine Happy Release 1.0 (https://drive.google.com/file/d/0B6PhZVm0Xh-NOWdhU1YwdEYxbFE/view?usp=sharing)
One Precision, this is not the Engine First Release, it just a way to let you have fun with the engine.
Inactive Features
The following features have been disabled or are not implemented yet
- Auto Save
- Save
- Load
- Grid
- Gravity (Grav X, Grav Y)
Break the Engine , Report bugs
Currently the Engine doen't defines limits, the canvas is infinite, the number of objects that can be added is infinite, the number of vertex in a line or polygon is infinite, objects can be zoom down or up at infinite etc.
So you are free to play as you want. I encourage you to try to break the engine in any you could think, and if you find bugs just report it.
Resources
The resources used in the download has been grabbed over the internet, i've no right on them, but they are mostly free resources.
You can use the Textures you want, just copy them in the /Resource/Texture folder.
How to use the Engine
I will make some regular posts on how to use the Engine, and if you have any question just ask, Those posts will be gathered later in order to build the engine Tutorial Book
The Engine use the following Inputs
- Mouse or TouchPad
- The Numpad
- CTRL, SHIFT, ALT : in combinaison with the Mouse, TouchPad and Numpad
- Space bar, Escape, Delete, R, P, B, Right Arrow, Return
-
Nero Game Engine Happy Release 2.0
Hi everyone, how do you do!
Before to begin with the Engine Howtos, i've taken the time to add the following features to the Engine.
- Save and Load Scenes
- Auto Save Scenes
- Undo and Redo Actions
I'll present those features briefly, the details will be for another post
Save and Load Scenes
Each Scene is saved in a single JSON file locate at NERO/scene_name/scene_name.json
Auto Save Scenes
The Auto Save feature is based on the Save and Load feature, when Auto Save is activate, the scene is saved each 30 seconds
Undo and Redo Actions
This feature is an unexpected one. I did not plan it since the beginning of the Project. But when, i've completed the Save and Load feature, I realised that I could use it to build a Undo Redo System.
Currently there no limit on the number of Undo-Redo.
Download link
Nero Game Engine Happy Release 2.0 (https://drive.google.com/file/d/0B6PhZVm0Xh-NWmhYZWxCN1BLR2M/view?usp=sharing)
Howtos
I'll begin the How to use the Engine series this weekend
-
How to use the Engine 00 : The Nero Dev Engine !
Hi guys ! Are you ready for the Nero Game Engine Adventure ?.....? Let's begin !
This series of Howtos will show how to use the Nero Dev Engine. Since the engine is not complete, those Howtos will cover only the available features.
You can download the Dev Engine in the beta version on the Post just above this one!
There is a little overview of those Howtos.
- How to use the Engine 01 : Play with Objects !
- How to use the Engine 02 : Control the Camera !
- How to use the Engine 03 : Let's Edit Meshes !
- How to use the Engine 04 : Workflow !
- How to use the Engine 05 : Use your own Resources !
Before we start, one more precision. The Dev Engine Interface can be divided into Three Main Part :
The Left : The left side of the Canvas : Engine Mode, Save, Load, Sprite Tab, Mesh Tab, Color Tab
The Center : The Canvas, the utility buttons on top the Canvas, the Log window bellow the Canvas
The Right : The right side of the Canvas : Layer, Mesh, Object, Scene, Draw Checkbuttons, etc.
So if I say you can change the current Scene using the Select Button in the Top Right of Engine you know where it is.
(http://i.pinimg.com/originals/1e/d2/10/1ed210e1ed0f508ffc324289e42096b6.png)
How to use the Engine 01 : Play with Objects !
Build a Game Scene consists to add Objects onto the Canvas and then Customize them. There are three (3) types of Objects : Sprite_Object, Mesh_Object, Meshed_Object
Add Sprite Objects
In order to add a Sprite_Object, click on a Sprite_Button. On the Left of the Engine, you have the Sprite_Tab. By passing the Mouse over the a sprite button you can see a Sprite_Preview. You can use the Numpad_Multiply and Numpad_Divide buttons to scale the Sprite_Preview.
Add Mesh Objects
In order to add a Mesh_Object, select a Mesh_Shape (Polygon, Circle, Line). On the Right of the Engine you have the Mesh_Selection_Button.
Mesh_Objects are created with a default Type. Polygons and Circles are always created as Dynamic Mesh and Lines as Static Mesh.
In order to change the Mesh type, select it and choose the Type you want (Dynamic, Static, Kinematic).
Add Meshed Objects
In order to add a Meshed_Object hold the CTRL key and click on a Sprite Button, it's the same way that to add a Sprite_Object but you need to hold the CTRL Key befor.
The default Mesh of a Meshed_Object is always a Dynamic Polygon Mesh. To change that, select your Meshed_Object then choose the Mesh_Shape and the Mesh_Type you want.
A Meshed_Object is a combinaison of a Sprite_Object and a Mesh_Object, so Actions that can be applied on one of the both, can be applied to the Meshed_Object.
Select Objects
When you make a Left_Click on an Object, you Briefly select it. As soon as you release the Left_Click the Object get unselected.
In order to make a Permanent Selection you have to make a Right_Click on the Object.
Remove objects
You have two ways to delete an Object. The first one is to make a Permanent Selection and then press the Delete Key. The second one is to hold ALT and Left_Click on the Object.
Move, Scale, Rotate Objects
You can Move, Scale, Rotate Objects with either the Numpad or Mouse.
Mouse / Move : Left_Click on a Object. Hold your click and move the mouse
Mouse / Scale : Hold the CRTL key. Then Left_Click on an Object. Hold your click and move the mouse Up or Down
Mouse / Rotate : Hold the SHIFT key. Then Left_Click on an Object. Hold your click and move the mouse Up or Down
Using the Numpad you have to make a Permanent Selection on the Object first and then Hold the CTRL key.
Numpad / Move : Numpad_4, Numpad_6, Numpad_2, Numpad_8
Numpad / Scale : Numpad_Addition, Numpad_Substract
Numpad / Rotate : Numpad_7, Numpad_9, Numpad_Multiply, Numpad_Divide
Flip Objects
The Flipping concerns Sprite_Object or Meshed_Object. When you apply it to Mesh_Object or even Meshed_Object you may encounter some weird behaviours, that because, Meshes are not meant to be flipped. But it's not a big deal, you just have to Edit your Mesh to fix it. I'll correct the Flipping function for Meshes one day :)
In order to Flip an Object, first make a Permanent Selection and then Hold the CTRL key
Numpad / Flip Horizontally: Numpad_1
Numpad / Flip Vertically : Numpad_3
Duplicate Objects
This is great to make Tiled-Like Scenes.
In order to Duplicate an Object, first make a Permanent Selection and then Hold the ALT key
Duplicate Horizontally and Vertically : Numpad_4, Numpad_6, Numpad_2, Numpad_8
Duplicate in Diagonal : Numpad_1, Numpad_7, Numpad_9, Numpad_3
Layers
On the Right you can see the Stack of Layers. There are some buttons to Add, Delete, Move UP and Move Down Layers.
The See_Button allows to Hide or Show a Layer
The Check_Button allows to Select a Layer
When you add an Object, it goes to the Currently Selected Layer. But Layers always contain the same Type of Object. So if you add a Sprite_Object when your currently selected Layer contains some Meshes, the Engine will create automatically a new Layer before to add the Sprite_Object.
Move an entire Layer
It is possible to move all Objects in a Layer. In order to achieve that, first, make sure the Layer is selected, then Hold CTRL and ALT and use the following keys: Numpad_4, Numpad_6, Numpad_2, Numpad_8
That's All!
That's all for the first Howto. Just bear in mind that you can play with Objects either with the Mouse or with the Numpad. By default the Numpad is used to handle the Camera, so in order to used it with Objects you have combine it with CTRL or ALT. We'll talk about the Camera in the next Howto.
-
How to use the Engine 02 : Control the Camera !
Hi everyone !
In the previous Howto, we saw how to add, remove, duplicate objects and more! so let's play with the Camera this time.
Scroll the Camera
Using the Numpad you can scroll horizontally and vertically the Camera using the following keys :
Numpad_4, Numpad_6, Numpad_8, Numpad_2
Using the Mouse you can achieve the same actions with CTRL + Mouse_Wheel for scrolling vertically and ALT + Mouse_Wheel for scrolling horizontally.
If you use a Touch_Pad you don't have to use ALT + Mouse_Wheel, you can scroll horizontally directly.
Scale the Camera
Using the Numpad you can scale the Camera with the Numpad_Addition and Numpad_Substruct keys.
Using the Mouse you can scale the Camera with the Mouse_Wheel
Rotate the Camera
Using the Numpad you can rotate the Camera with the Numpad_7 and Numpad_9 keys
Using the Mouse you can do the same with SHIFT + Mouse_Wheel
Save and Restore the Camera
I guess the actions above were pretty obvious, so what about this one.
The Canvas is infinite, so you may lose yourself going here and there. In order to avoid that you can register the current Camera state (Position, Scale, Rotation) with ALT + Numpad_5. Now you can go where you want and press the Numpad_5 key to come back.
-
How to use the Engine 03 : Play with Meshes ! | Part 1 : Mesh Edition !
Meshes are a key component of the Engine. I'm sure you'll like to play with them.
There are four types of Mesh. Polygon, Circle, Line and Chain. When you click on the Mesh_Selection button on the Right of the Engine, you don't see "Chain" along with "Polygon", "Circle" and "Line", that's normal because Chains are created out of Lines.
soooooooo Let's Begin !
Switch between the Object Mode and the Mesh Mode
You can switch easly between Object Mode and Mesh Mode using the Space bar key.
If you want to get to the Play Mode you have to do CTRL + Space bar, to come back to Object Mode, just press Space bar again (we'll talk more about that later).
When you are in Object Mode, you are dealing with the Object_Manager of the current Scene. By going in Mesh Mode, you are letting the Mesh_Editor take control of the Canvas.
The Mesh_Editor has access to all Meshes present in your Scene either the mesh is encapsulated in a Mesh_Object or a Meshed_Object. It can fully modified them but not delete them.
Move Vertex
To move a Vertex, Left_Click on it, and drag it where you want.
Move Line
To move a Line, Left_Click on it, and drag it where you want.
Add Vertex
Vertice can be added on any Line. For that, make a Right_Click where you want on a Line.
Remove Vertex
A Right_Click on a Vertex will remove it.
Drag Mesh
You can Left_Click and drag easly a Polygon, a Circle or a Line. To move a Chain you have to select it first (see below)
Select Mesh
Use CTRL + Left_Click in order to select any Mesh, it will become Orange
You can click any where else in the Canvas to make a deselection (In the next release I will configure the Escape key for deselection)
Move, Scale, Rotate Mesh
When a Mesh is selected you can Move, Scale or Rotate it the same way you do with Sprite : CTRL + Numpad Keys. The Mouse is not used here, it works only with the Numpad.
Extrude Line
If you have ever used a 3D modeling software you know what Extrusion means, if not you can Google it.
In order to Extrude a Line you just have to hold the SHIFT key then Left_Click and drag.
Extrude Vertex
Works same as for Lines. Hold the SHIFT key then Left_Click on a Vertex and drag.
It only works on Lines and Chains Edge Vertice Currently !!!, I may consider extend that to others Vertice in the next releases.
Flip Mesh
I did not consider that feature even once since I've begun the Project. I'll make that for Engine Second Release.
Mesh Validation
Each time a Mesh is modified the Mesh_Editor checks for its validity. When a Mesh it's not valid it becomes Red
A Red Mesh is not converted in Box2D Body because the Box2D library raise Exceptions when it can't generate a Body.
The Mesh Validation System is currently incomplete !!! You may encounter some crashes when you have at least three Vertices almost aligned. The current solution is to Save your Scene before hitting the Play_Button or the Return Key.
That's All !
So, that's all for this Howto. With the Mesh_Editor, you can create any shape like Trees, Animals , Landscapes, the limit is your imagination.
when you are done editing some Meshes, you can press the Space bar key to return in Object Mode and then press the Return key in order to see your Meshes come alive. On the Bottom Right of the Engine you have some Check_Buttons that allow you to hide or show divers information about Box2D Bodies.
-
I really enjoy reading your progress post and tutorials! It'd be cool if you had saving/loading working so you could include a complete project. Also, I can't play with it because you didn't statically link gcc runtime stuff or include the dll's.
-
Missing DLLs
I've forgotten to add GCC DLLs. If you don't have the GCC compiler installed, you won't be able to run the Engine. Thank you for pointing that out Ruckamongus, as you mentioned it's possible to link them statically, but I prefer to share the DLLs.
There is the download link : Missing DLLs (https://drive.google.com/file/d/0B6PhZVm0Xh-NR2dQaGhRM3ZjWkU/view?usp=sharing)
? ?
It'd be cool if you had saving/loading working so you could include a complete project.
I don't get what you mean here. If it's about Save and Load your Scene in the Engine, it works fine now.
-
When will the Source Code be released ?
Hi everyone, how do you do !
Many people have beeen asking for the Source Code, so I wanted to let you know about it.
The Code will be available after the Engine First Release. After that first release, I will work on the Code in order to reorganize it, add comments there and there and make it more clean. I can't give the exact time, but I may estimate that to three months.
As soon as the Code will be on Github, I'ill make a post to prevent you. Also from now, you can find the link to the repository in the Footers of my posts.
Howtos
I've been busy those days so I did not get some time to continue the Howtos. I will complete the remaining ones the next week.
-
How to use the Engine 03 : Play with Meshes ! | Part 2 : Mesh and Meshed Object Properties !
Hi everyone, how are you doing ! In this second Howto on Meshes we'll talk about some Mesh properties.
Mesh Object and Meshed Object
First of all, I hope that, both words are not confusing you, I don't think that munch before to choose my Classes names, I just took the first ones that come to my mind ;D.
There is a little reminder
- Mesh Object = Mesh
- Meshed Object = Mesh + Sprite
Both Objects carry a Mesh and that Mesh can be configured to suit your needs.
On the Left of the Engine, along with the Sprite Tab and Color Tab, you get the Mesh Tab, we gonna play with it. The properties below work the same way on both Objects types, you just have to select them and apply the one you want.
Fixed Rotation
This one is pretty easy, when activated, your Object will never rotate even if it stand on a sloping ground or if it get hit by a projectile.
Is Sensor
This is one of the Coolest feature of Box2D. When talking about Box2D the first thing people see is the "Physics Simulation" Part of the library. But the thing is, if you set all your objects to Sensor mode, you end up with a powerfull "Collision Detection Engine" without any Physic Simulation. This let you free to implement your own Physic Simulation.
Object in Sensor Mode stay affected by Gravity, but that's all, they don't participate to the "Physics Simulation". that's make them great to build your game logic. You can use them to check if your Character has reached a certain area and then trigger a specific event. When i'll build my game prototype, i'll show how you can use Object in sensor mode to do great things.
Allow Sleep
This property is activated by default, and it should stay like that. It will help reduce the computation operated by Box2D.
Density | value : [0 - 100]
What is Density ? in simple words it's a short of relation between an Object Volume and its Weight. For the same volume, the same Object will get a higher weight if its Density get increased. In your game, that will make your objects more stronger.
To check that, create two identical Polygon Meshes, let's call them Left_P and Right_P. Now using the mouse, take Left_P and throw it on Right_P. Right_P will get ejected easly, now increase its density to 100 and throw Left_P on it again, you will see that now Right_P is more resistant or stronger.
Also the Density don't affect the way Gravity affect the Object. Two Ojects with the same volume, and different density (e.g different weight) will be affected the same way by the gravity (in the absence of air resistance to be more accurate). Fo more detail on that go check Newton Laws.
Friction | value : [0 - 10]
What is Friction ? If you don't want your Object to slide on a sloping ground just increase its Friction. If you want your Object to slide on any surface like if it was ice set the Friction to 0. For more technical explication you can Google Friction Force
Internally Box2D use a range value of [0 - 1], In order to avoid using decimal, the Nero Engine use the range value of [0 - 10].
Restitution | value : [0 - 10]
What is Restitution ? Increase Restitution will allow your Object to bounce more easly. For more technical explication you Google Coefficient of restitution
Internally Box2D use a range value of [0 - 1], In order to avoid using decimal, the Nero Engine use the range value of [0 - 10].
Gravity Scale | value : [0 - 10]
If you want to change the way your Objects are affected by gravity, this is the property to configure. Set the value to 0 will allow your Object to float on the air. Increase the value, will make your object fall down more quickly.
The Engine Physics Default settings
When using Box2D the first time, The first thing you notice, is that the physics simulation is slow. According to my experience there are three Settings to configure in order to fix that.
- The Pixel / Meter Ratio used
- The Box2D World Computation Freqency
- The Box2D Bodies Gravity Scale
The Nero Engine use a Pixel / Meter Ratio of 30. It means that 30 pixel on your canvas will be equivalent to 1 meter for Box2D. This value is hard coded in the Engine, I may consider make it configurable in the next releases.
The Default Computation Frequency is set to 30 Hertz, you can see it on the Right of the Engine. Fill free to play with this value.
The Engine also use a default Gravity Scale of 3 for all Object. I've tried several values and comes up with this one, it's the most important parameter between the three. the computation Frequency coming in second position.
By adding more and more Dynamic object onto the Canvas, the Physic simulation may become slow, so, remenber to play with those Three parameters in order get the Simulition Speed that suit you.
-
How to use the Engine 04 : Workflow !
Hi! again, not sure that the title is the right one, but we'll stick with it. In this Howto we'll talk about some Util Actions that you may used every time during the process of creating a game.
Select Scene
The Engine is able to menage several Scenes, each one having its own directory under the NERO/ folder. On the Right of the Engine you have a selection button that let you choose the scene you are going to work on.
You can also use Numpad_1 and Numpad_3 to switch between the available Scenes.
What about Create Scenes ?
I purposely avoid adding a button to create new Scenes. This will be available when Lua will be added as a scripting language. The thing is that, currently you have to access your Scene Class in order to build your game logic.
You create a new Scene by declaring a new Class and then adding it to the Engine.
Class MyScene : public nero:DevScene
{
//Retrieve all Objects you created with the Engine and Build your game logic here
}
nero:DevEngine engine;
engine.addScene<MyScene>("My Scene Name");
engine.run();
You can add any number of Scenes, All the Scenes added will be available on the Scene selection button.
Load Scene
When the Engine start, it tries to load all the scene that have been added. For that it parses the NERO/ folder and check for your Scenes JSON file. If the JSON file doesn't exist it mean that the Scene as never been Saved and you end up with a empty Canvas.
The Load_Button on the Right on the Engine allows to load the content of your Scene JSON file at any time.
Load a Scene with the Load_Button can be Undo or Redo like as any other Action, so don't be afraid to lost your work, after accidently pressed the Load_Button.
Save Scene
The Save_Button allows to save your Scene at any time, this will overwrite your Scene JSON file.
In the next releases I'll add the CTRL + S shorcut to save the Scene.
Undo Redo Actions
On top of the Canvas you have two buttons to Undo and Redo your Actions. the |<--| button will Undo actions, and the |-->| will Redo Actions.
You can also use the the Left_Arrow and Right_Arrow keys to achieve the same thing.
Undo and Redo actions work in the Engine Object_Mode and Mesh_Mode.
Play Scene
When your are done creating some Objects you can Generate your Game Scene by pressing the Play_Button locate on top of the Canvas.
Using the keyboard you can also press the Return_Key.
The CTRL + Spacebar allows to switch to Play_Mode but it does not Generate the Game Scene like the Play_Button
Pause Scene
When in Play_Mode you can Pause the Scene using the Pause_Button or the keyboard P key or the Left_Arrow key.
Step Scene
When in Play_Mode you can Step the Scene using the Step_Button or the Right_Arrow key.
Reset Scene
When in Play_Mode you can Reset the Scene using the Reset_Button or the keyboard R key or the Up_Arrow key.
Quit the Engine
The Quit_Button button allows to close the Dev Engine. In the next releases I will configure it to Save all Scenes before to close the Engine.
-
How to use the Engine 05 : Use your own Resources !
Ones may use the word Asset, other like me may use the word Resource. So what is it? Resources are Textures, Sounds, Musics, Shaders and Fonts you are going to use to build your game. Manage Resources is an important point when building a game. In order to simplify things, the Engine take care of every. Most of time, if you need to use a resource, you'll just have to copy and paste it in the right sub-directory under the Resource/ folder.
The Name of your resource will be its Id in the Engine, so for a given Category of Resources, you can't give the same name to two different resources.
When the engine start, it parses the Resource/ directory and loads everything. If it founds a problem it throws an Exception and don't start. So, if you get the Engine start without any trouble be ensured that all resources have been loaded correctly.
The Engine use the Sansation Font locate at Resource/Font/Sansation.ttf for its own Text rendering, This is the only resource that must be always available, for others, you can delete them or replace them with what you want.
Retrieve Resources in the Code is pretty simple, there is some examples.
auto myFont = m_ResourceManager.Font.get("Font Name");
auto myTexture = m_ResourceManager.Texture.getTexture("Texture Name");
auto myTexture = m_ResourceManager.Texture.getSpriteTexture("Sprite Name"); //Return the Texture that contains your Sprite
auto mySound = m_ResourceManager.Sound.get("Sound Name");
auto myMusic = m_ResourceManager.Music.get("Music Name");
auto myShader = m_ResourceManager.Shader.get("Shader Name");
End of this First Series of Howtos
The Series of Howtos comes to its end. It was pretty fun for me to write them. I hope you have enjoyed reading them. I've tried to cover most of the features that have been implemented until now.
If you have been able to play with the Engine, I'll be happy to see some screenshoots of the Scenes your have created.
For the Next Step of the Projet, I'll use efficiently my free time in order to Release the Engine as soon as possible.
Have a good day ;D
-
Engine Update
Collision Management | Part I : Collision Filtering
I guys, how are you doing ;D. Today we gonna talk about collision, let say you have a game and you want certain objects to collide and others not, this post will show how easy it is to achieve that with the Nero Game Engine.
The nero::CollisionRule Class
Box2D offers two ways to filter collisions, filter collisions just means define which object can collide with which one. The first method use Category_Bits and Mask_Bits, the second use Goup_Indexs. Those are Box2D Fixtures properties. I'm not going to describe those two technics, the only thing to know it's the first one offers more flexibility, but it is pretty difficult to implement. The nero::CollisionRule Class use Category_Bits and Mask_Bits and it allows you to filter collision in the easiest way you could think.
In Practice
Using the Dev_Engine Interface you can provide a Category to any Object. Categories are represented by a String so you can write whatever you want (I plan to use regex to limit thing, but that's not for now).
For instance let say we have the following categories : player, friend, enemy, ground. All you have to do, is to write something like that :
nero::CollisionRule rule;
rule.canCollide("player", "ground");
rule.canCollide("friend", "ground");
rule.canCollide("enemy", "ground");
rule.canCollide("player", "enemy");
rule.canCollide("friend", "enemy");
rule.canCollide("enemy", "enemy");
rule.apply(m_RootObject);
the m_RootObject is the root object of your Scene Object TreeNode, it's a member attribut of your Scene. The apply() method, parse your Object Tree, detect all nero::PhysicObject and configure the Category_Bits and Mask_Bits in each Box2D Fixtures.
FullCollision and NoCollision
the Class also offers those two convenient methods
rule.fullCollision(m_RootObject); // everything collide
rule.noCollision(m_RootObject); // nothing collide
Limitation
You can have up to 16 categories, this limitation comes from Box2D itself.
This limitation of 16 categories only concern collision filtering and the nero::CollisionRule class, the Nero Engine itself, allows you to define an infinite number of categories, depending on your game, you may have to use categories for something else than collision.
Change Collision Rules on the fly
You can change the collision rules at any moment in your game, let say your player just picked up a potion that allows him to go through walls, all you have to do, is to create a new instance of the nero::CollisionRule class or call its clear() method, define the new collision rules and call the apply() method. A better practice would be to pre-define several collision rules, and then apply them whenener you want.
Collision Management | Part II : Collision Handling
Handle collisions is one the most interresting part in game programming, this is where you can say I want that object to explode if it get touch my super missile ;D.
Four methods : Begin, End, PreSolve, PostSolve
A nero::Scene offers four methods to handle collision.
void handleCollisionContactBegin(nero::Collision collision);
void handleCollisionContactEnd(nero::Collision collision);
void handleCollisionPreSolveContact(nero::Collision collision);
void handleCollisionPostSolveContact(nero::Collision collision);
Those four methods are called automatically when a collision occur. the nero::Collision object carries all information concerning the collision. For instance you can retrieve the two nero::PhyscicObject that are colliding like that:
auto objectA = collision.getObjectA()
auto objectB = collision.getObjectB()
if you want to check what objects they are, just retrieve the category (sf::string cat = objectA->getCategory()) or the name (sf::string name = objectA->getName())
More details on those four methods
In a previous post I have presented the four methods used by Box2D in order to process collisions, the four ones you are seeing here, is just a simplified version of the four methods provide by Box2D.
How do they work ?
The Begin method / handleCollisionContactBegin(nero::Collision collision), is called at the moment where two objects just collided. It means at the first moment of the collision. This is the method that you will use the most to process collisions.
After the two objects just collided, there will be a little period of time where they will be overlapping. During this overlapping phase the two methods PreSolve and PostSolve will be called alternatively and repeatedly. Those two methods may be useful in a game logic but for now I'm not going into more details.
After the overlapping phase, ours two objects are no longer colliding, so the End method / void handleCollisionContactEnd(nero::Collision collision), is called, that method just let us know that a collision just ended and give us the opportunty to do some stuffs.
That' all
That's all for collisions, Collisions allow you to add diversity in your game, you can use them in many ways, just let your imagination run free. I did not entered into details on how or when use collisions, I think the better way to anterstand collisions is to get our hand one it.
Next time
I'll make two others posts later today
-
Engine update
ActionObject and Action
The concept
ActionObject and Action is a interface that aim to simplify the manipulation of your game objects. Instead of manipulate your objects directly you can encapsulate them in a ActionObject. the ActionObject is then able to register several Actions that you can perfom later at any time.
An Action is a just a class that must override the following method "void call(object)". My first idea is that Actions should be Functors (C++ Function Object), I've tried to override the "call operator" but didn't get the result expected, so I end up using the "void call(object)" instead. ActionObject and Action can be used to perform instant action like jump or dash, but they can also be used to perform long or infinite actions like controlling the trajectory of a moving platform.
In Practice
The following code is just a pseudo code, it let you get an idea of how to use ActionObject and Action.
class JumpAction : public Action
{
call(Object)
{
// do some stuff with the object, like apply a impulse upward
}
}
class DashAction : public Action
{
call(Object)
{
// do some stuff with the object
}
}
auto object = enigne.findObject("player"); // find object by name
ActionObject my_player;
my_player.setObject(object);
my_player.registerAction<JumpAction>("jump"); // the name of the Action is given as argument, you can put what you want
my_player.registerAction<DashAction>("dash");
if(key J is pressed)
m_player.callAction("jump"); // make your player jump
else if (key D is pressed)
m_player.callAction("dash"); // make your player dash
Different types of ActionObject / Action
As it already been said the code above is just a spseudo code, the classes ActionObject and Action do not exist. Instead you have a pair of classes for each type of objects that is manipulable.
SimpleActionObject / ObjectAction // handle a generic nero::Object
PhysicActionObject / PhysicAction // handle a nero::PhysciObject
SpriteActionObject / SpriteAction // handle a nero::SpriteObject
LayerActionObject / LayerAction // handle a nero::LayerObject
-
Release of the source code in December
At this stage of development, I've implemented all the features that as been plan for the First release to be done. The Engine is still not ready to be used, but there is not much work left. I will begin the restructuration of the code in the next days. I may change some classes or methods name and change some implementations etc. The code will be on github in three or four weeks.
In the same time I will be developping my game prototype. I don't know how munch time it'll take but it's only when the prototype will be finished that the first release will be officially announced.
that's all, I wish you a good day :).
-
Release of the source code in December
At this stage of development, I've implemented all the features that as been plan for the First release to be done. The Engine is still not ready to be used, but there is not much work left. I will begin the restructuration of the code in the next days. I may change some classes or methods name and change some implementations etc. The code will be on github in three or four weeks.
In the same time I will be developping my game prototype. I don't know how munch time it'll take but it's only when the prototype will be finished that the first release will be officially announced.
that's all, I wish you a good day :).
Take your time, you're making such a piece of technology!
-
Hi DarkRoku12, you don't know how happy I was to read your comment
I would like to take this opportunity to thank all my readers, Thank you for reading my posts, it really encourages me to continue the project.
In the next weeks and months, I will take you in the development of my game prototype with a series of posts. It will be an occasion to learn a lot on game prototyping and you will dicover how the engine can be used in real scenario.
Finally the engine will be released when it will be ready, so you'll be able to try it right away ;D
-
That's cool.
I'm polishing a full featured 2D engine soon, with SFML as its base. I have 3 years in that development, i don't release it becuase i'm finishing university and i don't have a lot of time.
But i know it is hard, i can recognize the very good job you have done!
Keep going, i'll looking forward it.
-
Source code released
Hi! here, how are you doing ! ;D
The Engine source code has been uploaded on github, you can check the link bellow
Nero Game Engine Repository (https://github.com/NeroGames/Nero-Game-Engine)
From now on, I will update the repository after each progress in the engine development.
Need Help for the build process !
I will be working on the build process with Cmake in the following weeks, but I'm not an expert in Cmake, I may checkout the cmake files of projects like SFML or SFGUI to find my way, but it'll take me months before to come up with a proper build process. So if anyone can help I'll be very thanksfull ;D;
Resource Pack ! Thank Kenney !
I've searched for some free resources over the internet and finally found those beautiful textures made by Kenney Vleugels. The resources are free for both personnal and commercial use. The work of this guy is just great !
I've gathered some of those resoures on a github repository call Resource Pack, check the link bellow
Nero Game Engine Resource Pack (https://github.com/sk-landry/resource-pack)
The goal of the resource pack repository is to provide you all the resources you'll need to start with the Engine. Over the time there will be more resources like music, sound, particule and also more texture.
-
How is my game prototype doing !
I'm currently working on my game prototype, the objective is to simply test and improve the Engine. I'll be working on it all this month.
As for now I've implemented the following features.
- Make the camera track my player
- Move my player
- Multi-Jump (double jump)
- Dash
- Moving platform
- Go through Platforms when jumping from bottom
- Make my player rotate to fit the ground slope, despite it is configured as Fixed_Rotation true
- Remove objects at collision (It's like collecting coins or destroying enemies)
http://www.youtube.com/watch?v=FvEnGTooAag
The Nero Game Tools Library
The NGT (Nero Game Tools) Library is a sub-project of this current project. It's goal is to provide a set of tools that will allow to prototype a game in hours, or build a first version of a game in only 2 or 3 days.
The first version of this library will be composed of the tools use in my game prototype. I plan to provide this library as a header-only library.
The library will be based on the concept of Action and ActionObject object. In the video above the code that make my player move is the same that make the platform move. I've just built a Move_Action that I can provide to any Object. Therefor the NGT library will be a collection on Action and ActionObject ready to use, you just configure them and set it to any object in the Scene.
The Second Release will come soon
After finishing with my game prototype, I will publish the first version of the NGT Library and make a tutorial on how to make a game from start to end with the Engine.
Only after that I will add Sound Object and Animation Object to the Engine.
-
Adding Cmake to the project
Cmake is now available in order to build the Library. I've successfully built the engine as Shared and Static lib on a 32 bits Windows using Mingw. I will test the build in other platforms later.
The cmakelists file I've built is pretty minimal, I will update it later, when i'll have a better understanding of Cmake.
For reminder the Nero Game Engine use the following libraries:
- SFML 2.4
- SFGUI 0.3.1
- Box2D 2.3.0
- Boost 1.61.0 (filesystem and system)
-
Build the Nero Hello World
Hi everyone, how are doing ;D.
In this post I'm going to show how to build and run the Engine, The goal will be to make the following snippet of code work.
#include <NERO/engine/DevEngine.h>
int main()
{
nero_log("Nero game engine Hello World");
nero::DevEngine engine;
engine.run();
}
This tutorial will focus on Windows, CodeBlocks and MinGW, if you are familiar with other tools, I'm sure you will find your way out too. Also I will asume that you know a bit of Cmake GUI
Step 1 : Download the Sources
All the sources are available on github
Boost 1.61.0 : https://github.com/boostorg/boost (https://github.com/boostorg/boost)
Box2D 2.3.0 : https://github.com/erincatto/Box2D (https://github.com/erincatto/Box2D)
SFGUI 0.3.1 : https://github.com/TankOs/SFGUI (https://github.com/TankOs/SFGUI)
SFML 2.4.0 : https://github.com/SFML/SFML (https://github.com/SFML/SFML)
Nero 0.7.0 : https://github.com/NeroGames/nero-game-engine (https://github.com/NeroGames/Nero-Game-Engine)
The Nero project use a specific version of the others libraries, you may try to use the latest version of the corresponding libraries, but for this tutorial I will stay with the specific versions in order to avoid any incompatibilities.
After downloading SFML, SFGUI, Boost and Box2D, you will have to checkout the sources in order to get the right version.
It's pretty easy. Here is a exemple with SFML
git clone https://github.com/SFML/SFML.git // Download the SFML source code (latest version)
cd SFML // Move to the SFML source directory
git tag -l // Display all the available versions
git checkout tags/2.4.0 // Switch the code to the version 2.4.0, the command is " git checkout tags/<tag_name> "
And there it is, you now have the SFML 2.4.0 version, you can do the same for Boost, Box2D, and SFGUI
Step 2 : Build the Sources
Build Boost
Let's begin by the easiest one, we are going to build only the system and the filesystem libs.
for that, move into the boost source directory and issue the following two commands one after another
./bootstrap.sh
./b2.exe --prefix=build --with-filesystem --with-system link=shared variant=debug,release threading=multi
The result of the build will be in the folder stage/lib
Build Box2D, SFML and SFGUI
Box2D, SFML and SFGUI can be build easly with Cmake GUI
SFGUI depends of SFML, if Cmake does not find SFML, you can define the Path option SFML_ROOT.
the sfml root directory should look like this
sfml_root_path/inlcude/SFML //contains the sfml headers
sfml_root_path/lib //constains the sfml libs (.a files with MinGW)
Step 3 : Build Nero
After building Boost, Box2D, SFML and SFGUI you can now build the Nero project using Cmake GUI.
If Cmake does not find boost, you can define the Path option BOOST_ROOT
the boost root directory should look like this
boost_root_path/inlcude/boost //contains the boost headers
boost_root_path/lib //constains the boost libs (.a files previously build)
If Cmake does not find SFML, you can Define the path option SFML_ROOT like for SFGUI
If Cmake does not find Box2D or SFGUI you will have to configure manually the following cmake options.
BOX2D_INCLUDE_DIR
BOX2D_LIBRARY_DEBUG
BOX2D_LIBRARY_RELEASE
SFGUI_INCLUDE_DIR
SFGUI_LIBRARY_DEBUG
SFGUI_LIBRARY_RELEASE
If you have built Box2D and SFGUI in Release and Debug mode, you can provide the two libs version, if not, providing either the Debug or Release libs will be enough.
Step 4 : Organise your Libs
When you build a library you can choose where the libs will be install. Libraries like Boost have default installation path, so cmake or any IDE or compiler can find them easily. Personnaly I use a custom folder call "Library" to store all my libs. It's easy to find them if I know they are all in one place. Choose the method that suits you the best.
In the next section I will assume that you have all the libs in a folder "Library" like this:
Library/include //contains all the libraries headers
Library/inlcude/SFML
Library/inlcude/Box2D
Library/inlcude/SFGUI
Library/inlcude/boost
Library/inlcude/json // This one can be find in the Nero project source files, under the "extlibs" directory
Library/inlcude/easyloggingpp // "extlibs" directory also
Library/lib // contains all the libraries libs (.a files with MingW)
Library/bin // conatains all the DLL files
Library/doc // the libs doc
Step 5 : Link the lilbraries
Now that you have all the libs and DLL ready, you can create a new Project and make the following configurations.
On CodeBlocks, all of this is done in (Project --> Build Options)
activate the c++11 flag (Project --> Build Options --> Compiler Settings --> Compiler flags)
add the headers path "Libray/include" (Project --> Build Options --> Search directories --> Compiler)
add the libs path "Library/lib" (Project --> Build Options --> Search directories --> Linker)
add the dll path "Library/bin" (Project --> Build Options --> Search directories --> Linker)
link all the libs (Project --> Build Options --> Linker settings --> Link libraries and/or --> Other linker options)
Step 6 : Mandatory directories
After linking the libs, there is one more thing to do, the Engine expect some directories and files to be available.
Resource/
Resource/Texture/
Resource/Font/
Resource/Font/Sansation.ttf // This is one is important, the Engine use it for text rendering
config/
config/log_config //Pretty important, but not necessary
You can download those directories here : https://github.com/NeroGames/resource-pack/blob/master/Directory.zip (https://github.com/NeroGames/resource-pack/blob/master/Directory.zip)
Unzip the file and copy its content in your project directory
That's All
This post described all the steps you'll need to get start with the Engine. Build and Link libraries is one of the most difficult part when working on C++ programs. It may give you some headaches ::) :o :o. So try again and again if it does not work and feel free to ask any question in case of difficulties.
-
You should definitely think about putting together an SDK that interested users can just download and which can be used to start developing right away.
-
Hi @Tank, thank for your reply.
I know the build and installation process maybe challenging, this is why I decided to add a scripting language at the final stage of the project. I didn't thought about a SDK, it's a great idea you have here. thank you !
By the end of the week, I'll provide a Kit fully Setup, the Kit will contains a CodeBlocks installation and a MinGW compiler fully configure.
-
Nero Game Engine Startup Kit
Hi every how are you doing !
The kit is now ready, you can download it with the link bellow. The kit works like a Codeblocks standalone installation. you can carry it in a USB key and launch it wherever you want. It uses a 32 bits MinGW compiler, so it should run on any Windows System.
Downlaod Nero Game Engine Kit (https://drive.google.com/file/d/1THDFW4btsftdUqcacMjEqo81VKy7gGUS/view?usp=sharing)
The Kit already contains two projects. One call "Test" that you can use as you want, and another call "Kero", I will talk about this one later.
The content of the Kit is as bellow
CodeBlocks/ CodeBlocks and MinGW installation
Library/ All the necessary headers, dlls and libs
Projects/ All your projects should be created in this folder
Resource Pack/ A set of Textures and Fonts
Readme A readme file
Start Double click on this one to start CodeBlock;
There is nothing to configure, every new project has automatically access to the engine API
When you create a new project, there is only one thing to do. The Engine expect the "config/" and "Resource/" directories to be availabed. So don't forget to add them. You can simply copy the ones in the "Test" project in your New project directory.
-
Developing Games with the Engine 101
Hi everyone how are you doing :), In this post we'll see how to start programming with the Engine
1- Create a new Scene
In order to create a new Scene, you simply have to create a new Class inherating from nero::Scene. After that you can add your scene to the Engine with the method [ addScene<Scene_Class>("scene_name") ]. you can add any number of Scenes.
Pay attention to the scene name, the name will be used to generate a directory for your scene, So the characters you can enter there depends on your Operating System rules in term of Folder and File Name.
The Engine Instantiate your Scene each time you click on the Play_Button.
#include <NERO/engine/DevEngine.h>
class MyScene : public nero::Scene
{
public:
MyScene(nero::Scene::Context context):
nero::Scene(context)
{
nero_log("Hello bodies");
}
};
int main()
{
nero_log("Nero Game Engine Hello World");
nero::DevEngine engine;
engine.addScene<MyScene>("My Scene");
engine.run();
}
2- The init() method
The init() method is called automaticlly after the constructor of your Scene, This method exist in order to allow doing stuff that can't be done in the construstor. It's in this method that you can retrieve objects, preconfigure your player, your scene logic etc.
Using the Dev_Engine Interface, first create an Object named "test" before to run the bellow code.
#include <NERO/engine/DevEngine.h>
class MyScene : public nero::Scene
{
public:
MyScene(nero::Scene::Context context):
nero::Scene(context)
{
nero_log("Hello bodies");
}
void init()
{
nero_log("the init() method is called automatically after the constructor");
//Create a mesh object and give it the name "test" before to run this code
auto object = m_ObjectManager.findObject("test");
nero_log(_sn(object));
// the little "_sn" is a toString method; the "s" is for String, the "n" is for Nero Object
}
};
int main()
{
nero_log("Nero Game Engine Hello World");
nero::DevEngine engine;
engine.addScene<MyScene>("My Scene");
engine.run();
}
3- Run the Render_Engine
In order to launch the Render_Engine, simply replace the DevEngine header by the RenderEngine one [ #include <NERO/engine/RenderEngine.h> ], and then change the code in the main like bellow.
The Render_Engine takes only one Scene, so it use the method [ setScene<Scene_Calss>("scene_name") ]
The Render_Engine run a 800 x 600 window by default, you can change that by modifying its constructor like that
[ nero::RenderEngine engine("default name", 1024.f, 600.f) ]
#include <NERO/engine/RenderEngine.h>
class MyScene : public nero::Scene
{
public:
MyScene(nero::Scene::Context context):
nero::Scene(context)
{
nero_log("Hello bodies");
}
void init()
{
nero_log("the init() method is called automatically after the constructor");
//Create a mesh object and give it the name test "test" before to run this code
auto object = m_ObjectManager.findObject("test");
nero_log(_sn(object));
// the little "_sn" is a toString method; the "s" is for String, the "n" is for Nero Object
}
};
int main()
{
nero_log("Nero Game Engine Hello World");
nero::RenderEngine engine;
engine.setScene<MyScene>("My Scene");
engine.run();
}
4- No More DevScene
In some previous posts you may saw that a Scene could be created by inheriting from a nero::DevScene, this is no longer the case.
The DevEngine is only able to manage some nero::DevScene, so in principle you should only add DevScenes to it. In contrast the RenderEngine is only able to manage some nero::Scene. Switching between the DevScene engine and the RenderEngine, was requiring to manually change the inheratance of a Scene every time. I founded that combersome so, I made some changes.
Now only nero::Scenes are added to the DevEngine, and it is its responsibility to automatically generate a DevScene that will encapsulate the nero::Scene. With that, there is no change to made in a Scene when moving from the DevEngine to the RenderEngine and vis versa.
5- The nero::GameEngine
You never heard about this Class. The reason is simply because it doesn't exist yet. The Nero project is based on three seperated Engines.
- a Dev Engine, its role is to accelerate the development of a Game scene.
- a Render Engine, its role is to facilitate Scene distribution, if you want a friend or a colleage to test a particular scene, put it in the RenderEngine and share it.
- a Game Engine, its role is to hold a entire Game, a Game with multiple Scenes and Menus. Its particularity is to have a Scene_Stack and a way to switch between Scenes and Menus easly.
A this stage of the project, the GameEngine is not a requirement, so I put it away for now.
That's all for this 101, the true tutorial will begin later on
-
How to code with the Engine Series
Hi everyone, after the 101 (see the above post), we can now move further and see how to code with the engine.
As I made with the DevEngine Interface, I will made a series of posts to show how to develop a Game with the Engine.
In the Engine Kit there is the project Kero. this project is my game prototype, more exactly the quater of it. I design the prototype in four parts. You can take a look at the code to see how it works. The 3 others parts of the prototype will be part of this tutorial.
bellow you can see the outline of this new series of posts
Part 1: Let's begin slowly
1/ The nero logger
2/ Use constants
3/ Check Objects
4/ Retrieve objects
5/ Create a simple Player
6/ Create a moving platform
7/ Handle Collisions
8/ Analyse of the Kero Scene code
Part 2 : Let's finish that Prototype
1/ the Second part
2/ The Third part
3/ The Last part
-
How to code with the Engine Part 1-1 : The nero logger
Log things is pretty useful when programming, this is why I wanted to start this series of Howtos with the logger.
The Engine use the Easyloggingcpp library for logging. the default synthax look like this
[ LOG(INFO) << "log message here, this goes to the console" ]
If you ever used that library and are familiar with it, you can still use its default synthax.
I prefer function-like synthax, this is why I design the [ nero_log() ] and [ nero_log_if() ] functions to replace the original synthax. Those functions are in fact Macros, this is why they don't use the nero namepsace.
Here is a overview of these two functions
nero_log(message)
nero_log(message, level)
nero_log_if(message, boolean)
nero_log_if(message, boolean, level)
Two levels are availabled. Not specifing a level is equivalent to use the logger in INFO level
nero::Debug
nero::Warning
//The Debug and Warning level will give the File, the Line and the Method where the log has been called
[DEBUG | main.cpp | Line 21 | virtual void MyScene::init() ] --> Hello world
In addition to the logger Macros, you also got some toString Macros
_s(value)
//equivalent to nero::toString(value), it automatically add a space at the end.
_sn(object)
//call the toString method of the object, equtivalent to object->toString()
Things are always more easy with examples, so here are some
x = 5;
auto myPlayer = m_ObjectManager.findObject("player");
nero_log("whatever");
nero_log("whatever", nero::Warning);
nero_log_if("whatever", x < 10);
nero_log_if("whatever", x > 0, nero::Debug);
nero_log("step : " + _s(10) + "the winner is : " + _sn(myPlayer), nero::Debug);
-
How to code with the Engine Part 1-2 : Use constants
The Engine use a lot of Strings to do its stuffs. Objects in a Scene are identified by they Name and they Category. The Names and Categories are used everywhere and many time in the code, writting them every time is error prone, so as a good practice, this Strings should be declared as constants and maintained in one place. Also notice that Names and Categories should be unique.
As an example the kero project defined several constants in the Kero_utility.h file like this.
struct _NamePool
{
const sf::String start_ground = "start_ground";
const sf::String player = "kero";
const sf::String jump_power = "jump_power";
const sf::String start_platform = "start_platform";
const sf::String start_end = "start_end";
};
struct _CategoryPool
{
const sf::String ground = "ground";
const sf::String wall = "wall";
const sf::String player = "player";
const sf::String power = "power";
const sf::String platform = "platform";
};
struct _PlayerActionPool
{
const sf::String move_left = "move_left";
const sf::String move_right = "move_right";
const sf::String move_none = "move_none";
const sf::String jump = "jump";
const sf::String dash_left = "dash_left";
const sf::String dash_right = "dash_right";
};
const _NamePool NamePool;
const _CategoryPool CategoryPool;
const _PlayerActionPool PlayerActionPool;
-
How to code with the Engine Part 1-3 : Check Objects
Any Object can be retrieved at any moment with a [ m_ObjectManager.findObject("object_name") ] . The thing to know is that the Object_Manager return a Null_Ptr when it does not found a Object. The reasons the Object_Manager does not found a object may be because the Object simply does not exist, may be you misspelled the Object_Name, or you simply forget to assign the name with the Dev_Engine Interface. So in principle you should test any returned object before to use it like that.
auto object = m_ObjectManager.findObject("oject_name")
if(object)
{
//do something
}
This is pretty combersome. In order to reduce the risk of using unexisting Objects, you can check them all at the beginning of the init() method.
the method [ m_ObjectManger.checkAllObject(std::vector<sf::String>) ] is there for that. you can give it all the Object_Names you will be using. If it found that a object does not exist, it throws a exception and give you the culprit, I means the Object_Name, that refer to nothing.
void init()
{
//Test that all objects exist before to continue
m_ObjectManager.checkAllObject(
{
NamePool.start_ground,
NamePool.jump_power,
NamePool.player,
NamePool.start_platform,
NamePool.start_end,
});
// Everything fine here, we can continue safely
}
-
How to code with the Engine Part 1-4 : Retrieve objects
1- Find Objects
The findObject() method, run other the whole Object_Tree_Node to find an Object. This may be resource and time consuming if your Scene contains too many Objects. You can optimize the research if you know the nature of the Object you are looking up for.
If the Object is a Physic_Object by example, use the findPhysicObject() method, This method will skip all layer that does not contain Physic Objects during its look up process.
There are a list of methods you can use to retrieve Object more efficiently
Object::Ptr findObject(sf::String name);
Object::Ptr findLayerObject(sf::String layer_name);
Object::Ptr findObjectInLayer(sf::String name, sf::String layer_name);
Object::Ptr findSpriteObject(sf::String name);
Object::Ptr findPhysicObject(sf::String name);
Object::Ptr findSolidObject(sf::String name);
2- Move Objects
The Move methods, cut the Objects you are looking up for from the Object_Tree_Node. So you can re-attach them somewhere else in the Tree.
Object::Ptr moveObject(sf::String name);
Object::Ptr movePhysicObject(sf::String name);
Object::Ptr moveSpriteObject(sf::String name);
Object::Ptr moveSolidObject(sf::String name);
3- Remove Objects
The Remove methods, will destroy complety an object. If the Remove methods do not find the object you want to remove they return false
bool removeObject(Object::Ptr object);
bool removeObject(sf::String name);
4- Objects Casting
The Find and Move methods always return a generic nero::Object, if you want to perform object specific tasks, you will have to cast the returned Object first. All Object Type have a static Cast() method for that.
nero::Object::Cast()
nero::LayerObject::Cast()
nero::SpriteObject::Cast()
nero::PhysicObject::Cast()
Example
auto my_cloud_sprite = m_ObjectManager.findObject("cloud_sprite");
auto my_ground = m_ObjectManager.findObject("ground_01");
nero::SpriteObject::Ptr sprite_object = nero::SptriteObject::Cast(my_cloud_sprite);
nero::PhysicObject::Ptr physic_object = nero::PhysicObject::Cast(my_ground);
A Solid_Object is a Physic_Object with a Sprite_Object as a child. So a Solid_Object is casted to a Physic_Object
auto object = m_ObjectManager.findSolidObject("object_name");
nero::PhysicObject::Ptr physic_object = nero::PhysicObject::Cast(object);
nero::SpriteObject::Ptr sprite_object = nero::SptriteObject::Cast(object->getFirstChild());
-
How to code with the Engine Part 1-5 : Create Moving Objects and Platforms
Hi everyone! how are you doing :). I've been busy the last weeks so I couldn't pursue the series, but here I am.
In this post I'll present a custom PhysicActionObject called SimpleMovingObject. This ActionObject can be used to create moving platorm or to make move any PhysicObject.
There is little change in the schedule, the HowTo on the Player will come after the one on Collision. That said, let's begin.
1- Include the NERO\gamelib.h header
#include <NERO/gamelib.h>
The Nero Game Lib library defined some custom Actions and ActionObjects. This library is not part of The Engine Core, currently it is provided as a header only library. You can find it in the package in : Library\gamelib\NERO\gamelib.h
Further in the tutorial I will show How to create custom Actions and ActionObjects. For now let's use the ones provided in the gamelib library.
2- SimpleMovingObject, the constructor
nero::SimpleMovingObject(direction, velocity, maxOne, maxTwo);
direction : [right_left , up_down] // the direction of the movement
velocity : [float] // the speed of the movement
maxOne : [float] // the distance to cover in the first direction (right or up)
maxTwo : [float] // the distance to cover in the second direction (left or down)
3- Example
nero::SimpleMovingObject(nero::SimpleMovingObject::Right_Left, 20.f, 100.f, 150.f)
//In the following example, the targeted object will move right and left at a speed of 20 float;
//The object will first move 100 float to the right, then it will come back to its initial position before
//to move 150 float to the left. the total distance of the movement it's therefore 350 float
4- A little trick
If you want the object to move Left_Right, instead of Right_Left, just set maxOne to Zero (0.f)
nero::SimpleMovingObject(nero::SimpleMovingObject::Right_Left, 20.f, 0.f, 250.f)
//Since the object should move 0 float to the right before to go left,
//the object will go left first, what's give you a left_right movement. this work also for the up_down movement.
5- Add the SimpleMovingObject to the Object Tree
The role of an ActionObject is to provide a behavior to another Object (the Target). As we want our ActionObject to have full control of the target, we will first remove the target from the Object Tree, and then give it to the ActionObject. Only after that we can add the ActionObject to the Object Tree
We create the ActionObject as a Pointer since it will be added to the Object_Tree
nero::SimpleMovingObject::Ptr my_Platform;
my_Platform(new nero::SimpleMovingObject(nero::SimpleMovingObject::Right_Left, 20.f, 0.f, 250.f));
We remove the Target from the Object Tree and give it to the ActionObject.
the Object_Manager MoveObject method, cut the target from the Tree and return it
auto target = m_ObjectManager.moveObject("my_platform");
my_Platform->setObject(target);
The Object_Manager will add the ActionObject to the Object Tree
m_ObjectManager.addObject(my_Platform);
6- Some reminders
The SimpleMovingObject is a PhysicActionObject, currently it's the only ActionObject in the gamelib library. As a PhysicActionObject, it handles only PhysicObjects (SolidObjects are also PhysicObjects).
This ActionObject should be used on Kinematic PhysicObject.
Static Objects are not meant to move and Dynamic Objects are meant to be affected by a lot of things (gravity, collisions) what is not ideal for this ActionObject.
7- A full example
First create a Kinematic PhysicObject (Kinematic Mesh) named "my_platform" before to run this code
#include <NERO/engine/DevEngine.h>
#include <NERO/gamelib.h>
class MyScene : public nero::Scene
{
public:
MyScene(nero::Scene::Context context):
nero::Scene(context)
,my_Platform(new nero::SimpleMovingObject(nero::SimpleMovingObject::Right_Left, 50.f, 100.f, 100.f))
{
}
void init()
{
//First create a Kinematic PhysicObject (Kinematic Mesh) before to run this code
m_ObjectManager.checkAllObject(
{
"my_platform",
});
auto target = m_ObjectManager.moveObject("my_platform");
my_Platform->setObject(target);
m_ObjectManager.addObject(my_Platform);
}
nero::SimpleMovingObject::Ptr my_Platform;
};
int main()
{
nero::DevEngine engine;
engine.addScene<MyScene>("My Scene");
engine.run();
}
-
How to code with the Engine Part 1-6 : Handle Collisions
Hi everyone, hope you are doing great. Let's continue this series with Collisons processing
1- Setup the collision rules
Let's consider the following Object Categories (ground, platform, cirlce, cube) and the following rules
- circles and cubes can collide with ground
- only circles can collide with platforms
- circles cannot collide with circles
- cubes can collide with cubes
- circles and cubes cannot collide
using a nero::CollisionRule object you can configure this setup with the code bellow
nero::CollisionRule collisionRule;
collisionRule.canCollide("circle", "ground");
collisionRule.canCollide("cube", "ground");
collisionRule.canCollide("circle", "platform");
collisionRule.canCollide("cube", "cube");
collisionRule.apply(m_RootObject);
When the apply() method is called, the collisionRule object first remove all previous collision configuration by calling the noCollision() method. When this method is called, no object can collide with any other object, this is why you only have to tell which Category should collide with which one when setting up the rules.
2- Print the collision rule
if you want to see the collision rules in a more readable way, you can called the print() method
collisionRule.print();
3- Process collisions
when a collision occur, the handleCollisionContactBegin() method is called first. The collision is represented as a nero::Collision Object
void handleCollisionContactBegin(nero::Collision collision)
{
if(collision.isCollising("ground", "cube"))
{
nero_log("ground-cube collision detected");
auto object_1 = collision.getObject("ground");
auto object_2 = collision.getObject("cube");
nero_log(_sn(object_1));
nero_log(_sn(object_2));
}
if(collision.isObjectCollising("platform_1", "circle_1"))
{
nero_log("platform_1 and circle_1 just collided");
auto object_1 = collision.getObject("platform_1");
auto object_2 = collision.getObject("circle_1");
nero_log(_sn(object_1));
nero_log(_sn(object_2));
}
}
4- Test collisions
The collision object offer two methods to test collisions by category or by name
collision.isCollising("object_category_1", "object_category_2");
collision.isObjectCollising("object_name_1", "object_name_2");
The test with a category and a name is not availabled, I will had that for a future release.
5- Retrieve the colliding objects
You can use the getObject() method to retrieve the objects that are colliding, the method takes a category or a name as parameter. The returned object is a nero::PhysicObject
PhysicObject::Ptr collision.getObject(sf::String indicator)
//Example
auto object = collision.getObject("object_category");
//or
auto object = collision.getObject("object_name");
5- Disable collisions
A collision can be easly disabled with the code bellow
collision.setEnabled(false);
6- A full example
You can create the Scene for this example, with this following json file.
download the scene json (https://drive.google.com/file/d/1pG7oDecDvHdUy3uAbI1Kdd7NVtE_sCNM/view?usp=sharing)
#include <NERO/engine/DevEngine.h>
#include <NERO/scene/CollisionRule.h>
class MyScene : public nero::Scene
{
public:
MyScene(nero::Scene::Context context):
nero::Scene(context)
{
}
void init()
{
m_ObjectManager.checkAllObject(
{
"platform_1",
"circle_1",
});
nero_log("The collision rules");
nero::CollisionRule collisionRule;
collisionRule.canCollide("circle", "ground");
collisionRule.canCollide("cube", "ground");
collisionRule.canCollide("circle", "platform");
collisionRule.canCollide("cube", "cube");
collisionRule.apply(m_RootObject);
collisionRule.print();
}
void handleCollisionContactBegin(nero::Collision collision)
{
//this method is called first when a collision occur;
if(collision.isCollising("ground", "cube"))
{
nero_log("ground-cube collision detected");
auto object_1 = collision.getObject("ground");
auto object_2 = collision.getObject("cube");
//nero_log(_sn(object_1));
//nero_log(_sn(object_2));
}
if(collision.isObjectCollising("platform_1", "circle_1"))
{
nero_log("platform_1 and circle_1 just collided");
auto object_1 = collision.getObject("platform_1");
auto object_2 = collision.getObject("circle_1");
//nero_log(_sn(object_1));
//nero_log(_sn(object_2));
}
//If I disabled the collision here, the method (handleCollisionContactEnd) will never be called
//collision.setEnabled(false);
}
void handleCollisionContactEnd(nero::Collision collision)
{
//this method is your last change to process a collision
}
};
int main()
{
nero::DevEngine engine;
engine.addScene<MyScene>("My Scene");
engine.run();
}
-
How to code with the engine Part 1-7 : Build a simple player
Hi everyone, hope you are doing great. Let's continue with the series.
In this post I will show how to use an ActionObject and some Actions in order the build a simple player
Step 0 : Include the Nero GameLib header
#include <NERO/gamelib.h>
Step 1 : Create the player object
The first step is to create the object that will be your player using the Dev_Engine_Interface. For this example we can take a simple cube or circle to be the player. So let's create a Physic_Object (Polygon Mesh) with the name "my_player" and the category "player"
step 2 : Use an ActionOject to represent the Player
nero::PhysicActionObject my_Player;
my_Player.setObject(m_ObjectManager.findObject("my_player"));
In the Howto on Moving Objects and Platforms, we used a Custom PhysicActionObject called SimpleMovingObject. The SimpleMovingObject inherit from PhysicActionObject in order to build a more complex interface. But as you can see the default interface of the PhysicActionObject is enough for certain cases. There are many ways to use ActionObject and Action, and for this tutorial we are using the most basic one.
step 3 : Give the player defferent capabilities
Let's say we want our player to be able to move right and left. we also want it to be able to jump.
float move_velocity = 100.f
float jump_force = 150.f
my_Player.registerAction<MoveAction>("move_left", nero::getMoveLeftAction(move_velocity));
my_Player.registerAction<MoveAction>("move_right", nero::getMoveRightAction(move_velocity));
my_PLayer.registerAction<JumpAction>("jump", nero::getJumpAction(jump_force));
In the code above we've registered three Actions, the player can then perform those actions when ever it want.
void handleKeyboardInput(const sf::Keyboard::Key& key, const bool& isPressed)
{
if(isPressed)
{
switch(key)
{
case sf::Keyboard::J:
{
my_PLayer.callAction("jump");
}break;
}
}
}
If you want to see how Actions are built, click on the spoiler button.
the JumpAction class looks like this
class JumpAction : public PhysicAction
{
public:
float force = 0.f;
void call(PhysicObject::Ptr object, sf::Time time_step);
};
void JumpAction::call(PhysicObject::Ptr object, sf::Time time_step)
{
object->applyForce(sf::Vector2f(0, force), object->getWorldCenter(), true);
}
the getJumpAction() method looks like this
JumpAction getJumpAction(float force)
{
JumpAction action;
action.force = -force * SCALE; // SCALE = 30
return action;
}
Step 4 : Make the camera follow your player
The nero::Scene offers a method called setCameratTarget, that you can used to make the camera follow any Physic_Object.
auto player_object = m_ObjectManager.findObject("my_player"); //retrieve the object to follow
auto target = nero::PhysicObject::Cast(player_object); // cast the object to a Physic_Object
setCameraTarget(target); // set the target
It's possible to disable and enable this feature at any moment with the following method
setCameraFollowTarget(bool flag);
This post showed how ActionObject and Action could be used to create a simple player, for a complet example you can check the code in the Kero project.
-
How to code with the engine Part 1-8 : Anatomy of the Kero Scene
Hi everyone, how are you doing ;D. I thought to change this post title, but I finally kept it.
A litte story
There is the story of the Kero scene
once upon a time, there was a little cube with the power to move left and right. After a long long run, the little cube find a blue arrow. The arrow was moving up and down. Intrigued by this arrow the little cube decided to touch it, when it did, some thing amazing happened, the little cube get the power to jump. With its new power the little cube continue its aventure, it later found a moving platform, that was a great opportunity to test its new power, It jumped on the platform which carried it to the beginning of a new aventure.
http://www.youtube.com/watch?v=jXtW74kPTIA
Build a game with the Nero Game Engine
As you may have seen with the Kero Scene, there are basically two parts when developing a game with the Engine. I called them the Game Scene part and the Game Code part.
The game scene is built with the Dev Engine Interface, the game scene can be modified at any time without the need rewrite the code. That is great if you want to tweak the position or the shape of an object. Modifing the Game Scene also don't required to recompile your game program, and since the scene is represented as a simple json file, it's easy to share. If you think you are not good at Scene disign just ask a friend to build the scene for you and send you the json file (and also the sprites, ya don't forget them ).
The game code is where the logic is built. In the game code you can retrieve the objects created in the game scene and manage collisions and events. The modification of the game code require the recompilation of the game program. With this series you get a look at the engine API. The API is pretty generic and does not target a game genre. If you like a specific game genre you can build your own API on top of the engine one like I did with the Nero Game Lib. I'm a fan of plaftormers so the Nero Game Lib will focus only on the platformer genre.
Learn more and continue the development
The part 2 of the series is put in stand by. I won't have time to work on that in the following months. In place of that I will focus my time on learning game engine architecture and continue the development of the Engine (I will be working on Sound and Animation objects).
I'm pretty happy with the current state of the project considering that I taught my self C++ programming, SFML and game programming. I'm not a game engine expert, I came to that stage of the project using my intuition and determination. But I think it's time to learn some key notions on engine development. I came accross that book Game Engine Architecture of Jason gregory and found it pretty amazing. I will gather many others books and learn a lot in order to produce the best engine I can.
Thanks for reading my posts, and see you later ;D.
-
Hi everyone ! it's been a long time since my last post. Hope you are doing well :).
A new logo design
Here is the new design I made for the logo. Let me know what you think.
(http://i.pinimg.com/originals/70/2e/95/702e95afbb92820e8226cba51449aa42.png)
TexturePacker
Do you know TexturePacker from CodeAndWeb. It's a tool that easy the creation of Sprite Sheet. If you have a bunch of PNG files by example, you can import them in TexturePacker and it will "pack" them into one single PNG file. The geat thing, it's that it also provide you a JSON file (not only, there are other formats) describing the Sheet, so the Sprite Sheet can be easily "decoded" by a game engine.
As I mention in my last post I'm currently working on Animation. Before I started implementing anything I searched over the internet if I could find a tool that will simplify the creation of animation. That lead me to TexturePacker.
TexturePacker will be integrated in my Engine workflow. I will talk more about that when the integration with the engine it's done. For now you can learn more about TexturePacker here (https://www.codeandweb.com/texturepacker).
Development Progress
The development of the Engine progress very slowly these days since I don't have munch time to work on it. But with a little chance things can change in the upcoming months.
have a good day ;D
-
Hi everyone !, I'm back, how do you do ?
During the last two weeks I got a lot of free time, so I worked on the Engine. The Engine has evolved, I added some new features and fixed some bugs. I've made a review of the features that will be availabled in the Engine first version. The first version will be ready by the end on this year. The integration of Lua as a scripting language will take a lot of time, so for the first version there will only be a very minimalist integration of Lua. C++ will be the main language to use the Engine. Finally I plan to open a website early next year, maybe on Junuary.
that's said, Let's jump on the new features !!!
Startup Screen
The DevEngine now has a Startup Screen or a Loading Screen if you prefer. The Engine just use two threads on startup. While the main thread render the Loading Screen, a second thread load Resources and build the Engine_UI in background.
http://www.youtube.com/watch?v=tshPLzr8JN8
Custom Startup Screen
While the DevEngine has a fix Startup Screen, the RenderEngine can take a custom Startup Screen. That allows you to create your own game loading screen. In order to create a Startup Screen you simply have to create a class that henerite from nero::StartupScreen
class StartupScreen
{
public:
StartupScreen();
virtual ~StartupScreen();
virtual void handleEvent(sf::Event& event) = 0;
virtual void update(const sf::Time& timeStep) = 0;
virtual void render() = 0;
virtual const sf::Color getBackgroundColor() const = 0;
virtual const float getMinTime() const = 0;
protected:
sf::RenderWindow* m_RenderWindow;
};
All the methods in the class are virtual pure; you have to override all of them.
the getBackgroundColor() method return a color to clear the sf::RenderWindow;
the getMintime() method return a time in second. It allows you to choose if the LoadingScreen should last in 5 second or 10 second or whatever you want.
the Custom Startup Screen is given to the RenderEngine via it's constructor.
MyStartupScreen myStartupScreen;
nero::RenderEgine engine(myStartupScreen);
engine.setScene<MyScene>("my scene name");
engine.run();
Sound and Music
The Engine can now load and manage Sound and Music. Like other resources the loading is automatic. Just copy some sounds in the folder "/Resource/Sound" and some musics in the folder "/Resource/Music", the Engine will take care the rest. In your Scene class, there is a instance of the class nero::SoundManager. this class let you play a sound or a music at any time in your game.
The DevEngine allows to quickly access all your Musics and Sounds, so you can enjoy them while building a Scene.
http://www.youtube.com/watch?v=2NmvLW6bSaY
Configuration Files
In order to make the Engine more flexible, many hard coded properties are now made evailable as configurations. Configuration files are JSON files, they are all located in the folder "/config"
As a example, for each resource type (Texture, Sound, Music etc), you can now choose the folder where to put them, you can also choose the extensions you want to handle.
For Fonts, you can choose what Font to use as default.
{
"font" :
{
"folder" : "Resource/Font",
"extension" : ["ttf"],
"default" : "Sansation"
},
"sound" :
{
"folder" : "Resource/Sound",
"extension" : ["wav", "ogg", "flac"]
},
"music" :
{
"folder" : "Resource/music",
"extension" : ["wav", "ogg", "flac"]
},
"texture" :
{
"folder" : "Resource/Texture",
"extension" : ["png", "jpg", "bmp", "dds", "tga", "psd"],
"separator" : "-"
},
"shader" :
{
"folder" : "Resource/Shader",
"shader-list" : "Resource/Shader/shader.json",
"extension" : ["vert", "frag"]
},
"animation" :
{
"folder" : "Resource/Animation",
"extension" : ["png", "jpg"]
},
"script" :
{
"folder" : "Resource/Script",
"extension" : ["lua"]
}
}
Bug fixed : RenderCanvas glitch
In the version of the Engine provided with the SDK (Startup Kit), there is a glitch on the Canvas when you remove a Layer or when the Redo and Undo buttons are used. It tooks me some time to find the reason of this glitch, but it's now fixed.
that's all for this post, There are other new features like Animation and Grid, they are still in development, I will talk about them another day.
thanks for reading my posts and see you later :).
-
Hi everyone !, hope you are doing greet ;D. Today let's talk about Animation.
Animation Tools
In order to simplify Animations management the Nero Engine relies on other tools. Texture Packer and ShoeBox.
Texture packer
I've already talked about this one. It's a tool that let you pack several images in one Spritesheet.
When you use Texture Packer to pack your animation, you obtain two files. A image file (.png, .jpeg, etc) and a Json file. The Nero Engine relies on this two files to generate animations.
ShoeBox
What is ShoeBox ? ShoeBox also allows to pack image files. But the great thing is that it also allows to Unpack Spritesheets. When you search for animations over the internet, most of the time you will find some animation SpriteSheets. And there come a question : The animation is already packed, how am I going to use it in Texture packer ?. Well, ShoeBox can unpack SpriteSeets, it can also unpack GIF images. Yep, If you have an animation in GiF format, you can unpack it using an online service or with ShoeBox.
ShoeBox is free, you can find it here. (https://renderhjs.net/shoebox/)
Load Animation
When you obtain the two files generated by Texture Packer, you simply have to copy and paste them in the "/Resource/Animation" directory. The rest is automatic, the Engine read your files and build the Animations.
In the picture bellow, you can see that each animation is made of one PNG file and one JSON file. Both files must have the same name.
(https://i.pinimg.com/originals/56/a9/60/56a960914b3c3fbec6e893600487f772.png)
Animation Object
On the left of the Engine Interface, There is now an Animation Tab. All loaded animations can be founded there. Animations work like Sprites. If you put the mouse over an Animation_Button you can see a Preview.
If you click on a Animation_Button you add a Animation_Object onto the Canvas.
Animations are like any other Object, you can move them arround, Rotate them, Scale them, Duplication them etc.
Like Sprite, you can change the Color of your Animation, simply select the Animation Object and process like if it was a Sprite Object.
A Layer of Animations appears with a Yellow color, this is temporary I will review all the Colors for Layer's types
Animations and Physics
Again the process is the same as for Sprite_Object. Hold CRTL and Click on a Animation_Button to add a Animation_Meshed_Object onto the Canvas. When a Animation_Meshed_Object is selected you can go to the Mesh Tab and change the properties of its Mesh Object. When you build your Scene by clicking on the "Return key" or the "Play Button" the Animation_Meshed_Object becomes a Animation_Solid_Object.
A Layer of Animation_Meshed_Object appears with a Light Blue color, this is a temporary color;
Animation Sequences
An Animation is made of Sequences. Each animation has at least one sequence. If the Animation concerns a character we usally have something like ("idle", "walk", "run", "jump"). If the Animation concerns a simple background object like flowers or animals you simply have one sequence.
When you add an Animation Object onto the canvas, the Animation has it's default sequence selected. In order to do that, the Engine need to know the name of the default sequence. For a character the default sequence is the "idle" sequence. But for a none character animation is it called "idle" ? I had three choices : "idle", "default", "The name of the animation". I took the last one.
If you have an Animation called "player" and the following seqences ("idle", "walk", "run", "jump"), the Engine will expect you to name your sequences as followed
("player", "walk", "run", "jump").
If you have a Animation called "flower" whith one sequence, the engine will expect that sequence to be called "flower".
The Sequence Tab
Alongside with the Sprite, Animation and other Tabs, you now have the Sequence Tab. By default this Tab is empty, but when you select an Animation Object, the Sequence Tab shows all the Sequences available for the selected Animation Object.
From this tab you can configure the frame rate of each sequence. the value is in hertz (inverse of second). If you choose of frame rate of "10", it means "1/10 second";
(https://i.pinimg.com/564x/6c/5d/0e/6c5d0ed3b6e48415999d6f73d67680f0.jpg)
Animation is not Just Animation
You can see a nero::AnimationObject like a nero::SpriteObject that have the power to change is internal Sprite whenever it want. Imagine you have a breakable object in your game. That object will have several state ("healthy", "half break", "break"). This is not a animation, but it can be represented whith a Animation Object.
In order to say to a Animation to stop being a animation, you simply have to tell him to never update itself
animation_object->setUpdateable(false);
After that you have the power to controle the animation manually.
animation_object->setFrame(0) // by default the object is healthy
animation_object->setFrame(1) //the object has been half broken, let go to the second frame
animation_object->setFrame(2) //the object has been complety broken let go to the last frame
that's all for Animation, I will make a post later today in order to present other new features.
Here is a video that shows how Animation looks like
http://www.youtube.com/watch?v=My_IQXcQ1Dw
-
Hi again ! Now the Engine have Animations (see the post above), but that's not all. In this post I will show all the new features I've been working on
Merge Layer
It is now possible to merge two layers. The only condition is that, they have to be of the same type (the same color).
On the Right of the Engine there are two new buttons: "Merge UP" and "Merge Down".
When you merge up by example, the content of the currently selected layer is taken and added to the layer above.
(https://i.pinimg.com/originals/5b/3c/87/5b3c87b7318c8fa5880f7480ab28eb75.png)
The Axis icon
On the bottom left of the Canvas there is now a Icon that shows the direction of the X and Y axis. I saw this in Blender so I thought it would be cool to have one in the Engine 8). The Icon rotate when the Camera rotate. You can hide it if you want, just uncheck the "Axis" check box on the Right of the Engine Interface.
(https://i.pinimg.com/originals/dc/08/33/dc0833412f949568e050f16b724ff60e.png)
Scale preview with Mouse Wheel
When the mouse is over a Sprite_Button or a Animation_Button, you can now scale the preview with the Mouse Wheel. Previously the Divide_Key and Multiply_Key were used, but using the Mouse Wheel is more fun :).
Mesh Edition, Axe aligned movement
Mesh edition can be tough sometimes. In certain cases you want to move a vertex, only vertically or only horizontally but your mouse just doesn't want to let you do that. Now you don't have to be an expert at moving the mouse to do what you want. I made a little change in the algorithm. When moving a vertex, a line or an entire mesh, if your movement is more vertical than horizontal the Engine will assume that your movement is only vertical.
Example : we have a vertex at (1, 1). we apply a movement of (2, 4). the result should be (1+2, 1+4) = (2, 5).
but now the engine say, abs(4) > abs(2) so lets apply a movement of (0, 4) instead, the movement is nullify on the x Axis.
The Canvas Grid
This feature is still in development. By default the Grid is Hidden, you can make it visible by checking the "Grid" check box on the Right of the Engine.
What I am trying to do here is a "Infinite" Grid. When the Grid is Axe aligned there is no problem to simulate an "Infinite" Grid, you can move the Camera vertically or horizontally as you want, the Grid will adapt itself. But When the Grid is rotated, it becomes difficult to simulate "Infinity".
For now I am just playing with this feature I don't know exactly what it will be.
http://www.youtube.com/watch?v=oUJv06mcuLc
Lua Script
The integration of Lua in the Engine is beginning slowly. Each nero::Scene now have a instance of a "Lua State" called "L". All the Lua standard libraries are loaded by default. If you have some experience with Lua and C++ you can already begin to call your scripts in your nero::Scene Class.
Github updated
The Github repository (https://github.com/NeroGames/Nero-Game-Engine) have been updated. we are now at the version 0.8.0 . The code is not stable, I will have to review the code to make sure every is right. When it's done I will publish a new version of the SDK with all the new features. If you like the project don't forget to give a start to the project on Github
That's all for now. thank you for reading my posts and see you later.
-
The Nero Adventure Scene
Hi everyone, how do you do.
In order to complet the Engine and reach the first version, I needed to work on a concrete Game Scene. So I took the code of my game prototype and begin to update it. I gave up on the name "Kero", it's now call the "Nero Adventure Scene". The artwork I'am using is from the Open Pixel Project (http://www.openpixelproject.com) and the Kenney Asset Store (http://www.kenney.nl).
The Scene will be composed of 5 parts:
1- A Startup Screen (display when the Render Engine start)
2- A Game Menu Screen
3- A Game Scene (the actual game)
4- A Pause Screen
5- A Credit Screen (display when you finish the game)
The idea is to cover most of the Engine features. The code develop in this game will be added in the "Nero Game Lib" library.
Here is a first look of the main character
http://www.youtube.com/watch?v=-ezBUcU_hyM
-
Hi everyone !. Hope your are doing great. ;D
I made a lot of progress on the Engine development, I had not enough time to write a post, so there will be a lot to say.
Text Object
New object types have been added in the Engine. Let's begin by the Text Object.
On the left of the Engine Interface, along with the Sprite Tab, there is a new Tab named Text. From this Tab you can create some Text Objects and edit their properties.
Like other object types, a Text_Object can be moved, rotated, scaled, duplicated etc.
When a Text Object is selected you can change its font, its font size (character size), its outline thickness and its style (bold, italic, underline, linethrough).
From the Color_Tab you can change the text color but also the text outline color.
I'm currently using SFML 2.4.1, in the latest versions of SFML, there are two other text properties : Latter Spacing and Line Spacing. I will add those properties when I update SFML.
Write a New Line.
In order to return to the line when writting the text of your Text Object, you must insert a special character. By default it is the pipe ( | ) character. You can choose the character you want my modifying the configuration file config/engine_config.json. The property is named carriage_return
It's more easy to explain with a video. So here is one.
http://www.youtube.com/watch?v=AQNqCKycXhc
Re-order Object
There are now two buttons allowing to move a Object Up or Down in the current Layer.
(https://i.pinimg.com/originals/3e/a3/76/3ea37664544b04be9e5b7fe4ca4f17eb.png)
Default file/directory generation
In a previous post, I said the Engine need some directories and files to be available in order to work properly. For example we have the resource directory and all its sub directories, the log configuration file, the Sansation font, and some new config files I added recently.
From now on the Engine will generate those files and directories automatically on startup if they do not exist.
There are many configuration files in the config directory, If you made some changes on them and want to revert the changes, just delete them, the engine will bring them back.
The Log View
Bellow the Engine Canvas you got the Log View. It is now possible to log in this area from a nero::Scene. Each nero::Scene now provide a function void log(std::string message) that print its message in the Log view. This function internally call the nero_log(message) function, so the message will be also print in the console.
If you create a new class and want to log from this class to the Log View it's pretty easy. The log function is store in a std::function<void(string)>, you can retrieve it with the nero::Scene function getLog() and give it to your class;
myNewClass.setLog( getLog() );
FrameRate and FrameTime
From a nero::Scene it is now possible to retrieve the FrameRate and FrameTime with float getFrameRate() and float getFrameTime().
- The frame rate is the number frame in one second.
- The frame time is the duration of one frame in seconds.
The Engine Interface show its own frameRate and frameTime at the Canvas bottom right. The Engine Interface frameRate is not the actual Game frameRate. Since the Engine Interface manage more things, the Game frameRate will be higher.
(https://i.pinimg.com/originals/80/a6/9b/80a69bfc86ec77f9a2881e0445a0e4ff.png)
All nero::Scene Attributes Private
All the attributes in a nero::Scene are now private. Attributes will be accessed by some getters and setters.
It's no longer possible to write :
m_ObjectManager->findObject(name)
Now you will have to write :
getObjectManager()->findObject(name)
The objective is to secure the nero::Scene class. If a variable can be modified there will a setter, if a variable can be accessed there will be getter. This offer a more clean interface.
Last active Scene.
If you are working on several Scenes at the same time, you may switch between Scenes many time. From now on, if you close the Engine and restart it, the Engine will remember the last Scene you were working on, and will select it on Startup.
If the Engine is close properly via the Window close button or the Quit button above the Canvas, the Engine will save all your scenes befor to shutdown.
That's all for this post. There are more changes in the Engine, but those will be for another post. Have a good day ! :)
-
Hi everyone, how are you doing ! Let's continous with the Engine Updates.
Fix Game loop
When playing with my Adventure Scene I notices that the game speed was not stable. Sometime the game accelerate, some time it slow down. The default loop speed is 60 FPS. This is a fixed time, so it surprised me to have that issue. But after inspecting the Engine game loop I saw that the rendering was done in the while loop.
while(timeSinceLastUpdate > TIME_PER_FRAME)
{
//retrieve 1/60 second in the accumulated time
timeSinceLastUpdate -= TIME_PER_FRAME;
//1... handle user inputs
handleEvent();
//2... update the game
update(TIME_PER_FRAME);
//3... render the game
render();
}
I put the rendering out of the game loop, now thing work smoothly.
while(timeSinceLastUpdate > TIME_PER_FRAME)
{
//retrieve 1/60 second in the accumulated time
timeSinceLastUpdate -= TIME_PER_FRAME;
//1... handle user inputs
handleEvent();
//2... update the game
update(TIME_PER_FRAME);
}
//3... render the game
render();
The Grid
I now completed the Grid feature. I give up on the idea to build an infinite Grid. Building a grid that update it self when the camera moves is pretty complex and I didn't have time to do it.
The new Grid use a more simple approach. The Grid is made of cells. You can configure the width and the height of cells and choose how many cells you want horizontally and vertically. Finally you can move the entire Grid.
The movement of the Grid is not pixel based. You don't realy move the Grid , it is more accurate to say that you apply an offset to the Grid . Move the Grid is equalent to offset the Grid of one cell. By example if you move the Grid up, the Grid will move of one cell up and the same goes for the other directions.
Also the color of the Grid can be changed from the Color Tab.
Next time I will present the most important new feature that as been added to the Engine : Screens and Screens Stack. The Grid plays an important role for Screens so I needed to present it before.
http://www.youtube.com/watch?v=Gr2NlSX5hQI
-
Hi everyone, how do you do, Hope your are doing great. :)
Twitter account
I opened a Twitter account some days ago, you can follow me and stay update any time on the Engine development.
Twitter - NeroGameEngine (https://twitter.com/nerogameengine).
Scene Screens
Today we are going to talk Screens. This is a new feature in the Engine, I did not plan it for the first version, but I finally thought it would be cool to have it.
What is a Screen ?
First, let's begin by what most people know : Game States. In a Game we generally have several states like : the game levels (each level being a state), the start menu, the pause menu, the options menu and many more. In order to manage all those states people generally develop a Sates and States_Stack system. In this system you can switch between States by pushing or poping them.
Instead of using a State/States_Stack System, the Nero Game Engine will use two differents systems. the Screen System and the World Chunk System. Those two systems combined will offer more power than a simple State System.
Screens are displayed on top of the Game world. They can be used to build game menu but they can also be used as a UI Panel (window) in a menu.
A World Chunk is a part of the Game World that can be load or destroy dynamically (during the game). Therefore One World chunk can represent a game level, but also, One game level can have any number of World chunks. The ability to load and destroy World Chunks dynamically will allows to build very large level. World Chuncks will be added in the second version of Engine.
Add, Delete and Rename Screens
On the top left of the Engine Interface, just after the Utility_Tab, we now have the Screen_Tab. From this tab, we can see all the available Screens, add new Screens, delete Screens or rename Screens.
Each Scene always has at least one Screen, you can delete any Screens but once it left only one Screen, the delete button will have no effect.
(https://i.pinimg.com/originals/e3/b1/82/e3b182922f1ff4675fd5dc4e9bf13dc5.png)
World View and Screen View
By default the Engine start in the World View. In order to access Screens we need to switch to the Screen View. On the right of the Engine Interface there is a button called Screen View. It's a toggle button, when the button is activated we goes in Screen View, when it's desactivated we come back to the World View.
(https://i.pinimg.com/originals/c0/a9/03/c0a90317b60b9c77d6f0c1e2ebcf4025.png)
The current View mode is also displayed on the bottom right of the canvas.
(https://i.pinimg.com/originals/77/65/c6/7765c6b4b32713065406f565cda6b8ba.png)
Just below the Screen View button there is a list that allows to select a Screen.
(https://i.pinimg.com/564x/1e/60/48/1e60487f881e891b08a04c1ebc5b0848.jpg)
Build Screens
When a Screen is selected we can start building it. Each Screen has its own Canvas color, its own Grid, its own Camera, its own layers. Basically everything you do when a Screen is selected will affect only that Screen. Each Screen maintains its own Undos and Redos
Not all types of Objects can be added to a Screen. There is no Physics in a Screen, Therefore it's not possible to add Mesh_Objects, Meshed_Objects (Sprite with Mesh) and Animation_Meshed_Objects (Animation with Mesh) In Screens.
We can only add Sprite_Objects, Animation_Objects, Text_Objects and Button_Objects.
Button_Object is a new type of Object that can be add on Screens but not in the Game World, I will present it in my next post.
Screen and Grid
In my last post, I said that the Grid was important for Screens, it's time to know why. Screens are rendered on top of the Game World and they are not affected by the Camera movement. Therefore in order to be visible a Screen must be contained in a strict area. Since the Canvas is infinite it's become easy to be lost. This is were the Grid comes, if you plan to render your game in a 800 x 600 resolution or a 1024 x 800 resolution, you will have to configure a Grid of the same resolution with an offset of (0, 0). The Grid will represent the Screen area and everything in the Grid will be displayed.
That's all for this post, there is more on Screens but that will be for the next post. The video shows the different Screens I built for the Adventure Scene.
http://www.youtube.com/watch?v=yvLu3-_Vy5Q
-
Hi everyone! Hope you are doing great. :)
In this post I will present more stuffs concerning Screens, and review the state of the project.
Screens and Render Engine
While the DevEngine Interface allows to build Screens, the DevEngine is not able to render those Screens. Screens will be rendered only when the Scene is run within the RenderEngine. The reason for that is simply because the Screens are built arround a specific resolution. If you build a Screen with a resolution of 1028 x 800 by example, the Screen will not fit in the DevEngine Canvas.
Push and Drop Screens
The first thing to do when we want to use some Screens is to push them on the Screen_Stack. The methods pushScreen(screen_name) and dropScreen(screen_name) are there to manage the Screen_Stack. The only purpose of the Screen_Stack and those methods is to provide a way to order the rendering of the Screens. Also this allows to use only the Screens you need. You can create 10 Screens from the DevEngine but only push and use 3 of them.
Show and Hide Screens
Push a Screen into the Screen_Stack will not make the Screen visible. Pushing is just a way to order the Screen. Any Screen on the Screen_Stack can be make visible or hidden with the methods showScreen(screen_name) and hideScreen(screen_name).
Hide and Show the Game World
The Screens are rendered on top of the Game World, but if you want to show a Screen but not the World like for a Game Main Menu, it's possible to hide and show the Game World with the methods hideWorld() and showWorld().
Find Objects in a Screen
There are two methods to find Objects in a Screen
- The method findScreenObject(screen_name, object_name) will retrieve any Object that is not a UIObject (Sprite, Animation, Text).
- The method findScreenUIObject(screen_name, ui_object_name) will retrieve only UIObjects (Button);
Button Object
In addition to the Screen System the Engine now has a little UI Management System. On each Screen it's possible to add some nero::UIObject. Currently the only available UIObject is the ButtonObject.
In order to add a ButtonObject just hold the Shift Key and click on a Sprite_Button. In the DevEngine a Button is simply a Sprite, so you can apply any Sprite transformations on it.
In the future it will be possible to create ButtonObject from Animation and Text. And there will be more UIObject like TooggleButton, CheckBox etc.
A ButtonObject offers three callBacks.
button->setOnMouseEnter( [](){ a lambda function here });
button->setOnMouseLeave( [](){ a lambda function here });
button->setOnMouseClick( [](){ a lambda function here });
By default the opacity (color alpha) of the Buttons change when the mouse comes hover them.
Scenes Util methods
the nero::Scene now offers some cool new methods
//Manage the Scene lifetime
pauseScene()
resumeScene()
resetScene()
quiScene()
//Play with the Canvas Color
getCanvasColor();
getScreenCanvasColor(screen_name)
setCanvasColor(sf_color)
//Manage Logs
log(message, level)
logIf(message, condition, level)
std_function getLog();
std_funtion getLogIf();
//Others
isRenderEngine() //Is the Scene running from the DevEngine or the RenderEngine
isScenePause() //Is the Scene in pause state
What Next ?
I updated the Adventure Scene with some Screens. In the following video you can see the Custom Loading Screen of the Scene, and its different Menus. We are now close to the Engine First Version, but the most important thing remains to be done : Build an actual game.
Now that I have the skeleton of the Adventure Scene set up, It's time to comes up with a Game Play. I think it will be the coolest part of the project 8).
http://www.youtube.com/watch?v=HSnR_NJk7qk
-
Engine Update
Hi everyone, how do you do.
Last week I was about to continue working on the Adventure Scene, but something stoped me. I felt that the Engine was missing some key features. So I went to add some features that wasn't in the schedule.
The Scene Renderer
It is now possible to see the final result of your game without leaving the DevEngine. The Engine now has a feature call the Scene Renderer. The Renderer simulates the behavior of the RenderEngine from within the DevEngine.
How to start the Renderer ?
Above the Canvas, along with the buttons Play, Pause etc, there is now a button called Render. Click on this button will launch the Scene Renderer.
Window resolution
From your nero::Scene you can now set the resolution of your game with the method below. This resolution indicates the size of the Window used by the Scene Renderer.
setResolution(1024.f, 600.f);
http://www.youtube.com/watch?v=YIPp3p59t4Q
The Color Picker
The last week I tried ImGUI for the first time, and I was like : ooooooooooooh, waaaaah !!!, this is too too powerfull !!. So I quickly start to learn how it works and decided to integrate its Color Picker in the Engine.
Yeah, now there is a Color Picker 8) . By default the Color Picker is Hidden, but when you go to the Color_Tab it appears automatically.
http://www.youtube.com/watch?v=ofQpwYAZlnY
CodeBlocks Integration
Since the Engine uses CodeBlocks, I thought it would be great if CodeBlocks could generate a sample project for the Engine. So I went to learn the CodeBlocks scripting API, and I created a script that generates a Nero Game Project. Just for info Codeblocks calls that a Wizard, and it uses the Squirrel scripting language.
In the video below you can see the Nero Game Project Wizard in action. There are three types of samples you can generate. The coolest one is called Full Project. When you choose that, you can indicate a Namespace, some Class Names and CodeBlocks will create a complet project to start with.
http://www.youtube.com/watch?v=gvjSmse6y5U
Release of Version 0.9.0
In two or three weeks I will release a new version of the SDK, it will contains all the updates since the last one (version 0.7.1). The Adventure Scene will be included as an example.
That's all for this post. I think it will be my last post for 2018. So see you in 2019. Have a good day :)
-
Nero Game Engine 0.9.0 Released
Hi ! everyone. How do you do. I'm happy to announce the release of the Engine SDK version 0.9.0
You can download it from the website www.nero-games.com (http://nero-games.com/)
I tried to upload it several times, my internet connection failed me. But it succeed in the end ;D.
The Website is still in construction I will work on it on the upcomming weeks and months
Test Scene : The Adventure Scene
In the package there is a Project called Adventure Scene you can use it as a reference. It's a simple game where you have to collect some coins and some stars.
If you've already tried the version 0.7.1 there are many changes. I have commented the code, so it should be easy to understand what is going on.
Tutorials
In the upcomming weeks I will write some new tutorials. I will upload them on the website in a structured manner.
Nero Game Engine version 1.0
The version 1.0 is comming soon. There are basically three things to be done before to reach that release
1- Add some game related features (camera shaking, bullet firing and maybe more)
2- Build a complet game that will serve as a Demo
3- Run a complet test of the Engine. Track bugs and solve everything that can besolved
That's all, hope you'll enjoy the new SDK. Have a good day :D
-
Engine Update
Hi everyone, how do you do ! here is an Engine update :).
Bug fix 1 : Duplicate collisions
If you've tried the Adventure Scene, you might have encountered a bug when collecting coins. Some coins can be collected more than once. That's because when a Physic_Object is removed by the Object_Manager, the Physic_Object is not destroyed directly, instead it is marked as dead and removed only when the Engine thinks the time is right. Now there is a control that prevent dead objects to generate a collision.
Bug fix 2 : Crash at Scene Renderer exit
The Scene Renderer crashes sometime when you exit it. This was due to the way resources are shared between the DevEngine and the Renderer. Now the resources shared as been reduced to the strict minimum and the Renderer will run on its own thread.
Bug fix 3 : Player flickering in Scene Renderer
There was a kind of flickering on the player when it moves in the Scene Renderer. It seems the Engine has some trouble rendering the DevEngine and the Renderer at the same time. Now when the Renderer is launched the DevEngine will stop its rendering (only a gray screen will be visible). The DevEngine rendering will come back automatically when the Renderer is closed. With that change the Scene Renderer now performs with the same quality as the nero::RenderEngine.
Download the Update.
You can download the update with the link below. The download contains a folder named Library. Just copy this folder into your current SDK folder and replace all files. The files that will be replaced are the following
Library/lib/libnero.dll.a
Library/bin/libnero.dll
Library/include/Nero/[all files]
Download Engine Update 0.9.01 (http://nero-games.com/resource/Nero_Engine_Update_v0.9.01.rar)
-
Hi everyone, hope you are doing great ! :)
Engine Update
Bug fix : Physic Objects Center of Mass
In the current version of the Engine, Physic Objects (Box2D bodies) don't have their center of mass at the right place. The bug exists since the early versions of the Engine. I did not bother to solve it until now. It's a good thing to have this bug solved because now it's more easy to play with Box2D Joints.
Physic Objects new methods
With the center of mass bug fixed, it's now possible to retrieve the size and the bounds (AABB) of a Physic Object.
vector2f size = physic_object->getSize();
sf::FloatRect bound = physic_object->getGlobalBounds();
Physic Objects Joints
Here is a feature I did not plan to add in the first version, but after I solved the center of mass bug, I said why not ? ;D
11 Joint Types have been integrated in the Engine API
01- Distance Joint
02- Friction Joint
03- Gear Joint
04- Motor Joint
05- Mouse Joint
06- Prismatic Joint
07- Pulley Joint
08- Revolute Joint
09- Rope Joint
10- Weld Joint
11- Wheel Joint
Create Joints is pretty easy. For each Joint you have a JointProperty object that describes the Joint parameters. The code below shows how to create a Distance Joint between two Objects.
//Retrieve Objects (Physic_Object, Solid_Object or Aniamtion_Solid_Object)
auto object_A = getObjectManager()->findObject("object_a");
auto object_B = getObjectManager()->findObject("object_b");
//Create a Distance Joint
nero::DistanceJointProperty property;
getObjectManager()->createJoint(object_A, object_B, property);
Most of the parameters in a JointProperty depends on of the Joint Type. But all JointProperty has a parameter for the Joint Name.
nero::DistanceJointProperty property;
property.name = "distance_joint_01";
Find Joints
A Joint can be found using its name. The find method return a generic nero::PhysicJoint object. For each Joint Type you have a static Cast() method.
nero::PhysicJoint::Ptr my_joint = getObjectManager()->findJoint("distance_joint_01");
nero::DistanceJoint::Ptr distance_joint = nero::DistanceJoint::Cast(my_joint);
Remove Joints
A Joint can be removed using its name. If the deletion succeed the ObjectManager will return true.
bool removed = getObjectManager()->removeJoint("distance_joint_01");
Release of Version 1.0.0
Seems the time to wrap up the Project and deliver a first version has come. The version 1.0.0 will be released on April the first. Until that I will fix all bugs I can found. Most important I'll need to resit to the desire of adding new features :o :o :o.
Website and Tutorials
I don't have much time to work on the Engine and the Website now. So I'll focus on the Engine and begin to work on the website after the first version is released.
That's all, have a good day ! 8)
-
Hi everyone, hope you are doing great ;D
Nero Game Engine 1.0 released
The Engine first version is now released. The SDK can be downloaded on the Engine Website (https://www.nero-games.com/). It was fun to develop the Engine. There are many features that was planned that did not make their way into the first version, But there are also other that was not planned that endup in the first version. I guess it's how projects work :)
Website & Tutorials
From now on, I will focus on building the Website, I plan to do some videos tutorial and maybe write some articles on game development.
Nero Game Engine 2.0
Developing the Engine was pretty cool, so I plan to continue with a second version more powerfull. The second version will focus on three things
1- Cross platform with focus on Androind, IOS and Nintendo Switch (or its successor);
2- Introduction of Lua as scripting lauguage
3- A more powerfull Editor and more features in a Scene
-
Hi everyone how do you do ! :)
Engine Update 1.0.1
The Update can be donwloaded from the Website download Page (https://www.nero-games.com/download)
The installation is pretty easy. Just copy the content of the Update Folder into The Engine SDK Folder and choose yes when asked to overwrite the files.
**Important : The Update contains a file called Release. This file describes all the changes, please read this file before to install the Update.
This update is mainly a bug fix
When you render a Scene from the Dev_Engine using the [Render_Button] on top of the Canvas, a new Window opens up with a certain size. This size is specified in your Scene with the code below
void MyScene:init()
{
//set the Scene Renderer Window Resolution
setResolution( width, height );
}
The problem ? it does not work :o :P
The Update removes the two methods
//Methods removed.
setResolution( width, height );
getResolution();
The Scene Renderer window Resolution is now manage by a new method
sf::Vector2f MyScene::getSceneResolution()
{
//return the resolution size you want
return sf::Vector2f( width, height );
}
void MyScene:init()
{
//nothing to put here. the configuration of the resolution is no longer done in the init() method
}
Engine API Documentation
The Doxygen documentation is now availabled on the Website Documentation Page (https://nero-games.com/learn/engine-v1/cpp-api/).
This page is accessible via The Dev_Engine using the button [ Engine API ] on the left.
Nero Game Engine 2.0 Github Branch
A new branch as been created on Github for the Engine second version (https://github.com/NeroGames/Nero-Game-Engine). While the development of the second version is not a priority now, its design has already begun. You can stay updated to the progress by checking this branch from time to time.
-
Hello everyone ! :)
Engine Update 1.0.2
The Update can be downloaded from the Website Download Page (https://www.nero-games.com/download)
To install, copy the content of the Update Folder into The Engine SDK Folder and overwrite the current files.
The update replaces the files Library/bin/libnero.dll and Library/lib/libnero.dll.a
List of changes
- Bug: Fix Texture Packer Sprite Sheet Loading.
- Auto save : remove auto save log message.
-
Project Status
Hi everyone ! How do you do. :)
I've been silent for the last few months, I've been really busy. I recently moved to Montréal in order to complete a degree. this took off all my free time. The good thing with that is that I will be following a class on Video Game AI. The class is offered by people from Ubisoft. It's my chance to learn Unreal Engine and Video Game AI.
Nero Game Engine 2
I've made some progress on the Engine new Interface. Here are a few screenshots. The Interface is at a very early stage, but it will evolve quickly.
(https://i.pinimg.com/originals/37/1b/75/371b75de5a14e5d8670119a94723845c.png)
(https://i.pinimg.com/originals/c4/09/a4/c409a44ef4177b2d0031ce550eb5618c.png)
(https://i.pinimg.com/originals/79/05/4b/79054bf9f2c6003aa98b255d2a2fec2c.png)
Engine Forum
The Engine Forum is now open. It's a great place if you want to discuss a particular feature or if you have an issue with the Engine.
[Important]
The default registration link available on the Forum page will not work. I've received many spams since the Forum has been online. Since I don't have a lot of time to manage the Forum and remove spammers, a Registration Form as been made availabled on the Website [link here] (https://nero-games.com/forum-registration/).
(https://i.pinimg.com/originals/c6/74/ed/c674ed42ce8f2f895fd55f30159d3eb5.png)
What will I be working on now ?
I will be working on the Nero Game Engine 2. In my next post, I will probably be talking about the Nero Game Engine 2 key Concepts and its new Resource Manager.
I had planned to make Video Tutorials on Youtube, but that will have to wait the next summer, I don't have a lot of time to record and edit videos and I need to focus on my studies.
That's all for this post, have a good day! 8) 8)
-
Nero Game Engine 2 : Engine Update
Hi everyone, how do you do ? Today I am happy to announce that I started working on a regular basis on the Nero Game Engine 2. In this first update post, I will present the scope of the project and some new features.
The Project
The objective of the project is to build a Professional 2D Game Engine based on SFML. The first release of this new Game Engine will provide the possibility to deploy your Games on Windows, Android, and Steam. The Engine will try to consume all the SFML API and go further. It's a pretty big project, but things will be done one step at a time, little by little. As you already know, a major difference with the first Nero Game Engine will be the new Interface.
(https://i.pinimg.com/originals/58/bc/f9/58bcf96d9fd9b9ecb4c3fccd25ffbfef.png)
A New Approach to C++ Project
Unlike the first version of the Engine, the Nero Game Engine 2 will be available as an Editor like Unreal Engine or Unity. On Windows, you will just have to download and install the Engine like any other software. With this Engine you will be able to choose between three types of projects depending on your skill with each language : C++ only Project, Lua only Project, and C++ & Lua Project.
Here is a question : How do you build your game in C++ if the Engine comes as an Editor? The answer : Shared Library.
With the New Engine, It is now possible to create and compile your C++ Project from the Engine Editor as Unreal Engine does. Each C++ Project is compiled as a Shared Library that is then loaded at runtime.
Choose your Code Editor
The Engine does not have an built-in Code Editor, so you will need an external one. The Engine will support two Editor at launch. Qt Creator and Visual Studio
Right now the Engine is being developed with Qt Creator, so it will be the default Code Editor. The External Code Editor you choose will be seamlessly integrated into the Engine. That means you will be able to open the Code Editor from the Engine Editor.
Let's see the new Engine at work
Create a C++ Project
In the video below, I launch the Engine Editor, after a nice Loading Screen, the Engine new Interface appeared. I then proceed to create a new Workspace called "My Workspace" on my Desktop. I will talk about workspaces in a later post. When the workspace is ready I create a new C++ Project (CPP Project) called "My First Project" in that workspace. When I click on the button "Create", the Engine Generates my project files and Compiles them.
Open my Project
When the compilation is completed the Engine asks me if I want to open the Project, I click on "Open Project", the Qt Creator Code Editor is automatically launched. Since it is the first time I open the project with Qt, it asks me to choose a Kit or Import a build.
Import my Build
The Engine already compiled the project, so you just have to import the build generated during the compilation. Qt creator detects automatically the build done by the Engine, In order to import it, I select " Imported Kit - temporary" then I select "Build (my/desktop/path/My Workspace/my_first_project/Build)", Then I click on configure project.
Start coding
Like in the first version of the Engine, the base Class of your game is the nero::Scene Class. The Engine generates a Scene class base on the name of your project In this case "MyFirstProjectScene";
I go to the render() method, I draw a simple SFML Circle and compile the project. I can compile the project from Qt Creator or the Engine Editor. When compiling from the Engine Editor there is a little Orange and White box on the bottom right indicating the status of the build. When the build is completed I reload the code.
http://www.youtube.com/watch?v=bZYFphPuRBY
What Next?
In my next post, I will talk about Workspaces and Project directory Structure. Also, I will present the Engine new Resource Browser and Resource Manager features. until then have a good day.
-
Nero Game Engine 2 : Engine Update
Hi everyone, how do you do? ;D I have been working on the Engine over the last couple of weeks, I made a lot of progress.
Coding with Visual Studio
Visual Studio is now integrated into the Engine, When you create a new Project, you can choose between Visual Studio and Qt creator for the Code Editor. You can compile the code from Visual Studio or the Engine Editor seamlessly.
http://www.youtube.com/watch?v=LkdOYuehylY
Playing with the new Canvas
I begin transferring the features of the Nero Game Engine 1 to the new Engine and it works perfectly.
http://www.youtube.com/watch?v=jjc6VaoEsLc
Designing the new Scene API
I am currently designing the new Scene API, with the Nero Game Engine 2, I introduce the notion of Game Level, World Chunk, and Scene Factory.
To put things simply, a Game is made of a unique Game World that is divided into Game Levels, each Game Level will be divided into several World Chunks. World chunks are small parts of the World that can be loaded or unloaded during Play Time.
The Scene Factory will be a new feature that allows you to create Game Objects at Play Time. Those Game Objects can then be spawned into the World.
The main challenge with this new API will be on Resource Management. When World chunks are loaded or unloaded the Engine will have to automatically load or unload resources from memory. I am currently thinking of a way to keep track of used and unused resources.
That's all
There are more new features to present, but that will be for another post. have a good day 8) 8)
-
I haven't checked this thread for quite a while, but looking at the videos, it seems like you've made quite a bit of progress!
The focus is probably still platform / jump'n'run games? It definitely makes sense to keep the scope not too broad, as building flexible engines can be a massive endeavour ;) also nice to see that you thought about compiler integration.
-
I plan to diversify the game genres the Engine is able to handle. What I have in mind is
- Platformer : action, shooting, adventure
- Top Down : RPG, Scroller
- Fighting Game : like Street Fighter
- Card and Board Games
I have been playing with Unreal Engine and Unity lately, I took ideas from them and begin designing a new game development API for the Engine. the new API will make the Engine flexible on the type of game it can handle.
For now I'm focusing more on the Engine core, I believe if I get it right, adding more genre-specific features in the future will be pretty easy.
-
Nero Game Engine 2 : Engine Update
Hi everyone how do you do? ;D
Playing With Light
I have integrated Let There Be Light into the Engine. For now, it is a partial integration. It's possible to add Point Lights into the Game World and Static Physic Objects can block light;
http://www.youtube.com/watch?v=j6DbdY4rg-4
CPU Profiling
The Engine now has a CPU Profiler integrated, the one I've chosen is Easy Profiler(https://github.com/yse/easy_profiler). It is very simple to use and can become very useful if you decide to build a pretty large Game.
http://www.youtube.com/watch?v=JsdsA00efIo
What's Next ?
The next release of the Engine will be the Nero Game Engine 2 . It will be available somewhere during this next summer. Up until now, I was mostly experimenting with new features for the Engine. The code is currently a big mess :o :o. Now that I feel I know what am doing, I have decided on the new features that will be on the next release. The release will focus on the Engine new Interface, a New Scene API, and the Deployment of Games on Android. I had planned some features like Lua Scpriting, Shaders, Particle System, but that will be for the version 1.2.0.
Back to the Website
Now that I am confident with the development of the New Engine, It is time to return to work on the Engine Website (https://nero-games.com). I will continue the tutorial for the Nero Game Engine 1 and maybe write some random articles on game programming.
Until next time, have a good day :D!
-
Hi everyone! how to you do ;D ;D ;D
I have been busy the last couple of months, but I manage to get some time and progress with the Engine
Release of a Demo Version on May
I will release a reduced version of the New Engine around mid-may, Many features currently in development will be disabled for the demo. The core features of the New Engine Editor will be available :), you will able to create projects and code in raw SFML. I will give more details on my next post.
Nero Game Engine 2 : Engine Update
Now let's do a regular update 8)
Introducing the POCO library
I have been looking for a Network Library for a while now. I came across POCO (https://pocoproject.org/) recently and I was amazed by the features it provides. It's a pretty huge library like Boost (https://www.boost.org/). I integrated it into the Engine.
Also, the Engine now use C++17 Experimental. All the Boost libraries that need to be compiled as been removed.
Download Files with the Engine
Thanks to POCO you can now download files with the Engine. I begin building a Network Module for the Engine. The most interesting Class for now is the nero::DownloadManager. It provides two features.
The first feature is to retrieve the size of a file on the internet using a HTTPS request.
The second feature is to download a file on the internet and monitor the download progression.
//get a file size
float bytes = nero::DownloadManager::getFileSize("https/my/file/url");
//the pretty_string method print the size in a readable format like 600 KB, or 8.6 MB etc
nero_log(nero::DownloadManager::getPrettyString(bytes));
nero::DownloadProgression::Ptr progression = nero::DownloadManager::downloadFile("https/my/file/url", "local/path/destination");
while(progression->isDownloading())
{
//print the percentage [0 - 100]
nero_log(progression->getPercentage());
}
A New Logging API
With the introduction of POCO, I removed the Easyloggingpp Library (https://github.com/amrayn/easyloggingpp). The Logger offered by POCO is more flexible and adapted for the Engine needs.
As a user of the Engine, nothing changes for you, the macros nero_log and nero_log_if are still available and work the same.
Background Task Management
The New Engine will be using a lot of threads to perform tasks in the background. The Engine now offers a new class called nero::BackgroundTaskManager or simply nero::BTManager. The class is used like that nero::BTManager::startTask(callable, task_name, task_category), The callable can be a function pointer, a lambda or a class method.
class MyClass
{
void helloWorld(nero::BackgroundTask::Ptr task)
{
task->addMessage("starting project compilation");
//to something
task->addMessage("compilation, completed");
task->setCompleted(true);
}
}
MyClass instance;
nero::BTManager::startTask(MyClass::helloWorld, &instance, "compile_project");
auto my_task = nero::BTManager::findTaskByName("compile_project");
That's all for this post !
There are many other features in development, I will talk more about that during the summer. Here is what the Editor currently looks like. There is now a nice Toolbar, a Menu Bar, the Logging work perfectly. As with the Nero Game Engine 1, you have the mouse position on top of the canvas and the four buttons to change the canvas color 8)
(https://i.pinimg.com/originals/42/6c/93/426c93fcbf081a33e67af6cb9399463e.png)
-
Nero Game Engine d2.0.1 Released
Hi everyone ! how do you do :D, I am happy to announce the release of the Engine Demo version 2.0.1 8)
The Engine is provided with a BSD Licence
You can download it here : https://nero-games.com/download
It's my first time releasing an installable software, if you find any problem please let me known.
The Configuration Wizard
When the Engine starts, it checks that everything is ok before you can use it. When something is not ok the Configuration Wizard will help to configure it.
(https://i.pinimg.com/originals/6a/31/82/6a31829789b0f59dcd98719ba888b0cc.png)
Configure a Code Editor
You can choose between Qt Creator or Visual Studio 2019
Visual Studio 2017 will not work, only the latest versions of Visual Studio 2019 are compatible.
You can download Qt offline with the link provided by the wizard or search "qt online installer" on the internet.
(https://i.pinimg.com/originals/25/c5/ae/25c5ae89b2065879da5d26ed32e6c8f5.png)
Configure Texture Packer
(https://i.pinimg.com/originals/c1/2a/55/c12a55d6b96854a3c850276256739f90.png)
Configure a Workspace
The Engine needs at least one Workspace. If you already have one you can import it, if not, you need to create one.
All inputs are checked against a regex and need to match a certain pattern. For example, the namespace should only have 2 to 10 characters and only use letters (regex = ^[a-zA-Z]{2,10}). I will explain everything in detail later.
Here is an example of input
- Location : use the browse button and select your Desktop
- Workspace Name : My Workspace
- Company Name : Nero Games
- Project Lead : team-lead
- Project Namespace : ng
(https://i.pinimg.com/originals/aa/50/68/aa5068e893728fb6f56ffd65eb43ec2f.png)
-
Hi there, how do you do? ;D
First video tutorial released
I've just released a first video tutorial on the Nero Game Engine 2 Demo, watch it on you Youtube
https://www.youtube.com/channel/UCIR0nDUMGzJ3Pkpa3gDCUeQ
Nero Game Engine 1 SDK Update
I've just released a new version of the Nero Game Engine 1 SDK (r1.0.3). With this new update, you can now change the DevEngine Window size as you want.
The DevEngine has two constructors now
DevEngine(const unsigned int& windowWidth, const unsigned int& windowHeight);
DevEngine(const unsigned int& windowWidth);
With the first one, you specify the width and the height you want, with the second one you only specify the width and the engine will compute the height.
Important
There are a min-width (1305.f) and a min-height(670.f). If you set a value below these ones, the engine will ignore your inputs.
Example
nero::DevEngine engine(1900.f, 1000.f);
//or
nero::DevEngine engine(1900.f);
How to update
You can download the full SDK already updated (Nero Game Engine SDK 1.0.3) or you can download the update only (Engine Update 1.0.3) and copy its content in your current installation
download page here (https://nero-games.com/download/)
What next
Build the website and make tutorials
As of now, I will focus on building the Engine Website and making some youtube tutorials. I'll try to make 2 or 3 tutorials per week.
Engine development
I will slow down with the Engine 2 development in order to focus on tutorials. But just for info, the next thing I'll be working on is the Engine Android Backend. Like Unreal on Unity, the Engine will able to deploy your games on android automatically.
-
Hi everyone how do you do :D
Nero Game Engine 1 SDK Update 1.0.4
I've just released a new version of the Nero Game Engine 1 SDK version r1.0.4
I was working on a video tutorial when I found out that I've made a big, really big mistake with the last Engine Update :o :o :o.
I built the update 1.0.3 on top of the version 1.0.0, by doing so, the Engine lost the updates 1.0.1 and 1.0.2 [software regression ;D]
I just removed the update 1.0.3 from the website.
The first video tutorial should be ready by tomorrow, have a good day 8)
-
Nero Game Engine 1 Tutorial Series
Hi there, how do you do do, I just uploaded the first video tutorial on the Nero Game Engine 1 on Youtube. The next video should be ready by tomorrow.
I will use twitter to announce new videos, so don't forget to follow me here : https://twitter.com/nerogameengine
Have a good day ! ;D
-
Nero Game Engine 1 Tutorial Series - Part 2
Hi, I just uploaded Part 2 of the tutorial series on Youtube, I got busy on Wednesday and couldn't finish it at time ;D
-
Man every version just gets better and better, good job on this, this is really cool.
-
Man every version just gets better and better, good job on this, this is really cool.
Thanks, I really appreciate ;D
-
Nero Game Engine r1.0.5 Released
I was preparing a tutorial on Physics Joints and I found a bug when creating a Wheel Joint. The new release fixes the bug, there are also other changes, some methods have been renamed, others have been added.
Here is the list of all changes:
Release 1.0.5 [Engine Update]
- [Bug Fix]
- in method nero::ObjectManager::createJoint, in the case of wheel-joint, fix property localAxisA
- in method nero::ObjectManager::findChildObject, check if input object is nullptr
- [Enhancement]
- remove "const" qualifier from method nero::Scene::getContext
- rename method nero::Scene::enableFollowTarget to nero::Scene::enableCameraTarget
- rename method nero::Scene::updateTargetOffset to nero::Scene::setCameraTargetOffset
- add new method nero::Scene::getCamera
- rename method nero::Collision::isCollising to nero::Collision::isColliding
- rename method nero::Collision::isObjectCollising to nero::Collision::isObjectColliding
- add new method nero::ObjectManager::getNewJointId
- move method nero::Scene::enableLayer to nero::ObjectManager::enableLayer
- move method nero::Scene::disableLayer to nero::ObjectManager::disableLayer
- rename all joint property maxMotorForce to maxMotorTorque
- rename method nero::Scene::followTarget to nero::Scene::followCameraTarget and make it overridable (virtual void)
Physics Joints Tutorial
I have created a project where I experiment with all Joints. There are 11 Joints in total, So far I have implemented 8 Joints, 3 left to go
You can find the project on GitHub : https://github.com/NeroGames/enginev1-physicjoint (https://github.com/NeroGames/enginev1-physicjoint)
The project shows how to build a car with wheel-joints, how to build an elevator with prismatic-joint and many more ;D
(https://i.pinimg.com/originals/04/6e/5e/046e5e2b5baea63354fd57594bb5cc40.png)
-
Project Update
Hi ! how do you do? I was busy with school for the last few months, I didn't have much time to work on the Engine or the Website. But now I'm baaaack ;D!
- Website
Next week, I'll restart working on tutorials and youtube videos. I hope to finish the tutorials for Engine v1 by the end of January. - Engine v1
I found some bugs in the Engine while working on tutorials, I'll release the SDK v1.0.6 soon with all the fixes :D - Engine v2
The new Engine source code is on Github, From now on, the development will be completely open-source. I'll wait till January to start working regularly on the new Engine. I'll try to work with a bi-monthly (2 months) development cycle.
-
Nero Game Engine SDK v1.0.6 Released
Hi everyone ! How do you do ? ;D Happy new year ;D ;D
The Engine SDK v1.0.6 has been released, you can download it here (https://nero-games.com/download/). I made a few bugs fixes and some improvement
Here are the major changes
1- No more Default_Scene
The Engine/Editor will not create a Default Scene if you add at least one Scene
2- nero::Editor alias
The nero::DevEngine can now be referred as nero::Editor by including the header <Nero/engine/Editor.h>. It's just an alias, both classes are exactly the same.
#include <Nero/engine/Editor.h>
int main()
{
nero::Editor editor(1305);
editor.run();
return 0;
}
3- Linking Glew in the SDK
The SDK now comes with Glew autommtically linked. This allows you to create OpenGL projects without any configuration. If you want to learn OpenGL you can use the Engine SDK to do so.
4- New Info Tab
On the Editor left, along with the tabs Sprite, Animation, etc. there is a new tab called Info that shows the transform of a selected Object
(http://i.pinimg.com/originals/f2/8e/b5/f28eb5ed42f4b754862a4cfceb3a5832.png?epik=dj0yJnU9LXBrZk5kNlp3X2VwSEM1WEJaQTFOSUxtYzFPdTkxdXQmcD0wJm49alctODA1dnFFLTBDVHNDRzFKaDN5USZ0PUFBQUFBR0FWd0E0)
5- Bug : Engine modes and Screen View
In Screen View, switching between the Editor modes (Object, Mesh, Play) was making the Editor crash. To fix that, I added the following rules
- Rule 1 : Activating the Screen View (pressing on Screen_View Button) is only possible when the Editor is in Object Mode.
- Rule 2 : When in Screen View it becomes impossible to change the Editor Mode. Pressing the Spacebar will have no effect. Checking the Checkboxes will be impossible (nothing happens if pressed :P)
Here is the full Releases Notes
Release 1.0.6 [Engine Update]
- [Bug Fix]
- fix crash when changing mode (object to mesh) in screen_view
- fix switching to play_mode with ctrl + spacebar not working
- fix random bomb spawn position does not follow camera
- [Enhancement]
- remove editor default_scene when a scene is added
- add alias nero::Editor for nero::DevEngine
- add editor render_window icon
- link Glew in SDK to allow the creation of openGL projects
- add new finders in nero::ObjectManager (find [Text, Animation, SolidAnimation])
- add InfoTab (display selected object transforms)
- prevent mode switching in screen_view
- screen_view activation only work in object_mode
- add doxygen documentation generation in CMakelists.txt
- add Doxygen and Graphviz (dot) binaries in SDK
-
Build a Multiplayer Game Server for the Engine
Yes, it's decided, the Nero Game Engine 2 will support online multiplayer games at launch 8). I've spent the last couple of weeks doing researches on how to create multiplayer games. I found this GitHub repo https://github.com/MFatihMAR/Game-Networking-Resources, super awesome, it contains many articles on how popular games like Doom and Quake multiplayer work. I also discovered Glenn Fiedler, a guy who worked on multiple video game network modules (like God of War ). His website https://gafferongames.com/ has lots of cool articles and he has also created his own multiplayer library called Yojimbo.
The difficult part
Since the Engine uses Box2D for physics, the most difficult issue will be to sync all clients with the server so they can have the same exact physic simulation. In a series of articles, https://gafferongames.com/post/introduction_to_networked_physics/ Glenn Fiedler presents three techniques.
- Deterministic Lockstep
- Snapshot Interpolation (with Linear or Hermite Interpolation and Snapshot Compression)
- State Synchronization
What I decided for now
- Architecture: client/server with authoritative or semi-authoritative server
- Number of players: 4 players. (MMORPG won't be for now, but you never know :D)
- Sync Technique: State Synchronization
Choosing a library
I found multiple C++ libraries specialized in multiplayer gaming, the three that attract me the most are the following in order of preference. I will evaluate them and choose one.
- GameNetworkingSockets from Valve
- Yojimbo from Glenn Fiedler
- ENet
If any of you has experience with multiplayer programming let me know any advice is welcome :D
-
Changing the Engine website name
The Engine website will be down for a few moments, I'm changing the domain name from https://nero-game.com to https://nero-games.com. Just added an "s" at the end :D
The old domain https://nero-game.com is still available and will redirect automatically to the new one.
-
Update 1 : Changing the Engine website name
The website is now running on the new domain name https://nero-games.com.
There are many broken links, they will be fixed during the next 24h. I'll do another update to inform you
The old domain name will remain active for a year or two before it gets discarded.
-
Update 2 : Changing the Engine website name
All broken links should be fixed now :).
I added an additional domain name for fun, you can access the website at https://nerogameengine.com
-
Project Update
Hi, how do you do :), the summer is here, I'm back working on the engine regularly.
Latest Progess
Below you can see an overview of the Engine Editor Architecture. I'm currently working on the following : Level Builder, Screen Builder and Startup Screen Builder. The goal is to transfer and improve the features of the Engine v1 to the new engine and make a release in about two months.
I work directly on GitHub now, the latest code is on the branch engine/v2 (https://github.com/NeroGames/Nero-Game-Engine/tree/engine/v2).
(https://i.pinimg.com/originals/87/39/19/8739199be2e5b5328e65e059f1644515.jpg)
Coding Level
The Engine will offer three (3) levels of coding.
- The first level is your Scene class (like in the Engine first version).
- The second level is your Levels and Screens classes. Each time you create a new level or screen a new class will be created
- The third level is a Game Script. A game script can be created and attached to any object like a component. Several Game scripts can be added to the same Game Object
(https://i.pinimg.com/originals/6f/6f/56/6f6f565a97e947e5e7b8df4e4d5cfa5c.jpg)
(https://i.pinimg.com/originals/a3/e9/e6/a3e9e688dc4cb4ac91dc66fe86283c93.jpg)
What's next
In my next post, I'll present in detail the Engine Game Level and Game Level Builder features. Have a good day.
-
Hi Sk Landry,
I read through the Thread and it's awesome what progress you made. This is a really cool project. I want to try it out. Can you tell if and when a Linux version will be available?
Best,
Seim.
-
Hi Seim2k,
Right now I'm focusing on Windows only, between coding and running the website I don't have much time left to work on other platforms.
Maybe after I release the first version I'll compile it for Linux.
-
Hi Sk Landry,
thanks for the info. I'm looking forward to it and pherhaps i'll try it in Windows.
Best and keep on ! You do a great job!
Seim.
-
Nero Game Engine v2 Update : Game Levels (Part 1)
Create Game level
It is now possible to create Game Levels with the Engine. On the top right of the Canvas, there is a button "New Level", when you click on it a popup will open up and let you create a new level. The Level View at the button shows you the list of existing levels.
(https://nero-games.com/resource/artwork/sfml_forum/26june2021/create_game_level.png)
Game Level Directory
When a new level is created, a new directory is also created under "Project Folder/Scene/level/level_name". The directory contains all the data relative to the level : game assets, settings, etc.
(https://nero-games.com/resource/artwork/sfml_forum/26june2021/level_directory.jpg)
Game Level Class
The Engine generates automatically a new class for each level under "Project Folder/Source/Project Name/cpp/level/".
////////////////////////////////////////////////////////////
// Project One
/////////////////////////////////////////////////////////////
#ifndef GATEONEGAMELEVEL_H
#define GATEONEGAMELEVEL_H
///////////////////////////HEADERS///////////////////////////
//Nero
#include <Nero/core/cpp/scene/GameLevel.h>
//Boost
#include <boost/dll/alias.hpp>
/////////////////////////////////////////////////////////////
namespace ng
{
class GateOneGameLevel : public nero::GameLevel
{
public: //Utility
typedef std::shared_ptr<GateOneGameLevel> Ptr;
public: //Factory
static nero::GameLevel::Ptr createGateOneGameLevel(nero::GameLevel::Context context) noexcept;
public: //Scene core
GateOneGameLevel(nero::GameLevel::Context context);
virtual ~GateOneGameLevel() override;
virtual void init() override;
virtual void handleEvent(const sf::Event& event) override;
virtual void update(const sf::Time& timeStep) override;
virtual void render() override;
};
//Class export
BOOST_DLL_ALIAS(ng::GateOneGameLevel::createGateOneGameLevel, createGateOneGameLevel)
}
#endif // GATEONEGAMELEVEL_H
What's next
In my next post we'll talk about managing Game Level assets and World Chunks
-
Nero Game Engine v2 Update : Game Levels (part 2)
Hi everyone!, how do you do :)
Managing Game Levels
The Engine Editor loads one Game Level at a time, which means it is possible to "Open" and "Close" a Level.
When a Level is opened, it will appear in full orange background in the Level List view (image below, the second level "Gate of Fate" is the one currently opened). Also, the name of the opened Level appears on the bottom left of the canvas.
You can open and close levels manually with the buttons on top of the Levels list view. First, you have to select the level you want by simply clicking on it. Selected Levels have an Orange border. (image below, the third Level "End Gate" is currently selected).
(https://i.pinimg.com/originals/fe/69/75/fe6975e3a37b0b30c62921ba168c5070.jpg)
Game Level Resources
Once a Game Level is opened you can access its resources (sprites, fonts, etc). Each Level manages its own resources. The Resource Browser Tab (image below) only show the resources of the currently opened Level
Each time you import resources (sprites, fonts etc.) They get copied in the level resource directory at Project-Name/Scene/level/Level-Name/resource
(https://i.pinimg.com/originals/d9/6c/f1/d96cf12f25ad18c13f52b23534049f68.jpg)
What's Next
It is time to start building Game Levels, Next time the Engine will be able to build levels, save them and restore them when the Editor restart.
Have a good day 8).
-
Nero Game Engine v2 Update : Game Levels (part 3)
Hi everyone! How do you do ;D?
Building the Game World
It's now possible to add objects into Game Levels and build your Game World. Saving and Loading Levels work fine 8)
The video below shows the full process from creating a new project, adding game levels, and editing the game world
http://www.youtube.com/watch?v=AEtaAviZ7K8
What's next
I'll continue transferring all the features of the First Engine and work on the Editor Interface (Explorer, Edit object properties, etc.)
Current RoadMap
In order to reach the next release, I'll have to complete the following features
- Building the Game World : Implement all the features of the First Engine regarding the creation of Game World (mostly a lot of work on the Editor Interface)
- Playing the Game : Make Game Levels playable inside the Editor in real-time like with the First Engine
- Releasing the Game : Make the Editor generate your final game package with one click :)
That's all have a good day !
-
Nero Game Engine v2 Update : Explorer View
Hi everyone how do you do ?
The development of the Engine is progressing very well, I had to rewrite the Mesh Class, took me more time than expected :).
Scene Graph
At the top of the Explorer view, you now have the Scenegraph. You can use it to browse through all the objects inside the current level.
(https://i.pinimg.com/originals/c6/23/de/c623de2e814bda7175003125df3267a5.jpg)
Game Object Properties
At the bottom of the Explorer view, you can edit the properties of the selected object. I'm still working on this one 8).
(https://i.pinimg.com/originals/46/3f/ab/463fabc44fdff54e09cccd208260441d.jpg)
Demo video
http://www.youtube.com/watch?v=p7Ra4oOYzP8
What's next
It's time to bring back the Mesh Editor, when that's done I'll bring back all game object types : Sprite, Animation, Mesh, Text, Light etc.
-
Project Status
Hi, how do you do ! I disappeared for a few months :o. I was busy with school, it was my last semester, had to work on a project and write a lengthy report :o :o. I'll be back on soon 8).
Happy holidays !
(https://nero-games.com/resource/artwork/sfml_forum/17december2021/nero_games_2022.png)
-
I haven't followed Nero up for a while, but there's some really nice progress!
Are you still using ImGUI for the UI? Are you happy with it, and the concept of immediate-mode GUIs in general? :)
-
I'm still using ImGUI, The great thing about it, is how easy it let you update the UI, you can remove or add any part of UI at each Frame. This is good for applications where selecting or removing an object updates the UI.
The downside is that it isn't very intuitive, sometimes you don't know where to place items like popups and windows inside your code.
The best UI system would be a traditional UI like (SFGUI and QT) that provide some ImGUI widgets. This way you build your UI traditionally and if part of your UI needs to be updated regularly you use ImGUI just for this part.
-
Project Status
Hi everyone, Happy new year.
After a long break, I'm happy to announce that the development of the Nero Game Engine v2.0 as resumed, you will be getting regular updates as usual :D
(https://i.pinimg.com/564x/3b/ef/3f/3bef3f01b0e956df5065559d9b43416d.jpg)
Engine Update
Here are the latest Engine updates
# Editor Views
Up until now, all the Editor UI was contains in a single class EditorUI. This approach made it easy to start with ImGUI. But as the Editor grew, it became difficult to manage.
During the past couple of months, I worked to split the UI into multiple small views. And there we got it, All Popups and Windows have been moved into their own class. As of now the Editor is divided into 46 different views, took a long time to create all those classes ::) :o :o
(https://i.pinimg.com/564x/53/6a/08/536a0876055c28416d881fdfd9c43e51.jpg)
# Notifications
The Editor is now able to provide notifications after completing certain task. The notifications appear in the bottom right corner of the Editor. By default, each notification last 3 seconds.
(https://i.pinimg.com/564x/19/83/f9/1983f9244264aee80e27a3f6b71a3ee8.jpg)
Right now, the Editor will notify you when it finishes reloading your game DLLs or when it Auto Save your project.
The Notification API is pretty simple to use, here is some code.
// Default 3 seconds notification timeout
m_EditorContext->getNotificationManager()->notify("A Notification");
// Custom 10 seconds timeout
float timeOut = 10.f
m_EditorContext->getNotificationManager()->notify("A Notification", timeOut);
(https://i.pinimg.com/originals/39/4f/f5/394ff566ed56e2933cdf5b010b2e0b9b.gif)
# Create, Compile and Play your Game Level.
Each time you create a new Game Level, a new C++ class will be generated for that level. The Engine Editor is now able to compile, reload and play your Game Level class. A full demo of this will be done in another post.
The button to create a new game level is now located on the Toolbar, right side.
(https://i.pinimg.com/originals/50/c8/23/50c82334cac128895284ad1b09bcbd3d.png)
What's Next
While the Editor can play your Game Level class, it's not yet able to generate your game level Scene Graph. Meaning, if you add some Sprites and Animations to your level and hit the Play button, you won't see anything. For the next weeks and months, the focus will be on generating the Game Level Scene Graph.
That's it for this post, have a good day !
-
Super Update Series - Part 0
Hello everyone, how do you do 8)
Two months since my last post ::) :o, but no worries. I've been making a lot of progress on the Engine. I got so many updates to present that I've decided to make a Super Update Series, and this is part 0
Current Engine State
First, an overview on the current state of the Engine. The goal of the Engine V2 was to go beyond V1 and bring some cool new features : A more modern Editor Interface, an Editor able to compile and reload your C++ code like Unreal Engine, the possibility to add lights to your Game without effort, the ability to break your game world into small chunks that can be loaded and unload dynamically. As of now, I'm happy to say that the Nero Engine V2 supports all those features. It took a lot of time to build the new Engine Architecture, but we've made it :)
Bringing back the old features
Now that the new Engine Architecture is ready, it's time to bring back some old features, by that I mean: adding game objects to your canvas, play your game within the Editor etc. I've been working on that the last couple of weeks and pretty soon the Engine V2 will cover all the features that were present in V1.
That's all, next time I'll present the new Mesh and Physics System
-
Super Update Series - Part I : Mesh, MeshEditor and Physics
Hi, welcome to Part I of this Super Update Series, if you've missed Part 0, check out my previous post.
The Meshing and Physics system of V1 is back in V2. The Nero Game Engine 2 fully supports Box2D now. You can add Meshes to your Game Scene, edit them and see them transform into physical object when you play your Game Scene. I discovered some bugs in the meshing system of V1 and fixed them for V2. I also added an extra feature (Vertex Extrusion). You can now extrude any vertex on a Line, Chain and Polygon. Before the Vertex extrusion was working only on the Edges vertices of Lines.
A new Meshing System Architecture.
While on the surface the meshing system works the same as in V1, the internal architecture is no longer the same. V1 uses mainly three classes: nero::Mesh, nero::MeshObject and nero::PhysicObject. The nero::Mesh class was used to represent all four types of Meshes (Line, Chain, Circle and Polygon). In addition, it was storing the physical properties associated to that Mesh. That's a lot for one class.
The nero::Mesh class no longer exist in V2. The new mesh class is the nero::PointMesh, this class only represent Line and Chain Meshes. Polygons and Circles use the nero::PolygonMesh and nero::CircleMesh classes, which inherit nero::PointMesh.
Meshes no longer carry physics data, the nero::MeshObject no longer exist and is replaced by the nero::PhysicsMeshObject. This class store a mesh and the physical properties of your object.
The nero::PhysicObject is now the nero::PhysicsObject (just add an "s" ;D).
Demo Video
In this demo, I demonstrate the meshing and physics feature of the Engine.
http://www.youtube.com/watch?v=Cu7XoiM5uc8
What's next ?
In the next part of this Super Update Series, I'll present the lighting system of the Engine, you'll see how to add lights to your scene and how the light interact with the physics of your level
-
Super Update Series - Part II : Lighting
The lighting system
The Engine uses Let There Be Light 2 8) to provide lighting to your Game Scene. The lighting system uses Lightmaps (i.e special texture images) to generate light. Adding lights is very simple, first load your lightmaps, then simply add them to your Scene. The Engine will create some Point Lights based on the lightmaps you've added. The lighting can be enabled or disable at any time during your game.
There are three components in the lighting system
Component One : The background clear Color, which is White. By default, the Engine clears your background with a Black color, but when you enable the lighting, the Engine switches to a White color. You can change the clear Color if needed.
Component Two : The Ambient Light. When you enable the lighting, the Engine automatically adds an ambient color to your Scene. You can think of the ambient color as the Sun. By default, the Engine will use a dark blue color to simulate a nighttime, but you can change the ambient color as you which.
Component Three : Point lights. Point lights are lights you add to your Game Scene using lightmaps. Point lights are represented by a yellow light bubble Icon. You can disable a point light, doing this will turn the light Icon into a Red light bubble. You can scale up or down the light to change its size and also choose which color the light should be, by default all lights are white.
Light and Physics
All lights (ambient and point lights) interact with the Physics of your Scene. By default, Static Objects will block light and generate a dark shadow. The interaction with Dynamic and Kinematic Objects will be added in the future.
Video Demo
In this video, we build a small Game Scene where we add some Point Lights
http://www.youtube.com/watch?v=w1op52NXFHU
What's Next ?
All the Game Objects from V1 are now available in V2 with the addition of the LightObject. In the next post will review all Game Objects available in the Engine : Sprite, Animation, Text, Light, Physics and Solid, PhysicsSprite and SolidSprite, PhysicsAnimation and SolidAnimation.
That's all have a good day 8)
-
Super Update Series - Part III : Game Objects
Hello, how do you do !? 8)
Wanted to make this update sooner, but the Engine had a big frame rate issue, couldn't render physics, lighting and record I at the same time :o :o. I had to improve the physics simulation and modify LTBL (Let There Be Light) a little bit.
Game Objects
The Engine currently provides seven (7) Game Objects in its World Builder Mode. Using these 7 game objects, you can build an awesome game level.
- PhysicsMesh
- Sprite
- PhysicsSprite
- Animation
- PhysicsAnimation
- Text
- LightProb
Once you play your game level, these (7) game objects will transform into different objects at the exception of Sprite, Animation and Text which stay the same. In total, the Engine provides eleven (11) different game objects.
- PhysicsMesh -> PhysicsObject
- PhysicsSprite -> SolidSprite
- PhysicsAnimation -> SolidAnimation
- LightProb -> LightObject
PhysicsMesh
The Engine provides four types of Mesh (Polygon, Circle, Line, Chain). Chains are created out of Lines by adding more vertices. When removing vertices from a Chain, the Chain will become a Line if only two vertices remain.
When playing your game level, a PhysicsMesh will become a Physics object.
Sprite and PhysicsSprite
Adding Sprite Objects is pretty easy, you just have to click on a Sprite in the resource browser window.
To add a PhysicsSprite you have to hold CRTL and click on a Sprite. By default, a PhysicsSprite will come with a Polygon Mesh. To change the Mesh Shape, Right Select the PhysicsSprite and click the mesh shape you want (Polygon, Circle, Line) in the resource browser window.
When playing your game level, a PhysicsSprite will become a SolidSprite object.
Animation and PhysicsAnimation
Animations work the same way as Sprite, click on an Animation in the resource browser window to add an Animation and CTRL click on an Animation to add a PhysicsAnimation.
When playing your game level, a PhysicsAnimation will become a SolidAnimation object.
Text Object
In order to add a Text Object, simply click on the desire font in the resource browser window. If you want to change the font later, simply Right Select the Text Object and click on a different font in the resource browser window.
LightProb
In order to add a LightProb Object, simply click on a lightmap in the resource browser window. A LightProb is made of two parts
- A Light Icon : Represented as a yellow light bubble when the light enabled (On) and a red light bubble when the light is disabled (Off)
- A Light Ring : The color of the light ring represents the color of light, by default the ring is white because the default light color is white. The size of the ring updates when changing the scale of the light map used
Video Demo
http://www.youtube.com/watch?v=6RN2Qb1D_8Y
What's Next
We still have a lot to cover in this Super Update Series, Next time will talk about the improvement made on the Engine Editor Compilation System.
That's all have a good day 8)