Tilengine - The 2D retro graphics engine forum - News & Announcements

Tilengine 2.15 supports variable refresh rate monitors

Sat, 22 Apr 2023 18:24:39 +0000

I've uploaded a new release to GitHub and itch.io, that adds these features to the built-in window:

Support for non-60 Hz refresh rates. Auto adjusted when creating the window, or can be manually set
V-Sync can be disabled between frames, allowing to setup a target fps different than the monitor refresh rate
Window scaling factor can be setup at runtime with ALT-1 to ALT-5

Full post can be read here:
https://megamarc.itch.io/tilengine/devlo...5-released

Tilengine 2.14 with new layer window feature

Fri, 10 Feb 2023 15:07:29 +0000

Hi!

I've just released a new version that adds a per-layer window feature similar to the one pesent in SNES. Here is the full post with explanation and new samples to play with:

https://megamarc.itch.io/tilengine/devlo...yer-window

  Captura de pantalla 2023-02-09 181655.jpg (Size: 21.83 KB / Downloads: 3)

  Captura de pantalla 2023-02-09 181723.jpg (Size: 35.59 KB / Downloads: 3)

  Captura de pantalla 2023-02-09 182737.jpg (Size: 55.19 KB / Downloads: 3)

Tilengine 2.13 with per-tile palette selector

Sat, 12 Nov 2022 17:18:13 +0000

Hi,
I've uploaded to itch.io and github release 2.13 of Tilengine, which adds the ability to use different palettes on each tile of a tilemap, just like actual 2D chipsets work. Here's the full blog entry:
https://megamarc.itch.io/tilengine/devlo...e-selector

Tilengine 2.12 released with tile & sprite 90º rotation

Tue, 01 Nov 2022 07:30:31 +0000

Hi!

I've released version 2.12 that adds tile & sprite 90º rotation. It can be cloned from GitHub or downloaded prebuilt binaries from itch.io

Captura de pantalla 2022-11-01 073742.png (Size: 38.13 KB / Downloads: 2)

Full blog entry is here:
https://megamarc.itch.io/tilengine/devlo...0-rotation

Tilengine 2.11 released

Sat, 01 Oct 2022 16:04:16 +0000

Just released Tilengine 2.11 on GitHub and itch.io. This release enables tiled layers to be composed of up to 8 different tilesets each one.

Here is the full post:

https://megamarc.itch.io/tilengine/devlo...0-released

Some days ago I've released version 2.10 with a new CRT emulation effect, with simplified API and more modes. It looks better and it has better performance, using less CPU.

This release also includes some bugfixes.

Here is the full post:

https://megamarc.itch.io/tilengine/devlo...0-released

You can get the sources on GitHub or grab prebuilt versions at itch.io

Web-browser suport is comming!

Sat, 11 Sep 2021 16:25:12 +0000

Hi folks!

I've been busy compiling Tilengine with Emscripten, a clang-like compiler suite that outputs javascript and WebAssembly instead of traditional native machine code. What does this mean? The ability to run Tilengine programs inside the browser, instead of having to download and build a specific OS version.

Progress is almost complete, I'll soon release the end library. In the meantime, some insights:

Here you can see two screenshots from the samples "platformer" and "forest" running inside Firefox:

  emcc_platformer.png (Size: 97.61 KB / Downloads: 14)
  emcc_forest.png (Size: 95.9 KB / Downloads: 9)

A screenshot of "benchmark" tool for obtaining performance

  emcc_benchmark.png (Size: 40.87 KB / Downloads: 9)

A screenshot of the same benchmark tool running natively on the same computer, to compare performance.

  emcc_benchmark_native.png (Size: 19.58 KB / Downloads: 8)

As you can see, performance inside the browser is between 40% - 50% relative to native speed, that matches expected results for Emscripten ported programs.

I have to solve two caveats before releasing it, both related to SDL2 (the underlying windowing framework):

despite benchmark results, actual animations run slower while they shouldn't
pressed keys are not passed to the window manager

Let me know what you think about it!

Major refactor of Python Platformer

Fri, 25 Jun 2021 12:21:36 +0000

Hi,

