Soliloquy of the Stars Sprint 2

 This sprint, I had 2 primary tasks.

The first task was to make a first pass of the spaghettification effect.

At first, I wanted to do it in a shader in Unreal, but I found that getting the information into the shader that I needed as not going to be easy. So for no, I have decided to make a vertex animation texture solution.

So my work shifted to Blender, because I had a plan for how to achieve it with Geomertry nodes. My first attempt at creating the effect was to make a simple logarithmic spiral.

The Logarithmic Spiral approach. Not quite what I wanted...

 My second attempt was to use a curve, and sample the position of the curve. I calculated the offset from the curve by projecting the position of the mesh vertex onto the tangent of the curve. But this calculation was not correct, and it was complicated. So I had to scrap it and try again.

The first attempt with curves.

  After thinking on it overnight, I realized I was overlooking the obvious solution. I can compose a matrix from the sampled point on the curve, its tangent, normal, and binormal. Then all I had to do was transform the mesh points by that matrix.

The result of the matrix approach. Look how easy it is to modify the effect!

The Geometry Nodes graph for the effect.

At this point, had a really nice effect that is easy to modify and art direct.The curves can be edited to change the shape of the effect, and the radius of the effect can easily be changed. The effect can be placed on any part of the face, and moved around as much as desired. Finally, the effect can easily be layered and repeated.

The result of layering the effect.

At this point, I just had to get it into Unreal Engine.

