Matt Downey @SciFiGameDev@mastodon.gamedev.place

Got concave corners working:

Now I have concave/convex/"straight" edges and concave/convex corners working (i.e. all geometry that's possible in my game).

#screenshot https://mastodon.gamedev.place/media/9TQxSz43jgMj_AY2N10

Raycasting in spherical 2D [custom algorithm]

I created a mobius strip in my game, this means that you can walk on both the outside and inside of the 2D surface by going around the circuit "twice".

https://mastodon.gamedev.place/media/06Tyc-uccGjH-jQ-BXE

Here's a link to another mobius strip in case you're curious of what a 3D version looks like in real life: https://www.youtube.com/watch?v=Vxror-fnOL4

Three things:

1) I'm loving the zoom effect in 2D virtual reality.

2) My camera code just got really simple.

3) Today marks the first day (technically) I've played a 2D virtual reality game, since I previously has the typical 65mm eye-to-eye distance.

This is approximately the 10th time I've gotten collisions/movement "working" with all of the 6+ prototypes and constant refactoring.

Now I have a custom collider component that I can add to objects, though.

Just got my 3-sphere collision system working:

The intersection of two spheres captures a collision for a circle in 3D space, and three spheres captures an arc in 3D space.

https://mastodon.gamedev.place/media/vIcHCFq4QVTEXXYtsw8

This is a nice read for Unity programmers on how to use Update/FixedUpdate less:

http://bradkeys.com/2017/01/30/Avoiding-Unity-Update-Loops/

Until just now I was planning on only supporting FixedUpdate for my game engine XD

I mean, even if I did do that, I forgot that inputs gets "eaten" if you write your code that way.

It's also inefficient, of course.

My code is getting so fast, all of these optimizations make me so happy :D

Also, it's so interesting when I get to support another Unity feature (previously deemed "too slow") e.g. CollisionDetectionMode.Continuous

Poll: what do people think when they see "2D VR"?

Rendering is more or less done, off to work on Rigidbodies and refactor Colliders.

Remember that UnityEngine.Object overrides the definition of "null".

This is an example for an optional<Type> C# generics:

To determine if the object existed I (erroneously) set `exists = (original != null);` (spoiler: that doesn't work).

https://pastebin.com/5RS0xJ3k

full file:
https://github.com/mattrdowney/Planetaria/blob/master/Assets/Planetaria/Code/Utility/Optional.cs

If you care about speedrunning design:

https://kb.speeddemosarchive.com/Making_your_game_speedrunner-friendly

Research & development might just be my favorite asocial activity.

~2.5 years - 6 months ago I was frequently saying there were far better candidates for making my project(s) but it turns out I'm pretty good at making the new algorithms and architectures.

I might have found another 2D VR game: The Lost Bear

https://m.youtube.com/watch?v=QxZDG9EtAHM

https://blog.us.playstation.com/2017/08/01/cinematic-2d-platformer-the-lost-bear-coming-to-ps-vr-this-month/

It seems to be a 2D + 3D VR game throughout, but I'm gonna try to find a way to play it.

And--not even--it's easier than that: https://answers.unity.com/questions/705717/same-sorting-layer-and-order-in-layer-rendering.html

This is so amazingly easy compared to what I was doing before.

I get to delete a lot of code and just switch to a random sortingOrder + user defined sortingLayer.

Lol, I'm a scrub, the "Beginner" Unity tutorial explains sortingOrder really well:

https://unity3d.com/learn/tutorials/topics/2d-game-creation/sorting-layers

This will definitely work better than my solution, although I might have to do something about ZWriting/ZTesting for shaders depending on how that works (maybe Offset?).

Hey Unity programmers:

What are the downsides to using Renderer.sortingOrder?

Can it batch meshes/sprites effectively (for sortingOrder sequences with the same shader) or are there weird gotchas?

I realized like 2 minutes ago I was doing so many z-buffer/z/distance calculations (to hand craft positions that wouldn't z-fight), which feels like it's the wrong way to approach the problem.

I was just reminded of this tweet: https://twitter.com/ID_AA_Carmack/status/908488180512575489

Design-wise:

clamp(minimum, maximum, value),
clamp(minimum, value, maximum),
clamp(value, maximum, minimum),
clamp(value, minimum, maximum),
or one of the other two permutations,
and why? [needn't be C++]

Subquestion: any overloads or defaults?