i decided to watch the lectures as the documentation suggested after playing around with godot for a while. i'm trying to make a swap function that can swap the variables in a function from another function, but i'm not sure how to do that in godot. in cs50 they pass addresses to the function and then the function directly changes the values at the address just like that. any idea how that is done in godot?

I have already exported several models and the displacement does not follow the models, only the albedo and the normal map go, do I have to select any extra options?

I've been working on my game for just over a year now, and I was kind of surprised that my codebase was this huge. Is this the norm for you guys?

Hello! So I wanted to try making an isometric 2D game, but I kinda can't figure bunch of things out, so I think asking you awesome people would be a great idea! :D

So the thing is, how can be simple 8 direction (4 directions + diagonals) movement based on the tileset implemented? (Specifically, player clicks on a tile and the player moves there). The second, probably harder thing, how can be simple grid based building system implemented? Is using tilemaplayer for this a good idea? How to translate coordinates to the isometric system?

Thanks everyone for responses! It will help both me and people who would need this a lot! :D

I thought SSAO would have the same result, but it doesn't...

This is a visual effect that simulates the characteristic accumulation motion blur effect found in many PlayStation 2 games. This is my first shader I've ever created, but surprisingly it works! It is under an MIT license.

GDScript Version

## Creates a PlayStation 2-like accumulation motion blur effect.
##
## Add to _process(). The frame blending effect is applied to the area 
## within the boundaries of the texture_rect node.
## It is recommended to only set the alpha from 0 to less than 1.
func accumulation_motion_blur(texture_rect: TextureRect, alpha: float = 0.5, use_frame_post_draw: bool = true, viewport: Viewport = get_tree().root.get_viewport()) -> void:
    alpha = clamp(alpha, 0.0, 1.0) # Alpha values are 0 through 1

    var image: Image = Image.new()
    var texture: ImageTexture = ImageTexture.new()

    image = viewport.get_texture().get_data() # FORMAT_RGBAH
    image.flip_y() # Images start out upside-down. This turns it rightside-up.
    if use_frame_post_draw:
        yield(VisualServer, "frame_post_draw") # Changes when the effect is rendered. Changes the vibe.
    texture.create_from_image(image) # Turn Image to ImageTexture
    texture_rect.modulate.a = alpha # Changes the opacity of the frame blending
    texture_rect.texture = texture # Applies the image of the previous frame to the texture_rect

Godot Shader Version

This section gives the shader the image of the previous frame as a texture. (I don't know how to do this in just shader language as this is literally the first shader I've ever created.)

## Godot Accumulation Motion Blur
## By Lamb; MIT license
##
## Use in conjunction with the accumulation_motion_blur shader material.
func accumulation_motion_blur_shader(material: ShaderMaterial, viewport: Viewport = get_tree().root.get_viewport(), post_frame_draw: bool = true) -> void:
    var image: Image = Image.new()
    var texture: ImageTexture = ImageTexture.new()

    image = viewport.get_texture().get_data()
    texture.create_from_image(image)

    if post_frame_draw:
        yield(VisualServer, "frame_post_draw")

    material.set_shader_param("framebuffer", texture)

This section is doing the visual effect.

// Godot Accumulation Motion Blur
// Use in conjunction with the accumulation_motion_blur_shader() GDScript method
// to feed this shader the framebuffer texture.
// Apply this shader material to a ColorRect node to affect visuals underneath it.

shader_type canvas_item;


uniform float alpha: hint_range(0.0, 1.0, 0.001) = 0.5;
uniform float blur = 0.0;
uniform sampler2D framebuffer;


void fragment() {
    COLOR = texture(framebuffer, SCREEN_UV, blur);
    COLOR.a = alpha;
}

Such a cute mascot I wanna cuddle her

👉 Check out the tutorial on Youtube: https://youtu.be/fahDYsPjUvc

So - wanna improve your custom 3D skybox in Godot, to get rid of the annoying issue of "pole stretching"? Discover how to use equirectangular panorama images and cubemaps in a few minutes :)

(Demo assets at the beginning from Kenney)

Hey everyone!

A few months ago I posted about my analytics tool for Godot. Since then, I've been working on some features that were requested and wanted to share the progress.

New Feature: Pick Rate Analysis

This one came from feedback about tracking player choices. Instead of just counting events, you can now see actual selection rates:

