Hi! As the message states, this is implementing the basics of the concept of “getting back up” – some quirks remain, like the missing rotation into the right direction depending on the exit point and jobs seems to lose some information when being started from a non-standing state. Also, the same restrictions (no transition in terms of time or animation happen) as for sitting done apply. However, besides that the core mechanics work and after leaving the container object the slots become available again. 🙂
– Set the default idle animation depending on the current position status (standing, sitting, etc..) – Add first iteration of sitting animation – Add a few more helper functions to determine under what circumstances an object enters another – First WiP approach for the sitting down mechanic (just switches immediately for now, no standing up either) – Extend the Python bindings
More progress and getting closer to an actual object-in/on-object mechanic! It is now possible to let the controllable objects sit down on objects that support that – albeit immediately and without any animations. You also better not plan on them being able to get up again, unless of course you don’t mind simply deleting the object they are sitting on. Needless to say, this is all very much work in progress and will continue to do so for quite some time, but it is definitely progress 🙂
After all that time they finally get to sit down
This also brought up the rather unfortunate question of positioning of the model so that everything lines up in a generic way, it just happens to work very nicely for the couch model, not so much for the chair though. Let’s see what the next few days will bring in that regard. 🙂
– Add more boilerplate code to start object-into-object transitions, just stubs for now – Exposed more enums and functions to Python – Add more comments to the Python classes (and wrapper interfaces) – Fix configuration for the bed object to make it work with the changed entry point handling – Fix regression that was introduced for enterable 1×1 objects (looking at you, chair) – Fixed indentation in two C++ header files
– Add function that returns the calculated world coordinates of an object slot based on the world coordinates of an entry point – Use the new function so that objects can properly turn to their final target upon arriving at the entry point
As mentioned in the previous post, the selected objects now actually rotate towards their final target. If the prospect of this hasn’t sitting you on the edge of your seat already, why don’t you check out this video showing what that looks like in action:
The next step after this is to actually let start the object-in-object mechanics, but before that it will be time for some more content (read: animation) creation – or maybe not and it is straight back to coding again, the next few days will tell which. 🙂
– Add a generic method to convert coordinates relative to an unrotated object to global world coordinates – Make the action points use the same generic logic – Change configuration for sink/fridge to use the new, more intuitive way to define the action points
Hello! The work goes on, now the controllable objects can successfully navigate to the correct “entry points” of a selected object, as the next step they will also face the correct slot position that they are currently targeting. After that the actual entering and object-in/on-object mechanics can be worked on. 🙂
– Dynamically generate “virtual” job types (sitting down/lying down) for objects that have the appropriate category – Add these job types as supported actions to human.json to pass basic action support validation – Add dummy jobs for these new actions (sitting down being the exception, which is at least partially implemented) – Extend the Python interface a bit, so that an object’s “entry points” can be requested as well (not just the action points) – Refactor the calculation of action points on the C++ side so that the entry point calculation will not duplicate code
Hi! Before getting started with the actual workings of entering/leaving an object I’ve decided to first get the mechanics going to actually get the object we wish to put into another into the right position. While the rather verbose commit message more or less speaks for itself, there is actually a slight visual change to be seen this time:
..which shows how the dynamically generated jobs look when selecting an object in Sitting/Lying categories. With that working the next stop is to finish that navigation step before getting into the actual sitting/lying mechanics!
– Extend the slot (object-in-object) configuration of types (WiP) – Added a third concept of slots (job context, next to sitting and lying) – Add code that validates the slot configuration for sitting, lying and job – Add the O2 flag for release builds
Once again, not the most exciting commit, but that can probably be said for many commits in the early phase of bigger features. This commit adds the concept of a third type of slot (the term also happened to be introduced in the context of this commit): the job slot. That means it will also be possible to define special slots that can be used in the context of a specific task, as opposed as to the “passive” slots for sitting and lying down. A bit of code was written to finally validate and assemble the configuration information of all three slot types so that they can be added to the object types loaded when starting OLives. That very last step of added the newly assembled (and verified) information is what is still missing, and will be added in the next commit. Once that is done, newly created objects will also hold information about their respective slots, which paves the way for the more exciting (andvisible) changes. As always, stay tuned!
– Add boilerplate code for seating point (etc.) configurations – Make the way in which embedded configuration options are being loaded more generic – Add new object categories in relation to seating (etc.), still unused – Fix file name information for embedded configuration options, i.e. fix the error message in case of an invalid configuration property
Hi! On the outside this commit not particularly exciting, but it does get some of the rather cumbersome boilerplate type work done as well as addressing some issues that have been bugging me for some time, but not enough to actually look into them As an added plus, writing the configuration option definitions and parsing (and also making the changes to the configuration files themselves) made me think a bit more about the concrete requirements for some of the concepts. So while nothing can is visible yet, project “get those human-shaped things to sit down and also have them take showers” is finally off the ground. Stay tuned!