This was a straightforward process, all I had to do was make an animated texture sequence of the effect (For now, I have decided to use an image sequence rather than a VAT, for simplicity's sake). I made a material in Blender that shows the vectors on the surface of the mesh. It packs the -1 to 1 vector space into the 0-1 color space that a texture can hold.

The vectors of the effect displacement

 

  

The packed vectors of the effect's displacem

In order to do this, I transformed the object to its UV coordinates and rendered the image sequence with an orthographic camera. In order to prevent errors in the effect at UV seams, I used Blender's compositor to inpaint the empty part of the image (extending the texture, like texture padding). Bringing it into Unreal Engine turned out to be rather tedious - I had to import the image sequence using an "Image Media Source", hook it up to a "Media Player" and then route the media player output into a Media Texture.

Once I did all that, I had to make a material in Unreal Engine to read the packed vectors and apply them to the world offset position.

The material in Unreal Engine 

With the material working, it was a simple matter of making a video with the Unreal Engine sequencer... which was also a bit confusing. It turns out, in order to control the Media Player that drives the Media Texture that drives the effect, I had to make a Media Track in the sequencer, and then attach that Media Track to the Media Texture instead.

Here is the result:

 My Second Task was to set up the skinning for the  Mocap characters.
This was a lot more straightforward, since I had a document from the animators that explained the whole process.

Here is the result:

The character in its rest pose.

And taking a pose to show the effect of skinning.

Perforce screenshots:

These screenshots show the submission for the skinning task and the spaghettification effect first pass.

Soliloquy of the Stars Sprint 1

Tech artists didn't have a whole lot to do this time around, so our main contributition as a team was to discuss the VFX assets and divy them up among our tech artists. My VFX Asset is the Spaghettification effect. We also had a team meeing, where I contributed by helping to take notes.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Above are my notes from the first meeting.

 

I spent my time this week discussing with the lead how the effect should look and gathering references on out team reference board.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

I will be building this effect for future sprints!

Artist Interviews

Here are my slides

And here is the P4 turn in location and screenshot: //CLASSES/Cohort22/Classes/Art/CommonArt/Semester_02/ArtistInterviews/BrandenburgJoseph/joseph_brandenburg_Artist Interviews.pptx

Common Art Interactive Experience A Stage

This week I created a new material for the TV screens.

I updated the skinning for the characters.

I put a lot of work into the lighting, too. This has consistently been the hardest part of the process.

Finally, I updated the heartbeat sound effect. This week was mostly about quality assurance, and fortunately there was not a lot left to do!

Common Art Interactive Experience Stage 4 - First Bake - 'B' Stage

This week, I was mostly focused on creating a polished experience. First, I added a menu, with some pre-selection animation for the menu items and a fade-in/fade-out effect.

I updated the blueprints in the game to work with controllers, and set up the Sneak animation for the killer.

Finally, I made an ending sequence after the killer hides the old man's body.

I also added a lot of sound effects - the menu sounds, the updated footstep sounds for the sneak animation, the impact sound during the murder, the murmurs of the old man, the maniacal laugh of the killer, the schizophrenic voices in his head, probably a few more. Overall, this week was a lot easier than prior weeks and all I really needed to do was look for areas to improve things. Oh, and I touched up the lighting a little. I will focus more attention on the lighting next week since the menu and sounds are now working. Here is a video of the current state of the game, make sure to turn sound ON to hear the new audio!

Week 11 - High Res Meshing - 'C' Stage

This week my responsibility was to level up the lighting and work on the audio some.

I completely re-did the lighting this week. I aimed for much more nuance, better contrast, and more distinct color zones. I think the work really paid off and gave Richard's awesome shaders a chance to shine. I even added a flicker effect to sell the dark, moody amosphere. With the sounds and effects Richard added, it really feels good.

In order to achieve this, I had to overhaul my lighting tool again - now it has the ability to choose the type of light, to place any number of lights along the cylinder, and to control all kinds of light settings. For example, the light intensity is now set with Candela units, and there is a way to control attenuation radius and shadow hardness.

In addition to the lighting, I updated the rigs to prevent the flipping that was happening in the head earlier. It turns out, Maya doesn't do the math the way I thought it did... and I have no idea why it defaults to doing it wrong! I just had to set the interpolation type on the Parent Constraint to "shortest" and it worked as expected. Most of my work on the rig is not visible, since I spent a bunch of time improving the code and updating the generator with the ability to color the controls. This was a lot of work, but it isn't visible in the engine.

Finally, I worked on adding some sound to the game: the rain sounds, footsteps, creepy horror sting, and heartbeat effect. Richard added the hum of the lights and the flickering noise.

Week 10 - Protomeshing - 'D' Stage

 This week was a very busy one. I barely slept! But I got a lot done.

My first task was to build a quality rig for the animators - a rig I could easily update and fix and iterate on. In order to accomplish this task, I turned to Python. Here is a screenshot of my VSCodium workspace.

I'm dividing my work into two Python modules, ns_maya_utils and basic_autorig. ns_maya_utils is a collection of rigging tools and utilities, and the math helper functions that make it possible. The math functions are implemented in fast and portable NumPy, because I need to learn NumPy and this seemed like a good time to start. 

1590 lines of Python

The rigging script is written in the Maya cmds Python API, based on my own original design. It consists of an IK/FK switching limb, used by the arms and legs, an IK foot, an FK Hand with Curl Assist, a simple Neck/Head FK control, and a novel implementation of the classic Ribbon Spline IK spine rig .

Generating the rig. This gif is not sped up.

Generating the rig takes less than a second. It uses the widgets and meta-rig objects in the file as input and generates a complete control rig as output. The control rig and the deform rig are separated so it can export cleanly to the game engine.

The rig's IK foot features an intuitive heel roll control and a switch to enter FK mode. It has a pole-vector controller to set the knee direction.

The hands feature an auto-curl feature for easier posing.

The rig is stable in extreme poses and resists flipping even when turned around and on its side.

Here is an isolated view of the spine rig. I present a novel approach to the Ribbon Spline torso rig. If you look closely, you'll notice there is no ribbon! Instead, I use two identical NURBS curves, offset slightly on the X axis and hooked to the same cluster deform nodes. Because they always move together, they produce the same overall shape as a ribbon - without the overhead of calculating the spans, or the UVs, or the follicle positions on the ribbon. There is no risk of a rig component poking out of the mesh and getting rendered on accident. Instead, I use only two curves and a clever series of nodes.

In Maya's node editor, you can see the method behind my madness. First, I take the position, and tangent from each curve with a pointOnCurveInfo node. Using the positions from each curve, I calculate the normal. Taking the cross product of the tangent and normal gets me the binormal vector. Together, these three vectors make up an orthonormal basis matrix - just the thing to plug into the Offset Parent Matrix of this transform node (which has been set to not inherit transform). This lifts the curve's transformations into a simple node that I can use for constraints. The joints are parent-constrained to these curve-pin transform nodes. Easy!

My goal was to work on the rig for three days, from Saturday to Monday. In the end, it took four days - from Sunday to Wednesday. I didn't get it to my animators as fast as I wanted, and I didn't have time to fill out all the features or test it extensively -- but because I have a solid foundation, I can easily iterate through different versions of the rig.



My second task this week was to update the lighting in the level. This proved very challenging, because there were a lot of mesh light cylinders in the scene from the level designer's blockout. Because I already had a lot of light cylinders in the scene, I decided to use Blueprints to build a tool to take advantage of them. My tool places lights on the cylinders and creates a control to direct them. It is easy to art direct and modify.

The tool was made with these blueprints (arranged in a sequence):

I won't go into the tiny details, but the overall idea of the construction script here is to take the bounding box of the blockout light and use it to transform and place a nicer light object that uses proper Unreal light objects instead of mesh lighting.

I was having a lot of trouble getting the RectLight to point at the controller using the Look At Function node, so I ended up building my own constraint with vector nodes. Look familiar?

Just as in the Maya rig, I took the displacement between two points, crossed it with a known orthogonal vector, and used the normalized displacement, known orthogonal vector, and cross product to construct an orthonormal basis matrix (Unreal unhelpfully and very confusingly calls it a "rotator" instead of a basis).

Here is the result in the level: