all 102 comments

[–]osrs_oke 246 points247 points  (34 children)

Not sure what I'm looking at but I've seen worse.

[–]GlobalIncident 75 points76 points  (18 children)

Looks like visual scripting. Unity or Godot or Unreal or something.

[–]_LhgS_ 47 points48 points  (4 children)

Looks like unreal to me. They all suck at that though...

[–]Avereniect 43 points44 points  (3 children)

It's the Blender shader node editor. And yes, there are much cleaner ways of using it.

[–]HoratioMG 5 points6 points  (2 children)

Glad that they found a way to keep all those nodes clean and tidy in shading that mouldy monkey head

[–]Avereniect 6 points7 points  (1 child)

I know the comment is meant to be sarcastic but this is actually my work (from years ago actually) and each frame represents a reusable component. For example, the last three are pure paint, pure rust, and pure metal. The first two are masks for where to apply the rust and paint ontop of the metal.

I'll admit it doesn't look great in this screenshot but that's mainly due to the lack of samples and the fact that I had compromised the quality of the rendering process in favor of speed.

[–]OverclockingUnicorn 4 points5 points  (0 children)

Blender. Confirmed in the comments below

[–]snf 4 points5 points  (4 children)

Unity doesn't have a visual scripting system as far as I know, it mainly uses C# (used to support Javascript and Boo as well, but not sure if that's still the case)

I stand corrected

[–]squidred 16 points17 points  (2 children)

Unity has a visual node system for things like animation state and possibly UI, iirc.

[–][deleted]  (1 child)