I've done a major refactoring of Tilengine's sister project Python Platformer (https://github.com/megamarc/TilenginePythonPlatformer). I've split it onto separate, reusable modules what was a single-file implementation. The aim of this project is to showcase a real-world usage of tilengine to build a working game prototype, so everything must be keep clean and simple. Python can be quite tricky regarding imports, circular dependencies and sharing object instances, specially for someone having a strong background in C as things work quite differently. This refactoring supposed quite a bigger challenge than I expected at the beginning, but it's now completed.

It's structure can be of interest for those of you working on Python games...

Release 2.9.1 - Sprite pivot and layer enable

Wed, 24 Mar 2021 12:58:37 +0000

This small update introduces an useful feature: the ability to set the sprite's pivot position. Until now it was always fixed to top-left corner, but now it can be set freely inside its bounding rect. This pivot point sets the exact placement and scaling source. For gameplay configurations that use some kind of 3D projection -like 3/4 or racing roads-, it's much more natural to pivot sprites at the bottom middle, where the "ground" is.

GitHub project is updated and documentation online:
http://www.tilengine.org/doc/md_sprites....totoc_md93

In addition, a layer can be enabled again with TLN_EnableLayer after it has been disabled with TLN_DisableLayer, as long as it was previously configured:
http://www.tilengine.org/doc/md_layers.h...totoc_md39

Release 2.9.0 - World mode

Mon, 15 Mar 2021 22:27:33 +0000

Hi folks,

I've just pushed Release 2.9.0 to GitHub. This release adds a new feature called "World mode", where all the layers contained in a single .tmx file and any selected sprites are updated when the "world position" changes. Layers take into account the parallaxing factor recently introduced in Tiled editor, as well as offset values, visibility and transparency. And sprites take their "world position" and have them automatically converted into screen coordinates.

This mode simplifies greatly the setup of a whole level (just a single call). And updating the whole playfield, that previously required one call per layer and per sprite, and keeping track of their positions, now is done with another single call.

The documentation is already online, here it is the new section:
http://www.tilengine.org/doc/md_world.html

"Classic" mode continues working, so old samples and projects won't break, but new ones can benefit from this "world" feature.

Release 2.8.0 - revamped animation engine

Sun, 03 May 2020 05:46:51 +0000

This release doesn't introduce new features, but enhances existing ones.

Revamped animation engine

Prior to this release, animation engine was a globally slotted one, in the same way as sprites or layers. Each animation of any kind required a slot that had to be managed. That was tricky with tileset animations, where slots had to be allocated beforehand without having knowledge of how many slots was going to need. This was cumbersome to say the least.

No more.

Sprite and tileset animations are self sustained: they don't use slots anymore, using them is straightforward:

Tileset animations are started automatically when setting up a layer that has animated tileset
Sprite animation just require the index of sprite to animate.
Tilemap animations were a legacy feature don't used anywhere, removed
Slotted animations are now only used by palette animations (color cycles).

This of course has some minor breaking API changes to the animation system:

Removed `TLN_SetTilesetAnimation()` and `TLN_SetTilemapAnimation()`.
Removed parameter "index" from `TLN_SetSpriteAnimation()`, requires only sprite number.
Replaces `TLN_DisableAnimation()` with `TLN_DisablePaletteAnimation()` and `TLN_DisableSpriteAnimation()`

Improved sequence support

Now it's possible to have a tileset animation where one of the frames can be the same as the tile being animated, it's usual to do this way by map creators. You can now do this:

Code:
47 <- [47, 49, 50, 53]

In this example, tile 47 is both the tile being animated, and one of the frames of the animation.

Enhanced asset packer support

Previous version of asset packager format had a flaw where improbable -but possible- hash collisions weren't handled properly. That could lead to loading a different asset than intended. ResourcePacker has been updated without this flaw, and its loader is now integrated in this release. I also allows unlimited password length. Upgraded packer can be downloaded at itch.io: https://megamarc.itch.io/resourcepacker

Enhanced .tmx loader

It now supports up to 64 layers per .tmx file, and tilesets are cached. If multiple layers use the same tileset, only one copy of the tileset is loaded and animated, shared between all the tilemaps using it.

Updated examples

All examples are updated to be compliant with the new API changes. In addition "forest" sample now accepts optional command-line parameters to load assets from password-encrypted asset pack. For example:

Code:
forest assets.dat my_password

Starts forest example with assets being stored inside "assets.dat" encrypted with password "my_password"

Release 2.7.0 - sprite list order, sprite masking

Sun, 26 Apr 2020 09:24:02 +0000

Release 2.7.0 introduces two new features inspired on the Sega Genesis/MegaDrive and some tweaks & bugfixes

Sprite list order
Until now, sprites were drawn based in their order ID so when overlapping, sprite 0 was always under sprite 1, and sprite 2 was always on top of sprite 1. This release introduces the ability to change sprite ordering based on internal link list. Function TLN_SetFirstSprite() sets the index of the beggining of list, and TLN_SetNextSprite() tells which sprite follows which one. If you want that sprite 1 is drawn after sprite 4 (on top of it), you call TLN_SetNextSprite(4, 1).

Sprite masking
Now it's possible to define a horizontal region to mask out selected sprites with TLN_SetSpritesMaskRegion(top, bottom), setting a top and bottom scanline. Sprites flagged with TLN_EnableSpriteMasking() won't be drawn when crossing this region. The Sega Genesis had a cumbersome way to enable this feature, using specially positioned sprites on the screen and inside the sprite list order, but Tilengine does the same in a straightforward way.

Other tweaks and fixes include:

Fixes crashes when closing window and strange input behavior due to compiler-induced bugs with optimizations enabled for 64-bit builds
When CRT effect is disabled, sharp nearest-neighbour scaling is always used
Parameter "count" has been removed from TLN_CreateSpriteAnimation(), now is obtained automatically from sprite names inside spriteset.
Reworked some samples that used old and messy .sqx files for sprite animations, and replaced with newer spriteset-based sequences.

Check out in GitHub

Release 2.6.0 - loads .json and 24/32 bpp images

Wed, 22 Apr 2020 08:42:13 +0000

Enhanced asset loader compatibility

This release features two major improvements to supported assets:

Loads standard .json array format for spritesheets. This format is exported by major pixel art applications: Aseprite, Texturepacker, Piskel... Legacy .txt and .csv formats are supported too.
Loads 24 and 32 bpp pixel art images directly, no need to convert to 8-bit indexed first.

Keep in mind that the internal rendering pipeline is still based on indexed color. But the loader can take a 24/32 bpp image, and if it has less than 255 unique colors (common for pixel art) then converts it to an equivalent 8-bit indexed on the fly. If the image has more than 255 colors it won't be loaded.

These additions make much easier to work with spritesheets directly exported by standard editing tools.

The "forest" sample has now the spriteeshet in .json format and graphic assets in 24/32 bpp to showcase these new features.

GitHub project and itch.io packages are updated to this new release.

Release 2.5.0 - Image-based tilesets & object layers

Thu, 16 Apr 2020 16:15:34 +0000

Version 2.5.0 adds the ability to use image-based tilesets and use them on object layers. It is now possible to edit an object layer containing images in Tiled, and render it in Tilengine without having to define them at runtime like in release 2.4.0. It is also possible to iterate the objects contained in the layer from the application, to integrate them into the gameplay and not have to use an alternative reader. The "forest" example has been updated to show this new feature, and some bugs have been fixed.

GitHub project and itch.io packages have been updated.

post.png (Size: 163.58 KB / Downloads: 6)

Tilengine as libretro core with LUA games

Wed, 04 Dec 2019 14:12:43 +0000

I'm working on an experimental version of tilengine. It's a libretro core with loadable games written in lua. Libretro cores are plugins that can be run inside Retroarch emulation environment, which provides unified input and windowing with post-processing shaders.

To be able to load many tilengine-based games from a single core, I integrated luajit parser inside it, so the game logic is implemented in external LUA script. This script must define the following items:

a config {} table with initialization parameters
a game_load() function that loads assets and performs initial game setup
a game_loop(frame) function that gets executed every frame
a game_unload() function that gets called when closing the game

The input is still not implemented, so only non-interactive demos are working right now. And as the system depends on luajit and retroarch, only Windows versions are tested.

User -> RetroArch <-> tilengine_libretro <-> game.lua

Maybe this experiment is a dead end, but it looks promising and it's a great integration example.

You can check progress in this GitHub branch:
https://github.com/megamarc/Tilengine/tree/libretro

This is the basic "game":
https://github.com/megamarc/Tilengine/bl...e/game.lua

Let me know what you think

libretro.jpg (Size: 395.41 KB / Downloads: 11)

Tilengine 2.4.0 adds object layers

Fri, 10 May 2019 07:16:29 +0000

Release 2.4.0 introduces the new object layers, which consist of a list of sprite graphics that are displayed in certain positions. They are a hybrid between the layers of tiles and the sprites. Above all, they serve to apply decorations that are not composed of tiles but sprites.

It also adds the ability to assign priority to a full layer to be displayed in front of the sprites,

synchronized scroll between layers (several linked layers that move together to the layer designated as main).

The possibility of easily creating sprite animations from numbered name sequences is added.

Finally a new example called "Forest" illustrates all these new capabilities.

See the full story on facebook:
https://www.facebook.com/notes/tilengine...3597289575