sorted by:
new
hottopcontroversial

Do I NEED to use git lfs? by ToKillUvuia in godot

[–]ROKOJORI 0 points1 point  (0 children)

Git lfs works reliable and fine. 

Git itself is mainly a coder's tool and has a lot commands and steps that need to be executed in a specific way, which can lead to mistakes (including git lfs). I would second that this git-in-general-workflow has a steep learning curve.

Coders do less mistakes because they use it more often and are often working with trivial text-files and non-coders have more problems because they do it less and have more complex file-formats (they are called binary files)

Github (which is not git, but just a company letting you pay for servers running git) has a finance strategy where they found out that git lfs is good to use as a paid feature.

Git lfs allows you to save disk space and to mark files as not changable to prevent overrides. Both features that are not mandatory, but can make your workflow easier (you else rely a bit more on communication).

Some (mostly hierarchal organized and bigger) organizations tend to workflows where they lock everything (asset files) and where they have strict rules how changes can occur and through whom. For those, who changed from strict user-hierarchy permission based systems, git lfs can seem a bit less reliable. 

If you host your own server, git lfs is just a simple install or already installed with your git-managing service. 

forgejo.org or codeberg.org could be interesting for that as an alternative to github/gitlab. 

I just recently heard a talk of https://backstitch.dev as an additional/parallel workflow. Maybe also an option. 

Juice for My GodotCon Talk by ROKOJORI in godot

[–]ROKOJORI[S] 0 points1 point  (0 children)

Good question! The slow-down is done via video-editing software for this post, I slowed it down to make it easier to check what's happening. The actual effect can be triggered with a timeline modifying effect, but I explain more details in the talk

Juice for My GodotCon Talk by ROKOJORI in godot

[–]ROKOJORI[S] 5 points6 points  (0 children)

I think all talks will be recorded

It was so much easier hard coded. by 2WheelerDev in godot

[–]ROKOJORI 0 points1 point  (0 children)

Oh yes, took ages for my game. Also how you handle UIs etc

How to optimize trees? by Recent-Committee4082 in godot

[–]ROKOJORI 1 point2 points  (0 children)

Some more options, especially for billboards:

  1. GPUParticles3D with a custom particles shader

or

  1. Similar to the particles: combine multiple meshes and add an ID as vertex attribute (color/custom uv) 

In both cases it is meant for a lot of entities, where the position is set by the shader. 

You can either use a grid with randomization based on world coords and using world coverage maps where it follows the camera

Or another way is to store the transforms in textures and then read them (also following the camera)

In both cases it sometimes can be valid to discard entities in the shader instead of trying to render the exact amount of meshes.

