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

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.

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.

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.

Downgrade all headings inside selected text in LibreOffice Writer

If you’ve ever pasted or imported text into LibreOffice Writer from another source, you might have run into a common formatting headache:
the headings are all too high in the hierarchy.

For example, what should be a “Heading 2” in your document appears as “Heading 1,” bumping your outline out of balance and making your document structure harder to follow.

Why this happens

When content comes from another program — such as a web page, Markdown editor, or PDF — LibreOffice tries to match the original formatting to its built-in paragraph styles. It doesn’t always guess correctly, and often everything gets assigned to the top-level heading style.

The result: your imported section titles are at the wrong outline level, and fixing them manually means tediously selecting each heading and changing it one at a time.

A faster, smarter approach

You can save time by using a small LibreOffice macro that:

  • Works only on the selected text, leaving the rest of your document untouched.
  • Detects built-in heading styles (in English or Finnish).
  • Shifts every heading in the selection down one level — for example, Heading 1 becomes Heading 2, Heading 2 becomes Heading 3, and so on.
  • Keeps both the paragraph style and the document outline structure in sync.

How it works

The macro loops through each paragraph in your selection.
If it finds a heading style, it replaces it with the next-level heading style and adjusts the outline level property so that your Navigator view stays accurate.

This makes it ideal when:

  • You’ve pasted content that should be subordinate to your main document’s headings.
  • You need to merge multiple documents without breaking the hierarchy.
  • You’re working with structured outlines that must remain consistent.

The benefits

With one quick run, you can:

  • Preserve the original heading hierarchy while fitting it into your existing document.
  • Avoid manual, repetitive style changes.
  • Keep your outline and navigation tools accurate and easy to use.

How to Create and Run the Heading-Downgrade Macro in LibreOffice Writer

Follow these steps to add the macro to LibreOffice Writer and use it on your selected text.


1. Open the LibreOffice Macro Editor

  1. In LibreOffice Writer, go to Tools → Macros → Organize Macros → LibreOffice Basic.
  2. In the dialog that appears, select either:
    • My Macros → Standard (makes the macro available in all documents), or
    • Your current document (macro will be saved only with this file).
  3. Click New to create a new module, then give it a name (e.g., HeadingTools).

2. Paste the Macro Code

  1. In the macro editor window, delete any sample code that’s there.
  2. Paste the full macro code into the window (you’ll provide the code in your blog post).
  3. Click the Save icon or press Ctrl+S.
  4. Close the macro editor.

3. Run the Macro

  1. In your Writer document, select the text whose headings you want to downgrade.
  2. Go to Tools → Macros → Run Macro….
  3. In the dialog, navigate to the module where you saved the macro, select DowngradeSelectedHeadings, and click Run.
  4. All headings in your selection will shift down by one level.

The code to paste:

Option Explicit

' --- Utilities ---
Private Function HasUnoProperty(o As Object, propName As String) As Boolean
    On Error GoTo EH
    HasUnoProperty = o.getPropertySetInfo().hasPropertyByName(propName)
    Exit Function
EH:
    HasUnoProperty = False
End Function

Private Function DemoteHeadingStyleName(ByVal s As String) As String
    ' Downgrade “Heading n” (EN) or “Otsikko n” (FI) by one level
    Dim prefixes(1) As String
    prefixes(0) = "Heading"
    prefixes(1) = "Otsikko"

    Dim i As Integer
    For i = LBound(prefixes) To UBound(prefixes)
        Dim pre As String : pre = prefixes(i)
        If Left$(s, Len(pre) + 1) = pre & " " Then
            Dim lvl As Integer : lvl = Val(Mid$(s, Len(pre) + 2))
            If lvl >= 1 And lvl < 10 Then
                DemoteHeadingStyleName = pre & " " & (lvl + 1)
            Else
                DemoteHeadingStyleName = s
            End If
            Exit Function
        End If
    Next i
    DemoteHeadingStyleName = ""  ' not a built-in heading style
End Function

' --- Main ---
Sub DowngradeSelectedHeadings()
    Dim oSel As Object
    oSel = ThisComponent.getCurrentSelection()
    If IsNull(oSel) Then Exit Sub

    If oSel.supportsService("com.sun.star.text.TextRanges") Then
        Dim i As Integer
        For i = 0 To oSel.getCount() - 1
            DemoteInRange oSel.getByIndex(i)
        Next i
    ElseIf oSel.supportsService("com.sun.star.text.TextRange") Then
        DemoteInRange oSel
    Else
        MsgBox "Please select text in Writer.", 64, "Downgrade headings"
    End If
End Sub

Private Sub DemoteInRange(oRange As Object)
    Dim oText As Object, oCursor As Object, oEnum As Object
    oText = oRange.getText()

    ' Create a cursor that spans exactly the selection
    oCursor = oText.createTextCursorByRange(oRange)
    oCursor.gotoRange(oRange.getEnd(), True)

    ' Enumerate paragraphs within the selection
    oEnum = oCursor.createEnumeration()
    Do While oEnum.hasMoreElements()
        Dim oPara As Object
        oPara = oEnum.nextElement()

        ' Safety: only handle real paragraphs
        If oPara.supportsService("com.sun.star.text.Paragraph") Then
            ' 1) Demote outline level if present
            If HasUnoProperty(oPara, "ParaOutlineLevel") Then
                Dim lvl As Integer
                lvl = oPara.ParaOutlineLevel
                If lvl >= 1 And lvl < 10 Then
                    oPara.ParaOutlineLevel = lvl + 1
                End If
            End If

            ' 2) Demote built-in heading style names (EN/FI)
            If HasUnoProperty(oPara, "ParaStyleName") Then
                Dim s As String, sNew As String
                s = oPara.ParaStyleName
                sNew = DemoteHeadingStyleName(s)
                If sNew <> "" Then oPara.ParaStyleName = sNew
            End If
        End If
    Loop
End Sub

Awesome Free Icon Library

Who doesn’t love UI icons, especially when they are designed in a beautiful and consistent style?

And who doesn’t love permissible licenses that allow both commercial and non-commercial use without attribution?

TastyIcons is a great new icon library that matches all those conditions. It has advanced categorization, tagging and search and it let’s use customize your icons before download.

Here are some screenshots:

Visit TastyIcons now!