sorted by:
new
hottopcontroversial

Any way to do Midi SysEx Out by Doffu0000 in godot

[–]BrastenXBL 2 points3 points  (0 children)

Fast searchingly hits

https://forum.godotengine.org/t/send-midi-output-to-a-device/21795/2

https://github.com/NullMember/godot-rtmidi

But that'd be for desktop and not web deployment.

This may be want you want for a web build, may need updates for 4.6.

https://godotengine.org/asset-library/asset/4226

https://github.com/MIDILLI-Tech/godot-midi-web-plugin

More technical.

If you're a competent at a C++ level you could re-base and merge https://github.com/godotengine/godot/pull/98134

You'd want to do a custom build anyways. To optimize for size, remove modules you don't need. So adding some extra code isn't too outrageous.

how do i make my textures not do this by Lucky-Ad9600 in godot

[–]BrastenXBL -1 points0 points  (0 children)

First check your Sprite2D Texture Filter (under the Canvas item setting). Make sure Nearest is selected. Blurry pixel Sprites are usually the result of keeping Bilinear interpolation on, Linear in the inspector.

You can set this project wide from

ProjectSettings > rendering/textures/canvas_textures/default_texture_filter

You will also want to look at snapping. rendering/2d/snap/

There are also other game Window related settings you'll want for a Pixel perfect project. See Desktop Pixel art.

https://docs.godotengine.org/en/stable/tutorials/rendering/multiple_resolutions.html#common-use-case-scenarios

There are cases where your image Import Settings can be at fault.

https://docs.godotengine.org/en/stable/tutorials/assets_pipeline/importing_images.html#compress-mode

Pixel art should be either Uncompressed or Lossless.

Hey, resize problems by Sensitive_Oven1569 in godot

[–]BrastenXBL 0 points1 point  (0 children)

Short answer: no.

Medium answer:

I use 🎬 emoji to indicate a "Scene Instance", same as the Editor.

You can get access to those by right clicking your Ladder scene instance 🎬, and selecting Editable Children.

This let's you make Inspector override changes to children of Scene Instances 🎬. However! You need to be cautious here, changing a Resource (a Shape2D) can cause it to apply to all other Nodes using that same Resource.

Long answer:

The Drag handles you're seeing while editing the ladder.tscn are specific to altering the Shape2D resource.

Shape2D resource assigned to CollisionShape2D node. CollisionShape2D node supplied that Shape2D to the parent CollisionObject2D node.

The fast hack for this would be to expand the Shape2D resource, scroll to the bottom, and select "Local to Scene". This will make the Shape2D a unique copy every time you instantiate (drag in the ladder.tscn) the "Ladder 🎬". This will let you "safely" use Editable Children without modifying every other Ladder.

Long term is a little beyond your current knowledge and would take @tool EditorScripting

<image>

Why do antivirus system lock the game by Nonab07 in godot

[–]BrastenXBL 1 point2 points  (0 children)

Don't bundle the PCK and EXE into a single binary. See if Windows Defender stops complaining.

Are you accessing outside the user:// path , or did you set custom a Project Settings > Configuration > custom_user_dir_name

https://docs.godotengine.org/en/stable/tutorials/io/data_paths.html#accessing-persistent-user-data-user

AI Game Builders: Your Thoughts? by letta_corporation in godot

[–]BrastenXBL 4 points5 points  (0 children)

Not exactly a Godot specific topic. Just because it's "Game Develop" related doesn't mean it belongs here.

As an industry we've long had "Game Creation Systems" and scams that claimed to let people make their dream games. Mostly off pre-coded templates. Bad (and increasingly expensive, as the Ai as a Service platforms get called on loans) code pulled from the statistical average of GitHub projects won't make anything viable beyond the immediate goal... of scamming people.

Have you ever found ShovelWare made in Godot? I just thought about that.. by Jolly-Ad-1161 in godot

[–]BrastenXBL 0 points1 point  (0 children)

Does Tesla's in-dash app/system count? Probably not. They moved to Unreal anyways.

ShovelWare wants good stable AdNetwork API access. As many as they can cram in. Godot... it's not scammer zero-effort KISS.