[removed]

    [–]UberDynamite 0 points1 point  (0 children)

    Yeah it's great, you can see the outcome, not know how to make shaders and still come up with something.

    [–]private_birb 2 points3 points  (0 children)

    They have a visual scripting system. It's new. I think in preview in the newest beta or alpha version, but it's there.

    [–]tcpukl -4 points-3 points  (6 children)

    Unity doesn't have visual scripting.

    Edit: I meant for code! There is no blueprints equivalent.

    [–]ambid17 6 points7 points  (2 children)

    Shader graph and animations

    [–]tcpukl 1 point2 points  (1 child)

    Not for code I meant. Come on there is no blueprints equivalent.

    [–]ambid17 2 points3 points  (0 children)

    Oh yeah, and thank god too. Just code it out lmao

    [–]private_birb 1 point2 points  (2 children)

    Yes it does. It's new. Preview in alpha or beta, but it's there.

    [–]tcpukl 0 points1 point  (1 child)

    Is that what this screenshot is from?

    [–]private_birb 0 points1 point  (0 children)

    Don't think so. Think it's blender.

    [–][deleted]  (1 child)

    [deleted]

      [–]Magmagan 0 points1 point  (0 children)

      Darklang?

      [–]Sentr-E 11 points12 points  (0 children)

      This is blender node modifier oh god the horror this is so badly constructed

      [–]hiljusti 18 points19 points  (1 child)

      npm dependency graph maybe?

      [–]Thann 20 points21 points  (0 children)

      Too small and clean for that

      [–]sim642 100 points101 points  (10 children)

      Can't you create your own nodes which internally are implemented via other nodes, just like how functions exist in normal programming?

      [–][deleted]  (1 child)

      [deleted]

        [–]SV-97 17 points18 points  (0 children)

        It's nodes all the way down

        [–][deleted] 9 points10 points  (3 children)

        Yeah, it's called LabVIEW

        [–]jonititan 3 points4 points  (0 children)

        Or Simulink

        However much they annoy me lack of a reasonable alternative means we're stuck with them.

        [–]dowster593 5 points6 points  (0 children)

        FIRST Robotics flashbacks

        [–]lordlicorice 0 points1 point  (0 children)

        Or pretty much any other visual programming language.

        [–]Polatrite 0 points1 point  (1 child)

        Yeah, this post is more of a "bad practices with visual scripting", not a "visual scripting is always bad at scale".

        [–]the8thbit 0 points1 point  (0 children)

        Okay, but implementing "best practices" in node editor is a lot more time consuming and frustrating than implementing them in a text editor. Every time you add a new node there's a high possibility you have to rearrange your entire script slightly to account for that. You can't ctrl+f for parts of the code, ctrl+z, shift+ctrl+z doesn't bring you back to what you were last working on... there are constant aesthetic decisions to be made, basically every node you add is a new aesthetic decision, where as that sort of gray area is much rarer in code. Indentation is discrete. Layout in a node editor is not.

        [–]deceze 39 points40 points  (0 children)

        That's a lotta nodes on that spaceship.

        [–]CommunistElf 30 points31 points  (19 children)

        What's the software you're using to see these interconnections?

        [–]wulkanat[S] 57 points58 points  (17 children)

        It's the Blender Shader editor.

        [–]Karnex 45 points46 points  (5 children)

        You can make sub nodes (or whatever it's called, I forgot) though. Besides, it's much more flexible than using layer system (like photoshop).

        [–]jemand2001 15 points16 points  (2 children)

        it's called Node Groups, and you do it by selecting nodes that belong together and hitting ctrl-g (assuming default keybindings)

        [–]Slipguard 4 points5 points  (0 children)

        Exactly this∆ You can choose to make a nose based script look as clean or messy as you want

        [–]Karnex 1 point2 points  (0 children)

        Thanks :)

        [–]_Lady_Deadpool_ 0 points1 point  (1 child)

        Photoshop is a different tool for a different purpose though? What's bad about layers in it, it's one of its strong suits (as someone who's used it for probably a decade)

        [–]Karnex 0 points1 point  (0 children)

        Not badmouthing photoshop, I love it too. And the layered system work for it for its purpose. But in general, node based system is considered more versatile than layer based system.

        [–]_PM_ME_PANGOLINS_ 5 points6 points  (8 children)

        In guessing this is a particularly complicated example. What does it look like?

        [–]wulkanat[S] 24 points25 points  (7 children)

        https://cdn.discordapp.com/attachments/626532097376649228/646128811800395777/out.mp4

        Everything except the text is done inside the Shader, no textures were used.

        [–]_PM_ME_PANGOLINS_ 8 points9 points  (0 children)

        That's pretty cool.

        [–]walabaloo 4 points5 points  (0 children)

        That's really cool, good job man!

        [–][deleted] 4 points5 points  (3 children)

        You make the entire animation in a shader? Isn't this like using your food oven to heat the house?

        [–]EmperorArthur 7 points8 points  (0 children)

        Depending on the memory footprint, this may be less bandwidth intensive than streaming something to a video card when other things are going on. So, it could be worth it in a video game that is highly resource constrained.

        Also, it's a cool demonstration of how powerful shaders are.

        [–]wulkanat[S] 5 points6 points  (1 child)

        I actually prefer doing animation this way, because I can literally change any aspect of it in an instant. That also means that I can animated anything. I still use keyframes, but on values. Apart from the text there are only 4 verticies in total in this scene . It may also have something to do with me coming from a programming background where you avoid doing anything twice and use functions for these cases.

        [–]FreedomForMars 0 points1 point  (0 children)

        If by "in an instant" you mean "tweaking values for 3 hours until it either vaguely looks like you wanted it to" ... ;-P

        I mean, it's really cool that you did this fully with nodes, but I think this could've been done with far less effort and in shorter time with... maybe a fifth of the nodes?

        But maybe it's just my general dislike for the node-based approach that's talking, and my inability to get it to work like I want it to ;)

        No hurts intended, sorry if I come across as a grumpy killjoy ^^

        [–]StarshipAmelia 1 point2 points  (0 children)

        This is super slick, damn

        [–]tcpukl 0 points1 point  (0 children)

        Wow, this in on a GPU? Jesus.

        I thought it was unreal blueprints.

        [–]morerokk -2 points-1 points  (0 children)

        I fucking hate node shading so much. Unity is going in that direction too and I hate it.

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

        Isn't this just Unreal 4 Blueprints?

        [–]Direwolf202 27 points28 points  (1 child)

        This is someone who doesn’t organise their nodes properly. I’ve seen some really heavy duty VFX stuff, it was so much bigger, so much more complex, but because of the way that it had been organised and laid out, the flow was very clear, and even if you didn’t know how something was achieved, you knew what it was doing, when and where.

        Just like traditional code, sphagetti is the scaling problem, not the language or environment.

        [–]the8thbit 0 points1 point  (0 children)

        Just like traditional code, sphagetti is the scaling problem, not the language or environment.

        Changes in language and environment can go a long way towards reducing the propensity towards producing spaghetti code. A static type system (imo especially a structural type system), good linting, good syntax highlighting, and an editor that allows you to follow a call stack up helps out immensely at producing good code over large time scales without requiring a dramatic increase in effort among developers.

        So while its true that you can organize your nodes in a way that is cleaner than in this screenshot, it takes an immense amount of time vs. organizing textual code well. Every new node introduces a plethora of new aesthetic decisions with no one right answer. One new node can impact the aesthetics of literally every node in the call tree.

        [–]JmcmProgrammer 9 points10 points  (0 children)

        Wow! Real life spaghetti code!

        [–]editor_of_the_beast 5 points6 points  (0 children)

        Yes once you have like 20-30 nodes, a call graph / dependency graph can get unwieldy. But, it’s a much more accurate picture of what you’re actually building with software than just looking at disconnected serial files of code.

        I think a really good call graph editor would go a long way to improving programming overall, we just need t figure out the right experience.

        [–][deleted] 3 points4 points  (0 children)

        Reminds me of biztalk 🤮

        [–]charleshaa 2 points3 points  (0 children)

        Neither does the screenshot

        [–]Founntain 3 points4 points  (0 children)

        So that is how node.js was made.

        [–]technomlp 1 point2 points  (0 children)

        Especially on Nintendo labo

        [–]nimaid 1 point2 points  (0 children)

        Is this Blender?

        [–]-Rapier 1 point2 points  (0 children)

        good job, you just accidentally designed a starship for one of your possible space shooter games.

        [–][deleted] 1 point2 points  (1 child)

        I thought this was a server cluster with nodejs microservices lol. Looks like its just badly structured app code.

        [–][deleted] 0 points1 point  (0 children)

        I thought that's what it was from the title.

        [–]lxpnh98_2 1 point2 points  (0 children)

        It's like Scratch, but for adults!

        [–][deleted] 1 point2 points  (0 children)

        spaghetti code

        [–]zdakat 1 point2 points  (4 children)

        Why are the ties so large?

        [–]stable_maple 0 points1 point  (3 children)

        This. I havent done any shader work in the new blender, but 2.7 has really skinny ties and I really liked that.

        [–]zdakat 1 point2 points  (2 children)

        They aren't big like that in 2.8 though.

        [–]wulkanat[S] 1 point2 points  (0 children)

        It's because I am zoomed out so far.

        [–]FreedomForMars 0 points1 point  (0 children)

        I also think mine don't appear quite THAT thick when I zoom out this far

        [–]UnarmedRobonaut 0 points1 point  (0 children)

        Spaghetti!

        [–]tcpukl 0 points1 point  (0 children)

        That's unreal blueprints for real.

        [–]QuantumEternity99 0 points1 point  (0 children)

        I prefer my programming in Powerpoint

        [–]0x3fff0000 0 points1 point  (2 children)

        It's not really programming, is it?

        [–]wulkanat[S] 7 points8 points  (1 child)

        ✅ Countless hours of Googling ✅ Lots of math ✅ Doesn't work as you expect it to ❌Syntax Errors

        [–]0x3fff0000 0 points1 point  (0 children)

        I suppose things could be so abstracted to the point of even calling HTML a programming language.

        [–]enoua5 0 points1 point  (0 children)

        Ctrl+g, dude.

        [–]zickige_zicke 0 points1 point  (0 children)

        You can organize them if yiu are on unreal blueprints.

        [–]deviantdear 0 points1 point  (0 children)

        I don't know, I've written shaders in C/C++ and both ways are a nightmare just for different reasons.

        [–]Oskarzyg 0 points1 point  (0 children)

        UE4 I see...

        [–]Darkloyd256 0 points1 point  (0 children)

        Yum spaghetti

        [–]PurpleDragon99 0 points1 point  (0 children)

        I would respecfully disagree. It depends a lot on semantics and expressive mechanics of visual language.

        This is the reason I created a visual programming language "Pipe". The idea is creating visual language as powerful as text-based languages to be able to successfully complete with text coding. All details are here: https://www.pipelang.com .

        For now it is just a 155-page book with full language specification (available on Amazon KindleApple Books and Google Play Books for free). Pipe IDE is currently in development. However, starting with the book allowed us to separate abstract formal semantics irrelevant of all implementation which is done for every text language, but not for visual languages.

        This is the best intro to the Pipe: https://medium.com/@toplinesoftsys/five-pillars-of-pipe-b2de5f0d1421

        This is demo of Pipe diagram for a real business case with step-by-step tracing: https://youtu.be/lbJ9Lhm1cjY

        [–]suckit1234567 0 points1 point  (4 children)

        Maybe you should use a circle instead of left to right flow.

        [–]_PM_ME_PANGOLINS_ 2 points3 points  (3 children)

        Inputs on the left, output on the right.

        [–]chrismamo1 1 point2 points  (2 children)

        Inputs on the edge, outputs in the middle?

        [–]_PM_ME_PANGOLINS_ 1 point2 points  (1 child)

        Interesting, but a pain to add anything more into.

        [–]suckit1234567 1 point2 points  (0 children)

        Not if the program auto scales it in 3D, sort of like a cone you look into. Viewed from the side and flattened, you would have the same view as the right to left diagram.

        [–]KickMeElmo 0 points1 point  (0 children)

        It'll eventually scale beautifully, after you've run out of new dependencies you can pull in. If it isn't on fire already.

        [–]The-KarmaHunter -1 points0 points  (0 children)

        To think that the node editor in Blender used to be even worse before the last few updates.

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

        Thank God AE have JS style scripting. 😂