There's a discussion on the forum that sort of veered into talking about Khronos' GLTF file format specification:
Some of this gave me some ideas for changes in the art pipeline in Turbo Game Engine. I was not feeling very concentrated today so I decided to do some easy work and implement a loader class:
class Loader : public SharedObject
{
public:
std::vector<wstring> extensions;
virtual bool Reload(shared_ptr<Stream> stream, shared_ptr<SharedObject> o, const int f
The Seventh World is a Medieval Fantasy Survival game, inspired by the likes of Skyrim and ARK Survival Evolved.
It's been under development for the last two years but only in the last eight months has a real commitment been made to it. Spending every night after work and every other day working on it I've achieved a base from which to build on.
The cuboid landmasses are called fragments. They are arranged as a sphere to make up a planet. Game-play will eventually include mov
I found and fixed the cause of the cubemap seams in variance shadow maps so we now have nice soft seamless shadows.
I also changed the engine so that point lights use six 2D textures instead of a separate cubemap texture array. This means that all light types are sharing one big 2D array texture, and it frees up one texture slot. I am not sure if I want to have a hard limit on number of shadow-casting lights in the scene, or if I want to implement a system that moves lights in and out
As I work with the new engine more and more I keep finding new ways it makes life happy and productive.
Smart Pointers
I have talked about how great these are at length, but I keep finding new reasons I love them. The behind-the-scenes design has been a lot of fun, and it's so cool to be able to write lines of code like this without any fear of memory leaks:
LoadSound("Sound/Music/fully_loaded_60.wav")->Play();
What do you think that code does? It plays a sound, keeps it in m
Working out of this subject:
I tested a script for a simple "GoToPoint()" function for a customizable character controller for NPC. This may not be so good as the implemented LE character controller with classic navigation system but it could be promising to use it in open world (so not in much corridored dungeon game!) where the the NPC should crawl or swim or whatever do things as for example underscaled world (thats what I am actually interested in ?)
The NPCs are using an "
The Turbo Game Engine beta is updated! This will allow you to load your own maps in the new engine and see the speed difference the new renderer makes.
LoadScene() has replaced the LoadMap() function, but it still loads your existing map files.
To create a PBR material, insert a line into the material file that says "lightingmodel=1". Blinn-Phong is the default lighting model.
The red and green channels on texture unit 2 represent metalness and roughness.
You g
I've got the basic GI algorithm working but it needs a lot of work to be correct. I tend to do very well when the exact outcome is well-defined, but I am not as good at dealing with open-ended "artistic" programming. I may end up outsourcing the details of the GI shader to someone else, but the underlying data management is solid enough that I am not scared of it anymore.
There's a lot of aspects of the design I'm not scared of anymore. We worked out smart pointers (including Lua integratio
The beta branch has been updated. The following changes have been made:
Rolled beta branch back to release version, with changes below.
Added new FBX converter.
Fixed Visual Studio project template debug directory.
Fixed Visual Studio project template Windows Platform SDK version problem.
If everything is okay with this then it will go out on the default branch soon.
I finally have a cool screenshot to show you of our new real-time global illumination working.
Here is a comparison screenshot showing direct lighting only:
Now there are still lots of small issues to worry about. Right now I am only using a single cone trace. More cones will improve accuracy, but I think light leaking is just always going to be a fact of life with this technique. Still, the results looks great, require no precalculation, respond to environment changes, and
Now that we have our voxel light data in a 3D texture we can generate mipmaps and perform cone step tracing. The basic idea is to cast a ray out from each side of each voxel and use a lower-resolution mipmap for each ray step. We start with mipmap 1 at a distance that is 1.5 texels away from the position we are testing, and then double the distance with each steo of the ray. Because we are using linear filtering we don't have to make the sample coordinates line up exactly to a texel center, and
I have successfully transferred lit voxel data into a 3D texture. The texture is now being used to display the lighting at each voxel. Soft edges are appearing due to linear filtering in the texture. To achieve this, I used an OpenGL 4.2 feature which allows you to write values into any arbitrary position in a texture. This could also be used for motion blur or fluid simulations in the future. However, since Mac support for OpenGL only goes up to 4.1, it means we cannot use real-time GI on a Mac
We left off on voxels when I realized the direct lighting needed to be performed on the GPU. So I had to go and implement a new clustered forward renderer before I could do anything else. Well, I did that and now I finally have voxel lighting calculation being performed with the same code that renders lighting. This gives us the data we need to perform cone step tracing for real-time dynamic global illumination.
The shadows you see here are calculated using the scene shadowmaps, not b
Here are the results of the Summer Games Tournament. Make sure you update your mailing address, because posters are being sent out immediately!
Invade
The arcade classic "Space Invaders" has been re-imagined with modern graphics and cute 3D aliens!
Constanta
Constant is an abstract game about capturing cubes. Make sure you read the instructions!
Death Rooms
Procedurally generated levels and a lot of interesting rooms make this FPS worth trying. Watch out for traps
Between The Realities is an indie game in the genre of first-person shooter, which is being developed by our creative association Antology Games Studio. At the moment the game is in active development at the pre-beta stage, the release is expected in the winter of 2019. Our project is entirely inspired by oldschool games of the late 90s, such as Blood and Kingpin: Life of Crime, and by films like Streets of Fire (1984) and Dark City (1998).
Annotation:
Another world. Different rea
After three days of intense work, I am proud to show you this amazing screenshot:
What is so special about this image? I am now successfully uploading voxel data to the GPU and writing lighting into another texture, using a texture buffer object to store the voxel positions as unsigned char uvec3s. The gray color is the ambient light term coming from the Blinn-Phong shading used in the GI direct light calculation. The next step is to create a light grid for the clustered forward rende
I have shadow caching working now in Turbo. This feature is already in Leadwerks Game Engine 4. The idea is that static scene geometry should not be redrawn when a dynamic object moves. Imagine a character (6000 polys) walking across a highly detailed room (100,000 polys), with one point light in the room. If we mark the scene geometry as static and the character as dynamic, then we can render a shadow map cache of the static scene once. When the character moves, the static cache is copied into
Hi guys!
Bladequest – The First Chapter now finally is on Steam! I am very excited to see how it is going! Check it out if you want! I think it’s pretty cool to have my game on Steam :).
Recently I did some redesign and restructuring, affecting my logo, the newsletter and the website. I actually shut the website down and now use another service, which is easier for me to setup and maintain, so I have more capacity to develop Chapter Two!
Preproduction and conception for “Chapter T
An online implementation of physically-based rendering in the Khronos Github was pointed out to me by @IgorBgz90 and @shadmar. This is very useful because it's an official implementation of PBR that removes a lot of guesswork. Here is my first attempt, which is not using any cubemap reflections:
And here it is with cubemap reflections added:
I plan to use the real-time global illumination system to generate the reflection data, instead of using environment probes. T
New content has been added to Leadwerks Marketplace to provide you with assets for your games. All items are sized correctly and completely ready-to-use with Leadwerks
The Model class is being slightly restructured to add support for built-in LOD without the need for separate entities. Previously, a list of surfaces was included in the Model class itself:
class Model
{
std::vector<shared_ptr<Surface> > surfaces;
};
This is being replaced with a new LOD class, which allows multiple lists of surfaces containing less detail to be stored in the same model:
class LOD
{
std::vector<shared_ptr<Surface> > surfaces;
};
class Model
Hi guys,
First of all check out the newest episode of DevTalk, showing some progress of the development of Bladequest: Chapter Two!
Bladequest – The First Chapter is available since about one and a half month now and so far and has totally exceeded my expectations with about 2000 downloads in total. It was a very interesting project for me, and I got a lot of positive feedback and you definitely want to see more from Bladequest. I think the foundation is there, to create a really cool
With the help of @martyj I was able to test out occlusion culling in the new engine. This was a great chance to revisit an existing feature and see how it can be improved. The first thing I found is that determining visibility based on whether a single pixel is visible isn't necessarily a good idea. If small cracks are present in the scene one single pixel peeking through can cause a lot of unnecessary drawing without improving the visual quality. I changed the occlusion culling more to record t
SCP
