New modern API for vectors and matrices

Posted on

Chinchilla model in X3D, based on high-poly version in "Big Buck Bunny"

Our unit CastleVectors was completely reworked this week, and it now features a new, comfortable API for vector and matrix types, using “advanced records” (records with methods).

I hope that you like the changes 🙂 Of course you can already test it all by using the engine version from GitHub !

Type names

The main vector and matrix types (using Single-precision) are now called TVector2, TVector3, TVector4 (in short: TVector{2,3,4}) and TMartix{2,3,4}. So we have 2D, 3D and 4D vectors (4D vectors are useful for “homogeneous coordinates” in 3D, and to store colors with alpha). And we have 2×2, 3×3, 4×4 matrices.

These correspond to previous array-based types called TVector{2,3,4}Single and TMatrix{2,3,4}Single. As you can see, we have removed the Single suffix, as these types are used very often throughout the engine and, as such, they are our “default” vector and matrix types.

As before, we also feature vectors with Double precision (TVector{2,3,4}Double), and based on various integer types (Byte, Integer and Cardinal). They are all available in 2D, 3D, 4D variants, and are implented using the new “advanced records approach” and are consistent with Single-precision vectors.

Features

  • As these types are “advanced records”, they include various methods, class methods and constants nicely grouped within the record. This makes the API look nicer, e.g. now you can write MyVector.Length instead of VectorLen(MyVector). They have one field, Data, which is defined like array [0..2] of Single for TVector3. This allows to keep them fast (in terms of speed, and memory layout). See the documentation of the generic 3D vector (this API is used by both TVector3 and TVector3Double).

  • You can access the individual components of the vector as V.X, V[0] or V.Data[0]. And the last two notations are checked, even at compile-time, so this will make a clear warning (that index is 3, but should be between 0..2):

    uses CastleVectors;
    var
      V: TVector3;
    begin
      V[3] := 123; // incorrect example, index should be in 0..2 !
    end.
    
  • All the operators, like + and *, are overloaded on vectors and matrices. Just like with old types.

  • These types work in both FPC and Delphi. They work without the FPC macros (as Delphi doesn’t support them). I wish they could use generics, but they cannot (it’s not possible to put constraints on Pascal generics to enable efficient arithmetic operations on fields).

  • Along with it, triangles (TTriangle{2,3,4}) was also remodelled as a record, and the Double-precision equivalent (TTriangle3Double) was removed (not really useful, and implementing it without macros or generics is uneasy). See TTriangle3 documentation.

  • Along with it, the TBox3D was a bit improved, it now has Min and Max properties, that look friendlier than Data[0] and Data[1]. See TBox3D documentation.

  • Along with it, the color types have changed too, as TCastleColor and TCastleColorRGB are still just aliases for (respectively) TVector4 and TVector3. See CastleColors unit documentation.

  • The new vectors vaguely resemble the vectors from Delphi standard unit System.Math.Vectors, but are better in many ways. We offer many more types and with many more methods. And, frankly, our naming is more consistent, IMHO 🙂

Backward compatibility

While the change is for good, it is not 100% backward-compatible. I put a lot of effort to minimize the compatibility “disruption”, adding many “glue” functions and types to keep your existing code working (and merely warn about being “deprecated” during compilation). But there is still chance that you will need to change something in your code to make it compile with the engine >= 6.3 API. Read the hints below, and please ask on the forum if you’re unsure how to upgrade.

The changes that break compatibility (things that you will have to change in your code in order to compile):

  • When declaring constants, your old code may use this:

    const MyConstant: TVector2Single = (1.0, 2.0); // old code

    As the vectors, matrices, colors and triangles are now record types with a Data field, so it has to be changed to:

    const MyConstant: TVector2Single = (Data: (1.0, 2.0));
  • The TBox3D.Data, and your custom array of TVectorXxx types, are no longer “arrays of arrays”. They are now “arrays of records”. Your old code may use this:

    Box.Data[0, 0] := 0.0; // old code

    This has to be changed to:

    Box.Data[0][0] := 0.0;

    Or this, if you want to avoid any “getter” properties and just access the (addressable) variable directly:

    Box.Data[0].Data[0] := 0.0;
  • Although you can still access the vector component using V[0], this is now a “getter” property. It often doesn’t matter… unless you want to use it as var or out parameter for some function, or if you use C-like operators like +=. So if your old code has this:

    V[0] += 10; // old code

    This has to be changed to this:

    V.Data[0] += 10;

    Of course, in this case you can also just resign from using C-like operators, and have this:

    V[0] := V[0] + 10;

    Or this:

    V.X := V.X + 10;

