Category: Game design

Posted on

Fit Plane To Game Camera — effortless framing for 3D image planes in Godot 4.5

When you’re working with image planes or textured quads in Godot 4.5, one of the most common headaches is getting them to fit exactly inside the game camera view.

Maybe you’ve rendered a 2K background, a pre-baked scene layer, or a stylized UI element you want displayed in 3D space — not in a 2D canvas or control node. You size your plane to match the image resolution, align it by hand, adjust scale, tweak position… and it still never quite fills the game viewport the way you expect.

That’s where Fit Plane To Game Camera comes in.

What it does

Fit Plane To Game Camera is a tiny Godot editor plugin that adds a single button to your 3D editor menu:
“Fit to Game Camera.”

When pressed, it automatically:

  • Finds your active Camera3D (the one with Current enabled)
  • Reads your project’s game resolution from Project Settings
  • Rotates, scales, and positions the selected MeshInstance3D plane
  • Ensures it fills the camera’s in-game view exactly edge-to-edge
  • Works with both Perspective and Orthogonal camera projections
  • Leaves the plane unparented (no runtime linking or scripts required)

The result: your 2K (or any resolution) image sits perfectly inside the game frame — no guessing, no hand-alignment, no UI layers.

When to use it

This is ideal when you want to:

  • Display a 2D image or graphic in 3D space — such as a backdrop, matte painting, or projection surface
  • Composite 3D elements over a pre-rendered or painted background
  • Place orthographic UI-style planes without switching to CanvasLayer or Control nodes
  • Align a fullscreen effect plane in front of your camera for fades, transitions, or shaders

Essentially: any time you want a textured plane to exactly fill your camera’s in-game viewport

How to install

  1. Drop the folder res://addons/fit_plane_to_game_camera/ into your project.
  2. Go to Project → Project Settings → Plugins
    and enable Fit Plane To Game Camera.
  3. In your scene, make sure your Camera3D has Current turned on.
  4. Select your MeshInstance3D (usually a QuadMesh plane).
  5. Click Fit to Game Camera in the top 3D menu.

Done. The plane now fills the camera view exactly as it will appear in the running game.

Why this exists

When testing art-driven or cinematic scenes, I often wanted to import a high-resolution image — a 2K sky matte, for example — and see it precisely in 3D without manually guessing the scale or FOV.
Godot’s editor view and game view can differ subtly in projection, so eyeballing it was never reliable.

This plugin solves that permanently: one click, instant framing.

Download

fit_image_to_viewportDownload
Posted on

Texture Quad Creator — quick editor tool for Godot 4.5.x

Do you just want to import a image to Godot and automatically create a same size 3d-mesh for it with alpha automatically handled correctly? I did, so I made a tiny Godot editor plugin that turns any image in your FileSystem into a perfectly-sized, alpha-friendly 3D quad. This post explains what it does, how to install and use it, and a few quick troubleshooting tips

What it is

Texture Quad Creator is an EditorPlugin for Godot 4.5.x that:

  • lets you select an image in the FileSystem dock,
  • creates a new MeshInstance3D at the scene origin,
  • generates a QuadMesh sized so the quad matches the image pixel dimensions (scaled by a configurable Pixels Per Unit value),
  • applies the image as a texture and configures the material for correct alpha/blending and no backface culling,
  • selects the new node for immediate editing.

It’s aimed at artists and level designers who want to quickly place UI-like or 2D artwork into a 3D scene without manual mesh setup.

Key features

  • Exact pixel → world unit sizing via Pixels Per Unit (PPU).
  • Proper alpha handling (TRANSPARENCY_ALPHA, alpha-to-coverage AA, culling disabled).
  • Works with common image formats Godot imports (PNG, JPG, WEBP, TGA, BMP, SVG).
  • Adds the node directly to the currently opened scene and selects it immediately.

Install & enable

  1. Download the plugin zip and extract to your project addons/ folder so you have: res://addons/texture_quad_creator/plugin.cfg res://addons/texture_quad_creator/texture_quad_creator.gd
  2. In Godot: Project → Project Settings → Plugins and enable Texture Quad Creator.
  3. The dock appears (by default) in the right sidebar as Texture Quad.
