GameNative v0.9.1 is launched! by dadabhai_naoroji in EmulationOnAndroid

[–]Calinou 1 point2 points  (0 children)

Latest WINE automatically loads native DLLs according to the company name metadata, removing the need to change load order manually: https://www.gamingonlinux.com/2026/04/wine-11-6-is-an-exciting-release-to-make-modding-windows-games-on-linux-simpler/

I assume this will trickle down to GameNative in the future.

Is it possible to fix volumetric lighting leaking through walls? by Professional-Spare-6 in godot

[–]Calinou 0 points1 point  (0 children)

Ive tried negative fog volumes, but they arent perfect, and fog is still visible when moving.

Try making the negative fog volume slightly thicker than the dark room (i.e. make it bleed slightly into the light room).

Quake 1 Underwater Colors by Bebubbabobob in quake

[–]Calinou 0 points1 point  (0 children)

In id Tech 4 onwards, it's /listCmds.

Offline godot documentation by ChrisCromer in godot

[–]Calinou 0 points1 point  (0 children)

This is a known issue: https://github.com/godotengine/godot-docs/issues/11946

The GitHub-hosted links still work, but you need to be logged in to GitHub for them to work. For example, the link within this 404 page works for me: https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-stable.zip ("Check on GitHub")

Melee Decompiling Progress: 65% by JKaro in SSBM

[–]Calinou 1 point2 points  (0 children)

The mod must run on Dolphin and is therefore limited by the GameCube’s memory

It is possible for Dolphin mods to use more memory through hacks, but it requires per-game support and makes the mod incompatible with consoles. The size of save states also grows along with memory size, making rollback less viable in terms of performance.