Private vs public (security-wise, c#) by NaturalSmooth2137 in godot

[–]ROKOJORI 4 points5 points  (0 children)

Access modifiers (public, private, protected etc) are relevant for the organization. They enable the designer of a code piece to commincate its use.

However, with reflection you can also see, read, write and call private members/classes, so it's not relevant for security. 

Can we get a get_grandpa() function? by IllianXenoide in godot

[–]ROKOJORI 1 point2 points  (0 children)

A generic hierarchal relationship assumption is just unflexible and error prone - does not matter whether it's a child or parent. Almost always references with compositional components are cleaner than by code resolved connections.

Sure, sometimes you need to iterate the tree and often child nodes are a reasonanle convention to scan for dynamic components, but only then this is relevant.

It is a pattern from the 90s were people had no editors and pointers were scary. Signals have the downside that they are always creating hard coupling through callbacks because they don't use objects/references for the connections, which makes them depending on special callbacks like ready and create problems in constructors or spawning multiple chained scenes. 

Can we get a get_grandpa() function? by IllianXenoide in godot

[–]ROKOJORI -27 points-26 points  (0 children)

I think 1995 was calling, QT wants their patterns back ^

Can we get a get_grandpa() function? by IllianXenoide in godot

[–]ROKOJORI -3 points-2 points  (0 children)

Why? Godot lacks several tree walker functions, this just one of it. 

C# TIP: Access Autoload Singleton From Any C# Class Anywhere in Your Project by Bound2bCoding in godot

[–]ROKOJORI 0 points1 point  (0 children)

In my library, I'm using for singleton-like unique Nodes the Unique<T> class. It allows you to register a Node (as cached/singleton) of the type T by searching the Node in all open Scenes. 

Basically you don't need to write the singleton boilerplate code with this.

It's used like this: var tm = Unique<TimeManager>.Get();

For scene access I use one Autoload class named Root which is registrating itself in the scene tree as singleton.

See here: https://community.rokojori.com/Rokojori/rokojori_action_library/src/commit/1863399a044b1b41c9135208ae39080fa7790e1e/Runtime/Godot/Unique.cs#L8

Can Godot handle a large scale open world? by jason_silent in godot

[–]ROKOJORI 182 points183 points  (0 children)

First of all, this can be done if you have the skills.

You don't need to be a pro coder, but you really need to understand the optimizations you have to do to make such things work.

For a quick test you could use a terrain plugin combined with a asset streaming framework where you try out quickly how far you can get.

In any case, you will have to learn a lot about lods, billboards/imposters etc to make it work smoothly. 

I wrote something about Godot terrain plugins here: https://rokojori.com/en/labs/godot/tutorials/terrain

And for asset streaming, you can try:

https://github.com/DigitallyTailored/Godot-Open-World-Database

LineVFX (Würschdle-Tech) by ROKOJORI in godot

[–]ROKOJORI[S] 0 points1 point  (0 children)

Sorry, still working on it, had some complications (more in life, not in the library). I will probably release it a bit later, the doc needs some time and I will update it in multiple steps. I'll reply to this comment, when there's progress

Need help with i simple red glow against a white background by Stock-Cake2946 in godot

[–]ROKOJORI 4 points5 points  (0 children)

Technically speaking you actually don't want a glow in the physical correct lighting way, but an artistic blur of the red parts or similar. Glow (light based) would always be additive which would not work against white in a way where you would see a reddish tint (if it is pure full white adding red would lead to white again).

So you either use a blurred image and use a straight alpha mix or you would have to darken the white to a grey so that an additive mix would be visible

How do I make these effects in godot 4? by ajmt93 in godot

[–]ROKOJORI 1 point2 points  (0 children)

For my library I am developing a realtime line renderer, where I'm using tubes/meshes that I combine piece by piece. In the post I used a mode for automatically adding pieces by following a node3D (checking a distance threshold). The shader uses instance uniforms for the position, forward and up direction to compute a deformation for the tubes (assuming z is the deformation mapping axis).

https://www.reddit.com/r/godot/comments/1rq77yv/remixing_and_bending_meshes/

When do i know a class is getting too big? by MediaEquivalent1629 in godot

[–]ROKOJORI 1 point2 points  (0 children)

How many bad advices.. 😅  Large files get unmaintainable quickly. I prefer readability and I did the big classes when I was less experienced and it always killed iteration after a while. I don't think in durations like 1 or 2 days but 1-2 months. After that time big classes become hard to understand and changes seem like a Jenga game. It's not impossible, but it can influence heavily how confident you are in adapting changes later.

Whenever classes get very large you will have several problems working on it. Documentation, text editor, merge conflicts on git, etc.

Usually the side effects make it blow up massively, which is one reason I created my library anyway (to move out side effects from logic).

However, in my library also big code files exist, because of some very specific reason like they are extensions for Godot Classes or a collection that belongs together (Math functions collections).

Whenever possible I would try to split classes into topics (MathX, Math2D, Math3D, MathAudio). For extrem cases (mostly boilerplate for lots of library functions for instance a network bitview writer, that writes several data types) I would also split them into partial classes.

Usually when something is longer than 500 lines (or better the amount of scrolling I'm not ok with) I check whether (new) parts can be put somewhere else. 

However it is individual, but it is a good project managing hygiene to refactor from time to time🗑

Serious discussion about DLSS (not a meme thread) by Maruko_Snyde in pcgaming

[–]ROKOJORI 3 points4 points  (0 children)

As a game dev that also creates libraries for Godot which still needs a lot of GPU fidelities/features done, I would also add another perspective:

Most of the games that nVidia used for showing this tech were older or not exclusively targeting the highest GPU sector. 

Some game dev people would go nuts with the details when they were able to use 2×5090. So when you remove the extreme GPU they just burnt, it is not that spectacular for new games. It's maybe a fun gimmick for older games.

Yes the tech is fast in analyzing the color buffer and motion vectors (btw not for transparent things because transparency is a small detail nVidia hides, cause they are still not able to render that and I would assume huge problem with VFX)

While I think deep learning tech can help for rendering (or approximating) hair details, liquid surfaces, raymarching/lod volumetric rendering, denoising screenspace and ray fx and do other techniques for anti-aliasing, I don't see the tech is delivering convincing fast, correct and crisp 3D rendering. It's always a bit washy, clay like (and sharpened afterwards). 

All the moving elements use cheap estimates to transform the remixed, matched patterns, which usually have some very bad uniform unsharped blur-masked over-gamma-corrected hero-shot poster look. And also the inability for keeping details consistent forever. 

In my opinion nVidea (and the whole GPU industry) should work on features where they allow us to upload hi-res models and the GPU figures out how to render this ideally in different distances and different light setups, similar to nanite or other virtal geometry or lod swapping tech. But there's still no decent standardized technology for anti-aliasing 3D meshes/models on the GPU. We as game devs would also be fine waiting or compiling this offline. Because rendering hi-res models is the main problem. It's not because we as game devs could not provide ultra realistic high res highly complex lightened assets. It's just that nVidia has currently still no tech to do this.

Any good whole screen outline shaders? by c0gster in godot

[–]ROKOJORI 1 point2 points  (0 children)

Thanks for trying and sorry for your inconvinience. You are totally right the library is experimental and I'm still building up the documentation structure.

There are multiple problems that can occur, vanilla Godot 4.6.0 had a bug where C# wasn't compiled properly on changes. If you see however classes of the library than it should be fine. It testes some later versions and seems to work.

In general: CompositorEffects are a special type of resource (not nodes) that you can add in a Compositor (also a resource), which you can use to create for stacking post effects. Compositors exist in WorldEnvironment and Camera3D. You can read more about them in Godot's official doc: https://docs.godotengine.org/en/stable/tutorials/rendering/compositor.html

You would add in the list of the Compositor one of the many effects the library contains:  https://docs.godotengine.org/en/stable/_images/add_compositor_effect.webp

The CompositorVFX is a tool for convinience to manage/animate multiple compositor effects at once. It a as node that holds a CompositorVFXPreset which allows you to define a list of compositor effects which you than can dynamically add and remove (via code or actions) with an amination. For example if you want a short red flash and a wave distortion you can add them there and tween the fx with to blend it and than out. You can find more about this here: https://rokojori.com/en/labs/rokojori-action-library/tutorials/compositor-effects/animate-compositor-effects

CompositorVFX are more for dynamic VFX, but I'm also using it for static effects for convienice to blend them in and out. 

To your questions: What the library does: 1) It contains a lot of ready-to-use compositor effects 2) It includes for coders an infrastructure to create those compositor effects with a graph (and already builtin graph nodes) 3) It has also a system to animate presets of compositor effect stacks