texture_quad_creatorDownload

How to use

  1. Open a 3D scene (the plugin adds the created node into the edited scene root).
  2. In the FileSystem dock, select an image (single click or Ctrl+click).
  3. Optionally adjust Pixels Per Unit:
    • 1 PPU → 1 px = 1 world unit (huge in most projects)
    • 100 PPU → 100 px = 1 world unit (good starting point)
  4. Click Create Quad From Selected Image.
  5. The new MeshInstance3D will appear at the scene origin named ImageQuad_<filename> and be selected.

Tips & recommended workflow

  • If your texture is used in 3D, check import settings (mipmaps / compression) and reimport if you need exact pixel rendering or no compression artifacts.
  • Use PPU to tune the quad scale so it fits your world. Try values like 32, 64, 100 depending on project scale.
  • If you want the quad to always face the camera, add a small Billboard script to it or parent it to a YSort/controller node.
Posted on

State of Construct 3 vs GDevelop in 2025

Construct was a groundbreaking tool for visual and intuitive code-free game making when it was originally released. Since then we have gotten into Construct version 3 and the pricing has changed to a subscription model, which is not attractive to all users. Recently there hasn’t been many major features developed for Construct and it’s development feels stalled, while the free alternative called GDevelop has been developing really rapidly. Here is an overview of the current state between the two game engines.

What GDevelop already does quite well / has achieved recently

Before diving into gaps, it’s useful to note that GDevelop has made strong progress and closed many gaps in recent versions:

  • Native 3D support (scene, lighting, models) is now built into core (rather than only via extension).
  • As of version 5.5, GDevelop now includes 3D physics (via Jolt engine)
  • Multiplayer / real-time networking support is more integrated (5.4 added multiplayer improvements)
  • Steamworks integration (achievements, matchmaking, workshop) is exposed.
  • Improved organization features like object folders, better resource unloading strategies, and QOL tweaks have been introduced.
  • Extensions / behaviors allow adding capabilities, and there is support for scripting via JavaScript blocks in event logic.
  • GDevelop remains fully open source (MIT license) for the engine/editor; the “premium” parts are about online services/builds, not core capability.

So GDevelop is no longer “just a simple 2D engine with events” — it is evolving toward a richer, more feature-complete tool.

Key areas where GDevelop is still behind (or weaker) in comparison to Construct 3

Below are frequent critiques and observed missing or less polished features (or trade-offs) when comparing to Construct 3. Some are functional gaps; others are usability, tooling, or ecosystem gaps.

