Monday! New builds! Fun!

• The new Besti SDK (now with the ability to make Oculus Quest content!)
• Besti X Beta 16 for Windows
• Besti X Beta 16 for Oculus Quest

• The in-game options are now all procedurally generated based on the platform you are running the game on and what options are available for that platform. 
• The in-game options for remapping your controls now functions in-game.
• Internally the controller remapper was rewritten in such a way that the menus and in-game systems function off of the same code in a single prefabricated module. This permits new control types to be added down the road in one place rather than all over the program. For instance, when we add playstation/xbox controller support, I'll only need to add it in one spot and it will automatically propagate all over the system.
• The controller remapper is now significantly more efficient due to hundreds of small changes in how it does what it does.
• While remapping controls all previously mapped controls are disabled while it is scanning for inputs.
• The in-game UI cursor has been significantly modified and is now completely accurate. Previous inaccuracies were due to the fuzzy selection algorithm I wrote for the beam cursor. This conceptually permits the system to make something of an educated guess as to what you're after so you don't need to be extremely precise with the pointer system. This is a good thing when you're interacting with objects or teleporting, but it was causing the pointer to slightly bend and make decisions when absolute precision was sort of the idea when using a menu system. The pointer now disables fuzzy select logic when you are pointing it at a screen (when the cursor becomes the mouse cursor pointer) and re-enables fuzzy select logic while teleporting or grabbing objects.
• The event system has been modified to prevent logical tunneling through raycast objects. To not be super technical, the Unity event system for graphical elements (UI things) sends an infinite beam through the scene at the target point, creates a list of potential objects to interact with, and then permits you to click on them. In our case I only want the beam to hit the front-most object when using this type of beam so I've altered the logic in how this works to ignore all elements except the very front-most object. There are some elements that require this type of logic so I've written a specific beam-tunneling program to handle these special cases (specifically the "Scroll View" element though the tunnelling program works on anything.) This is invisible at the user level but it generally makes the pointer work more reliably in more cases.
• Modified the Universal Starter scheme to have the red, blue, and green schemes be identical. This is to avoid trapping you in the menus while you're pushing buttons before you know how the control remapper works. You can always change the controls in the main menu because those button mappings are hard-coded, but if you trap yourself without a universal cursor button in the game itself you're stuck there until you exit and change your controls. I can see this leading to confusion so I'd rather make sure that you can't easily trap yourself.
• Modified the newly-created save file to also use the new Universal Starter control scheme.
• The control scheme now operates based off of a global event. What this does for us is that the code that performs the various functions involved in changing the control scheme don't need to be wired to one another. For instance, the display on the menu does not need to be wired to the controllers, as they're both just listening for the event.
• The control scheme swap system now functions, permitting you to switch between red, blue, and green schemes. This still requires a graphical/sound effect, but I haven't made those yet. I put in the code for that, though, so once I have these effects and animations made it'll just be drop-in.
• Resized the individual menu entries so they fit on the scrollers better.
• Wrote the "Now" menu of the menu. This is a place where I can say what's new/cool to do. This will be a cool place for people to get a writeup on the newest build changelog, new SDK guides and videos, or when the store is up I can feature the cool stuff people make on here. I made some example artworks to go with it to demonstrate how it works.
• Modified the Besti SDK interpreted manifest and master asset generator to permit n number of languages rather than defining them explicitly.
• Modified the initialization process of Besti SDK scenes to use the name of the module that was defined by the creator in the first position to be the name displayed during initialization.
• Ported over most of the Besti SDK place loading code, but found most of it too RAM heavy so I re-wrote almost all of it. It was fine when you were working on just PCs, but Quest is a lot more needy when it comes to RAM optimization. New version takes a small fraction of the RAM that the previous version did (about 6MB total instead of 6 x number of modules you have.) That obviously loads faster, too.
• Moved the slowest calculations that need to happen in the game to the startup sequence. This reduces interruptions in the process 
• Wrote an analysis system on SDK scene loading that looks for errors that could crash the game. Instead of it running those and crashing the game, it refuses to load the scene, instead.
• Modified the color LUT modification subroutine (this is what makes the world lose color when you open the menu) using a technique I devised for the Now menu that performs a frame-by-frame calculation with less mathematical overhead on the CPU. This is a huge improvement on CPU use and greatly reduces CPU overhead at all times. Nice! Especially for slow CPUs like Oculus Quest. I'm going to retroactively implement this all over the place but that'll take some time.
• Made dozens of small changes to the way little behaviors work/sizes of things in the menus. Still not happy with it but it will work for the duration of the beta. We'll go through and re-think how the menu should look/feel. Overall the origin of this is that I'm dissatisfied with the way the in-world UI code works, because it's just an unreliable mess that's prone to race conditions. Once we're towards the end of the beta I'll replace this system entirely with one derived from the Deep Learning Hands experiment rather than one derived from Besti 9. The reason why we're not doing that now is because that system can't handle sliders, whereas the old one can (poorly.) I'll write slider code for the DLH interactor which will solve all our problems. Besti X is entirely modular so it'll be trivial to fix later.
• Made a fun exit sign. 
• Wired up all the exit buttons appropriately. There's no home assignment system yet so I have it hard wired to take you back to the canyon home scene. Once the home assignment system is in you'll be able to specify a home scene.
• Wrote a soft exit program so it doesn't just dump you out of the program when you exit. It fades to black first if you attempt to quit while playing.
• Made the menu react to the scene change system by closing if it's already open.
• Altered the organization of the scene processors for SDK tools now so it doesn't become trouble later. They were individually assigned/referenced before, but it's better to make each processor a derived class of a base class so I can put all of the processors into a big list, so that way adding new processors is just drag/drop into one spot (a list) rather than also defining a method on how to process it and stuff. This keeps things simple and efficient and will let me crank out the Besti SDK tools faster. 
• Wrote the BestiSDK processor for the tool "Teleport Surface." This functions as expected, now. The Besti SDK now uses a modular processing system compared to the previous iteration, so each tool requires its own processing module to function. This is much more organized.
• Modified the PhysX subsystem interface for the universal pointer. While I like it a little better the way it is now, I feel like it's burdensome to SDK creators because it requires understanding a little bit about PhysX (or at least how to deal with it.) By altering this it doesn't matter and in cases where a function of PhysX is required to be messed with it can be done at compile time with an SDK tool. For reference, the PhysX layers that can be hit by UPs are now Default, UI, and PhysicsObject. When the menu is up, it can only hit the MenuUniverse layer.
• Modified the tool processor for Teleport Surface to account for those changes to PhysX
• Added additional logic to the now menu that accounts for the .2 second transition time between now menu pages. This makes the now menu no longer recapture the menu if you happen to click on a primary navigation button during the transition.
• Wrote the BestiSDK processor for the tool Random Startup Entities in the new SDK tool processor.
• Wrote the BestiSDK processor for the tool Timed Activation in the new SDK tool processor. My god I'm so happy I re-wrote the SDK activator like this. It's so trivial to write an SDK processor now.
• Wrote the reactionary script for TimedActivation that needs to be spawned to manage the function of that tool.
• Wrote a tool to get a quick 1-line answer to the current time Besti thinks it is. There are lots of ways that you can handle time in the Besti SDK and this returns the correct time no matter how the time is calculated.
• Added a logical check on timed activation to make sure that the influenced object still exists before it tries to affect it. 
• Wrote the BestiSDK processor for the tool Grabbable Object in the new SDK tool processor.
• Fixed a vector math error that occurs when changing scenes to SDK scenes and the start position is set at a specific value.
• Fixed a bug in body physics that I introduced when I brought in the weather system. What a fucking nightmare that was to diagnose.
• Fixed a bug in the movement systems that I revealed once I fixed the bug in body physics, which was hiding it.
• Fixed a conceptual problem in movement code. I wasn't calculating your look vector properly at all. 
• Reduced CPU usage in 2D mode
• Wrote a whole new handler for how grabbables work, as they work very differently now. I simplified it a bit so it's going to need some new documentation. The old one had a ton of options that didn't really have any use outside of some strange edge cases (drop the item if you teleport?), and now that there's a complete zinnia system if you want to make something very complicated (penis gun!), there's no need to have Besti SDK tools be that complicated. I did add a nice feature though: a child object that can have weird gravity.
• Wrote an all new weird gravity system that uses a fraction of the resources and is significantly more stable than the previous way this worked.
• Changed the tooltip for child vs joint to better reflect the difference between these things in Besti X
• Re-wrote the mouse look system. It's awesome now. Also a fucking nightmare. Took me entirely too long to come up with the math on this one.
• Fixed a bug that could cause the pointers to emit from your hands but have the active UI pointer emit from your head.
• Revised the function of one of the settings events to also ripple through any local settings that you define in the settings screen, as I'd rather just call an event to check settings rather than manually invoking that. 
• Added an error check function to all SDK tools to overcome an issue that happens when you duplicate objects with SDK tools attached to them.
• Changing mouse sensitivity now emits an appropriate event to update in realtime as you adjust the slider rather than waiting for you to reload the scene.
• Fixed an issue with the mouse sensitivity system that was causing an incompatibility with loading external Besti SDK scenes. 
• Added a requested feature of movement speed to the MISC section. Increasing this increases your ground movement speed.
• Added a requested feature of rotation speed to the MISC section. Increasing this increases the speed you rotate.
• Choosing to reset all settings now causes the game to save your save file. Weird oversight.
• Wrote maintenance-free settings managers for movement and rotation.
• Wrote a little fix to make the pointers a little better behaved when you start the capture system when remapping the controls in-game. We'll see if this makes the Quest shit the bed.
• Wrote the settings connection for the anti-nausea system.
• Made a new material that can compensate for how I'm drawing the clouds for the anti-nausea system. The clouds were drawing on top of the anti-nausea system. Oops.
• BestiSDK pictures are now encoded as jpg files rather than the platform's native texture format. This is a little slower, but it's way more compressed and will allow us to use larger pictures.
• Wrote an SDK processor for the SDK tool Invisible Teleporter.
• Altered the SDK tool to be easier to use
• Re-wrote the whole processor for that to be less prone to error and use significantly less memory.
• Altered the body physics PhysX data to have specific interactions rather than appearing the same as a misc PhysX entity. This way we can more precisely define the relationship between you and other objects.
• Created a PhysX layer for friends. 
• Created a PhysX layer for multiplayer entities.
• Created a subscribable event for menu deployment and undeployment.
• Made SteamVR remotes show up when you deploy the menu based on that event I created on the main menu.
• Made Oculus remotes show up when you deploy the menu based on that event I created on the main menu.
• Added raycast blockers to cases where the menus are layered in ways that can produce unexpected behavior.
• Fixed an issue that caused the border on the right-side (active items) menu to not show up.
• Fixed a shader issue that was causing undesirable graphical glitches on Quest in situations where you can see the horizon.
• Fixed a rendering issue with the skybox system on Quest (sort of.) 
• Added a settings listener for the anti-nausea system that updates when you change that setting in realtime. 
• Created a test scene for the Besti SDK on quest. Drag and drop, baby!
• Changed the SDK compile logic to automatically switch between building a Quest or Windows SDK module. Once the store is up I suppose I'll probably add an option that lets you make both with one click. For now you just need to do a couple things and it builds to Quest.