The demo adds an Effect node by code, to a model loaded from glTF, and also shows how to manipulate custom effect parameter (which maps to GLSL uniform) at runtime. These effects use shader code (GLSL, running on GPU) that is automatically integrated with standard engine rendering shaders.
If you come from Unity then these effects are CGE analogy of Unity “surface shaders” (but much more flexible 🙂 ).
Last week we did an important fix for glTF skinned animation combined with normalmaps. It fixed the problem with incorrect lighting, but also made the code a little slower in case of skinned animation + normalmaps (we had to turn “off” one optimization). To counteract this, I’m reworking a relevant part of CGE renderer, to not only bring the old optimization back, but also optimize it even more, and bring other small improvements.
It’s a work-in-progress, but we already have:
Colors per vertex passing optimized (faster copy, 3/4 less data for RGB colors).
Custom shader attribute passing optimized (faster copy) and fixed for non-indexed primitives (see demo file).
Tangents and bitangents passing optimized (pass 2/3 less data due to not duplicating normal info).
Thanks to a great work by Andrzej Kilijański, we now have a brand new way of using sprite sheets in Castle Game Engine: you can load sprite sheets to TCastleScene and arrange them within a TCastleViewport.
This means that you can load, display, transform, animate sprite sheets just like all other scenes. Refer to our manual, in particular chapters about loading, displaying and transforming, animating. Everything described there now just applies to sprite sheets.
This also means that you can arrange sprite sheets in CGE editor.
I’ll give a presentation about Castle Game Engine at MiniDebConf Online #2 “Gaming Edition”, an online Debian conference devoted to game development. The presentation is already recorded :), and I hope it is good. I focus on Castle Game Engine editor. I create a 3D level in Blender and put it in a 3D CGE game, I do some code editing, and I build a 2D game for Android too — all in 38 minutes. I hope it will serve as a nice introduction to CGE, from scratch, going over the core engine/editor features and showing how to use it in practice.
Afterwards there will be ~7 minutes for live questions.
My presentation starts on Sunday, 22 November, 13:30 UTC, see schedule.
We have an extensive documentation how blending (partial-transparency) works. While the engine tries its best, it’s not always possible to make blending automatically “just work”. This documentation should help you understand what and why you can tweak.
We have renamed mouse button names/types to buttonXxx and TCastleMouseButton. This way they do not conflict with LCL. The old names mbXxx still remain, but are now deprecated, and we will be able to remove them in later CGE (7.2?). Thanks to Eugene Loza!
In the editor, we now expose “Scene (Optimal Blending for 2D Models)”, which is just TCastleScene with Setup2D performed.
It is better than the now-deprecated TCastle2DScene. Dealing with TCastle2DScene was sometimes uncomfortable: when you wanted to derive descendants and mix 2D and 3D models in your game. And existence of TCastle2DScene was not really justified: in the end, it is a completely trivial variant of TCastleScene, the Setup2D just sets "RenderOptions.BlendingSort := bs2D" (really, that’s it! nothing more needed for 2D scene).
With many thanks to Kagamma (Trung Le), we now support screen-space reflections in Castle Game Engine! It is a cool technique that generates reflections completely in screen-space, using color and depth buffer information to look for the reflected color.
It is trivially easy to use, just toggle TCastleViewport.ScreenSpaceReflections boolean. As we don’t have material information available in screen space (yet, because we do not have deferred rendering), so everything in the whole viewport is reflective now. That said, the effect is extra pretty and just works “out of the box” on various scenes, so I’m sure it will find it’s use even in current “everything is reflective” form 🙂 You can configure glossiness for the entire viewport by TCastleViewport.ScreenSpaceReflectionsSurfaceGlossiness (in 0..1 range, by default 0.5).
You can also test it with view3dscene, just toggle menu item View -> Screen Effects -> Screen Space Reflections.
Our screeen effects GLSL API also got a small upgrade by the way. We now expose screenf_01_position varying and functions screenf_01_get_color(...) and screenf_01_get_depth(...) to quickly query the screen.
You can now configure RenderOptions of every TCastleScene. Simply access it like MyScene.RenderOptions.OcclusionQuery := true. It is available also in the editor, as you can see on the screenshots 🙂 All the features are documented in TCastleRenderOptions class, in particular you can:
This mechanism replaces (and deprecates) previous Scene.Attributes.
As part of this rework, we also deprecate or even remove some stuff that had very low usage.
In particular, Scene.Attributes.OnRadianceTransfer and Scene.Attributes.OnVertexColor are now removed. They were causing quite a complication throughout the renderer, and were never ready for “production” usage due to being inherently slow (doing per-vertex work on CPU). Their effect can still be achieved by a simple utility that maintains the X3D Color node, updating it every frame. So if you need this (and can accept the slowness of per-vertex processing on CPU) you can still do it, our sceneutilities.pas example unit demonstrates this in practice, and is used by dynamic_ambient_occlusion and radiance_transfer examples. Feel free to reuse SceneUtilities in your projects in you need an upgrade path from the OnVertexColor and OnRadianceTransfer.