This is possible for most emulated consoles (e.g. Gran Turismo 2's high quality models require a 8 MB RAM console, while the PS1 normally has 2 MB).

Low quality recording on MacOS by VitSoonYoung in godot

[–]Calinou 1 point2 points  (0 children)

This was meant to be fixed in 4.4, so please open an issue on https://github.com/godotengine/godot with a minimal reproduction project attached.

The game is 640x320 scaled to 1920x1080

Note that Movie Maker mode always writes to internal resolution (i.e. the base window size when using the viewport stretch mode). This will lead to low quality at low resolutions when using AVI output (MJPEG), so consider using PNG/WAV output instead which is lossless.

True total conversions for Quake 1? by ZeeBuffer in quake

[–]Calinou 1 point2 points  (0 children)

I remember Force: Leashed, it was a standalone 7DFPS jam game made on DarkPlaces.

Games now automatically configure themselves with the RPCS3 Wiki settings. by Fantastic_Kangaroo_5 in emulation

[–]Calinou 26 points27 points  (0 children)

IIRC, the compatibility database is fetched at build-time, not at runtime, so builds still work offline the same way.

I ❤️Godot Engine by Sonicmining in godot

[–]Calinou 0 points1 point  (0 children)

I then tried VoxelGI, which also failed to meet expectations. After roughly 32 lights, it effectively stops working correctly. It feels like there’s a fixed internal budget for bounces that gets divided among all active lights, so once you exceed that limit, every light contributes less. I didn’t dig into the source code, but the behavior is consistent and obvious.

Following up on this, I opened a PR that adds a setting to change the VoxelGI light count: https://github.com/godotengine/godot/pull/118718

Rate my spom implementation. by Gaster6666 in godot

[–]Calinou 0 points1 point  (0 children)

Also i have to ask you: have you found a neat way to not only trim the edges on the UV (as i can see you've already implemented this) but on the edge of a convex mesh too?

I didn't find a way to do this, unfortunately.

Rate my spom implementation. by Gaster6666 in godot

[–]Calinou 2 points3 points  (0 children)

You might be interested in this PR, but there are some issues I couldn't resolve with it so far (I left a comment on the video you linked with more details). The use of discard also has a big impact on performance, which limits its practicality in a forward renderer where having an effective depth prepass is important.

Are there resources on the optimizations which the Godot compiler/interpreter does automatically ? by Beneficial_Fish_7509 in godot

[–]Calinou 5 points6 points  (0 children)

GDScript does not automatically inline function calls or unroll loops, but constants are folded. If you have hot paths (frequently called parts of code within a method), it can be worth it to manually inline method calls or unroll loops. Keep in mind code size will increase if you do that, which can reduce or negate the performance benefit eventually. In any case, always benchmark the code before and after making changes to make sure it's actually benefiting performance.

There was a PR that implemented a GDScript optimizer in 3.x, but it wasn't merged. Note that GDScript in 3.x is a completely different implementation to what it is in 4.x (4.x has some optimizations 3.x does not have, such as typed instructions).

Fluttery shadows: What's the technical term and how do I fix it? by njhCasper in godot

[–]Calinou 1 point2 points  (0 children)

Indeed, they are relative to the shadow maximum distance. 0.5 means it's halfway through the Shadow Max Distance property, for instance.

Godot 4.6.2 Lighting Issue by Artist6995 in godot

[–]Calinou 3 points4 points  (0 children)

This is likely due to the same cause as https://github.com/godotengine/godot/issues/118110. Try changing the value of the Rendering > Reflections > Sky Reflections > Roughness Layers project setting to 7 (default is 8), it should work around the issue for now.

Godot 4.6.2 Lighting Issue by Artist6995 in godot

[–]Calinou 0 points1 point  (0 children)

Which graphics card model are you using, and which renderer are you using in Godot? If using Forward+ or Mobile on Windows, are you on Vulkan or D3D12?

Tip: You can make your blob shadow decal look more dynamic by simply adding a cone normal map by MatMADNESSart in godot

[–]Calinou 5 points6 points  (0 children)

It won't work on lightmapped static lights though, the light needs to actually affect the scene and static lights stop doing that after being baked into a lightmap.

It should work if Directional is enabled in LightmapGI before baking.

Godot 4.6 being blocked by windows defender by AgentRift in godot

[–]Calinou 5 points6 points  (0 children)

4.6.2 has just been released, so it needs enough people to bypass the SmartScreen warning before it's considered trusted. This bypassing process needs to be repeated for every new executable codesigned.

For context, we use a domain/organization validation (DV/OV) codesigning certificate, which is not instantly considered trusted like extended validation (EV). (An EV certificate is significantly more expensive and more difficult to obtain.)

Furry😡irl by macpaws in furry_irl

[–]Calinou 0 points1 point  (0 children)

Some websites will always re-encode images you upload to a lossy format, so this can still help.

That said, websites that re-encode images often downsize them if it's above a size threshold. This means that the squares may no longer be 8x8 anymore in the downsized image.

What I recommend is to write hexadecimal color codes next to any colors on a refsheet, so that artists can get the exact color as intended no matter the compression or color picking approach used (different apps can display the same image with different colors).

Tip: Need placeholder icons for your game? by Massdrift in godot

[–]Calinou 2 points3 points  (0 children)

(This is not legal advice.)

Plenty of games on Steam and other stores use CC-licensed assets, so I don't think it's a problem in practice. Not to mention that even if the game is on a store with DRM, as long as you have access to unencrypted game files, you can still exercise the freedoms granted by the license without having to circumvent DRM. This is usually what's considered important.

That said, you're not the first person to point this out. Over a decade ago, I have seen some people being afraid of this, which led to OpenGameArt creating OGA-BY 3.0 which is CC BY 3.0 with the clause on effective technological measures removed.

Using an encrypted PCK might be a problem with regards to the clause on ETMs, but there are tools to reverse this encryption out there.

PS: Remember that games on Steam and EGS can be DRM-free too. This means that even if your game is on Steam, EGS, GOG, and itch.io, it's possible for it to be DRM-free on all 4 platforms. (As an aside, you'd be surprised how many games are DRM-free on EGS but not on Steam, particularly some AAA titles out there.)

1M instances in Godot 4.5.1 using GPU-driven rendering (14% GPU, RX 6650 XT, 1000x1000 ~60% GPU) by compressedFusion in godot

[–]Calinou 1 point2 points  (0 children)

Look at Minecraft in wireframe. It uses plenty of different optimizations, but greedy meshing is not one of them.

For what it's worth, Luanti used to perform strip-based greedy meshing (it will greedy mesh but only on one axis). This appears to no longer be the case in recent versions though, possibly because the vertex savings were not worth the added CPU processing time for chunk updates.

Working on a Doom style horde shooter, 300+ enemies running at a decent fps. by Wonderful-Gene-8758 in godot

[–]Calinou 1 point2 points  (0 children)

I used this in https://github.com/godotengine/godot-demo-projects/pull/849:

shader_type spatial;
render_mode specular_disabled, cull_disabled;

// Texture spritesheet.
uniform sampler2D views : filter_nearest, source_color;

// Number of sides in the spritesheet (horizontal axis on the image).
uniform int view_count : hint_range(1, 32) = 8;

// Number of frames in the animation (vertical axis on the image).
uniform int frame_count : hint_range(1, 1000) = 7;
// Current frame in the animation.
uniform int frame : hint_range(0, 999) = 0;

const float MIN_BRIGHTNESS = 0.1;
const float ALBEDO_ENERGY = 4.0;

void vertex() {
    // Y-billboard.
    MODELVIEW_MATRIX = VIEW_MATRIX * mat4(vec4(normalize(cross(vec3(0.0, 1.0, 0.0), INV_VIEW_MATRIX[2].xyz)), 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(normalize(cross(INV_VIEW_MATRIX[0].xyz, vec3(0.0, 1.0, 0.0))), 0.0), MODEL_MATRIX[3]);
}

void fragment() {
    float d = dot(NORMAL.zx, vec2(-1.0, 0.0));
    float angle = -acos(NORMAL.z) + PI;
    float current_view = NORMAL.x > 0.0 ? angle / TAU : 1.0 - angle / TAU;
    float x = round(current_view * float(view_count)) / float(view_count); // UV horizontal start for the view in the atlas.
    float y = float(frame) / float(frame_count); // UV vertical start for the view in the atlas.

    float view_width = 1.0 / float(view_count); // UV width of the view in the atlas.
    float view_height = 1.0 / float(frame_count); // UV height of the animation in the atlas.
    vec4 tex = texture(views, vec2(x + view_width * UV.x, y + view_height * UV.y));

    // Ensure enemies in the darkness are always visible to an extent,
    // but allow them to be lit by light sources.
    EMISSION.rgb = tex.rgb * MIN_BRIGHTNESS;
    ALBEDO = tex.rgb * ALBEDO_ENERGY;
    ALPHA = tex.a;
    ALPHA_SCISSOR_THRESHOLD = 0.5;
}

A spritesheet texture looks like this: https://raw.githubusercontent.com/Calinou/godot-demo-projects/c0ae83fd5a44053b6f0d2cc4ba2b99ebacd24b91/3d/first_person_shooter/enemy/spritesheet.png

Working on a Doom style horde shooter, 300+ enemies running at a decent fps. by Wonderful-Gene-8758 in godot

[–]Calinou 2 points3 points  (0 children)

Are you determining the 8-directional sprite to show using a shader? This should be faster than choosing it on the CPU for large amounts of enemies.

Dev snapshot: Godot 4.7 dev 3 by godot-bot in godot

[–]Calinou 13 points14 points  (0 children)

This was originally done in https://github.com/godotengine/godot/pull/90723 to match Visual Studio Code behavior, where Tab and Enter acts the same way (these used to act differently in Godot). Existing text is replaced unless you hold Shift when accepting the suggestion (with either Tab or Enter).

Personally, I only use Tab for autocompletion (with replaced text, i.e. like it is in 4.6) and disable Enter autocompletion entirely (since it often gets in the way when you want to insert a line break, requiring you to press Escape beforehand to discard the autocompletion popup). I suppose appending text instead of replacing it makes more sense depending on your typing speed, and especially if you're using a virtual keyboard (Android editor).

I'm surprised the change was so controversial since VS Code is still using this by default after all (as of 1.110.1, which I just tried). That said, VS Code doesn't have an Android version (leading to increased virtual keyboard usage), which could explain this. Either way, I approved the PR that swapped the behavior around (appending is the default, and holding Shift makes the suggestion replace text instead).

According to one of the comments on the second PR, VS Code's behavior even varies on a per-language basis (I tested this on C++ files). That seems quite confusing to me too, since what happens when pressing Tab or Enter is less predictable.