Sidenote: I tried a different approach to backward-compatibility too (keeping both old and new APIs in parallel) but this was creating more compatibility than it was solving (gory details in the KEEP_OLD_VECTOR_API comments in this commit).

Have fun with the new API, and, as always, please ask on the forum if you have any questions!

Comment on this post ➤

Generics.Collections in the book and CGE

Posted on

To help you familiarize with the Generics.Collections unit, I wrote a nice chapter about it in the “Modern Pascal Introduction”. It’s a longer chapter, with 4 nice examples using containers from Generics.Collections.

In the related news: complete migration to Generics.Collections in Castle Game Engine is done 🙂 We now use Generics.Collections for all the purposes where we previously used the FGL and CastleGenericLists units. This brings us closer to Delphi compatibility, and it makes code better (Generics.Collections works with records out-of-the-box, it has a TDictionary with a much cleaner API, etc.)

Also, Michalis is back from vacations, with lots of new strength 🙂

Comment on this post ➤

Generics.Collections, vacations

Posted on

Wizardry VII - Crusaders of the Dark Savant
Half Life 2: City 17
Half Life 2: We don't go to Revenholm
ADOM
  1. I am going on vacation, so I will be (mostly) offline for 2 weeks 🙂 So, please have patience with any questions to Michalis — I will get back to you, but with some delay!

    I don’t have a new screenshot from the engine for this news. Instead, I wanted to share some screens from the games I like — the games that inspired me to make games (and, subsequently, an engine to make games 🙂 ).

  2. The GitHub code now contains a start of migration from FGL unit containers to Generics.Collections unit containers. The Generics.Collections contains a much richer (and Delphi-compatible) generic containers. I use generics a lot in the engine code, so this will be a larger change.

    The main classes from Generics.Collections are TList<T> and TObjectList<T>. TObjectList<T> is very similar to the TFPGObjectList<T> you know from FGL.

    Generics.Collections were implemented in FPC by fantastic Maciej Izak, who also put a lot of work to actually make them part of the FPC standard library in FPC 3.1.1. In older FPC versions, we currently use a local copy of them (in src/compatibility/generics.collections/src/ ). This “compatibility” path should be automatically added to your unit search path for all our supported compilation methods. If you use the build tool, be sure to recompile the build tool after getting the latest code from GitHub.

  3. The requirements on FPC version increase, in order to use Generics.Collections (unit names with dots). We now require now FPC >= 3.0.0. See also FPC versions supported docs.

  4. I’m also working on a new improved API for vectors / matrices, based on advanced records, somewhat cleaner and also Delphi-compatible. More news when I’ll get back from vacations 🙂

  5. Our Automatic Cloud Build server has now cool scripts to switch FPC versions, which allows me to automatically check that the engine compiles with various FPC versions, and on various platforms. I really enjoy continuous testing, time to set it up always “pays off” by doing a lot of things automatically for you, and Jenkins rocks!

Comment on this post ➤

Castle Game Engine 6.2 release – iOS, CommonSurfaceShader…

Posted on

DSC_0248
DSC_0235
CommonSurfaceShader with steep parallax bump mapping and self-shadowing
1_blender_monkey_0
Castle Game Engine sound/music player
Knocker in STL format, by Shira, www.thingiverse.com/thing:1458545
Robot woman in the STL format, by Shira, see http://www.thingiverse.com/thing:614366
ray_tracer_textures

We’re proud to announce the release of Castle Game Engine 6.2!

Download it from our main page.

New features in this release:

  1. Trivially easy recompilation of your games for iOS (through an XCode project). You can now use our build tool to recompile the same game for all our platforms (desktops, Android, iOS, web plugin…). The iOS documentation was extended to describe everything necessary.

  2. CommonSurfaceShader is our new “material on steroids” that allows you to configure material by normalmaps, specular maps, shininess maps, ambient maps… We include an extensive documentation and examples of it (in new demo models).

  3. Improved Blender exporter. It’s now easier to install (it’s now a normal Blender add-on), and it can generate a CommonSurfaceShader node with all the goodies described above. The artist can now comfortably set normalmaps, specular maps and much more in Blender, and they “just work” in the engine.

    The CommonSurfaceShader and Blender exporter improvements were implemented thanks to the support on Patreon. If you like what we do, please consider supporting the engine development on Patreon. This really helps me spend more time on the engine, and develop cool features like this!

  4. Other build tool improvements, for all platforms:

  5. Other API and examples improvements:

    • TSound.Offset to get/set sound offset in time.
    • Sound/music player in examples/audio/audio_player_scrubber.
    • STL format support
    • Our ray-tracer now supports textures and smooth normals.
    • TCastleEdit (example in examples/2d_standard_ui/edit_box/ )
    • Application.ParseStandardParameters, Application.Version