• Card games: "Lightning Bolt picked 87% of the time when offered"
• Shop systems: "Health potions bought in 34% of encounters"
• Dialogue trees: "Players chose aggressive option 62% of the time"

The charts show percentages instead of raw numbers, which makes balancing decisions way clearer. I've been testing it with a few card game devs and the insights have been pretty useful.

Multi-Engine Plugins (All Open Source)

Also expanded beyond Godot based on requests (useful if you use more than one engine):

• Unity: https://github.com/TokebiAcademy/tokebi-metrics-unity-plugin
• Unreal: https://github.com/TokebiAcademy/tokebi-metrics-unreal-plugin
• GameMaker: https://github.com/TokebiAcademy/tokebi-metrics-gamemaker-plugin
• RPG Maker MV: https://github.com/TokebiAcademy/tokebi-rpgmaker-mv-sdk
• RPG Maker MZ: https://github.com/TokebiAcademy/tokebi-rpgmaker-mz-sdk
• Godot: https://godotengine.org/asset-library/asset/4225 | https://github.com/TokebiAcademy/tokebi-metrics-godot-plugin

All the plugins are open source so you can modify them or contribute fixes. The idea is you can track multiple projects in one dashboard regardless of which engine you're using.

What's Different

The pick rate stuff is specifically built for game mechanics, most analytics tools just count events, but this calculates meaningful percentages for player choice data. Plus having all your projects (Unity, Godot, whatever) in one place is pretty convenient.

The plugins are all available on GitHub if you want to see how they work or add features.

Link: https://tokebimetrics.com

If anyone tries the pick rate analysis, curious to hear what you discover about your player behavior.

What kind of player choice data would be most useful to track in your current projects?

"FireLight" is an omniLight btw

Hey everyone! The Greenening is my first bigger project using Godot (after about 8 years of using Unity) and things are going quite well! I just released the demo and I'm super excited to share it with you!

🎮 You can play it here: https://store.steampowered.com/app/3634980/The_Greenening_Demo/

In The Greenening, you control a fluffy cloud, raining down on a forgotten planet. Discover the secrets hidden beneath the ashes and bring the world back to life. 🌱

It also features tons of upgrades, a cute character by the name of Sparkle and a cozy idle space garden.

I’d love to hear what you think - especially about the audio-visual style, pacing, and overall game feel.

Your feedback means a lot, thank you so much! 💚

Premise

Hello everyone! In a post a few months ago I was struggling to find a good workflow for level design in my PSX style game using Vertex Lighting. I have now found a really solid, modular workflow that I wanted to share for anyone in a similar predicament!

The goal here was something modular that I can combine and experiment with easily in Godot, while being able to use Vertex Lighting and achieve a PS1 aesthetic. This flow seems to be working for me well in that regard!

Trenchbroom didn't work for me because I needed smaller vertices to make vertex lighting work- Trenchbroom makes massive surfaces for things like walls and overall it didn't feel like it was facilitating what I wanted to do very well. Instead I ended up with a very beginner friendly and simple Blender + Godot workflow

Base Asset Creation + Import

1. Create some tileable square textures however you prefer (wall and floor for now).
   • Tune these to map to about a 1 meter space in Blender / Godot
   • Lots of tutorials out there on making tileable textures; I'd recommend looking into this step further if you don't know how!
2. Configure Blender to a 1m grid with snap and just create some 1m tiles, maybe some 0.5m tiles too.
   • I was able to achieve a lot with just a base wall, floor, and half-variant of each.
   • I cut my quads in half, or sometimes "pinned" them (cut in half twice) to make them work nicely with vertex lighting. PS1 games did this for vertex lighting as well.
3. Import the .blend file to Godot. In the import/re-import settings, go to the meshes tab and click "save to file" for each mesh. Put these in a kitbash or level_tiles folder.

Creating Tile Scenes (Components to make larger scenes with)

1. For each tile, make a new scene with the parent node as a "StaticBody3D". Make child nodes for MeshInstance3D and CollisionShape3D.
2. Assign the appropriate tile mesh to MeshInstance3D and create a BoxShape3D as the collision shape in your CollisionShape3D.
3. Align the parent "StaticBody3D" so that its bottom left corner aligns to 0,0,0 (rather than being centered) and align the children so that they follow the same practice (e.g. if your blender file was centered, transform it so that it matches the bottom left corner to 0,0,0 along with the parent).
4. Shape your collision shape to match the tile, with its surface aligning with the surface of your mesh.
   • It should be like a shallow box that goes under the floor or behind the wall with the same width / height.