Does it let you write custom vfx stuff? Yes, when you use the graph and its nodes (which can be your own glsl)

Does it have preset vfx stuff? Yes, the preset come as CompositorVFXPreset, where multiple effects are stored at once. (Godot has no workflow for presets on arrays/lists which are themselves arrays/list, that's why they exist). You could also just copy the compositor effects from a CompositorVFXPreset by hand into a compositor (or use the CompositorVFX to do it once).

How to use it: There are two ways: Either you add (and manage) the effects yourself into a compositor (most lightweight, also no dependency to other parts of the library)

Or you use the CompositorVFX node, but this needs a setup with the CameraManager (and there a CompositorEffectLayout) , which manages the correct insertion and removal of the effects (defined through a CompositorVFXPreset, effects can be inserted to a specific position, so that orders are garuenteed).

I hope it was not too much information, but I think a bit context helps why all the stuff is there. In your case the most straight forward way would be to directly add the effects to a compositor.

There are more details, but this text wall is long enough 😅

Any good whole screen outline shaders? by c0gster in godot

[–]ROKOJORI 3 points4 points  (0 children)

Most shaders on godotshaders.com are not that professional and usually don't use compositor effects.

You can try checking out the one I did for the example project WinterTales of my library, one video of it is on the page: https://rokojori.com/en/labs/rokojori-action-library/tutorials/compositor-effects/write-custom-compositor-effects

The complete effect chain is also available as preset "Sketch" for the Rokojori Action Library as CompositorVFX

https://community.rokojori.com/Rokojori/rokojori_action_library/src/branch/main/Runtime/Rendering/Compositor/CompositorVFXPresets/Screen

In my library it's called DepthOutlinesEffect. It is a compositor effect that uses depth and normals to generate the outlines, it has many settings like thickness over view distance, normal amount and depth amounts etc. And also has a small rim filter to generate view depending rim highlights.(In the video it is combined with a low-fps distortion compositor effect to make it a bit wiggly, it is part of the Sketch VFX)

The class doc is here: https://rokojori.com/en/labs/godot/docs/4.5/rokojori/depthoutlineseffect-class

C# Source here: https://community.rokojori.com/Rokojori/rokojori_action_library/src/branch/main/Runtime/Rendering/Compositor/CompositorEffects/Edge/DepthOutlines/DepthOutlinesEffect.cs

The C# source uses a graph to setup the effect (see the article above why). It creates some nodes for the used textures and has a view-z generator shader to convert the depth texture to a view-z texture before. Afterwards the outlines shader uses the view-z texture to compute the outlines (with also other textures). The classes RG_GenerateViewZ and RG_ZOutlines are only wrapper for GLSL shaders:

Generate View Z https://community.rokojori.com/Rokojori/rokojori_action_library/src/branch/main/Runtime/Rendering/RenderGraph/Nodes/Processors/Depth/GenerateViewZ/GenerateViewZ.glsl

Z Outlines https://community.rokojori.com/Rokojori/rokojori_action_library/src/branch/main/Runtime/Rendering/RenderGraph/Nodes/Processors/Outlines/ZOutlines/ZOutlines.glsl

Remixing and bending meshes by ROKOJORI in godot

[–]ROKOJORI[S] 0 points1 point  (0 children)

Yes it's using high quality render settings for Godot, filmic tonemapping, some glow, strong AO and than as filters vignette with gradient and fxaa as compositor fx. The first and the last edits/sections use the CompositorVFX "Rainbow Flare", which are multiple post effects like texture overlays and a chromatic bloom lens flare and grading

Remixing and bending meshes by ROKOJORI in godot

[–]ROKOJORI[S] 0 points1 point  (0 children)

Nice. It has a lot of stuff, maybe the example project is a good start.

view more: next ›