Together with the new engine, we also release a new version of view3dscene 3.17.0, our viewer for X3D and other 3D formats. As a tool developed using the Castle Game Engine, it inherits all the enhancements 🙂 You will probably be most interested in new CommonSurfaceShader node and STL format support.

Comment on this post ➤

Sound player/scrubber using Castle Game Engine

Posted on

Castle Game Engine sound/music player

I made a simple sound/music player using the Castle Game Engine 🙂 It is available in the engine sources in examples/audio/audio_player_scrubber .

It has all the features you would expect:

  • Volume,
  • Loop,
  • Sound offset (position in time) control,
  • Programmer-designed user-interface (ah, this brings back good memories:).
  • It can open wav and ogg files, and plays them using OpenAL.

It was coded to show that TSound.Offset works cool. It’s a new property added today (for Eugene Loza, see here), allows to get/set the sound offset (aka “position in time”).

You can view the code on GitHub.

Comment on this post ➤

Design-time editing of 3D world (initial fun), many other improvements

Posted on

Editing SceneManager.Items at design-time
Editing SceneManager.Items at design-time
TCastleEdit control demo

First of all, I hope to finish and release Castle Game Engine 6.2.0 this weekend! So, watch this page closely.

The next release 6.4.0 will focus on Delphi compatibility, and start of visual editing (of 3D world and 2D controls) within Lazarus and Delphi. In all the pre-release excitement, I started playing around with it already today 🙂 I added a property RenderAtDesignTime to the Lazarus OpenGL control (patch here), and I made a simple design-time menu to add a sphere to the SceneManager at Lazarus design-time. See the screenshots!

In other news, there is a bunch of engine features done recently, not announced properly yet. Here they are (officially coming in 6.2.0 release this weekend):

  1. Rendering of normalmaps (through CommonSurfaceShader.normalTexture or Appearance.normalMap) was improved to work even when no diffuse texture is defined.
  2. TCastleEdit: a simple edit box. Demo in examples/2d_standard_ui/edit_box/game.pas . Not perfect, but already useful anyway 🙂
  3. New build tool command “generate-program”, to generate perfect starter program code and Lazarus lpi.
  4. Added easy Application.ParseStandardParameters method to the TCastleApplication in CastleWindow, may be useful for your standalone games.
  5. image_convert (in examples/images_videos/) has an additional command-line option –alpha-bleed, to perform “alpha bleeding” in batch mode.
  6. Added TDebug3DCustomTransform – a simple reusable utility to debug bounding boxes and spheres of T3DCustomTransform (like T3DTransform or T3DOrient). A generalized version of what you get for creatures (the ones from CastleCreatures unit) when you use RenderDebug3D.
  7. x3d-nodes-to-pascal is our new tool to parse X3D nodes and produce skeleton code to glue X3D with Object Pascal.
Comment on this post ➤

Updates to the “Modern Object Pascal Introduction for Programmers”

Posted on

I wrote a few new chapters to the “Modern Object Pascal Introduction for Programmers” book:

It is also available now under a shorter URL, on a new domain for our Castle Game Engine. The book is not tied to the Castle Game Engine (I want it to be something useful on it’s own). Although it is also part of my plan for “how Castle Game Engine can succeed”, as it helps programmers interested in Castle Game Engine to use the Object Pascal language 🙂 If you like it, please consider supporting me on Patreon !

Comment on this post ➤

In Space Everyone is Screaming (gamejam game:)

Posted on

in-space-everyone-is-screaming_screen_1
in-space-everyone-is-screaming_screen_3
in-space-everyone-is-screaming_screen_4
in-space-everyone-is-screaming_screen_5
in-space-everyone-is-screaming_screen_10

Simple platformer-shooter done during 12-hour gamejam using Castle Game Engine! Binaries on https://gitlab.com/michaliskambi/in-space-everyone-is-screaming/tags/v1.0 , source code on https://gitlab.com/michaliskambi/in-space-everyone-is-screaming . This is really just a technical beginning, without any playable level design, or fancy enemies swarms, or graphics.. But it’s a working start, with jumping and shooting and enemies, ready to be extended! 🙂

Comment on this post ➤