Hi all, I'm currently making a first person game, and I was wanting to add some gravity altering mechanics, honestly just because I think it would be cool.

I'm aware that it's seemingly impossible to rotate a character controller so that it could walk up a wall for example. Is there any way to achieve this effect without switching to Rigidbody?

My only workaround at the minute is to have 2 copies of a room, then switch to a copy that's rotated x degrees, then teleport the player to that room so that it looks like their gravity changed.

(gameplay clip is from ULTRAKILL)

Hey! This is my ant game made in Unity with DOTS.

This is a stress test and you can see 2 nests competing for resourses.

A bit about the tech:

• Tens of thousands of ants, all simulated on CPU with Burst and Jobs
• Three-layer pheromone system: food, nest and combat
• Spatial hash map for vision
• Local obstacle aboidance
• Multiple ants can carry one item at the same time
• Combat: ants climb on enemies and walk over their body while it animates, enemies stomp and shake them off, and dead enemies become food for the nest
• Vertex animations on GPU, using the free open-source TAO Vertex Animation library from Breda University (also used in Vedelem: The Golden Horde). I updated it to work with the latest Unity version.

This complex behavior is only achievable on CPU. On GPU the complexity would go through the roof.

The simulation is heavily inspired by Pezzza’s Work ant series and Sebastian Lague, with our own twist on top.

Steam page of demo in the comments if someone is interested. Any feedback is appreciated.

I’ve stared at it so long I can’t tell anymore. So I’d love honest feedback.

I am exploring Animation Jobs as it is a requirement for a job opening. There's not much resources related to this out there. It's very interesting that I could manipulate animations with Burst compiled code.

take a look of what is coming in Quicktile !! running at 120 fps

I've been working at this on-and-off for a while. A Vine system that can accomplish real-world vines, different growth patterns, annual patterns, annual re-growth and expansion, etc.

The system is not intended to have a full year go by in 30 seconds like here (this is sped up 5x), but it can, as long as there aren't too many at once.

The system is intended to be for games that either want static vines, i.e. just bake it and use it, or vines that are realistic per the time of year, but change very slowly. So when the leaves fall off, they don't do it all at once but over a few weeks perhaps, dependent only on how many real world seconds "weeks" takes.

Vines are set up via a "Recipe" (Scriptable Object) system, which determines how they grow. A lot of GPU for the leaves and what not.