Feature / areaWhere GDevelop is weaker or missingNotes / examples
Debugger / Performance profilingThe debugging / performance-monitoring experience is often cited as lacking compared to Construct’s live, fine-grained tools. Users report that Construct allows toggling individual elements, live variable inspection, breakpoints, etc., with responsive UI. In GDevelop, performance spikes are harder to trace.
Event sheet UX & advanced event toolingConstruct’s event sheets tend to be more polished: features like bookmarks, event folding, subfolders, grouping, “search events,” better event navigation, etc., are more mature. GDevelop has events, nesting, and extension mechanisms, but some users feel the UX, navigation, and large-scale event management is less smooth.
Timeline animations / cinematics / cutscenesConstruct has a built-in Timeline system for smoother animations, sequencing, easing curves, etc. GDevelop doesn’t (or didn’t at last known state) have a fully comparable, first-class timeline editor integrated. (You could build custom logic via events, but not with the same native timeline editor.)
Plugin / module ecosystem & marketplace maturityConstruct has a long-established plugin / addon ecosystem; many more mature, battle-tested third-party plugins.Because Construct has been in commercial use longer and has a stable ecosystem, many niche or platform-specific plugins are better polished. GDevelop’s extension ecosystem is growing but sometimes suffers from fragmentation, version compatibility, or lack of maturity.
Polished asset / resource management & in-editor toolingConstruct often offers tighter editor-integrated tools: e.g. sprite font styling, text effects, integrated mesh distortion, advanced effects, etc. GDevelop supports shader effects, but may not have as many built-in high-end per-asset editing tools or integrated pipelines.
Performance / runtime optimizations & memory managementConstruct’s runtime is optimized (e.g. expression compilation, tilemap optimizations, memory management) to deliver smoother performance, especially in heavier projects. GDevelop’s engine is evolving, but in projects with many objects, complex logic, or resource constraints, users sometimes see performance or memory pressure as a limiting factor.
Export / build services and platform handlingConstruct offers integrated build services (mobile, native, etc.) with smoother flows.GDevelop’s free users are limited in the number of online builds (e.g. 2 exports/day) via its build servers. But you can always export manually.
Editor polish, UX quality, collaboration, versioningConstruct has had more time to polish UI/UX, editor stability, in-editor collaboration (e.g. sharing, live preview across devices)GDevelop is improving constantly, but users sometimes note editor bugs, workflow rough edges, or less mature collaboration tooling.
Maturity of 3D toolsetWhile GDevelop now supports 3D and 3D physics, its 3D tools, lighting, advanced effects, 3D modeling import, scene graph tooling, and advanced 3D workflows are likely less mature than a mature 2D engine’s 3D “add-on” would beBecause 3D is relatively new in GDevelop, its 3D pipeline may lack many niceties, optimization paths, or extensive tooling compared to more mature 2D features.
Legacy / backward compatibility & stability in large projectsConstruct, being commercial and mature, often ensures backward compatibility and robust stability across versions; GDevelop’s rapid development sometimes introduces breaking changes or refactorsUsers sometimes report that older projects may need adaptation after engine updates.
Native code / performance-critical modulesConstruct’s core is more battle-tested, and many performance optimizations are deeply engineeredGDevelop’s engine, being open and evolving, may lag in some ultra-high-performance edge cases.
Monetization / platform SDK supportSome users note that integrations for in-app purchase, ad networks, or platform-specific SDKs in GDevelop are less polished or more cumbersome. CapterraE.g. GDPR support in ad modules, or integration of multiple ad networks, may require more manual work.
Community size, resources, documentation, tutorialsConstruct has a larger commercial user base, more polished tutorials, asset packs, plugins, community supportGDevelop is growing and has an active community, but in some niche cases, you may find fewer fully polished ready-made tutorials or plugins.

Summary & perspective

  • GDevelop has closed many past gaps, especially with the addition of native 3D, physics, multiplayer, better asset unloading, object organization, etc.
  • The remaining differences are less about “can’t do” features and more about the polish, stability, tooling UX, debugging power, plugin ecosystem maturity, editor refinements, and performance visibility.
  • In many cases you can build with GDevelop what you could with Construct, but you might invest more effort on tooling, debugging, or workarounds.
Posted on

Automating the import of hundreds of sprites to Construct

I’m making a game where an area of ground is broken piece by piece. I managed to create a python script that uses a voronoi pattern to shatter my image into several small irregular pieces. Here’s how that looked:

I then needed to import those 200 pieces into Construct. I figured out that if I set the position of each piece to 0,0, they would form the full image perfectly. After that I can just crop the pieces to their actual pixels and things work really nicely: the voronoi jigsaw puzzle comes together like it should.

The only pain point I had left was importing 200 sprites one by one into Construct. I knew that I could drag them all at the same time on top of Construct, which would create an animation. But I needed to create several individual sprites instead of animation frames.

The real life saver in this situation turned out to be the Project Folder feature in Construct (works best in Chrome), since it gives direct access to the project file structure. So here are the steps I performed and the scripts I used:

Please don’t attempt this with your production code, instead start a new empty Construct project and save it as a Project Folder on your local hard disk