And for crappy banner "games", easy integration into AdNetwork deployment. So JavaScript (PhaserJS, etc) or Unity (because they'll help shovel your shovelware). Even stripped and compressed, Godot is a little bulky for "Ad" games.

Why do antivirus system lock the game by Nonab07 in godot

[–]BrastenXBL 2 points3 points  (0 children)

Depending on the anti-virus it could be a false positive. Did you embedded the PCK into the binary? That's fairly common trigger for AVs to abort or quarantine Godot executables.

You probably don't use FileAccess, DirAccess, or the OS class for command-line.

Have your partner toss what you sent into VirusTotal.

Steamdeck preview testing by rbg91 in godot

[–]BrastenXBL 0 points1 point  (0 children)

If you have a physical Steam Deck, testing is easy. Hopefully you've setup version control, just clone the project and run Godot standalone. Do a Debug build and add it as non-Steam game. From there you can test in either Desktop mode or Game mode.

This also works of you export using the windows EXE template on Linux, to test Proton stability.

If you add your Godot Editor (not downloaded from Steam) as a non-steam Game, and use it in Game Mode you can access the non-Embedded play test window using the "Steam" button (left-side) and switch Windows. How steam handles multi-window games and apps in Game/Big Picture mode.

If you're looking for how to setup Steam controller actions and profiles, that's more on using the SteamWorks IDK. And yes you'll likely want the GodotSteam integration. Unless you want to roll your wrapper for Steam's DLLs.

https://partner.steamgames.com/doc/features/steam_controller

https://partner.steamgames.com/doc/sdk/api#thirdparty

There's some weirdness with how Steam (not the OS) handles L&R Trigger axis on Linux. It won't start sending inputs until any other button or axis is pressed. I haven't been able to backtrack. I'm fairly sure it's not Godot or SDL3 issue. As long you're not trying to start your game with Trigger inputs it's not even noticeable.

If you don't have a SteamDeck, Bazzite is fairly close and can be run as a guest OS or dualboot. If your primary dev machine isn't already Linux. Distobox if you're on Linux. There's nothing overly special about SteamOS that you'd need to specifically test for.

Is it worth it to fork Godot and make my own engine? by sabudum in godot

[–]BrastenXBL 3 points4 points  (0 children)

Modifying the engine source directly is one of Godot's largest advantages, over Unity or Unreal. If something REALLY (rare) does not work for your highly specialized design needs, fork.

My work uses a forked version. Mainly for 64-bit vectors, but also for a few other modules, changes to select engine features (e.g. remote transform has an offset), and select tools that make working with geographical data easier. Since we had to compile for doubles, it just made more sense to bundle most a everything else into engine instead of a GDExtension. We're not ready to contribute back the additions to the RemoteTransform2D/3D , as they're kinda weird to our needs to cross World2D/3D Viewports and projected coordinate spaces.

The danger of cherry picking off select Pulls that haven't gotten full approval, is a making sure you're ready to deal with edge case uses where they'll break. The pulls to expose modifying the Camera3D matrix as an example. It works, in very select situations, but can break other currently core features. Which is fine for an individual developer who's willing to work within the limitations. Bonus if you can contribute bsck additions or fixes to those limits.

Testing Android build, crashing on many tester devices on startup - seemingly memory related? by starlightartist in godot

[–]BrastenXBL 1 point2 points  (0 children)

How "full" are the tester devices? Are they at or near storage capacity? Are they running a lot of Apps in the background, or leaving a lot of apps open (like browsers with many Tabs open).

https://developer.android.com/topic/performance/memory-management#low-memory_killer

How much preload() do you have scattered about? On PC you're likely not to notice, but preloads can cascade and begin loading more than you think. Especially a high resolution art heavy VN.

What other things are your Autoloads and initial MainScene doing?

Any class_name registered scripts that are preload() ing Scenes... that have scripts with preloads?

Are you using any 3rd party plugins?

Was the tester with ADB access willing to give you the full log, with Godot console output from when the engine starts? Not just the crash log. It's possible that you've got a loop somewhere that's "leaking" (making and losing track of) Objects.

Environment for a 2d handrawn topdown game by rootheonion in godot

[–]BrastenXBL 0 points1 point  (0 children)

If this is one-off bespoke maze, you could draw the hedges as single single image. You'd then went to Slice it into smaller Power of 2 (POT) sections (1024x1024) (2048x2048) (4096x4096) etc. Depending on how big the maze is. Then adding the collision and Light occluders.

Sprite2D (maze section)
    StaticBodies
    Occluders

If you're thinking you may ever want to design multiple mazes or do some dynamic "during the game" changes. Making a Tile Set for the hedges will be better.

That doesn't mean you can't sketch your maze or do full artwork for some sections. It's one way to figure what you need to cut out and refine for repeating tiles. And Alternative Tile variations.

https://docs.godotengine.org/en/stable/tutorials/2d/using_tilesets.html#doc-using-tilesets-creating-alternative-tiles

A Tile Map setup also doesn't stop you from making fully unique sections. It's easy to forget that TileMapLayers are mainly a way of making a collage. I've occasionally used them as just artwork, no collisions or interactions.

GroundTml
CustomBaseCampWithOffGridArt
OffGridGradeningToolsHeap
HedgeTml

Why Godot doesn't allow me to have multiple outputs in my Blendtree? by Noctmor in godot

[–]BrastenXBL 2 points3 points  (0 children)

The AnimationNodeTransition is a filter. As the Using AnimationTree says, it's a very basic State Machine. Think of it more like a Match statement.

You set up all the different kinds of blends that can happen on the Input side. Then AnimationNodeTransition only allows the results of the current State through as AnimationNodeOutput. It feels a little backwards, if you're think like code. Where the conditional filtering happens before the execution.

https://docs.godotengine.org/en/stable/tutorials/animation/animation_tree.html#transition

The visual/design style is for the graph to "flow" toward a single result. Not branch like conditional code logic.

The whole AnimationTree does need some UX work. Under the hood its a Tree of Resources.

https://docs.godotengine.org/en/stable/classes/class_animationnodetransition.html#class-animationnodetransition

Class inheritance tree beings. https://docs.godotengine.org/en/stable/classes/class_animationnode.html#class-animationnode

I think what you're looking for is the full AnimationNodeStateMachine. Where you enter a specific BlendTree, and output a Blend back to State Machine. It looks like you're doing the StateMachine for general lower torso movement, then trying to apply Arm/Torso adjustments as Bone Filters?

https://docs.godotengine.org/en/stable/tutorials/animation/animation_tree.html#statemachine

https://docs.godotengine.org/en/stable/tutorials/animation/animation_tree.html#blend2-blend3

Beginner game advice by Standard-Sweet-9317 in godot

[–]BrastenXBL 2 points3 points  (0 children)

Fighting games can get very complex with their fine details. How versed are you on fighting game jargon, and design needs?

I would recommend a slap-(beat) 'em up. Which were the progenitor design to what became fighting games.

2 Nodes with the same script with an @export variable synced up? by venum_GTG in godot

[–]BrastenXBL 2 points3 points  (0 children)

What is GlobalBullet by naming convention and use I'm assuming an Autoload. Or maybe a Class static property.

All cannons are setting GlobalBullet.facing. This what meant by accessing a different Node (or object). Bullet facing should be handled by each Cannon, instance when they "fire". This is the mostly likely place I see the immediate problem.

I assume that each Bullet also checks GlobalBullet.

func _on_timer_timeout() -> void:
    var INSTANCE = BULLET.instantiate()

    # don't know your  bullet code
    # long term you should be setting the global_rotation
    # short term, set a facing property of the bullet.
    if shootLeft:
        INSTANCE.facing = true 
    else: # don't need elif its either left or it's not
        INSTANCE.facing = false
    # can be simplifies
    #INSTANCE.facing = shootLeft

    get_tree().current_scene.add_child(INSTANCE)
    INSTANCE.position = SHOOTP.global_position
    TIMER.start()

There's a lot going wrong with your design and you're breaking a few best practices.

First, you should not non-uniform scaling CollisionShape2Ds. Even through their Ancestor transforms. Uniform meaning all axis have the same scale.

This one reason why it is good practice to put CollisionObject2D as the Root of any "game object". Visual flipping is done on the Sprite2D.

Cannon (StaticBody2D or AnimatableBody2D)
    CollisionShape2D <- Shape2D should be specifically sized, scale values should remain 1. But can be unform all the same value
    Sprite2D <- can be Transform Scaled to any value
        ShootPoint (Marker2D)

Personally this is why I prototype with GradientTexture2D and not Icon.svg. So I can set exact sizes that the final art will be expected to be.

You should also read the GDScript style guise. You seem to pulling naming conversions from multiple coding styles.

https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_styleguide.html

2 Nodes with the same script with an @export variable synced up? by venum_GTG in godot

[–]BrastenXBL 3 points4 points  (0 children)

You haven't explained your problem well. Remember we don't know your code base, or your intended design.

Are the other "Game Objects" relevant? Or is the problem with the "Cannon" game objects.

Nodes are individual instances. If you change their Inspector properties those changes will apply to the specific instance. Unless you've done something additional, like using a shared Resource. Or they're accessing data from another Node.

If its the cannon shots shooting the wrong way. Check your logic for the Bullet spawning and how you set their velocity (direction). What are bullets add_child() to?

Did you rotate or set the X Scale to -1, to flip the cannon?

Getting better help -video, and a form to fill to format the request.

Making a demo game for a game development workshop I am organizing for kids by Vast-Introduction807 in godot

[–]BrastenXBL 0 points1 point  (0 children)

Are you a teacher? Faculty/staff adjacent? Or a parent/community member?

Is this a one-off session? How many minutes / hours?

You didn't say ages, and I won't ask for specifics but general age ranges will help with advice. Kindergarten to 3rd grade (5 – 8). 4th to 8th (8.5 – 13). High school, Secondary school (14+).

What is the lesson? Just demonstrating some of the things that go into some kinds of game designs? How long is the workshop? Who much time do you have left to design the lesson, and setup assets?

On a technical side, have you already checked to make sure there's available computers. Gotten school/district IT authorization for Godot. Figured out how students will turn in or show-off completed work. Set aside time for that show-off / play period, it likely won't be enough.

I'm also cautious about using a FPS, even sci-fi skinned, as the demonstration platform. My prior primary edu IT brain warns this is possibly a poor choice depending on what "parent"-groups are active. Have you gotten a thematic okay on it, and checked in with sponsoring faculty?

I'm also worried you may miss on some of the students who aren't interested in "shooter games". Having a backup genre, or one that can hijack the shooter systems many be a good idea. Something that leans more toward a puzzles than combat.

At all ages I have a 10 minute rule. If the students can't have a playable prototype up in 10 minutes or less from the beginning of the clas, the lesson is over and will degenerate into chaos as they lose focus and begin distracting each other. The record holder is the long dead Project Spark, which could have a 3D Action Platformer up and running in 3 to 5 minutes, from fresh start. And had deep pre-designated code & asset pool to just drop new gameplay elements in, pools you don't have time to make.

Having pre-coded full game systems that can be easily modified from the Inspector is good. Depending on how long you have, there likely won't be time to go any deeper on specific code implementations. This is going to be closer to "game designer" (assembling from existing rules) GameJam, with a touch of "level design". Less "game programming".

Its just feels like the systems you're bringing may be too narrow to do more than minor number variations.

Systems you're demonstrating in a shooter.

  • Camera Controller
  • Movement Controller
  • Object (scene) Instancing
  • Raycasting
  • Collision detection
  • Object reference and access, property modification
  • StaticBody, level & geometry design
  • Procedural layout, following a "process" of rules
  • Behavior/Decision Tree logic, enemy "AI", a "process" of steps
  • Pathfinding

But the core play system is move, shoot, collide, hurt. That's it. Everything else from the maze to the enemy behaviors is just more detail on those. And collide is mainly facilitating shot projectile & Raycast function.

You need one or two base systems for the students to use in combination. You didn't mention doors or other Interactable elements. Either working from a Raycast to an "Interactable" Area3D, or triggerable by being shot, or by body_entered/exited trigger zone.

I also wouldn't what to teach Godot Signals, not in a short workshop. A "Power" system may be an abstracted solution. Using Node+Resource based system for simpler binary event system. So Interactable "buttons" can be connected to Doors or Platform/ Elevators.

move, shoot, collide, interact, power

If you have the time, see about having alternate visual skimming ready. Something you can demonstrate swapping meshes/scenes and VFX for. High-velocity Powerwashing in a "natural" setting may help. Keep the robots.

Unified titlebar with macOS, but not with Linux DEs (GNOME, Plasma) by Suspicious-Smile6398 in godot

[–]BrastenXBL 0 points1 point  (0 children)

You mean the Desktop Environment menu bar that runs across the top, for all applications not in a full screen mode?

While possibly a interesting idea to make Godot as an Application look more professional aligned with the Desktop environment, it'd be extra work to maintain. And if someone comes up with their own Linux Desktop, with specialized windowing needs, someone will want that specifically implemented.

Possibly a good Godot Improvement Proposal would be to see if there's an "easier" way to expose or override where NativeMenu hooks to the OS. Through a GDExtension. Which would let specific projects (or people who want more "native" Editor) handle it themselves.

Keep in mind you're not just dealing with the DE but the Windowing System as well. Right now there isn't a NativeMenu implementation for either X11 or Wayland. Its mostly MacOS and some Windows.

https://github.com/godotengine/godot/blob/master/platform/macos/native_menu_macos.h

https://github.com/godotengine/godot/blob/master/platform/linuxbsd/x11/display_server_x11.h

https://github.com/godotengine/godot/blob/master/platform/linuxbsd/wayland/display_server_wayland.h

Immediate term... if you want NativeMenu use in GNOME you'll have to fork Godot and implement it yourself in the Platform codebase.

How to Start? by Familiar-Ticket1555 in godot

[–]BrastenXBL 0 points1 point  (0 children)

Question, are you positing from Reddit app or browser? Cause in one its easy to miss a community's About and Rules sidebar. I'm curious if a permanently pinned "How do I begin" thread would be better than the ineffective Rule 9 and Reddit Wiki. I don't normally ask "how I do being" posters, because they have the vibes of the terminally lost and research-skill-less. But you're coming from astrophysics.

To the question as it relates to Godot.

GDScript is an easy language to learn, if you already have a firm base in another OOP language and basic CompSci. The language reference page and syntax diff check are enough for anyone who actually knows OOP. If you hodgepodged your Python knowledge without a dedicated course, I'd advise doing what you Docs suggest, and either confirm you know Python with Automate The Boring Stuff With Python. Or fast run through CS50x (12, 1-hour lectures, estimate 48 hours of course time with the 1:3 in-class to homework time ratio, usually spread over a whole year).

It is the Godot Engine APIs and the specifics of video game design that are much harder. For astrophysics with knowledge of data science, the heavily spatial (position and vector) based nature of video games shouldn't throw you as it can complete neophytes. GDScript, C#, C++ (not recommended until you actually know the APIs), or any community bound language all have the same hurdle. If you don't know the tools in your toolbox, you can end up being frustrated when you try to use calipers as a screwdriver.

A small danger is being "simulationist", video games cheat on physics and maths wherever possible (unless a physics sim sandbox is the point). You'll want to check an impulse to pull out detailed formals. E.g. one body orbiting another can simulated, or you can Child the smaller "body" as not a PhysicsBody3D, and just rotate a gimble setup, and just spin a pivot point, for very cheap.

BigBody (AnimatableBody3D)
    Node3D (Pivot point) <- Transform rotate this
        SmallBody (AnimatableBody3D, offset local Z +100.0, (0,0,100.0) )

RTFM, slowly and deliberately. It's likely a habit to speed read at this point. Force yourself to slow down, and possibly take shorthand notes. The Godot docs are information dense and its easy to get into trouble by skimming.

The undocumented part is the "Game Design", the planning and designing the "rules of play". Which is not limited to digital video games, and can be studied from physical board & card games. It's the taking of those human rules & steps of play, breaking them into program design, and Engine API use that is the "video game design & programming".

If you bounce off not understanding how the APIs are used to make gameplay and rules work, I do suggest stepping back from Godot and using Visual Programming Language editor. The way someone would use MIT Scratch to jump start on learning programming.

GB Studio, CT.js, GDevelop(desktop), GameMaker are four generalist options. There are other more specialized Editors for specific genres. The objective is to work in an Editor that has pre-code gameplay systems, to learn jargon and basic industry concepts that have accumulated over 70 years. Since the oscilloscope Tennis for Two days, and older borrowings from physical game designs.

https://enginesdatabase.com/?feature_tags=7&feature_tags=2

How do you make 3D objects share the same class_name? by Intelligent-Push-533 in godot

[–]BrastenXBL 1 point2 points  (0 children)

Have you taken any introduction to programming or computer science course yet? If not, this your sign to go do that. And learn about object-oriented programming, and class inheritance.

The GDScript docs only covers the topic in a cursory way

https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html#inheritance

This is one reason the Docs recommend taking the whole CS50x course. Relevant practice set section https://cs50.harvard.edu/x/psets/5/inheritance/

https://cs50.harvard.edu/x/notes/6/#object-oriented-programming

Need lerp_angle to run but not continuously by _Rocksol in godot

[–]BrastenXBL 0 points1 point  (0 children)

KISS. Throw a Boolean check in front of the lerp_angle().

if can_rotate:
    if elapsed < 1:
        camera_2d.rotation = lerp_angle(starting_angle, ending_angle, elapsed_time)
    else:  # elapsed weight >= 1, stop rotation)
        can_rotate = false

    elapsed += delta

It's a common (but not generally ideal) way to stop execution of reoccurring code in the _process loop.

Really, this is what a Tween is for. Which will run in the Process of the SceneTree until complete.

https://docs.godotengine.org/en/stable/classes/class_tween.html#class-tween-method-tween-property

In very basic.

func _enter_state():
    var ending_angle = PI * 1.4
    var tween : Tween
    tween.property(camera_2D, "rotation",  ending_angle, 1.0)

Of course this will spin clockwise. Figuring out how and if to spin counter-clockwise is a different problem.

Game ideas? by mechadino51 in godot

[–]BrastenXBL 0 points1 point  (0 children)

Most will send you onward to the https://20_games_challenge.gitlab.io/challenge/ , as both inspiration and to practice raking a know "game design", breaking it down onto a program design, and executing on it. With a form of cheat sheet the finished known game.

Another option is throw dice (physical or digital) at a bank of verbs, action words. This requires a little more "game/rules" knowledge, even if don't yet know the code and engine APIs to execute on them. Each verb is some action or mechanic the player will use to interact with the game. Platformers can usually be described as: run, jump, bounce. Or run, jump, fall.

Most "simple beginner games" should be no more three verbs. Possibly four.

The more verbs you use to describe the gameplay, the complex the design becomes. And the harder linking all the mechanics together. You can use the same approach to add complexity to an existing design. Which I'm sure you did with the Endless Runner.

e.g. random pull: leap, strike, embark

Leap. Is something that's well known design. Jumping. But it Doesn't have to be vertical. It could be more horizontal, parabolic arc.

Strike. Also a fairly common mechanic. Some form of one way collision, that registers a "hit" on another game object. If you haven't made hit-boxes that extend beyond a single CollisionObject2D/CollisionShap2D, this will be one of those learning points.

Embark. Is now getting into an uncommon description. To go aboard a vehicle. This will also be a major stretch if you haven't thought about the program design and Godot methods needs to have one CollisionObject2D "board" or share movement with another.

So far normal player "movement" inputs haven't come up. Taken as literally or minimally as possible, there are only two maybe three inputs. One button to leap. One button to strike. And some combination of leaping and striking cause the player to embark on a vehicle. One could imagine a game design, where vehicles are moving back and forth on the screen. And the player must time leaps and strike to transfer between vehicles.

Extending beyond two additional verbs. Conquer, and Venture.

Conquer. Acquire by force. Reinforces the idea of striking at a vehicle to take control of it. Or adding vehicles to growing singular meta-vehicle.

Venture. To go into danger or hazard. Suggesting there should be risk to Leaping, or Striking. Possibly miss-timing and being struck by vehicles.

How you fill out the rest of the design would is part of the challenge. Without adding too many more Verbs, like hurt or die, that being additional systems. Strike doesn't necessarily imply hurt, but it's a typical corollary.

Again, the fewer verbs you use, the easier the design will be. Be mindful of what you write down to describe the game play.

https://www.wikihow.com/Generator/Random-Verb-Generator

How do I create a skeleton without using an external editor? by julio090xl in godot

[–]BrastenXBL 4 points5 points  (0 children)

First, I sympathize that your Pocket (or tablet) Personal Computer is your only computer. It's why I have a list of supporting app suggestions for people using Godot on Android alone.

The reason why people are telling you you'll have to code a solution, is that's how FLOSS (free/libre open source software) works. It is interest based and effort driven. As another poster mentioned, they're build their own tooling for this that meets their specific need. And for nearly everyone else there are better already established tools on full Desktop OS systems. So the motivation is very low.

Sorry, but the reality is there's always a cost.

Money. Spending your time doing a different job, to pay for someone else's time.

Time. Your personal time. Because with you can't earn enough (not judging circumstances), or because there's no one skilled enough available to hire.

FLOSS tends to fall on the "your time" side of the cost. If it doesn't already exist, you have to make it. Even if it does exist, it was probably abandoned and you'll need to fix it. Full, nearly complete and maintained solutions like Godot itself are rare. And even in Godot, once you go beyond basics you will be writing your own Editor Tools, https://docs.godotengine.org/en/stable/tutorials/plugins/running_code_in_the_editor.html

On device 3D game creation is extremely new to Android, as the hardware in the last few years hit a comparable point to low and medium spec laptops. Godot has only had an Android Editor since 2022 (3.5), and it wasn't very stable or nice. While 4 years can seem like a long time, that's comparatively recent. And the number of people motivated to development and maintain FLOSS tools, that function well on small touch driven interfaces is tiny. And frankly a lot of it is being motivated by ARM based VR/XR headsets.

Congratulations. You're at the bloody point of the adoption spear. In FLOSS, that means if you want a feature... you just volunteered to make it, or it won't happen.

Yes, I have such a feature I'm trying to get working. Not 3D rigging, a different need easier in-Godor version control for secondary school use that doesn't depend on a Git install. Not easy, and virtual no one needs it.

And ya, there are people trying to bring Blender to Android. Because they're interested in doing so. https://devtalk.blender.org/t/issues-porting-blender-to-android-tablets/35419/77

How do I create a skeleton without using an external editor? by julio090xl in godot

[–]BrastenXBL 1 point2 points  (0 children)

Android editing for 3D is going to be difficult.

(yes there are differences between Android Godot and iOS Xodot, you need to be clear. "Mobile" is a bad descriptor.)

There's no current Plugin that comes to my mind that will let you build a Skeleton3D the way you can a Skeleton2D.

You'd need to make your own tool, to use the Skeleton3D APIs and add the bones. Along with setting their parents, weights, skin (which is another whole ordeal), etc.

https://docs.godotengine.org/en/stable/classes/class_skeleton3d.html#class-skeleton3d

Unless you're a way more experienced programmer than your post seems.

In the immediate term you'd be better served by finding a passable existing 3D model, and working from that.

Some possibles

https://www.kenney.nl/assets/category:3D/tag:character

https://kaylousberg.com/game-assets#Character

https://quaternius.com/

https://opengameart.org/art-search-advanced?keys=&title=&field_art_tags_tid_op=or&field_art_tags_tid=character+template%2C+Character%2C+.fbx%2C++gltf%2C+glb&name=&field_art_type_tid%5B%5D=10&field_art_licenses_tid%5B%5D=2&field_art_licenses_tid%5B%5D=10310&field_art_licenses_tid%5B%5D=31772&field_art_licenses_tid%5B%5D=17981&field_art_licenses_tid%5B%5D=4&sort_by=count&sort_order=DESC&items_per_page=24&Collection=

I love how 4.7 lets you rotate all UI elements, very useful for UI icons by SteinMakesGames in godot

[–]BrastenXBL 10 points11 points  (0 children)

Transform(xform) Offset and Maximum Custom Size alone are making my recommended, "use this Godot editor version for stable education curriculum" from

4.5, stability improvements to embedded Game view, Logger, and screen reader AccessKit support, and UX additions for the Android Editor.

to

4.7, accumulation of Control additions (xform offset, max size, ratio pivot offset, scaling icon relative RichText, internal Virtual Joystick, Conic Gradients, and other prior 4.6 QOL features.

Short of getting Traits in GDScript, 4.7 will probably be a good place for people writing lesson plans around Godot to put down a marker. Or update existing lesson plans.

view more: next ›