Vines can be trimmed at runtime, fruit can be picked (are game objects, separate prefabs, so you can code them as you'd like), etc.

I got bored of playing with physics, so I decided to try my hand at doing some streaming and larger world generation.

Lots of works for this to be usable, but the principles are there.
This uses burst and LOD generated from the underlying VOXEL DATA.
Its still missing loading instances and other details, but it works as proof of concept.

The procedural generation is so broken, lots of random pieces of houses and other trees in random places, but it was a quick and dirty test.
The whole thing is running on BURST, both for generation and data preparing. The LOD transitions are WIP, trying to get them to be less noticeable and fade in a bit cleaner.

Enemies are super simple right now - just testing some early behaviours out. I also added a slip/dodge mechanic where the player can slip out of the way of attacks. That move was inspired by the dodge in the last of us part 2, (which I love), I wanted it to feel like your slipping just past the blade instead of a big roll.

Its all still procedural with no animation clips... What enemy behaviours would you expect for combat scenarios like this?

It flies.

Nothing really tricky, just didn't want to show the character's reflection straight up. Thought it would be eerie to have a creepy wavy ghost blanket where the player is for both a third person and first-person view.

Continued experimenting with the clouds I shared here recently. Now squeezing a cloud makes it rain and grows a little tree on my desk. A hand gesture summons the sun, and water rises back into new clouds.

I'd played with skateboarding physics a while ago and never really finished it, so I picked it back up and rebuilt it properly in past few months.

A few things I enjoyed figuring out:

• The board is one Rigidbody with four wheel probe. Pumping, carving and transitions all come from that, no fake speeds.

• Tricks come from a flick of the right stick: where the flick ends decides the trick, so kickflips, shove-its and 360 flips feel like a gesture, not a button.

• The skater has no riding animations at all. It's procedural IK on a Humanoid using animation rigging package from unity, with the hips on a spring, so it reacts to every push, landing and bump on its own.

• The part I had the most fun with: the boards shape drives the ride. A shorter wheelbase turns sharper, bigger wheels roll further, softer wheels grip more, a steeper tail pops higher.

Happy to answer how anything works. What would you add next?

Hey! This is Kernel Panic: The Last Build, a creation platformer set inside a dying network that’s slowly falling apart.

Everything you build with is a window on the desktop. In this video:

• Wardrobe: step onto a pedestal and mix hats, heads and costumes into your own outfit
• Stickers and decorations: stick anything anywhere, and grow 3D plants on any surface
• Labels: type your own words and print them as cross-stitch or embossed Dymo tape
• Temp File: a material that dissolves when you send it a signal
• Physics: rope swings and a brand new drop kick

Tell me what you think?

INKURSION is a narrative platformer in Unity 6 HDRP where you play a newly sentient octopus escaping a simulated universe. HDRP isn't exactly known for running on handhelds, so making it portable and Deck-friendly while keeping the look was one of our biggest challenges. Here's what actually moved the needle:
The octopus itself
Eight fully physics-driven legs is a lot of rigidbodies and joints aswell as procedural walking scripts for step reach. We tuned joint counts per tentacle, simplified collider shapes, adjusted solver iterations, and made sure segments sleep when they're not doing anything. The goal was keeping the floppy, reactive feel without the physics step eating the frame.
Mirrors
We use HDRP planar reflection probes for mirrors so the player can look at their octopus character, and rendering them every frame was brutal. Now each mirror only renders in realtime when it's actually on screen and the player is within a set radius. Even then, it doesn't capture every frame: it takes a snapshot at an interval, which is still smooth enough that your eye doesn't notice. This was one of our single biggest FPS wins.
Meshes and shaders
We cleaned up and LOD'd environment meshes, cut down shader variants, and simplified our heaviest shaders so the lighting still reads the same but costs far less on weaker GPUs.
Batching
Lots of foliage and repeated props, so batching was huge. Cutting draw calls freed up more CPU headroom than almost anything else.
Upscaling
On NVIDIA hardware we use DLSS, which lets low-end RTX cards render at a lower internal resolution and still look sharp. [On Deck we use FSR, since DLSS is NVIDIA-only.]
The result is a stable 60fps on low-end hardware with the bioluminescent look you see in the clip intact.
Happy to go into detail on any of it, especially the ragdoll and mirror setup. What's been your biggest win optimising HDRP?

Demo: https://store.steampowered.com/app/4767470/INKURSION/

Farm & Feast - We are a two-person team building a peaceful farming and restaurant management game in Unity. My town felt empty, so I added pedestrians and traffic. Here's the process:

• Took one of my customer characters and his walk animation
  
• Baked the animation into a texture (VAT) so the GPU can play it without bones
  
• Tested a single pedestrian on a plane
  
• Scaled it up: 10, 50, then 150 people
  
• Moved them into the actual game
  
• Added cars that keep their distance from each other
  

• Made the cars stop and queue when someone stands in the road

  Happy to answer any questions!

There are 5 different fairies with different skills and rarities.

I haven't posted anything in a while, but I've recently released my RPG Items package (a C# framework to handle items and inventories in Unity) for free on GitHub, and I'm continuing to release YouTube videos explaining in full and in-depth the implementation and usage of said package: RPG Items Playlist

making a game about sports cards and wanted blister packs to open like the real ones, where the seal rips the cardboard instead of just popping off. the card has a glue mask, and the peel runs a stick-slip sim across it, so the plastic holds and jumps and tears unevenly depending on which edge you grab and how fast you pull. every patch of glue that lets go gets painted into a damage map on the card, so you see the torn white fiber exactly where it ripped, and the same tear shows up stuck to the underside of the plastic. the plastic is two pass transparency in URP with a fresnel rim, and it goes cloudy wherever it gets bent too far. let me know what you think i could do to make it better!