1. Use a Python script to loop through all the image files in a folder and have it generate the JSON files Construct expects to have in the objectTypes folder. Here is the script for that (zipped due to security considerations). To run that, just unzip, place it in the same folder with the images, open a terminal there and type: python generateProjectJSON.py and hit enter. A bunch of JSON files should appear which you should copy to your Project Folder’s objectTypes folder.

2. Next the project.c3proj file needed to have the files listed in the items array in this manner:

“objectTypes”: {
“items”: [
“myImage_0”,
“myImage_1”,
“myImage_2”
],

So made a script to generate the array. Note that this is a very simple script and could be improved to support more files name conventions. At the moment it is just adding an incrementing number at the end of each image name. This script will output a simple array in a file called names.txt. Copy the array to your project.c3proj file.

3. The images needed to be renamed with -default-000.png appended to their file name. Time for another script, run this similarly in the folder with the images. After that I copied the images into the images folder inside the Project Folder.

4. That’s basically it but I also wanted the sprites already placed in the layout at coordinates 0,0 so I wrote one more script to do that. Run this script where you have your JSON files (that we generated earlier) and it will give you a new file called new_layout.json. Take the “instances” array from the generated file and merge it with your Layout 1.json file (which can be found in the layouts folder).

Now just reload the project and something magical happens: all your images will appear in the project and in the layout! Even if it’s hundreds or even thousands of images.

So there we have it. This workflow is obviously not useful if you just need to import a small number of sprites. But if you needs hundreds, then this can definitely save you some frustrating manual labor.

Posted on

Finally, an insanely good pixel art AI

As a 2D game creator, I have been searching for an text-to-pixel art generator AI for a long time. It looks like we have finally arrived! Check out the results I got for the prompt

“a sprite sheet of several pixel art doors”!


Wow! Those are INSANELY good compared to previous pixel art generative AI’s!

So by now you must be dying to know which tool I used to generate those and how much it costs! Well I have good news for chatGPT users! I used Dalle-3, which you can now use for free with a chatGPT subscription! That’s right, since I already subscribe to chatGPT, I generated those awesome images for free!
This is getting really exciting for indie game developers everywhere!

Posted on

How to concatenate strings and variable values in GDevelop

I’m currently studying the relatively new open source “code free” game engine GDevelop, so I will write some tips and tricks regarding it here.

One basic thing you should learn to do in any game engine is mixing strings and variable values together. The way to do this varies in different game engine.

In GDevelop, you can do this:

"Score is " + GlobalVariableString(myVar)
Posted on

Anyone can try NeRF now with a free app!

The 3D industry has been buzzing about Nvidia’s Instant NeRF (which stands for neural radiance fields) ever since they published their first demo video.

This technology has since been in rapid development and we now have a free iPhone app called Luma AI that anyone can use to capture NeRFs.

I tested the app with a toy robot, here’s a automatically generated video of the result:

The amazing thing about NeRF renders is that they can handle light reflections and bounces in a very realistic manner. This makes it a good fit for VFX work. We can also export a textured 3D-model from the Luma AI app, but it’s not as impressive as rendering with NeRFs. It’s still quite good compared to a basic photogrammetry process, especially considering that the surface of our object was quite reflective. Here’s a screenshot from Blender:

Here is how the mesh looks like (very dense):

Here’s another cool shot from a Robotime Ball Parkour toy:

@oneminutevideotutorial

Wow! NeRFs are going to be great for displaying products like this!

♬ original sound – user635578337916 –
Posted on

A tool for recoloring pixel art to a new color palette

I have been searching through the webs for a long time for a good, easy to use tool for recoloring pixel art to a specified color palette. The perfect tool should make it easy and fast to test out different palettes for a provided bitmap image or a sprite sheet, but it should also make it possible to fine tune the color mappings and add new colors to the palette if needed.

This has provided to be a rather challenging task. Photoshop and other similar graphics programs do have the possibility to switch to indexed color which lets you force the image to a new color palette, but I find that workflow to be rather tedious and time consuming. Illustrator has the recolor artwork tool, but it works only with vector images.

Here are some of the tools that I did find:

Continue reading “A tool for recoloring pixel art to a new color palette”