Create Kit Pieces

1. This part takes some experimentation based on the needs of your project, but I've found that the most useful kit pieces are just sections of floor and wall in a 2x3, 3x3, or 5x5 layout. I name them things like floor_1_2x2 or wall_1_5x5.
   • You can make other things like pieces where a floor meets 3 wall tiles and a ceiling, but I found this clunky for more freeform design where I didn't know how tall I wanted the walls yet etc.
   • You can circle back to this step later to make kit pieces as they become more obviously needed in your development loop.

Creating Actual Levels

1. Create a new Node3D root scene. This is where you will combine tiles / kit pieces to make a level or level chunk.
   • Feel free to mix "Tile" pieces and "Kit" pieces here. You don't need to make a kit piece for everything, only what you find yourself reusing or doing by hand repeatedly!
2. Place a bunch of your new floor_1.tscn tiles together (or floor_1_3x3.tscn's together etc), making sure to enable "snap to grid". You should be able to build out floors, walls, etc.
3. If you make "level chunks" this way, you can again make a larger scene to combine your level chunk scenes into for a nice modular workflow!

Sorry if this is a dumb question but I tried and failed to look up the answer on my own.

I store my character sheet data on a singleton autoload, stuff like name, attributes, skills etc.

I want the same files to also hold the formulas that calculate the derived stats. Something like:

var str = 5

var dex = 5

var attack = round(str/2 + dex)

This works fine when I print the values in a debugger with the initial attributes, and the attack value changes correctly when I manually change the str and dex values in the file and then start the game.

However, when I change the values in-game manually through a little debug menu I created, the base attributes are updated correctly while the attack value still prints the result as if it were still using the default values.

In this case, after increasing str by 10 points, it correctly reads out Str: 10, Dex: 5 but still prints Attack: 7.

All of the code that uses these variables is in the _process function, which makes it confusing to me.

If the str variable is updated in the _process function, and then the attack variable is called in the same _process function after str has changed value, does Godot not use the current value when calculating what attack is? Does it calculate the value of attack once when first loaded and then never again?

This is just the intro. The full video -- which exceeded Reddit's 15-minute upload limit -- is linked below.

Hey everyone!

I'm Jordan, the developer of Top Down Sprite Maker. Like the name suggests, my program is a pixel art character customizer. But wait, there's more! Unlike pretty much every other program in that niche, my program supports multiple "sprite styles", and let's you create and share your own. A "sprite style" combines an art style, supported directions (whether 4, 6, or 8), animations, layers and assembly rules into a cohesive system of character customization. Sprite styles are defined by a single script file and packaged as ZIPs. They can then be shared, uploaded to the program, and immediately used to customize characters and export sprite sheets.

If that sounds intriguing, check out the tutorial for how to make your own sprite style: https://youtu.be/jqZTsHniSUE

The video description has lots of useful resource links as well if you want more information.

Thanks for your time. Let me know what you think!

You can buy Top Down Sprite Maker on Itch.io: https://flinkerflitzer.itch.io/tdsm

Hey everyone,

I’ve been doing game design/art for a while and lately I’ve been shifting focus toward helping other devs instead of just making my own projects.

I know a lot of folks here are working solo or in small teams and hit walls when it comes to:

• Integrating art into Godot
• Setting up pixel-perfect rendering/scaling
• Workflow bottlenecks
• Design/UX decisions

But I don’t want to assume—I’d rather hear directly from you.

👉 If you could wave a magic wand and fix one Godot-related pain point in your project right now, what would it be?

I'm trying to make a model with animations work when I start the game, still trying to learn Godot, have no idea how is the right aproach exacly... I have the model with animations, It plays just right in the viewport but when I hit Play, the character is just frozen.

func _ready():

\# Ensure Idle animation starts

if anim_player.has_animation("Idle"):

    anim_player.play("Idle")

    anim_player.playback_speed = 1.0

    \# Set Process Mode in Inspector: Physics or Idle

    \# anim_player.playback_process_mode = AnimationPlayer.ProcessMode.PHYSICS

# Play FurtiveRun if not already playing

    if anim_player.current_animation != "FurtiveRun" and anim_player.has_animation("FurtiveRun"):

        anim_player.play("FurtiveRun")

Edit: Make Local is an option when you right click a GLTF imported node in the scene tree. I'm not talking about Make Local on a resource, which makes more sense to me.

Let me start by saying I have used Godot 4 just about every day since launch, so I am pretty experienced in the engine. This is a long rant, so I'll put a TLDR here:

TLDR: After years of using Godot, I don't understand the point of "Make Local". Nobody makes a 3D model once and then it is perfect. It precludes the option of iterating on it, or at best, makes iterating extremely painful. So what's the point of this feature?

When it comes to importing models, textures, etc., .gltf + .bin file importing makes a lot of sense. The Godot docs also suggest this as the best way to do it. I don't like .blend importing, the external blender call is slow, and sometimes it breaks things. So .gltf + .bin is the way to go.

Now, once the file is actually in the engine, you have two options:

- Drag the .gltf file into a scene to make its own node containing all of the contents of the .gltf file

- Set mesh save paths, save animations, etc., to extract the contents of the .gltf file

Most game developers will immediately recognize the problem with the first option: namely, that you will need to modify the structure of what gets imported. You might need physics bodies, scripts, or ShaderMaterials applied to the objects contained within it. You might need to add signals or dynamic behaviour, or groups. At this point you have two options:

1. Hit Make Local - effectively destroying the link to the original blender file, but allowing you to modify the node however you want
2. Hit Make Editable - gives you some ability to add nodes and change things, but not completely

To my knowledge, developers don't like either of these options. I know in Brackey's video on importing things into Godot, he strongly suggests the option of "set mesh save paths", to create a more modular workflow where you still maintain the link to the .gltf file.

So that's all fine and well - and I use this workflow myself sometimes - but doesn't that defeat the purpose of .gltf in the first place? We have an entire scene hierarchy that we aren't using.

To my knowledge the solution to this is either:

Use convoluted pipelining steps (like the Blender-Godot addon, which I develop), or use GLTFDocumentExtension (a better way) to get more integrated pipelining.

I know there is some effort to get GLTFExtensions integrated in the engine, but won't this ultimately have some limitations as well? The extensions can't cover all usecases. Even something simple like trying to make a dynamic door opening object - there's no specific extension that would cover this type of dynamic functionality. In an ideal world, this type of thing could be pipelined, like how the Trenchbroom editor allows dynamic functions to be baked into the level design.

Should every developer make their own GLTFDocumentExtension pipeline to design their or asset conditioning pipeline? In principal I like the idea, but the overhead is intense, and even though I know how to do it, I often don't opt for it because it's slow or may end up not actually fitting my usecase.

Hello,

Im following the beginner Tutorial for godot from Brackeys but stumbled upon a Problem with my Tile Map Layers.

In the video he just creates a new node called Tilemap wich i too did. then he continues as normal and selects the layers in the inspector. Time Stamp

So i did this too in my first Try but i did something wrong or idc and it fucked everything and i just started over bc repition is good anyways.

Now on my seconf try i noticed an error on the tilemap that said "TileMap node is Deprecated" so i googled the prolem and found this video

I did it after the video and was okay with it, I just grated another "TileMapLayer" node and moved it above my platforming stuff so it sitzs in the background and it worked.

Anyways now i want to put an enemy in the game and it shows under the background layer so i cant see it and i would like to know why and how to fix it.

i tried to use the same trick as with the player but since the enemy is a normal node it doesnt have any options for that.

Thank you for ur help im going to get dinner.

What is ResourceUID intended for exactly? I've been using it to create unique identifiers for some nodes, but according to the documentation it sounds like ResourceUID might be used specifically for naming resources, potentially ones created dynamically mid-process?

Is it alright to use it for my own purposes as well, or may this mess up some hierarchy/organization stuff later down the line.

I’ve been working on a small game, but can’t find any documentation on how skyboxes are made, and Looking at real N64 games I still can’t figure it out

Like many of you, I had to roll back to 25.6.1 due to the more recent drivers not playing nice w Godot's 3d rendering.

I have peripheral neuropathy so I try not to type a lot. Is there a way to to copy/paste runtime errors in red to google them easier?

https://imgur.com/a/y4jhCtt

If you loved to play puzzle game "Mathora" on your phone then you can play this game for free. https://play.google.com/store/apps/details?id=com.himal13.MathIQGame

Features: Basic puzzles with word based and more Other 4 modes to play to improve your math Ingame rewards and more

Support me to reach 1k download

what Shader to make next ?
pick low-mid difficulty Shader or VFX and I will try my best

Shader Link : https://godotshaders.com/shader/colored-fresnel-shader/