Annie’s Substack

Motion Warping

Annie Drake — Tue, 04 Feb 2025 23:07:02 GMT

What is it:

Updates an animation so it contorts gracefully when asked to move or rotate a distance

Enable Motion Warping in your plugins

In your animation sequence, check EnableRootMotion

In your animation montage (if you don’t have one, right click the Animation Sequence > Create > Create AnimMontage) right click in notifies track, Add Notify State > Motion Warping

Set the bounds around the area movement is occurring most
Under Details
- Anim Notify > Root Motion Modifier: Select Adjustment Blend Warp
- Give it a Sync Point Name
- Warp Translation toggles whether the warping will impact the character position
- Ignore ZAxis will toggle whether or not the character is locked to the ground
- Warp Rotation will toggle whether the character will rotate to face target
  - Default: Instancing the rotation of the object in the world
  - Facing: Will face the direction of the object.

In the Character’s Blueprint:

Add a component called “Motion Warping”
Drag this into your event graph, and connect it to “Add or Update Warp Target from location and rotation”
- Set the warp target name to match the Sync Point name in your Animation Montage
- Target location and rotation are where the object will target
Get the actor you want to target
- Node “Get Actor of Class” > “GetActorLocation”
- plug into either translation, rotation, or both, depending on effect you want
Play Anim Montage
- Drag the mesh in, “Play Montage”’
- Select montage asset

In Animation Blueprint

if you don’t already have it, create Montage > “Slot’DefaultSlot’” and feed that into Output Pose
- Which slot you play in is determined in your Animation Montage
  If you need to change the slot:

PyQt Basics

Annie Drake — Thu, 04 Jul 2024 15:45:52 GMT

I just wanted a frame for building basic interfaces in Maya, so jumping into PyQt

import pymel.core as pm
from PySide2 import QtWidgets, QtCore
import maya.OpenMayaUI as omui
from shiboken2 import wrapInstance

def maya_main_window():
    main_window_ptr = omui.MQtUtil.mainWindow()
    return wrapInstance(int(main_window_ptr), QtWidgets.QWidget)

class BasicWindow(QtWidgets.QDialog):
    def __init__(self, parent=maya_main_window()):
        super(BasicWindow,self).__init__(parent)
        self.setWindowTitle("My Basic Window")
        self.setMinimumWidth(200)
        
        self.setWindowFlags(self.windowFlags() ^ QtCore.Qt.WindowContextHelpButtonHint)
        
        self.create_widgets()
        self.create_layouts()
        self.create_connections()

    def create_widgets(self):
        #add widgets here later
        pass

    def create_layouts(self):
        #add layout here later
        main_layout = QtWidgets.QVBoxLayout(self)

    def create_connections(self):
        #connect signals and slots here
        pass

def show():
    ui=BasicWindow()
    ui.show()

show()

Breakdown:

Import the necessary modules
- import pymel.core as pm
  - This line gives us access to Maya’s functionality
    - Python module that gives an object oriented programming approach to Maya’s MEL language
- from PySide2 import QtWidgets.QtCore
  - This line creates our GUI system and handles the elements
    - The Qt Framework is a comprehensive set of C++ library classes
    - PySide2 is Qt for Python
    - QtWidgets contains classes for creating classic desktop-style UIs
    - QtCore provides non-UI functionality, like signal and slot mechanisms, property systems, ect
- import maya.OpenMayaUI as omui
  - This gives us a reference to maya’s main window
    - OpenMaya is Maya’s API, and openMayaUI provides access to Maya’s UI system
- from shiboken2 import wrapInstance
  - This is used to wrap Maya’s main window pointer into a PySide2 widget object
    - Shiboken2 is a binding generator tool used by PySide2
    - WrapInstance is used to convert C++ pointers to Python objects
Define maya_main_window() function to create a parent for our dialog
- This creates an interface which is parented to Maya’s UI interface, ensuring that it is part of the program and abides by its rule set.
- As it will be part of the interface, maya will handle things for us like object stacking, keyboard focus and input events are handled properly, lifecycle dialog (it will close when maya closes)
- It is also using a wrap instance, to convert this pointer to a PySide2 Widget, giving us that library of UI functionality
Creates a BasicWindow class that inherits from QtWidgets.QDialog
- Because BasicWindowe is inheriting from QtWidgets.QDiagog, it has the Qt C++ library functionality
  - Qt comes with built in functionality like standard button layouts and default closing behaviors
- Our __init__(parent) window links us to Maya’s main window
Defines basic window properties
- Basic things like title name and width
Defines placeholder methods for creating widgets, layouts and connections
- create_widgets():
  - Individual UI elements that are interactive, such as buttons, text fields, drop down menus, checkboxes, sliders, ect
  - Examples UI elements you can use
    - QPushButton
    - QLineEdit
    - QComboBox
    - QCheckBox
    - QSlider
- create_layouts():
  - Manage the layout and organizaton of widgets (how are they positioned, how do they resize, ect)
  - Common layouts are things like horizontal, vertial, grid and form
  - Example Layouts:
    - QVBoxLayout
    - QHBoxLayout
    - QGridLayout
    - QFormLayout
- create_connections()
  - Connections take user interactions with your widgets and link them to code behavior
  - This is where you setup signal slot connections, which is how Qt handles events
  - Like in other programming environments, a signal is what is sent out when a UI event is triggered (like a button click) and and slots are the functions which respond to those events
  - This is where you would connect widget signals to slots
Provides a “show()” function to add and display the window

Here is a practical application of that script, which overrides the selected NURBS shape’s color override with a set color (the words in bold are what we added to modify the last script for our purposes):

import pymel.core as pm
from PySide2 import QtWidgets, QtCore
import maya.OpenMayaUI as omui
from shiboken2 import wrapInstance

def maya_main_window():
    main_window_ptr = omui.MQtUtil.mainWindow()
    return wrapInstance(int(main_window_ptr), QtWidgets.QWidget)
    
class CurveColorUI(QtWidgets.QDialog):
    def __init__(self, parent=maya_main_window()):
        super(CurveColorUI,self).__init__(parent)
        
        self.setWindowTitle("Set Curve Color")
        self.setMinimumWidth(200)
        
        self.setWindowFlags(self.windowFlags() ^ QtCore.Qt.WindowContextHelpButtonHint)  

        #replace the "self.setWindowFlags" with the below code in italixBold to get rid of the help toggle (it is not setup to do anything)
        #flags = self.windowFlags()
        #flags &= ~QtCore.Qt.WindowContextHelpButtonHint
        #self.setWindowFlags(flags)
        
        self.create_widgets()
        self.create_layouts()
        self.create_connections()
        
    def create_widgets(self):
        self.color_combo = QtWidgets.QComboBox()
        self.color_combo.addItems
        (["Red","Green","Blue","Yellow","Cyan","Magenta"])
        
        self.apply_btn = QtWidgets.QPushButton("Apply")
        
    def create_layouts(self):
        main_layout = QtWidgets.QVBoxLayout(self)
        main_layout.addWidget(self.color_combo)
        main_layout.addWidget(self.apply_btn)
        
    def create_connections(self):
        self.apply_btn.clicked.connect(self.apply_color)
        
    def apply_color(self):
        color_name = self.color_combo.currentText()
        color_index = {"Red":13, "Green":14, "Blue":15, "Yellow":17, "Cyan":18, "Magenta":20}[color_name]
        
        selected_curves = pm.ls(selection = True, type = 'transform')
        for curve in selected_curves:
            shapes = curve.getShapes()
            for shape in shapes:
                if isinstance(shape, pm.nodetypes.NurbsCurve):
                    shape.overrideEnabled.set(1)
                    shape.overrideRGBColors.set(0)
                    shape.overrideColor.set(color_index)
                    
        pm.select(selected_curves) #reselect the curves
        
def show():
    ui=CurveColorUI()
    ui.show()
        
show()

Expression Editor Math Functions

Annie Drake — Tue, 02 Jul 2024 11:18:12 GMT

Taking notes on the math functions available in the expression editor, because the documentation uses circular descriptions.

Absolute

The value (decimal or whole) of a number converted into the positive axis.
Example: The absolute value of -5 is 5, of 5 is 5, of 1.2 is 1.2, of -1.2 is 1.2
Useful in rigging scenarios where you need to work with the magnitude regardless of direction or sign. Its particularly useful with symmetry and distance based effects.

Acos

This is helpful in rigging scenarios that involve angle calculations, especially with normalized vectors. Its commonly used in orientation constraints, calculating joint angles, and solving various geometric problems in 3D space, in combination with other trigonometric and vector operations.
Takes a value between -1 and 1, and returns an angle (in radians) whose cosine is the input value
Example:
- float $value = 0.5;
  float $angle = acos($value);
  // $angle will be approximately 1.0472 radians (60 degrees)
This is used in rigging to:
- Calculate angles between vectors
- Creating arc based motions
- Inverse trigonometric relationships
Practical - calculate the angle between two objects and stores it in a control attribute
- vector $vector1 = <>;
  vector $vector2 = <>;
  vector $normalized1 = normalize($vector1);
  vector $normalized2 = normalize($vector2);
  float $dotProduct = dot($normalized1, $normalized2);
  float $angle = acos($dotProduct);
  // Convert to degrees for easier interpretation
  control.angle = rad_to_deg($angle);
Notes:
- The output is in radians, so convert to degrees if needed
- Acos is often used in conjunction with dot product for angle calculations

Add

Adds two values together
Example
- float $value1 = 5;
  float $value2 = 3;
  float $result = $value1 + $value2; // result is 8

AndBool

One of the logical operators, useful to ensure multiple criteria are met before triggering an action
There are two variants:
- AndBool (for boolean values)
- AndInt (for integer values, treating non-zero as true)
Syntax: &&
Example:
- int $condition1 = control1.attribute > 0;
  int $condition2 = control2.attribute < 10;
  int $result = $condition1 && $condition2;

AngleBetweenVectors

Excellent for creating orientation aware behaviors in rigging. Its useful in scenarios involving aiming, constraint systems, or any situation where you need to understand or manipulate the relationship between directions in 3D space.
Syntax: anglebetween(vector1, vector2)
Functionality:
- Takes two vectors as input
- returns the angle between those vectors in radians
Example:
- vector $vec1 = <<1, 0, 0>>;
  vector $vec2 = <<0, 1, 0>>;
  float $angle = anglebetween($vec1, $vec2);
  // $angle will be approximately 1.5708 radians (90 degrees)
Usages:
- Calculating joint angles
- Creating orientation based constraints
- Implementing aim or lookat behaviors
- Designating rotation limits or angle based effects
Practical - a simple aim constraint that rotates an object to point at its target
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $upVector = <<0, 1, 0>>; // World up vector
  vector $aimVector = normalize($targetPos - $objectPos);
  vector $rightVector = normalize(cross($upVector, $aimVector));
  vector $newUpVector = cross($aimVector, $rightVector);
  float $yRotation = anglebetween(<<1, 0, 0>>, <<$aimVector.x, 0, $aimVector.z>>);
  float $xRotation = anglebetween($aimVector, $newUpVector) - 90;
  if ($aimVector.z < 0) $yRotation = -$yRotation;
  object.rotateY = rad_to_deg($yRotation);
  object.rotateX = rad_to_deg($xRotation);
Advanced Practical - Creating a join rotation limit system
- vector $parentForward = <<1, 0, 0>>; // Assuming local X is forward
  vector $childPosition = <>;
  float $angle = anglebetween($parentForward, $childPosition);
  float $maxAngle = deg_to_rad(45); // 45 degree limit
  if ($angle > $maxAngle) {
  vector $limitedVector = normalize($childPosition) * sin($maxAngle);
  child.translateX = $limitedVector.x;
  child.translateY = $limitedVector.y;
  child.translateZ = $limitedVector.z;
  }

Asin

Asin calculates the inverse sine (aka the arc sine) of a given value. It’s useful in rigging scenarios that involve calculating angles from normalized values or component ratios. Its used in creating arc-based motions, solving inverse kinematic problems, and any situation where you need to determine angle based on a sine value. Typically used concurrently with other trigonometric and vector operations.
Syntax: asin(value)
Functionality:
- Takes a value between -1 and 1 as input
- Returns the angle (in radians) whose sine is the input value
- Output range is -90° to 90°
Example:
- float $value = 0.5;
  float $angle = asin($value);
  // $angle will be approximately 0.5236 radians (30 degrees)
Practical - a rig that calculates the elevation angle of a object from the XZ plane and stores it in a control attribute
- vector $objectPos = <>;
  vector $planeNormal = <<0, 1, 0>>; // Assuming XZ plane
  vector $direction = normalize($objectPos);
  float $dotProduct = dot($direction, $planeNormal);
  float $elevationAngle = asin($dotProduct);
  // Convert to degrees for easier interpretation
  control.elevationAngle = rad_to_deg($elevationAngle);
Advanced Practical - create a semicircular motion path based on the input attribute
- float $input = control.inputAttr; // Assume this ranges from -1 to 1
  float $angle = asin($input);
  float $radius = 5;
  float $x = $radius * $input;
  float $y = $radius * cos($angle);
  object.translateX = $x;
  object.translateY = $y;

Atan

Calculates the Arc Tangent function - it’s useful in rigging scenarios that involve calculating angles based on ratios or in situations where you need to determine orientation from positional data. Its often used in look at systems, dynamic rotation calculations, and in creating responsive rig elements that need to orient themselves based on spatial relationships.
Syntax: atan(value)
Functionality:
- Takes any real number as an input
- Returns the angle (in radians)
- Output range is -90° to 90°
Example:
- float $value = 1;
  float $angle = atan($value);
  // $angle will be approximately 0.7854 radians (45 degrees)
Practical - create a simple look at behavior for an object
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $direction = $targetPos - $objectPos;
  float $yRotation = atan($direction.x / $direction.z);
  float $xRotation = atan($direction.y / sqrt($direction.x * $direction.x + $direction.z * $direction.z));
  // Adjust for quadrant
  if ($direction.z < 0) $yRotation += 3.14159;
  object.rotateY = rad_to_deg($yRotation);
  object.rotateX = rad_to_deg($xRotation);
Advanced Practical - using for dynamic foot placement, this adjusts the foot’s rotation to match an angled floor surface.
- float $floorHeight = 0;
  float $toePos = toe.translateY;
  float $heelPos = heel.translateY;
  float $footLength = abs(toe.translateZ - heel.translateZ);
  float $floorAngle = atan(($toePos - $heelPos) / $footLength);
  foot.rotateX = rad_to_deg($floorAngle);

Atan2

Calculates the inverse tangent of y/x, taking into account the quadrant of the resulting angle. It is a more advanced system than the arc tangent, it’s valuable in scenarios where you need to calculate angles that cover all 360°, such as look-at systems, circular motions, or when dealing with local coordinate systems.
Syntax: atan(y,x)
Functionality
- Takes two inputs, y and x (in that order)
- Returns the angle (in radians) from positive x-axis to the point (x, y)
- Output range is (-180° to 180°)
Example:
- float $y = 1;
  float $x = -1;
  float $angle = atan($y, $x);
  // $angle will be approximately 2.3562 radians (135 degrees)
Practical - an improved lookat behavior that handles all quadrants correctly, allowing the system to rotate a full 180°
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $direction = $targetPos - $objectPos;
  float $yRotation = atan($direction.x, $direction.z);
  float $xRotation = atan($direction.y, sqrt($direction.x * $direction.x + $direction.z * $direction.z));
  object.rotateY = rad_to_deg($yRotation);
  object.rotateX = -rad_to_deg($xRotation); // Negative because Maya's rotation is opposite
Advanced Practical - adjusts a foot’s rotation to match uneven terrain, considering both pitch and roll
- vector $anklePos = <>;
  vector $toePos = <>;
  vector $heelPos = <>;
  vector $footForward = $toePos - $heelPos;
  vector $footUp = cross($footForward, <<1, 0, 0>>);
  float $slopeAngle = atan($footUp.y, $footUp.z);
  foot.rotateX = rad_to_deg($slopeAngle);

Average

Calculates the arithmetic mean of a set of values
Variants:
- Average (float)
- AverageInt (int)
- AverageAngle (angle)
- AverageVector (vector)
- AverageMatrix (matrix)
Syntax: average([value1,value2,value3,…])g
Example:
- float $values[] = {10, 20, 30, 40, 50};
  float $result = average($values);
  // $result will be 30
Practical - a control which centers itself at the average location of multiple objects:
- vector $positions[];
  $positions[0] = <>;
  $positions[1] = <>;
  $positions[2] = <>;
  vector $averagePos = average($positions);
  control.translateX = $averagePos.x;
  control.translateY = $averagePos.y;
  control.translateZ = $averagePos.z;
Advanced Practical - Creates a camera that smoothly follows a target by averaging its positions over several frames
- vector $targetPositions[];
  int $numFrames = 10;
  for ($i = 0; $i < $numFrames; $i++) {
  float $time = `currentTime -q` - $i;
  setAttr time1.outTime $time;
  $targetPositions[$i] = <>;
  }
  vector $averagePos = average($targetPositions);
  camera.translateX = $averagePos.x;
  camera.translateY = $averagePos.y;
  camera.translateZ = $averagePos.z;

AxisFromMatrix

Extracts a specific axis vector from a transformation matrix. You can use it to extract local or world space orientations, create aim up or vector constraints, implement space switching mechanisms, and analyze object orientations in complex hierarchies.
Syntax: axis(matrix,axis) //matrix is the input matrix and axis is an integer
Functionality
- Takes a transformation matrix and an axis index as input
- Returns a vector representing the axis from the matrix
- Returns a normalized vector (unit length)
Example:
- vector $matrix[4] = `object.worldMatrix`;
  int $axisIndex = 0; // 0 for X-axis
  vector $axisVector = axis($matrix, $axisIndex);
Practical - Simple aim constraint using the forward axis of an object:
- vector $sourceMatrix[4] = `source.worldMatrix`;
  vector $forwardAxis = axis($sourceMatrix, 0); // Assuming X is forward
  vector $targetPos = <>;
  vector $sourcePos = <>;
  vector $toTarget = normalize($targetPos - $sourcePos);
  float $dotProduct = dot($forwardAxis, $toTarget);
  vector $crossProduct = cross($forwardAxis, $toTarget);
  float $angle = acos($dotProduct);
  vector $rotationAxis = normalize($crossProduct);
  // Convert to degrees and apply rotation
  float $rotationAngle = rad_to_deg($angle);
  setAttr("source.rotateX", $rotationAxis.x * $rotationAngle);
  setAttr("source.rotateY", $rotationAxis.y * $rotationAngle);
  setAttr("source.rotateZ", $rotationAxis.z * $rotationAngle);
Advanced Practical - Calculates a twist angle for an object based on its local up vector compared to the worlds up
- vector $objectMatrix[4] = `object.worldMatrix`;
  vector $upVector = axis($objectMatrix, 1); // Y-axis as up
  vector $forwardVector = axis($objectMatrix, 0); // X-axis as forward
  vector $worldUp = <<0, 1, 0>>;
  vector $rightVector = normalize(cross($forwardVector, $worldUp));
  vector $newUpVector = normalize(cross($rightVector, $forwardVector));
  float $upDot = dot($upVector, $newUpVector);
  vector $upCross = cross($upVector, $newUpVector);
  float $twistAngle = atan2(dot($upCross, $forwardVector), $upDot);
  object.twist = rad_to_deg($twistAngle);

Ceil

Rounds a floating point number up to the nearest integer.
Types:
- Ceil (floats)
- CeilAngle (for angles)
Syntax: ceil(value)
Example:
- float $value1 = 3.2;
  float $value2 = 3.8;
  float $result1 = ceil($value1); // result1 will be 4
  float $result2 = ceil($value2); // result2 will be 4
Practical - Snaps an object to the nearest integer grid point above its current position in all axes
- float $rawX = control.translateX;
  float $rawY = control.translateY;
  float $rawZ = control.translateZ;
  float $snappedX = ceil($rawX);
  float $snappedY = ceil($rawY);
  float $snappedZ = ceil($rawZ);
  object.translateX = $snappedX;
  object.translateY = $snappedY;
  object.translateZ = $snappedZ;

Clamp

Restricts a value to stay within a specific range.
Variants:
- Clamp (float)
- ClampInt (int)
- ClampAngle (angle)
Syntax: clamp(value, min, max)
Functionality:
- Takes three inputs, the value to be clamped, the minimum allowed value, and the maximum allowed value.
- Returns the input if its with range
- Returns the max if its above the max, or the min if its below the min range.
Example:
- float $value = 15;
  float $min = 0;
  float $max = 10;
  float $result = clamp($value, $min, $max);
  // $result will be 10
Practical - Create a control that limites an object’s scale between 0.5 and 2
- float $scaleX = object.scaleX;
  float $scaleY = object.scaleY;
  float $scaleZ = object.scaleZ;
  float $minScale = 0.5;
  float $maxScale = 2.0;
  object.scaleX = clamp($scaleX, $minScale, $maxScale);
  object.scaleY = clamp($scaleY, $minScale, $maxScale);
  object.scaleZ = clamp($scaleZ, $minScale, $maxScale);
Advanced Practical - creating a smooth falloff effect
- vector $objectPos = <>;
  vector $centerPos = <>;
  float $distance = mag($objectPos - $centerPos);
  float $maxDistance = 10;
  float $minDistance = 2;
  float $falloff = 1 - clamp(($distance - $minDistance) / ($maxDistance - $minDistance), 0, 1);
  object.scaleX = lerp(0.5, 1, $falloff);
  object.scaleY = lerp(0.5, 1, $falloff);
  object.scaleZ = lerp(0.5, 1, $falloff);

Compare

Evaluates the relationship between two values and returns an int indicating their relative order.
Variants:
- Compare (float)
- CompareInt (int)
- CompareAngle (angle)
Syntax: compare(value1, value2)
Functionality:
- Takes 2 values as an input
- Returns -1 if value1 is less than value2
- Returns 0 if value 1 is equal to value2
- Returns 1 if value1 is greater than value2
Example:
- float $value1 = 5;
  float $value2 = 10;
  int $result = compare($value1, $value2);
  // $result will be -1
Practical - simple state machine based on an object’s position:
- float $posX = object.translateX;
  int $state = compare($posX, 0);
  if ($state == -1) {
  setAttr("leftLight.intensity", 1);
  setAttr("rightLight.intensity", 0);
  } else if ($state == 1) {
  setAttr("leftLight.intensity", 0);
  setAttr("rightLight.intensity", 1);
  } else {
  setAttr("leftLight.intensity", 0.5);
  setAttr("rightLight.intensity", 0.5);
  }
Practical Advanced - a dynamic parenting system
- float $controlValue = control.parentingAttr;
  vector $targets[] = {<>,
  <>,
  <>};
  int $index = 0;
  for ($i = 1; $i < size($targets); $i++) {
  if (compare($controlValue, $i) < 0) {
  break;
  }
  $index = $i;
  }
  vector $parentPos = $targets[$index];
  object.translateX = $parentPos.x;
  object.translateY = $parentPos.y;
  object.translateZ = $parentPos.z;

CosAngle

CosAngle calculates the cosine of an input angle. Its useful in generating wave-like behaviors, circular motions, and in solving trigonometric problems.
Syntax: cos(angle)
Functionality:
- Takes an angle as input (in radians)
- Returns the cosine of that angle (a value between -1 and 1)
- Works with floats
Example:
- float $angleInDegrees = 60;
  float $angleInRadians = deg_to_rad($angleInDegrees);
  float $result = cos($angleInRadians);
  // $result will be approximately 0.5
Practical - creating a simple oscillating side-to-side motion:
- float $time = `currentTime -q`;
  float $frequency = 0.1; // Controls how fast the oscillation occurs
  float $amplitude = 5; // Controls the range of the motion
  float $xPosition = $amplitude * cos($time * $frequency);
  object.translateX = $xPosition;
Advanced Practical - Creates a look-at behavior with an additional twist calculation using cosine
- vector $targetPos = <>;
  vector $objectPos = <>;
  vector $direction = normalize($targetPos - $objectPos);
  float $yRotation = atan2($direction.x, $direction.z);
  float $xRotation = asin(-$direction.y);
  object.rotateY = rad_to_deg($yRotation);
  object.rotateX = rad_to_deg($xRotation);
  // Calculate twist
  float $upDotX = dot(<<0,1,0>>, <>);
  float $twist = acos($upDotX);
  object.rotateZ = rad_to_deg($twist);

CrossProduct

Calculates the vector perpendicular to two input vectors. This is helpful in creating orientation matrices, calculating surface normals, and implementing various constraints.
Syntax: cross(vector1, vector2)
Functionality:
- Takes two Vector3 values as input
- Returns a new vector perpendicular to both input vectors
- Resulting vector follows right hand rule
Example:
- vector $vec1 = <<1, 0, 0>>; // X-axis
  vector $vec2 = <<0, 1, 0>>; // Y-axis
  vector $result = cross($vec1, $vec2);
  // $result will be <<0, 0, 1>> (Z-axis)
Practical - a simple aim constraint with an automatic up-vector:
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $aimVector = normalize($targetPos - $objectPos);
  vector $worldUp = <<0, 1, 0>>;
  vector $rightVector = normalize(cross($aimVector, $worldUp));
  vector $upVector = normalize(cross($rightVector, $aimVector));
  float $aimMatrix[4][4] =
  $aimVector.x, $aimVector.y, $aimVector.z, 0,
  $upVector.x, $upVector.y, $upVector.z, 0,
  $rightVector.x, $rightVector.y, $rightVector.z, 0,
  $objectPos.x, $objectPos.y, $objectPos.z, 1
  >>;
  setAttr object.matrix $aimMatrix;
Advanced Practical - creating a ribbon-like deformation between two joints with a sinusoidal twist
- vector $startPos = <>;
  vector $endPos = <>;
  vector $upVector = <<0, 1, 0>>;
  vector $ribbonDir = normalize($endPos - $startPos);
  vector $ribbonWidth = normalize(cross($ribbonDir, $upVector));
  float $ribbonLength = mag($endPos - $startPos);
  float $currentU = uCoordinate; // Assume we have a U coordinate from 0 to 1
  vector $ribbonPoint = $startPos + $ribbonDir * ($currentU * $ribbonLength);
  vector $offset = $ribbonWidth * sin($currentU * 2 * 3.14159) * 2;
  point.translateX = $ribbonPoint.x + $offset.x;
  point.translateY = $ribbonPoint.y + $offset.y;
  point.translateZ = $ribbonPoint.z + $offset.z;

DebugLog

Prints a value to the Maya Script Editor
Variants:
- DebugLog (float)
- DebugLogInt (int)
- DebugLogVector (vector)
- DebugLogAngle (angles)
- DebugLogMatrix (matrix)
Syntax: debuglog(value)
Example:
- float $value = 3.14;
  float $result = debuglog($value);
  // Prints "3.14" to the Script Editor
  // $result will be 3.14
Practical - monitor a simple IK stretching setup
- vector $startPos = <>;
  vector $endPos = <>;
  float $currentLength = mag(debuglog($endPos - $startPos));
  float $originalLength = 10; // Assume this is the original chain length
  float $stretchFactor = debuglog($currentLength / $originalLength);
  middleJoint.scaleX = $stretchFactor;

Divide

Classic division
Variants
- Divide (float)
- DivideAngle (angle)
- DivideByInt (divides a float by an integer)
- DivideAngleByInt (divides an angle by an integer)
Syntax: x / y
Example:
- float $value1 = 10;
  float $value2 = 2;
  float $result = $value1 / $value2;
  // $result will be 5
Practical - a simple stretch IK system
- vector $startPos = <>;
  vector $endPos = <>;
  float $currentLength = mag($endPos - $startPos);
  float $originalLength = 10; // Assume this is the original chain length
  float $stretchFactor = $currentLength / $originalLength;
  if ($stretchFactor > 1) {
  middleJoint.scaleX = $stretchFactor;
  } else {
  middleJoint.scaleX = 1;
  }

DotProduct

DotProduct calculates the scalar product of two vectors. It is useful for calculating angles, determining alignment, and creating direction-based effects.
Syntax: dot(vector1, vector2)
Example:
- vector $vec1 = <<1, 0, 0>>;
  vector $vec2 = <<0, 1, 0>>;
  float $result = dot($vec1, $vec2);
  // $result will be 0 (because the vectors are perpendicular)
Practical - create a simple look-at behavior with a falloff effect, this scales an object based on how well its aligned with its target:
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $toTarget = normalize($targetPos - $objectPos);
  vector $objectForward = <>;
  float $alignment = dot($toTarget, $objectForward);
  // $alignment will be 1 when perfectly aligned, -1 when opposite, and 0 when perpendicular
  float $falloff = ($alignment + 1) / 2; // Remap to 0-1 range
  object.scaleX = lerp(0.5, 1, $falloff);
  object.scaleY = lerp(0.5, 1, $falloff);
  object.scaleZ = lerp(0.5, 1, $falloff);
Advanced Practical - create a surface sliding behavior, where an object slides along as urface, removing any movement in the direction of the surface normal
- vector $objectPos = <>;
  vector $surfaceNormal = <>;
  vector $moveVector = <>;
  float $normalComponent = dot($moveVector, $surfaceNormal);
  vector $tangentVector = $moveVector - $surfaceNormal * $normalComponent;
  object.translateX = $objectPos.x + $tangentVector.x;
  object.translateY = $objectPos.y + $tangentVector.y;
  object.translateZ = $objectPos.z + $tangentVector.z;

DistancePoints

Calculates the Euclidean distance between two points in 3D space. Useful for creating distance-based behaviors, implementing stretch systems, and designing proximity-based effects. Other usages might be calculating lengths of joints or limbs, implementing distance based constraints, or creating falloffs based on proximity, or measuring spatial relationships between objects.
Variants:
- DistancePoints (for point to point distance)
- DistanceTransforms (for distance between transform nodes)
Syntax: distance(point1,point2)
Functionality:
- Takes two Vector3s as input
- Returns a scalar value representing the strait line distance between the points
Example:
- vector $point1 = <<0, 0, 0>>;
  vector $point2 = <<3, 4, 0>>;
  float $result = distance($point1, $point2);
  // $result will be 5
Practical - a simple stretchy IK setup, in which the arm scales uniformly when extended beyond its original length
- vector $shoulderPos = <>;
  vector $handPos = <>;
  float $currentLength = distance($shoulderPos, $handPos);
  float $originalLength = 10; // Assume this is the original arm length
  float $stretchFactor = $currentLength / $originalLength;
  upperArm.scaleX = $stretchFactor;
  lowerArm.scaleX = $stretchFactor;
Advanced Practical - Creating a proximity based blending system, where an object is influenced by multiple targets based on proximity
- vector $objectPos = <>;
  vector $influences[];
  float $weights[];
  float $maxDistance = 10;
  for ($i = 1; $i <= 3; $i++) {
  $influences[$i] = <<(`target$i.translateX`), (`target$i.translateY`), (`target$i.translateZ`)>>;
  float $dist = distance($objectPos, $influences[$i]);
  $weights[$i] = 1 - clamp($dist / $maxDistance, 0, 1);
  }
  float $totalWeight = $weights[1] + $weights[2] + $weights[3];
  if ($totalWeight > 0) {
  vector $blendedPosition = <<0, 0, 0>>;
  for ($i = 1; $i <= 3; $i++) {
  $blendedPosition += $influences[$i] * ($weights[$i] / $totalWeight);
  }
  object.translateX = $blendedPosition.x;
  object.translateY = $blendedPosition.y;
  object.translateZ = $blendedPosition.z;
  }

Floor

Floor rounds a floating point number down to the nearest integer
Variants:
- Floor (float)
- FloorAngle (angle)
Syntax: floor(value)
Example:
- float $value1 = 3.7;
  float $value2 = -2.1;
  float $result1 = floor($value1); // result1 will be 3
  float $result2 = floor($value2); // result2 will be -3
Practical - creates a stepped rotation system, which controls that step in 45° increments, always rounding down
- float $rotationStep = 45; // Rotate in 45-degree increments
  float $currentRotation = control.rotateY;
  float $steppedRotation = floor($currentRotation / $rotationStep) * $rotationStep;
  object.rotateY = $steppedRotation;

Inverse

Calculates the inverse of a given value or transformation. Useful for handling transformations and space conversions, like complex hierarchical relationships or space switching systems. It provides a way to invert values and transformations, allowing riggers to create more flexible control systems, and enabling objects to maintain their positions and orientations across different coordinate spaces.
Variants:
- Inverse (float)
- InverseMatrix (for matricies)
- InverseQuaternion (for quaternions)
- InverseRotation (for rotations)
Syntax: inverse(value)
Functionality:
- For scalars: Returns 1 divided by the input
- For matrices: Returns the inverse matrix
- For quaternions and rotations: returns the inverse rotation
Example:
- float $scalar = 2;
  float $inverseScalar = inverse($scalar); // Result: 0.5
  vector $matrix[4] = `object.worldMatrix`;
  vector $inverseMatrix[4] = inverse($matrix);
Practical - a simple space switching system, which converts an object’s world space to local space relative to the parent object
- vector $worldMatrix[4] = `object.worldMatrix`;
  vector $parentMatrix[4] = `parent.worldMatrix`;
  vector $localMatrix[4] = inverse($parentMatrix) * $worldMatrix;
  setAttr object.matrix $localMatrix;
Practical Advanced - Creates a dynamic parent constraint, which creates a smooth transition between world space and parent space for a child object
- vector $childWorldMatrix[4] = `child.worldMatrix`;
  vector $parentWorldMatrix[4] = `parent.worldMatrix`;
  float $parentInfluence = parent.influence; // Assume this ranges from 0 to 1
  if ($parentInfluence > 0) {
  vector $parentLocalMatrix[4] = inverse($parentWorldMatrix) * $childWorldMatrix;
  vector $blendedLocalMatrix[4] = slerp(`child.matrix`, $parentLocalMatrix, $parentInfluence);
  vector $newWorldMatrix[4] = $parentWorldMatrix * $blendedLocalMatrix;
  setAttr child.matrix $newWorldMatrix;
  }

Lerp

Lerp takes the input of one value, and then drives the output between two other given values. This is a classic way to create smooth transitions, and is particularly helpful when you need to interpolate between known states or values.
Variants:
- Lerp (float)
- LerpAngle (angle)
- LerpVector (vector)
- LerpMatrix (matrix)
Syntax: lerp(value1,value2,alpha)
Functionality
- Takes three inputs, two values to interpolate between, and an alpha (how much they should blend between each other)
- Returns a value linearly interpolated between value1 and value2
- Alpha typically ranges between 0 (full value1) and 1 (full value2)
Example:
- float $value1 = 0;
  float $value2 = 10;
  float $alpha = 0.3;
  float $result = lerp($value1, $value2, $alpha);
  // $result will be 3
Practical - a simple blend between two rotations, controlled by a single attribute
- vector $rotation1 = <<0, 0, 0>>;
  vector $rotation2 = <<90, 45, 30>>;
  float $blendFactor = control.blendAttr; // Assume this ranges from 0 to 1
  vector $blendedRotation = lerp($rotation1, $rotation2, $blendFactor);
  object.rotateX = $blendedRotation.x;
  object.rotateY = $blendedRotation.y;
  object.rotateZ = $blendedRotation.z;
Advanced Practical - a multi-target blending system where an object can be blended between three different positions
- vector $pos1 = <>;
  vector $pos2 = <>;
  vector $pos3 = <>;
  float $blend1 = control.blend1;
  float $blend2 = control.blend2;
  vector $intermediatPos = lerp($pos1, $pos2, $blend1);
  vector $finalPos = lerp($intermediatPos, $pos3, $blend2);
  object.translateX = $finalPos.x;
  object.translateY = $finalPos.y;
  object.translateZ = $finalPos.z;

MatrixFrom

Used to create a transformation matrix from various input components. This is useful in rigging for creating complex transformations, setting up space switching, or defining custom object orientations.
Syntax:
- matrixFromRotation(rotateX, rotateY, rotateZ, rotationOrder)
- matrixFrom(scale, rotation, translation)
- matrixFromTranslation(translateX, translateY, translateZ)
- matrixFromDirection(directionVector, upVector)
- matrixFromElements(XX, XY, XZ, XW, YX, YY, YZ, YW, ZX, ZY, ZZ, ZW, WX, WY, WZ, WW)
Functionality:
- Inputs: depends on which variant you are targeting
- Output: a 4x4 transformation matrix
Example:
- // Create a rotation matrix and apply it to an object
  matrix $rotMatrix = matrixFromRotation(object1.rotateX, object1.rotateY, object1.rotateZ, "xyz");
  object2.matrix = $rotMatrix;
Practical - Space Switching for IK Controls
- // Switch between local and world space for an IK control
  matrix $localMatrix = matrixFrom(<<1,1,1>>, <>, <>);
  matrix $parentMatrix = parent.worldMatrix;
  matrix $worldMatrix = $localMatrix * $parentMatrix;
  if (ikControl.space == 0) // Local space
  ikHandle.matrix = $localMatrix;
  else // World space
  ikHandle.matrix = $worldMatrix;
Advanced Practical - Ribbon Spine System
- // Create a ribbon-like spine system
  vector $startPos = <>;
  vector $endPos = <>;
  vector $spineVector = unit($endPos - $startPos);
  vector $upVector = <<0, 1, 0>>;
  vector $sideVector = unit(cross($spineVector, $upVector));
  matrix $spineMatrix = matrixFromDirection($spineVector, $upVector);
  // Apply to middle joint
  middleJoint.matrix = $spineMatrix;

MatrixFromDirection

Creates a rotation matrix that orients an object to face a specified direction. Useful when you need objects to face or align with specific directions while maintaining a stable up orientation. It simplifies the process of creating look at behaviors, aim constrains, and other direction-based orientation systems.
Syntax: direction(directionVector, upVector)
Functionality:
- Takes two inputs, a direction vector and up vector
- Returns a 4x4 matrix representing the rotation that aligns an object’s local forward axis with the direction vector.
- Uses the up vector to determine the object’s local up direction.
Example:
- vector $directionVec = <<1, 1, 1>>;
  vector $upVec = <<0, 1, 0>>;
  vector $resultMatrix[4] = direction($directionVec, $upVec);
Practical - orients an object to always face a target object
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $directionVec = normalize($targetPos - $objectPos);
  vector $upVec = <<0, 1, 0>>; // World up vector
  vector $lookAtMatrix[4] = direction($directionVec, $upVec);
  // Extract rotation from matrix
  vector $rotation = rot($lookAtMatrix, "xyz");
  object.rotateX = rad_to_deg($rotation.x);
  object.rotateY = rad_to_deg($rotation.y);
  object.rotateZ = rad_to_deg($rotation.z);
Advanced Practical - creating a ribbon-like chain of objects
- int $numObjects = 10;
  vector $startPos = <>;
  vector $endPos = <>;
  vector $chainDir = normalize($endPos - $startPos);
  vector $upVec = <<0, 1, 0>>;
  vector $sideVec = normalize(cross($chainDir, $upVec));
  $upVec = cross($sideVec, $chainDir);
  for ($i = 0; $i < $numObjects; $i++) {
  float $t = (float)$i / ($numObjects - 1);
  vector $pos = $startPos + $chainDir * ($t * mag($endPos - $startPos));
  vector $localUp = $upVec * sin($t * 2 * 3.14159) + $sideVec * cos($t * 2 * 3.14159);
  vector $orientMatrix[4] = direction($chainDir, $localUp);
  setAttr ("object" + ($i+1) + ".translateX") $pos.x;
  setAttr ("object" + ($i+1) + ".translateY") $pos.y;
  setAttr ("object" + ($i+1) + ".translateZ") $pos.z;
  setAttr ("object" + ($i+1) + ".matrix") $orientMatrix;
  }

MatrixfromTRS

Constructs a 4x4 transformation matrix from separate translation, rotation and scale components. It allows you to combine all these values into a single matrix, which is crucial for complex transformation operations, space switching, and advanced constraint systems.
Syntax: trs(translation, rotation, scale)
Functionality:
- Takes three inputs, a translation vector, a rotation (euler or quaternion) and a scale vector
- Returns a 4x4 matrix that represents the combined transformation
- Applies the transformations in the order, scale, then rotate, then translate
Example:
- vector $translation = <<10, 20, 30>>;
  vector $rotation = <<0, 90, 0>>; // In degrees
  vector $scale = <<2, 2, 2>>;
  vector $resultMatrix[4] = trs($translation, deg_to_rad($rotation), $scale);
Practical - a simple space switching setup between local and parent space
- vector $localTranslate = <>;
  vector $localRotate = <
  deg_to_rad(object.rotateY),
  deg_to_rad(object.rotateZ)>>;
  vector $localScale = <>;
  vector $localMatrix[4] = trs($localTranslate, $localRotate, $localScale);
  int $spaceSwitch = control.spaceSwitch; // 0 for world, 1 for parent
  vector $parentMatrix[4] = `parent.worldMatrix`;
  if ($spaceSwitch == 1) {
  vector $worldMatrix[4] = $parentMatrix * $localMatrix;
  setAttr object.matrix $worldMatrix;
  } else {
  setAttr object.matrix $localMatrix;
  }
Advanced Practical - an animated transformation combining oscillating translation, rotation, and scaling
- float $time = `currentTime -q`;
  vector $translation = <>;
  vector $rotation = <<0, $time * 10, 0>>; // Rotate around Y-axis
  vector $scale = <<1 + sin($time * 0.05) * 0.2,
  1 + sin($time * 0.05) * 0.2,
  1 + sin($time * 0.05) * 0.2>>;
  vector $animMatrix[4] = trs($translation, deg_to_rad($rotation), $scale);
  setAttr object.matrix $animMatrix;

Max

Returns the larger of two variables
Variants:
- Max (float)
- MaxInt (Int)
- MaxAngle (Angle)
Syntax: max(value1, value2)
Functionality:
- Takes two input values
- Returns the larger of the two inputs
Example:
- float $value1 = 5.3;
  float $value2 = 7.8;
  float $result = max($value1, $value2);
  // $result will be 7.8
Practical - Creating a stretchy IK Limb with a minimum length:
- def stretchy_ik(start_joint, end_joint, ik_handle, min_length):
  current_length = distance(start_joint.worldMatrix[3], end_joint.worldMatrix[3])
  original_length = ik_handle.poleVectorX # Assuming we stored the original length here
  stretch_factor = max(current_length / original_length, 1)
  start_joint.scaleX = stretch_factor
  start_joint.scaleY = max(1 / sqrt(stretch_factor), min_length / original_length)
  start_joint.scaleZ = max(1 / sqrt(stretch_factor), min_length / original_length)
- in this example the limb never compresses below its original length and maintains a minimum thickness.
Advanced Practical - dynamic scaling system based on distance
- vector $objectPos = <>;
  vector $targetPos = <>;
  float $distance = mag($targetPos - $objectPos);
  float $minScale = 0.5;
  float $scaleFactorPerUnit = 0.1;
  float $dynamicScale = max($minScale, 1 + $distance * $scaleFactorPerUnit);
  object.scaleX = $dynamicScale;
  object.scaleY = $dynamicScale;
  object.scaleZ = $dynamicScale;

MaxElement

Returns the largest value from an array of values
Variants
- MaxElement (float)
- MaxIntElement (Int)
- MaxAngleElement (Angle)
Syntax: maxelement(array)
Functionality:
- Takes an array of numeric values as an input
- Returns the largest value in the array
Example:
- float $values[] = {3.5, 7.2, 1.8, 9.1, 4.6};
  float $result = maxelement($values);
  // $result will be 9.1
Practical - Scales an object based on the largest scale factor from three different influences
- float $scaleFactors[];
  $scaleFactors[0] = influence1.scaleFactorAttr;
  $scaleFactors[1] = influence2.scaleFactorAttr;
  $scaleFactors[2] = influence3.scaleFactorAttr;
  float $maxScaleFactor = maxelement($scaleFactors);
  object.scaleX = $maxScaleFactor;
  object.scaleY = $maxScaleFactor;
  object.scaleZ = $maxScaleFactor;
Advanced Practical - orients a control object based on the maximum rotation values from multiple joints
- vector $jointOrientations[];
  $jointOrientations[0] = <>;
  $jointOrientations[1] = <>;
  $jointOrientations[2] = <>;
  float $maxRotationX = maxelement(<<$jointOrientations[0].x, $jointOrientations[1].x, $jointOrientations[2].x>>);
  float $maxRotationY = maxelement(<<$jointOrientations[0].y, $jointOrientations[1].y, $jointOrientations[2].y>>);
  float $maxRotationZ = maxelement(<<$jointOrientations[0].z, $jointOrientations[1].z, $jointOrientations[2].z>>);
  control.rotateX = $maxRotationX;
  control.rotateY = $maxRotationY;
  control.rotateZ = $maxRotationZ;

Min

Min returns the smaller of two values. Its useful in scenarios where you need to ensure maximum values, implement clamping behjaviors, or create dynamic systems that respond to the samller of two values.
Variants
- Min (float)
- MinInt (int)
- MinAngle (angle)
Syntax: min(value1, value2)
Functionality:
- Takes two input values
- Returns the smaller of the two inputs
- Works with numeric values (floats, ints, angles)
Example:
- float $value1 = 5.3;
  float $value2 = 7.8;
  float $result = min($value1, $value2);
  // $result will be 5.3
Practical - Simple clamping system for a control’s translation, never exceeding 10 in any axis:
- float $rawX = control.translateX;
  float $rawY = control.translateY;
  float $rawZ = control.translateZ;
  float $maxValue = 10;
  float $clampedX = min($rawX, $maxValue);
  float $clampedY = min($rawY, $maxValue);
  float $clampedZ = min($rawZ, $maxValue);
  object.translateX = $clampedX;
  object.translateY = $clampedY;
  object.translateZ = $clampedZ;
Advanced Practical - a dynamic scaling system based on distance from a target, within a maximum scale of 2:
- float $rawX = control.translateX;
  float $rawY = control.translateY;
  float $rawZ = control.translateZ;
  float $maxValue = 10;
  float $clampedX = min($rawX, $maxValue);
  float $clampedY = min($rawY, $maxValue);
  float $clampedZ = min($rawZ, $maxValue);
  object.translateX = $clampedX;
  object.translateY = $clampedY;
  object.translateZ = $clampedZ;

MinElement

Returns the smallest value from an array of values.
Variants:
- MinElement (float arrays)
- MinIntElement (int arrays)
- MinAngleElement (angle arrays)
Syntax: minelement(array)
Functionality:
- Takes an array of numeric values as input
- Returns the smallest value in the array
- Works with arrays of floats, integers or angles
Example:
- float $values[] = {3.5, 7.2, 1.8, 9.1, 4.6};
  float $result = minelement($values);
  // $result will be 1.8
Practical - A system that scales an object based on the smallest scale factor among multiple influences
- float $scaleFactors[];
  $scaleFactors[0] = influence1.scaleFactorAttr;
  $scaleFactors[1] = influence2.scaleFactorAttr;
  $scaleFactors[2] = influence3.scaleFactorAttr;
  float $minScaleFactor = minelement($scaleFactors);
  object.scaleX = $minScaleFactor;
  object.scaleY = $minScaleFactor;
  object.scaleZ = $minScaleFactor;
Advanced Usage - A dynamic multi-joint compression system, based on the minimum scale of multiple joints:
- vector $jointScales[];
  $jointScales[0] = <>;
  $jointScales[1] = <>;
  $jointScales[2] = <>;
  float $minScaleX = minelement(<<$jointScales[0].x, $jointScales[1].x, $jointScales[2].x>>);
  float $minScaleY = minelement(<<$jointScales[0].y, $jointScales[1].y, $jointScales[2].y>>);
  float $minScaleZ = minelement(<<$jointScales[0].z, $jointScales[1].z, $jointScales[2].z>>);
  control.compressionX = 1 - $minScaleX;
  control.compressionY = 1 - $minScaleY;
  control.compressionZ = 1 - $minScaleZ;

ModulusInt

Calculates the remainder of integer divisions between two values
Syntax: x % y
Functionality:
- Takes two integer values as input: a divident and a dividor
- Returns the remainder after division of the first value by the second value
Example
- value1 = 17
  value2 = 5
  result = value1 % value2
  # result would be 2 (17 divided by 5 is 3 with remainder 2)
Practical - cucles an object’s color between red, green and blue every 24 frames
- float $time = `currentTime -q`;
  int $cycleLength = 24; // Change color every 24 frames
  int $colorIndex = (int)$time % $cycleLength;
  if ($colorIndex < 8) {
  object.colorR = 1; object.colorG = 0; object.colorB = 0; // Red
  } else if ($colorIndex < 16) {
  object.colorR = 0; object.colorG = 1; object.colorB = 0; // Green
  } else {
  object.colorR = 0; object.colorG = 0; object.colorB = 1; // Blue
  }
Advanced Practical - rotates multiple objects at the same speed but with evenly distributed offsets
- int $numObjects = 5;
  float $rotationSpeed = 5; // Degrees per frame
  float $time = `currentTime -q`;
  for ($i = 0; $i < $numObjects; $i++) {
  int $offset = ($i * 360) / $numObjects;
  float $rotation = ($time * $rotationSpeed + $offset) % 360;
  setAttr ("object" + ($i+1) + ".rotateY") $rotation;
  }

Multiply

Classic multiplication between two values
Syntax: x * y
Example:
- float $value1 = 5;
  float $value2 = 3;
  float $result = $value1 * $value2;
  // $result will be 15
Practical - a simple scaling system based on distance:
- vector $objectPos = <>;
  vector $targetPos = <>;
  float $distance = mag($targetPos - $objectPos);
  float $scaleFactor = 1 - ($distance / 10); // Assume 10 is the max distance
  float $baseScale = 1;
  object.scaleX = $baseScale * $scaleFactor;
  object.scaleY = $baseScale * $scaleFactor;
  object.scaleZ = $baseScale * $scaleFactor;

Negate

Returns the additive inverse of a value. Particularly useful for creating symmetrical behavior, toggle systems, and reciprocal relationships between attributes or objects. Allows riggers a more dynamic control system, especially with mirroring, balancing, or any scenario where you need to reverse the effect of a value or motion.
Variants:
- Negate (float)
- NegateAngle (Angle)
- NegateInt (Int)
- NegateVector (Vector)
Syntax: negate(value) or -value
Functionality:
- Takes a value as an input
- Returns the negative of that value
- Multiplies the input by -1
Example:
- float $value = 5.3;
  float $result = negate($value);
  // $result will be -5.3
  // Alternatively:
  float $result2 = -$value;
  // $result2 will also be -5.3
Practical - mirrors the rotation of a source control to a target control across the YZ
- float $sourceRotateX = sourceControl.rotateX;
  float $sourceRotateY = sourceControl.rotateY;
  float $sourceRotateZ = sourceControl.rotateZ;
  targetControl.rotateX = negate($sourceRotateX);
  targetControl.rotateY = $sourceRotateY; // Assuming Y is the up axis
  targetControl.rotateZ = negate($sourceRotateZ);
Advanced Practicle - allows toggling between moving towards or away from an object
- float $constraintToggle = control.constraintToggle; // Assume this is 0 or 1
  vector $targetPos = <>;
  vector $objectPos = <>;
  vector $offset = $targetPos - $objectPos;
  vector $negatedOffset = negate($offset);
  vector $finalOffset = $offset * $constraintToggle + $negatedOffset * (1 - $constraintToggle);
  object.translateX += $finalOffset.x;
  object.translateY += $finalOffset.y;
  object.translateZ += $finalOffset.z;

NormalizeVector

Returns a unit vector (a vector with a magnitude of 1) in the same direction as the input vector. It is useful in creating aim constraints, calculating orientations, and designing systems that rely on direction information regardless of scale or distance.
Syntax: normalize(vector)
Functionality:
- Takes a vector as input
- Returns a vector pointing in the same direction but with a length of 1
- If the input vector is 0, returns a 0 vector
Example:
- vector $inputVector = <<3, 4, 0>>;
  vector $normalizedVector = normalize($inputVector);
  // $normalizedVector will be <<0.6, 0.8, 0>>
Practical - creates an aim constraint where the object always faces the target while maintaining a stable up oreintation
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $aimVector = normalize($targetPos - $objectPos);
  vector $upVector = <<0, 1, 0>>; // World up vector
  vector $rightVector = normalize(cross($aimVector, $upVector));
  vector $newUpVector = normalize(cross($rightVector, $aimVector));
  float $aimMatrix[4][4] =
  $aimVector.x, $aimVector.y, $aimVector.z, 0,
  $newUpVector.x, $newUpVector.y, $newUpVector.z, 0,
  $rightVector.x, $rightVector.y, $rightVector.z, 0,
  $objectPos.x, $objectPos.y, $objectPos.z, 1
  >>;
  setAttr object.matrix $aimMatrix;
Advanced Practical - creates a ribbon-like deformation between two joints
- vector $startPos = <>;
  vector $endPos = <>;
  vector $ribbonDir = normalize($endPos - $startPos);
  vector $upVector = <<0, 1, 0>>;
  vector $ribbonSide = normalize(cross($ribbonDir, $upVector));
  float $ribbonLength = mag($endPos - $startPos);
  float $currentU = uCoordinate; // Assume we have a U coordinate from 0 to 1
  float $currentV = vCoordinate; // Assume we have a V coordinate from -0.5 to 0.5
  vector $ribbonPoint = $startPos + $ribbonDir * ($currentU * $ribbonLength);
  vector $offset = $ribbonSide * $currentV * $ribbonLength * 0.1; // 10% of length for width
  point.translateX = $ribbonPoint.x + $offset.x;
  point.translateY = $ribbonPoint.y + $offset.y;
  point.translateZ = $ribbonPoint.z + $offset.z;

NormalizeArray

Scales an array of values so they sum to 1, while maintaining their relative proportions. Useful in scenarios where you need to blend between multiple inputs or targets while ensuring that the total influence always remains constant.
Syntax: normalizearray(array)
Functionality:
- Takes an array of numeric values as input
- Returns an array of the same length where all values sum to 1
- Maintains the relative proportions of the input values
- If all input values are 0, it returns an array of equal values that sum to 1.
Example:
- float $inputArray[] = {2, 3, 5};
  float $normalizedArray[] = normalizearray($inputArray);
  // $normalizedArray will be approximately {0.2, 0.3, 0.5}
Practical - creates a constant where an object is influenced by three targets with normalized weights
- vector $target1Pos = <>;
  vector $target2Pos = <>;
  vector $target3Pos = <>;
  float $weights[] = {control.weight1, control.weight2, control.weight3};
  float $normalizedWeights[] = normalizearray($weights);
  vector $blendedPosition = $target1Pos * $normalizedWeights[0] +
  $target2Pos * $normalizedWeights[1] +
  $target3Pos * $normalizedWeights[2];
  object.translateX = $blendedPosition.x;
  object.translateY = $blendedPosition.y;
  object.translateZ = $blendedPosition.z;
Advanced Practical - orients an object based on the weighted influence of multiple joints, with weights determined by proximity
- vector $jointOrientations[];
  $jointOrientations[0] = <>;
  $jointOrientations[1] = <>;
  $jointOrientations[2] = <>;
  float $distances[];
  $distances[0] = mag(<>);
  $distances[1] = mag(<>);
  $distances[2] = mag(<>);
  float $weights[] = {1/$distances[0], 1/$distances[1], 1/$distances[2]};
  float $normalizedWeights[] = normalizearray($weights);
  vector $blendedOrientation = $jointOrientations[0] * $normalizedWeights[0] +
  $jointOrientations[1] * $normalizedWeights[1] +
  $jointOrientations[2] * $normalizedWeights[2];
  object.rotateX = $blendedOrientation.x;
  object.rotateY = $blendedOrientation.y;
  object.rotateZ = $blendedOrientation.z;

NormalizeWeightsArray

Same as normalize array, but it treats any negative number as 0. Scales an array of values so that they sum to 1 while maintaining their relative proportions, with special handling for negative or 0 values.
Syntax: normalizeweights(array)
Functionality:
- Takes an array of numeric values as an input
- Returns an array the same length where all positive values sum to 1
- Maintains the relative proportions of the positive input values
- Treats negative values as 0
- If all values are 0 or negative, returns an array of equal positive values that sum to 1
Example:
- float $inputArray[] = {2, 3, -1, 5};
  float $normalizedArray[] = normalizeweights($inputArray);
  // $normalizedArray will be approximately {0.2, 0.3, 0, 0.5}
Practical - constraint where an object is influenced by three targets with normalized weights, safely handling negative or zero inputs
- vector $target1Pos = <>;
  vector $target2Pos = <>;
  vector $target3Pos = <>;
  float $weights[] = {control.weight1, control.weight2, control.weight3};
  float $normalizedWeights[] = normalizeweights($weights);
  vector $blendedPosition = $target1Pos * $normalizedWeights[0] +
  $target2Pos * $normalizedWeights[1] +
  $target3Pos * $normalizedWeights[2];
  object.translateX = $blendedPosition.x;
  object.translateY = $blendedPosition.y;
  object.translateZ = $blendedPosition.z;
Orients an object based on the weighted influence of multiple joints, safely handling cases where joints might coincide with the object.
- vector $jointOrientations[];
  $jointOrientations[0] = <>;
  $jointOrientations[1] = <>;
  $jointOrientations[2] = <>;
  float $distances[];
  $distances[0] = mag(<>);
  $distances[1] = mag(<>);
  $distances[2] = mag(<>);
  float $weights[] = {1/$distances[0], 1/$distances[1], 1/$distances[2]};
  float $normalizedWeights[] = normalizeweights($weights);
  vector $blendedOrientation = $jointOrientations[0] * $normalizedWeights[0] +
  $jointOrientations[1] * $normalizedWeights[1] +
  $jointOrientations[2] * $normalizedWeights[2];
  object.rotateX = $blendedOrientation.x;
  object.rotateY = $blendedOrientation.y;
  object.rotateZ = $blendedOrientation.z;

NotBool

Just checks to see if something is false
Syntax: x != y
Example:
- value = 1 # true
  result = !value
  # result would be 0 (false)

OrBool

Logical “or” comparison node
Syntax: x || y
Example:
- if (control1.active || control2.active) {
  visibility = 1;
  } else {
  visibility = 0;
  }

Power

Raises a base number to a specified exponent
Syntax: power(base,exponent)
Functionality:
- Takes two inputs: the base and the exponent
- Returns the result of base raised to the power of exponent
Example:
- float $base = 2;
  float $exponent = 3;
  float $result = power($base, $exponent);
  // $result would be 8 (2^3 = 2 * 2 * 2 = 8)
Practical - creates an object that scales down exponentially as it moves away from a target
- vector $objectPos = <>;
  vector $targetPos = <>;
  float $distance = mag($targetPos - $objectPos);
  float $maxDistance = 10;
  float $minScale = 0.1;
  float $falloffExponent = 2;
  float $scaleFactor = power(1 - clamp($distance / $maxDistance, 0, 1), $falloffExponent);
  float $finalScale = $minScale + (1 - $minScale) * $scaleFactor;
  object.scaleX = $finalScale;
  object.scaleY = $finalScale;
  object.scaleZ = $finalScale;
Advanced Practical - creates a smooth easing-in-and-out animation using a custom power-based easing function
- float $time = `currentTime -q`;
  float $startTime = 1;
  float $endTime = 120;
  float $duration = $endTime - $startTime;
  float $normalizedTime = ($time - $startTime) / $duration;
  float $easedTime = power($normalizedTime, 3) * (1 - $normalizedTime) * 3 + power($normalizedTime, 3);
  float $startValue = 0;
  float $endValue = 10;
  float $animatedValue = $startValue + ($endValue - $startValue) * $easedTime;
  object.translateY = $animatedValue;

QuaternionFrom

Converts an Euler Rotation or a rotation matrix into a quaternion. Useful when dealing with complex rotation scenarios, continuous rotations, or when implementing smooth interpolations between orientations.
Variants:
- QuaternionFromRotation (Euler angles)
- QuaternionFromMatrix (from a rotation matrix)
Syntaxes:
- quat(rotation, rotation order) // for Euler
- quat(matrix) for matrices
Functionality:
- Takes rotation data as input (Euler with rotation order or a rotation matrix)
- Returns a quaternion
- Provides a gimbal-lock free representation of rotation
Example
- vector $eulerRotation = <<30, 45, 60>>; // In degrees
  string $rotOrder = "xyz";
  vector $quaternion = quat(deg_to_rad($eulerRotation), $rotOrder);
  // $quaternion will be a 4D vector representing the quaternion
Practical - Create a smooth interpolation between two rotations using quaternions
- vector $startRotation = <>;
  vector $endRotation = <>;
  vector $startQuat = quat(deg_to_rad($startRotation), "xyz");
  vector $endQuat = quat(deg_to_rad($endRotation), "xyz");
  float $blendFactor = control.blendAttr; // Assume this ranges from 0 to 1
  vector $resultQuat = slerp($startQuat, $endQuat, $blendFactor);
  vector $finalRotation = rad_to_deg(rot($resultQuat, "xyz"));
  object.rotateX = $finalRotation.x;
  object.rotateY = $finalRotation.y;
  object.rotateZ = $finalRotation.z;
Advanced Practical - Create a weighted blend between three different orientation targets using quaternions
- vector $target1Rot = <>;
  vector $target2Rot = <>;
  vector $target3Rot = <>;
  vector $quat1 = quat(deg_to_rad($target1Rot), "xyz");
  vector $quat2 = quat(deg_to_rad($target2Rot), "xyz");
  vector $quat3 = quat(deg_to_rad($target3Rot), "xyz");
  float $weight1 = control.weight1;
  float $weight2 = control.weight2;
  float $weight3 = 1 - $weight1 - $weight2;
  vector $blendQuat1 = slerp($quat1, $quat2, $weight2 / ($weight1 + $weight2));
  vector $finalQuat = slerp($blendQuat1, $quat3, $weight3);
  vector $finalRotation = rad_to_deg(rot($finalQuat, "xyz"));
  object.rotateX = $finalRotation.x;
  object.rotateY = $finalRotation.y;
  object.rotateZ = $finalRotation.z;

Remap

Scales a value from one range to another, maintaining the relative position of the value within the range.
Variants:
- Remap (float)
- RemapInt (Int)
- RemapAngle (Angle)
Syntax: remap(value, oldMin, oldMax, newMin, newMax)
Functionality:
- Takes five inputs, the value to remap, the old range (min and max), the new range (min and max)
- Returns the input value scaled to the new range
- Performs linear interpolation between the ranges
Example:
- float $input = 5;
  float $result = remap($input, 0, 10, -1, 1);
  // $result will be 0 (5 is halfway between 0 and 10, so it maps to halfway between -1 and 1)
Practical - create a foot roll system where a single control attribute drives multiple joint rotations with appropriate ranges
- float $footRoll = foot_ctrl.roll; // Assume this ranges from -1 to 1
  // Heel rotation (active from -1 to 0)
  heel.rotateX = remap($footRoll, -1, 0, -45, 0);
  // Ball rotation (active from 0 to 0.5)
  ball.rotateX = remap($footRoll, 0, 0.5, 0, 60);
  // Toe rotation (active from 0.5 to 1)
  toe.rotateX = remap($footRoll, 0.5, 1, 0, 30);
Advanced Practical - Create a dynamic falloff effect where objects scale based on their distance from an effector.
- vector $objectPos = <>;
  vector $effectorPos = <>;
  float $distance = mag($objectPos - $effectorPos);
  float $innerRadius = effector.innerRadius;
  float $outerRadius = effector.outerRadius;
  float $falloff = 1 - remap($distance, $innerRadius, $outerRadius, 0, 1);
  $falloff = clamp($falloff, 0, 1);
  object.scaleX = lerp(1, 2, $falloff);
  object.scaleY = lerp(1, 2, $falloff);
  object.scaleZ = lerp(1, 2, $falloff);

Round

Rounds a floating point value to the nearest integer, with anything above 0.5 going up and anything below 0.5 going down
Variants:
- Round (float)
- RoundAngle (Angle)
Syntax: round(value)
Functionality:
- Takes a floating point input
- Returns the nearest integer value
Example:
- float $value1 = 3.2;
  float $value2 = 3.7;
  float $result1 = round($value1); // result1 will be 3
  float $result2 = round($value2); // result2 will be 4

RotateVectorBy

Rotates a vector by a specified rotation (euler angles, quaternion or matrix)
Variants:
- RotateVectorByRotation (Euler)
- RotateVectorByQuaternion (Quaternion)
- RotateVectorByMatrix (Rotation Matrix)
Syntax:
- rotate(vector,rotation,rotationOrder) //Euler
- rotate(vector,quaternion) //Quaternion
- rotate(vector,matrix) //Matricies
Functionality
- Takes a vector and a rotation as an input
- Returns the rotated vector
- Allows precise control over vector orientation
Example:
- vector $inputVector = <<1, 0, 0>>; // Vector pointing along X-axis
  vector $rotation = <<0, 90, 0>>; // 90 degrees around Y-axis
  vector $rotatedVector = rotate($inputVector, deg_to_rad($rotation), "xyz");
  // $rotatedVector will be approximately <<0, 0, -1>>

Practical - Simple aim constraint with an up vector

vector $objectPos = <>;
vector $targetPos = <>;
vector $upVector = <<0, 1, 0>>; // World up vector
vector $aimVector = normalize($targetPos - $objectPos);
vector $rightVector = normalize(cross($aimVector, $upVector));
vector $newUpVector = cross($rightVector, $aimVector);
vector $forwardAxis = <<1, 0, 0>>; // Local X-axis as forward
vector $upAxis = <<0, 1, 0>>; // Local Y-axis as up
vector $rotationQuat = quatFromTwoVectors($forwardAxis, $aimVector) * quatFromTwoVectors($upAxis, $newUpVector);
vector $rotatedForward = rotate($forwardAxis, $rotationQuat);
vector $rotatedUp = rotate($upAxis, $rotationQuat);
vector $finalRotation = rot(rotationFromTwoVectors($rotatedForward, $rotatedUp), "xyz");
object.rotateX = rad_to_deg($finalRotation.x);
object.rotateY = rad_to_deg($finalRotation.y);
object.rotateZ = rad_to_deg($finalRotation.z);

RotationFrom

Converts a Quaternion or Matrix into Euler. Its useful in scenarios where you need to convert between different rotation representations, implement space switching systems, or analyze the orientation of objects in complex hierarchies.
Variants:
- RotationFromMatrix (converts a matrix to euler angles)
- RotationFromQuaternion (converts a quaternion to euler angles)
Syntax:
- rot(matrix, rotationOrder)
- rot(quaternion, rotationOrder)
Functionality:
- Takes a matrix or quaternion as input
- Returns a vector representing euler angles (in radians)
- Allows specifying the desired rotation order
Example:
- vector $matrix[4] = `object.worldMatrix`;
  vector $eulerAngles = rot($matrix, "xyz");
  // $eulerAngles will contain the rotation in radians
Practical - Extracts the rotation from the target’s world matrix and applies it to the object in a simple orientation matching system:
- vector $targetMatrix[4] = `target.worldMatrix`;
  vector $targetRotation = rot($targetMatrix, "xyz");
  // Convert radians to degrees for Maya's rotate attributes
  object.rotateX = rad_to_deg($targetRotation.x);
  object.rotateY = rad_to_deg($targetRotation.y);
  object.rotateZ = rad_to_deg($targetRotation.z);
Practical Advanced - creating a space switching setup using matrix multiplication and rotation extraction
- vector $localMatrix[4] = `object.matrix`;
  vector $parentWorldMatrix[4] = `parent.worldMatrix`;
  vector $worldMatrix[4] = $parentWorldMatrix * $localMatrix;
  int $spaceSwitch = control.spaceSwitch; // Assume 0 for world, 1 for local
  vector $resultMatrix[4];
  if ($spaceSwitch == 0) $resultMatrix = $worldMatrix;
  else $resultMatrix = $localMatrix;
  vector $resultRotation = rot($resultMatrix, "xyz");
  control.rotateX = rad_to_deg($resultRotation.x);
  control.rotateY = rad_to_deg($resultRotation.y);
  control.rotateZ = rad_to_deg($resultRotation.z);

ScaleFromMatrix

Extracts the scale components from a transform matrix. This is useful where you need to understand or compensate for scaling effects in a transformation hierarchy. It’s a component in making scale-aware systems, maintaining consistent sizing across hierarchies, or implementing advanced constraint systems that need to account for parent scaling.
Syntax: scale(matrix)
Functionality:
- Takes a 4x4 transformation matrix as input
- Returns a vector representing the X, Y, and Z scale
- Extracts scale even if the matrix includes rotation and scale
Example:
- vector $localMatrix[4] = `object.matrix`;
  vector $parentWorldMatrix[4] = `parent.worldMatrix`;
  vector $worldMatrix[4] = $parentWorldMatrix * $localMatrix;
  int $spaceSwitch = control.spaceSwitch; // Assume 0 for world, 1 for local
  vector $resultMatrix[4];
  if ($spaceSwitch == 0) $resultMatrix = $worldMatrix;
  else $resultMatrix = $localMatrix;
  vector $resultRotation = rot($resultMatrix, "xyz");
  control.rotateX = rad_to_deg($resultRotation.x);
  control.rotateY = rad_to_deg($resultRotation.y);
  control.rotateZ = rad_to_deg($resultRotation.z);
Practical - a scale compensation system for a child object:
- vector $parentMatrix[4] = `parent.worldMatrix`;
  vector $parentScale = scale($parentMatrix);
  child.scaleX = 1 / $parentScale.x;
  child.scaleY = 1 / $parentScale.y;
  child.scaleZ = 1 / $parentScale.z;
Advanced Practical - Creating a world-space scale indicator, taking into account all parent transformations:
- vector $localMatrix[4] = `object.matrix`;
  vector $parentWorldMatrix[4] = `object.parentMatrix`;
  vector $worldMatrix[4] = $parentWorldMatrix * $localMatrix;
  vector $worldScale = scale($worldMatrix);
  scaleIndicator.scaleX = $worldScale.x;
  scaleIndicator.scaleY = $worldScale.y;
  scaleIndicator.scaleZ = $worldScale.z;

Select

Chooses between two values based on a conditional input. Its useful for implementing logic-based systems, creating toggles between different states of behaviors, and designing more complex decision-making structures in your rigs.
Variants:
- Select (float)
- SelectInt(Int)
- SelectAngle (Angle)
- SelectVector (Vector)
- SelectMatrix (Matrix)
Syntax: select(value1, value2, condition)
Functionality:
- Takes three inputs: two values and a condition
- If the condition is true (non-zero) it returns a value 1
- If the condition is false (zero) it returns value 2
Example:
- float $control = node.control; // Assume this is a 0 or 1 value
  float $value1 = 5;
  float $value2 = 10;
  float $result = select($value1, $value2, $control);
  // If $control is 1, $result will be 5
  // If $control is 0, $result will be 10
Practical - Switch the Y-rotation of the driven object between two different drivers:
- float $switch = control.switch; // Assume this is a 0 or 1 value
  float $rotation1 = driver1.rotateY;
  float $rotation2 = driver2.rotateY;
  driven.rotateY = select($rotation1, $rotation2, $switch);
Advanced Practical - Creates a system where an object moves between four positions based on a single state control:
- float $state = control.state; // Assume this ranges from 0 to 3
  vector $pos1 = <<0, 0, 0>>;
  vector $pos2 = <<10, 0, 0>>;
  vector $pos3 = <<0, 10, 0>>;
  vector $pos4 = <<0, 0, 10>>;
  vector $selectedPos = select(
  select(
  select($pos1, $pos2, $state > 0),
  $pos3,
  $state > 1
  ),
  $pos4,
  $state > 2
  );
  object.translateX = $selectedPos.x;
  object.translateY = $selectedPos.y;
  object.translateZ = $selectedPos.z;

SelectArray

Chooses between two arrays of values based on a conditional input - essentially the same as select but dealing with arrays. This is useful when you need to switch between multiple related values simultaneously. It allows for cleaner expressions when dealint with data sets, such as poses, transformations, or any multi-attribute states.
Variants:
- SelectArray (float array)
- SelectIntArray (int array)
- SelectVectorArray (vector array)
- SelectMatrixArray (matrix array)
Syntax: selectarray(array1,array2,condition)
Functionality:
- Takes three inputs: two arrays of the same type and length, and a condition
- If the condition is true (non-zero) it returns array 1
- If the condition is false (zero), it returns array 2
Example:
- float $control = node.control; // Assume this is a 0 or 1 value
  float $array1[] = {1, 2, 3, 4};
  float $array2[] = {5, 6, 7, 8};
  float $result[] = selectarray($array1, $array2, $control);
  // If $control is 1, $result will be {1, 2, 3, 4}
  // If $control is 0, $result will be {5, 6, 7, 8}
Practical - Switches the rotation of three joints between two predefined poses based on the switch value
- float $switch = control.switch; // Assume this is a 0 or 1 value
  vector $pose1[] = {<<0,0,0>>, <<30,0,0>>, <<-30,0,0>>};
  vector $pose2[] = {<<0,30,0>>, <<0,-30,0>>, <<0,0,30>>};
  vector $selectedPose[] = selectarray($pose1, $pose2, $switch);
  joint1.rotate = $selectedPose[0];
  joint2.rotate = $selectedPose[1];
  joint3.rotate = $selectedPose[2];
Advanced Practical - Creates an FK/IK switch system for a chain of joints, switching between FK and IK positions based on a blend attribute
- float $ikFkBlend = control.ikFkBlend; // Assume this ranges from 0 to 1
  vector $fkPositions[] = {<>,
  <>,
  <>};
  vector $ikPositions[] = {<>,
  <>,
  <>};
  vector $blendedPositions[] = selectarray($ikPositions, $fkPositions, $ikFkBlend > 0.5);
  for ($i = 0; $i < size($blendedPositions); $i++) {
  setAttr ("joint" + ($i+1) + ".translateX") $blendedPositions[$i].x;
  setAttr ("joint" + ($i+1) + ".translateY") $blendedPositions[$i].y;
  setAttr ("joint" + ($i+1) + ".translateZ") $blendedPositions[$i].z;
  }

SinAngle

Calculates the sine of an input angle. Its useful in generating wave-like behaviors, circular movements, and in solving various trigonometric problems.
Syntax: sin(angle)
Functionality:
- Takes an angle as input (in radians)
- Returns the sine of that angle (a value between -1 and 1)
- Works with float values
Example:
- float $angleInDegrees = 30;
  float $angleInRadians = deg_to_rad($angleInDegrees);
  float $result = sin($angleInRadians);
  // $result will be approximately 0.5
Practical - Creates a smooth, sinusoidal up-and-down motion for an object
- float $time = `currentTime -q`;
  float $frequency = 0.1; // Controls how fast the oscillation occurs
  float $amplitude = 5; // Controls the height of the oscillation
  float $yPosition = $amplitude * sin($time * $frequency);
  object.translateY = $yPosition;
Advanced Practical - Creates a spiral motion that combines circular movement in the XZ plane with a steady upward motion:
- float $time = `currentTime -q`;
  float $speed = 0.1;
  float $radius = 5;
  float $height = 0.1;
  float $angle = $time * $speed;
  float $xPosition = $radius * sin($angle);
  float $zPosition = $radius * cos($angle);
  float $yPosition = $height * $angle;
  object.translateX = $xPosition;
  object.translateY = $yPosition;
  object.translateZ = $zPosition;

SlerpQuaternion

Performs Spherical Linear Interpolation between two quaternions. Useful where smooth and predictable rotation interpolations are crucial. It blends between orientations in a way that avoids the problems associated with linear interpolation of euler angles, such as gimbal lock and non-uniform angular velocities.
Syntax: slerp(quaternion1,quaternion2,weight)
Functionality:
- Takes two quaternions and an interpolation weight as input
- Returns a quaternion that represents a smooth interpolation between the two input quaternions
- The weight determines the blend between the two quaternions.
Example:
- vector $quat1 = <<0, 0, 0, 1>>; // Identity quaternion
  vector $quat2 = <<0, 0.7071, 0, 0.7071>>; // 90-degree rotation around Y
  float $blend = 0.5; // Halfway between the two rotations
  vector $resultQuat = slerp($quat1, $quat2, $blend);
Practical - Creates a smooth rotation from one object’s orientation to another as the blend attribute goes from 0 to 1
- vector $startRot = <>;
  vector $endRot = <>;
  vector $startQuat = quat(deg_to_rad($startRot), "xyz");
  vector $endQuat = quat(deg_to_rad($endRot), "xyz");
  float $blend = control.blendAttr; // Assume this is a 0-1 slider
  vector $interpolatedQuat = slerp($startQuat, $endQuat, $blend);
  // Convert back to Euler angles for Maya's rotate attributes
  vector $resultRotation = rad_to_deg(rot($interpolatedQuat, "xyz"));
  object.rotateX = $resultRotation.x;
  object.rotateY = $resultRotation.y;
  object.rotateZ = $resultRotation.z;
Advanced Practical - Creates a weighted blend between three different orientation targets using SLERP:
- vector $target1Rot = <>;
  vector $target2Rot = <>;
  vector $target3Rot = <>;
  vector $quat1 = quat(deg_to_rad($target1Rot), "xyz");
  vector $quat2 = quat(deg_to_rad($target2Rot), "xyz");
  vector $quat3 = quat(deg_to_rad($target3Rot), "xyz");
  float $weight1 = control.weight1;
  float $weight2 = control.weight2;
  float $weight3 = 1 - $weight1 - $weight2;
  vector $blendQuat1 = slerp($quat1, $quat2, $weight2 / ($weight1 + $weight2));
  vector $finalQuat = slerp($blendQuat1, $quat3, $weight3);
  vector $finalRotation = rad_to_deg(rot($finalQuat, "xyz"));
  object.rotateX = $finalRotation.x;
  object.rotateY = $finalRotation.y;
  object.rotateZ = $finalRotation.z;

SmoothStep

Performs smooth Hermite interpolation between 0 and 1, creating an S-shaped curve. Useful for creating natural-feeling transitions and easing effects. It adds an organic feeling to linear inputs, making controls and animations feel less mechanical and more fluid. Often used in user interface elements, blend shapes, constraint weights, and any scenario where a smooth, S-curved transition between two states is desirable.
Syntax: smoothstep(x)
Functionality:
- Takes a value between 0 and 1 as an input
- Returns a smoothly interpolated value between 0 and 1
- Provides an S-shaped curve that starts slow, accelerates in the middle, and slows down at the end.
Example:
- float $input = 0.5;
  float $result = smoothstep($input);
  // $result will be 0.5, but with a different rate of change compared to the input
Practical - Creates a visibility fade that starts and ends gradually, with a faster transition in the middle
- float $fadeControl = control.fade; // Assume this ranges from 0 to 1
  float $smoothFade = smoothstep($fadeControl);
  object.visibility = $smoothFade;
Advanced Practical - Creates a smooth animation that eases in and out over the specified duration:
- float $time = `currentTime -q`;
  float $duration = 120; // Animation duration in frames
  float $normalizedTime = clamp($time / $duration, 0, 1);
  float $smoothProgress = smoothstep($normalizedTime);
  float $startValue = 0;
  float $endValue = 10;
  float $animatedValue = $startValue + ($endValue - $startValue) * $smoothProgress;
  object.translateY = $animatedValue;

Subtract

Subtracts one value from another
Syntax: x - y
Example:
- float $value1 = 10;
  float $value2 = 3;
  float $result = $value1 - $value2;
  // $result will be 7
Practical - a simple follow behavior with an offset
- vector $targetPos = <>;
  vector $offsetVector = <>;
  vector $followPos = $targetPos - $offsetVector;
  object.translateX = $followPos.x;
  object.translateY = $followPos.y;
  object.translateZ = $followPos.z;

Sum

Used to add multiple values (more than two) stored in an array’
Syntax: sum([x,y,z,…])
Example:
- float $values[] = {1, 2, 3, 4, 5};
  float $result = sum($values);
  // $result will be 15
Practical - multi-influence blending system from multiple targets
- float $weights[] = {control1.weight, control2.weight, control3.weight};
  float $totalWeight = sum($weights);
  if ($totalWeight > 0) {
  vector $targetPos1 = <>;
  vector $targetPos2 = <>;
  vector $targetPos3 = <>;
  vector $blendedPos = ($targetPos1 * $weights[0] + $targetPos2 * $weights[1] + $targetPos3 * $weights[2]) / $totalWeight;
  object.translateX = $blendedPos.x;
  object.translateY = $blendedPos.y;
  object.translateZ = $blendedPos.z;
  }

TanAngle

Calculates the tangent of an input angle. It is used less frequently but has applications in creating certain types of motion curves, solving angular problems, and designing specialized mathematical relationships to rigs. Its tendency to produce extreme values near certain angles can be either a challenge or a feature, depending on the desired behavior.
Syntax: tan(angle)
Functionality:
- Takes an angle as input (in radians)
- Returns the tangent of that angle
- Works with float values
Example:
- float $time = `currentTime -q`;
  float $duration = 120; // Animation duration in frames
  float $normalizedTime = clamp($time / $duration, 0, 1);
  float $smoothProgress = smoothstep($normalizedTime);
  float $startValue = 0;
  float $endValue = 10;
  float $animatedValue = $startValue + ($endValue - $startValue) * $smoothProgress;
  object.translateY = $animatedValue;
Practical - Creates a control that rotates faster as it approaches 90°, due to the nature of the tangent function:
- float $inputRotation = joint.rotateX; // Assume this is in degrees
  float $inputRadians = deg_to_rad($inputRotation);
  float $exaggeratedRotation = rad_to_deg(atan(tan($inputRadians) * 2));
  control.rotateX = $exaggeratedRotation;
Advanced Practical - Creates a rotation behavior that snaps to the nearest 15° increment, with a smooth transition between snaps:
- float $inputRotation = joint.rotateX; // Assume this is in degrees
  float $inputRadians = deg_to_rad($inputRotation);
  float $exaggeratedRotation = rad_to_deg(atan(tan($inputRadians) * 2));
  control.rotateX = $exaggeratedRotation;

TranslationFromMatrix

Extracts the translation component from a transformation matrix, making it possible to create rigs that can adapt to different coordinate spaces and parent-child relationships. This fucntion is particularly useful in creating advanced constraints, space switching systems and any rig component that needs to understand and respond to the positions of the objects in various coordinate spaces.
Syntax: translation(matrix)
Functionality:
- Takes a 4x4 transformation matrix as input
- Returns a vector representing the X, Y, and Z translation components
- Extracts translation even if the matrix includes rotation and scale
Example:
- vector $matrix[4] = `object.worldMatrix`;
  vector $position = translation($matrix);
  // $position will contain the X, Y, and Z world space position
Practical - Makes an object follow the world space position of a target:
- vector $targetMatrix[4] = `target.worldMatrix`;
  vector $targetPosition = translation($targetMatrix);
  object.translateX = $targetPosition.x;
  object.translateY = $targetPosition.y;
  object.translateZ = $targetPosition.z;
Advanced Practical - Offsets an object’s position in its local space, regardless of parent transformations
- vector $objectMatrix[4] = `object.matrix`;
  vector $parentWorldMatrix[4] = `object.parentMatrix`;
  vector $offsetVector = <<5, 0, 0>>; // 5 units offset in X
  vector $localOffset = inverse($parentWorldMatrix) * $offsetVector;
  vector $currentPosition = translation($objectMatrix);
  vector $newPosition = $currentPosition + $localOffset;
  object.translateX = $newPosition.x;
  object.translateY = $newPosition.y;
  object.translateZ = $newPosition.z;

TwistFrom

Extracts the twist rotation around a specific axis from a rotation or matrix output. Allows riggers to isolate and manipulate specific aspects of rotation, which is crucial for creating natural-looking deformations in areas like arms, legs, and spines. By extracting and redistributing twist, riggers can create more nuanced and anatomically correct motion in their character rigs.
Variants:
- TwistFromRotation (Extracts twist from euler angles)
- TwistFromMatrix (Extracts twist from a transformation matrix)
Syntax:
- twist(rotation, axis, rotationOrder) // for euler angles
- twist(matrix, axis) // for matrices
Functionality:
- Takes a rotation (euler angles or matrix) as input
- Requires specification of the twist axis (0 for X, 1 for Y, 2 for Z)
- Returns the angle of twist around the specified axis
- For Euler angles, also requires the rotation order
Example:
- vector $rotation = <<30, 45, 60>>; // Rotation in degrees
  float $twistAngle = twist(deg_to_rad($rotation), 1, "xyz"); // Extract twist around Y-axis
  // $twistAngle will be in radians
Practical - Extracts the twist of the hand relative to the upper arm and applies half of it to the forearm
- vector $upperArmMatrix[4] = `upperArm.worldMatrix`;
  vector $handMatrix[4] = `hand.worldMatrix`;
  float $twistAngle = twist($handMatrix, 0); // Assuming X is the twist axis
  // Apply a portion of the twist to the forearm
  forearm.rotateX = rad_to_deg($twistAngle * 0.5); // 50% of the twist
Advanced Practical - Creates a multi-segment twist distribution for the spine evenly across multiple joints:
- vector $hipsMatrix[4] = `hips.worldMatrix`;
  vector $chestMatrix[4] = `chest.worldMatrix`;
  float $totalTwist = twist($chestMatrix, 1); // Assuming Y is up
  int $numSegments = 5;
  float $twistPerSegment = $totalTwist / $numSegments;
  for ($i = 1; $i <= $numSegments; $i++) {
  float $segmentTwist = $twistPerSegment * $i;
  setAttr ("spineJoint" + $i + ".rotateY") rad_to_deg($segmentTwist);
  }

VectorLength

Caluculates the magnitude (length) of a vector
Example:
- vector $myVector = <<3, 4, 0>>;
  float $magnitude = length($myVector);
  // $magnitude will be 5
In rigging you can
- Calculate the distance between objects
- Normalize vectors
- Implement scale based behaviors
- create radius based effects or constraints
Practical - Create a distance based scaling effect, where the scale decreases as the distance increases
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $difference = $targetPos - $objectPos;
  float $distance = length($difference);
  float $maxDistance = 10;
  float $scale = 1 - clamp($distance / $maxDistance, 0, 1);
  object.scaleX = $scale;
  object.scaleY = $scale;
  object.scaleZ = $scale;
Advanced Practical - this creates a simple stretch effect for a middle joint based on a the overall length of a three joint chain
- vector $startPos = <>;
  vector $endPos = <>;
  float $currentLength = length($endPos - $startPos);
  float $originalLength = joint2.originalLength; // Assume we stored this somewhere
  float $stretchFactor = $currentLength / $originalLength;
  joint2.scaleX = $stretchFactor;

VectorLengthSquared

Calculates the sqared magnitude of a given vector without taking the square root. This is useful in situations where you need to work with distance based effects, but don’t need the exact linear distance. By avoiding square root calculations, you can improve performance in rigs that involve many distance based calculations.
Syntax: lengthsquared(vector)
Functionality:
- Takes a vector as an input
- Returns a float representing the squared length of the vector
- Calculates the sum of the squares of the vector components
Example:
- vector $myVector = <<3, 4, 0>>;
  float $magnitudeSquared = lengthsquared($myVector);
  // $magnitudeSquared will be 25
Practical - Toggles an object’s visibility based on its proximity to a target, using squared distance for efficiency
- vector $objectPos = <>;
  vector $targetPos = <>;
  vector $difference = $targetPos - $objectPos;
  float $distanceSquared = lengthsquared($difference);
  float $thresholdSquared = 100; // 10 units squared
  if ($distanceSquared < $thresholdSquared) {
  object.visibility = 1;
  } else {
  object.visibility = 0;
  }
Advanced Practical - Creates a scaling effect that falls off based on distance from a center point, using squared distances for better performance
- vector $centerPos = <>;
  vector $objectPos = <>;
  float $maxDistanceSquared = 400; // 20 units squared
  float $distanceSquared = lengthsquared($objectPos - $centerPos);
  float $falloff = 1 - clamp($distanceSquared / $maxDistanceSquared, 0, 1);
  object.scaleX = lerp(1, 2, $falloff);
  object.scaleY = lerp(1, 2, $falloff);
  object.scaleZ = lerp(1, 2, $falloff);

WeightedAverage

Calculates the average of a set of values, with each value having its own weight. It allows sophisticated multi-target constraints, smooth transitions between multiple states, and can be used to create dynamic, responsive rigs that adapt to multiple influences.
Variants:
- WeightedAverage (float)
- WeightedAverageAngle (angle)
- WeightedAverageInt (integer)
- WeightedAverageVector (vector)
- WeightedAverageMatrix (matrix)
Syntax: weightedaverage(value1, weight1, value2, weight2, …)
Functionality:
- Takes pairs of values and weights
- Returns the weighted average of the input values
- Calculates (value1 * weight1 + value2 * weight2 + …) / (weight1 + weight2 + …)
Example:
- float $value1 = 10;
  float $weight1 = 2;
  float $value2 = 20;
  float $weight2 = 1;
  float $result = weightedaverage($value1, $weight1, $value2, $weight2);
  // $result will be 13.333... (40 / 3)
Practical - Creates a position that’s a weighted blend of three target positions:
- vector $pos1 = <>;
  vector $pos2 = <>;
  vector $pos3 = <>;
  float $weight1 = control.weight1;
  float $weight2 = control.weight2;
  float $weight3 = control.weight3;
  vector $blendedPos = weightedaverage($pos1, $weight1, $pos2, $weight2, $pos3, $weight3);
  object.translateX = $blendedPos.x;
  object.translateY = $blendedPos.y;
  object.translateZ = $blendedPos.z;
Advanced - A dynamic multi-joint orient constraint, where the influcence of each target is based on its distance from the object.
- vector $targetRot1 = <>;
  vector $targetRot2 = <>;
  vector $targetRot3 = <>;
  float $distance1 = mag(<
  object.translateY - target1.translateY,
  object.translateZ - target1.translateZ>>);
  float $distance2 = mag(<
  object.translateY - target2.translateY,
  object.translateZ - target2.translateZ>>);
  float $distance3 = mag(<
  object.translateY - target3.translateY,
  object.translateZ - target3.translateZ>>);
  float $weight1 = 1 / ($distance1 * $distance1);
  float $weight2 = 1 / ($distance2 * $distance2);
  float $weight3 = 1 / ($distance3 * $distance3);
  vector $blendedRot = weightedaverage($targetRot1, $weight1, $targetRot2, $weight2, $targetRot3, $weight3);
  object.rotateX = $blendedRot.x;
  object.rotateY = $blendedRot.y;
  object.rotateZ = $blendedRot.z;

XorBool

Performs a logical XOR (exclusive OR) operation between two boolean values. It is useful in rigging scenarios where you need to create mutually exclusive behaviors or states. Its handy when you need to trigger an action or state change based on the difference between two conditions, rather than their similarity. It performs a logical XOR (exclusive or) operation between two boolean values.
Variants:
- XorBool (for bools)
- XorInt (for int values, treating non zero as true)
Syntax: x ^ y (where ‘x’ and ‘y’ are boolean or int values to be compared)
Functionality:
- Takes two inputs
- Returns true (1) if exactly one of the inputs is true, false (0) otherwise
- Truth table:
  - false XOR false = false
  - false XOR true = true
  - true XOR false = true
  - true XOR true = false
Example:
- int $value1 = control1.attribute > 0;
  int $value2 = control2.attribute > 0;
  int $result = $value1 ^ $value2;
Practical - visibility toggle that’s on only when exactly one of the two controls is active:
- int $control1Active = control1.active;
  int $control2Active = control2.active;
  object.visibility = $control1Active ^ $control2Active;
Advanced Practical - two-switch state machine, where three objects are exclusively visible based on the combination of two switches
- int $switch1 = control1.switch;
  int $switch2 = control2.switch;
  int $state1 = !$switch1 && !$switch2;
  int $state2 = $switch1 ^ $switch2;
  int $state3 = $switch1 && $switch2;
  object1.visibility = $state1;
  object2.visibility = $state2;
  object3.visibility = $state3;

Fun Animation Features

Annie Drake — Wed, 22 May 2024 23:40:38 GMT

Motion Matching: Loading a library of animations into a data set. Based on movement parameters you set up, (velocity and direction most common) UE5 will play the one whose movement most closely matches your movement.

Animation Graph: Event Graph and Anim Graph live under the Anim Blueprint. The Anim Graph handles animation specific connections and logic (state machines, poses, ect)

Animation Blueprint: The Anim Blueprint handles all animation, and needs to be assigned under the character’s blueprint.

Blendspace: This creates a 2D graph in which two values can be mapped (IE Position, orientation, velocity ect). Animations can be dropped in a grid pattern depending on where that slider is in its intensity.

Additive Animation: Adds two animation values together rather than overriding. You could use this to lean when you reach fast speeds, create more dynamic reactions when you fall and hit the ground, ect.

Animation Notifiers: An “event” you can put into an animation (examples: audio FX, Particle FX, Damage ect)

Layered Blend per Bone: Play 2 animations on one skeleton - this lets you delegate which bone in the hierarchy the second animation begins playing at. (IE if that bone is L clavical, the entire left arm will play animation #2, but the rest of the body will play animation #1)

Blend Poses by Bool / Enum: Attribute in Anim Graph, you can apply any movement sequence according to bool/enums. Bool example - is falling play 1D blendspace (according to speed), upon hit ground bool turns off and return to standard motion space.

State Machine: Series of nodes which contain animation states (idle, walking, death ect) and transition states. You’ll load logic into the transition states, and animation rules into the states (blendspaces, enum state ect).

Animation Montage: A great way to call one off animations, it has lots of options (play rate, start position, On Complete, On Blend Out, On Interrupt, On Notify Begin/End

Physical Animation: Robust ragdoll, there are ways of blending animations with the ragdoll state to achieve looks (IE slight amount of ragdoll could make character look more “tired”, or you could apply ragdoll for taking hits, falling, then blend animations in before hitting the ground depending on fall direction to “catch” themselves and recover.

Save Pose Snapshot: Lets you grab a pose in a moment. This is helpful for transitioning from one system to another (Physical Animation would be a good use)

Cached Animation: Its a way of grabbing a snapshot of a pose that you can feed into multiple different inputs. This only works in the Anim Graph, and not in state machines.

Pose Assets: Save out a series of poses from maya (starting on frame 0 incrementing every frame). You can then load into Unreal as driven animation. (Examples: Driving auto facial animation like Faceware, or shifting armor around depending on rotation of arm, or animating muscles or auxillary info like hair)

Shader Principals

Annie Drake — Mon, 04 Mar 2024 16:32:49 GMT

Normal Maps

Every pixel of a normal map gets a different direction. Front left is blue, front right is red. Back Left is yellow, back right is green. Up is lighter, down is darker. You would think then that normal maps would be multicolored, and model space normal maps are. We are more used to dealing with tangent space normal maps, however, which orient themselves locally to the direction of the normal.

Tangent Space Normal Map

Model Space Normal Ma

Dot Product

If you have two angles on a 2D plane, and took the first of the two vectors, you would have your dot product. The dot product essentially measures how much two vectors are pointing in the same direction. So if the angle between two normal directions were 90°, the dot product would be 0, and if the angle were 0° the dot product would be 1.

Game engines look for the relationship between lighting and materials. Indirect light approaches an object from all angles, direct light approaches from one. Diffuse materials reflect light in all directions, specular in one. The game engine views both the incoming light and reflected light as a normal, and mapping the relationship between the light and the material type is an example of how the dot product can be practically applied.

Of course, we are not in 2D space, were in 3D. Our vector which emanates directly from the face or vertex is our Normal (everyone knows that term) and the two vectors parallel to our face are our tangent and bitangent vectors. A perfectly neutral normal map (no deformation) would read with our tangent and bitangent values at 0, and our z tangent at 1.

Lighting Vectors + Normal Vectors

A Direct Light pointing at a normal with a dot product of 0 will have full illumination, and a dot product of 1 will be unlit by that light. Adding a normal map into the equation essentially adds new vectors onto the surface as a map, which the light normals use to calculate how much that space on the object should receive light.

Fresnel

The amount of light reflected from an object is dependent on the viewing angle. If fresnel were on 100%, you would not see any reflection when looking strait at the object. As its normals moved away from you at a 90° angle, the reflection would increase.

This is an effect which you would see in water, or when building a cloth shader.

Reflectivity

Reflectivity of most objects is 4% - which maps to 0.5 (on a 0-1 float). A super reflective surface would be up to 8% (1), but all of these objects increase in their reflectivity as the Normals tilt away from the viewing angle. Most game engines come with reflectivity built in, by setting metallic to 1 and roughness to 0 you get it.

Under the hood, reflection is the 90° angle from the viewing vector to the surface, and refraction is the 180°

Refraction

As with the image above, the default value from the camera vector to the refraction is a strait line. Some objects have refraction on them, which bends the view angle slightly. To achieve refraction, you need to know your refractive index for your origin (viewing angle) and your target (model). Wikipedia has a great page on refractive indices of objects. Assuming you’re not viewing from inside water, the refractive index of air is 1, which would be your typical default. Your refractive index of say water, is 1.333. The graph above shows the refracted vertex bend appropriately.

To simulate a glass of water, you would apply a Fresnel effect to the reflection and refraction, where you would get a water refraction in the middle, and a reflection on the edge.

Rendering: Real-Time Pre-Existing Methods vs. Raytracing

Raytracing is a rendering method which projects rays from the camera into the scene, and interprets the color of pixel. Shadows, AO, and Reflections require further bounces, which can bounce again, and so the number of rays which need to be calculated can become quite large; this it is a very computationally expensive method.

Rasterization is the typical real-time rendering method, which works the inverse (maps object to screen). It requires a lot of tricks and work to get things looking good, where raytracing calculates it automatically.

Unreal updates combine the two, using Rasterization for things like diffuse, blurred reflections, and Raytracing for things like sharp reflection. Ambient Occlusion and Shadows split which method they use.

Ambient Occlusion

Measures how much light is blocked from reaching certain parts of the object. AO is calculated by bouncing a number of rays from the point on the model they hit. If none of those secondary rays hit anything, then the point is unoccluded, and inversely the more that hit an object, the more that point is occluded. This is quite expensive, so Unreal uses a method called Temporal Accumulation, which reduces the number of bounces by sending them out in turns at different frames and averaging the results for its real-time raytracing.

Previously AO was faked using Screen Space AO, which reconstructs the scene using the depth buffer. For each pixel on the screen it samples the depth of the surrounding pixels to determine if they are closer to the camera. This is fairly fast to compute but creates artifacts and isn’t perfectly accurate. For example, if the bottom of a chair is not in view of the camera, it will not be included in the depth buffer, and will not cast AO on the floor below it. Because Raytracing bounces around the scene, it can calculate against objects that are not in view of the camera, but whose effects would be seen on screen. (Like that edge case)

Reflections

There are many reflection methods, all of which have strengths and weaknesses. A nice feature of Unreal is that it if data is not available using one method, it will fall back to another.

Light Probes: A light probe is an object in the scene which captures a cubemap from its position. If you’re within that cubemap’s radius the reflections you see reflect that cubemap. The obvious limitation being that you are not seeing the reflection from your point of view. Light Probes have to be setup by an artist, and anytime the scene changes they have to be re-baked, and they can only reflect static objects.

Screen Space Reflections: Just like with AO, screen space calculates the depth buffer based on the camera viewpoint. Because you’re capturing your buffer from the camera POV, anything your camera can see can be reflected in the reflection, which means it captures more accurately to its position than Light Probes. A limitation is that it can only reflect what is on screen, so it does not capture elements outside the viewport (say behind the camera). If there are elements that cannot be captured via the screenspace method, the reflection falls back to the lightprobe. Because of the blindspots it creates strange effects at times due to the changing camera position.

Raytracing: This corrects all issues and creates perfect, dynamic reflections with no baking involved. It works by shooting a ray from the camera, and when it hits a reflective surface, shooting another ray at a 90 angle. Sharp reflections will shoot a single ray, but the blurrier the reflection the more rays it shoots, in a cone shape.

In order to save on performance, Unreal creates a threshold of blurriness called max roughness, at which point it will switch to a blurred cubemap method.

Two other methods of minimizing the performance hit of real time reflection raytracing is by limiting the max bounces (number of times a ray can bounce before it dies), and turning off shadows in your reflections.

Shadow:

Traditional method is called shadow mapping. This is where you render the scene from the POV of the light, and compare that to the POV of the camera. If there are parts of the scene that the camera can see but the light cannot, we assume they are in shadow.

Raytracing implements in the same way, but does away with a few visual glitches, and also allows for much better soft shadows.

Global Illumination:

So far we’ve talked about direct light - Global Illumination is indirect lighting. When a light is in the scene it doesn’t just light from one angle, the light bounces around the scene and lights everything. We used to handle that using baked lighting, in which the CPU would handle it and that information would be stored.

Raytrace Global Illumination, by contrast, bounces the light after it hits an object, creating those secondary reflections. It can inherit the color of the object it touches. There are two raytraycing methods: Brute Force (more accurate) and Final Gather (less expensive)

In pre-rendered environments, this method also opens us up to lighting a scene using an HRDI image projected to a spherical map as a lightsource.

Bringing a Marvelous Designer Cloth Simulation into Unreal

Annie Drake — Mon, 04 Mar 2024 16:28:04 GMT

title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen>

Method 1: Simulate in Marvelous Designer and import as Geometry Cache

Create your Animation in Maya

First you will need a preview mesh with a head on it. You can get them here, or you can export using quixel bridge and reexport. If you get your preview from that link, make sure it is the same body type as the metahuman you’re using. In the import settings for skeleton select “metahuman_base_skeleton”
Grab your body animation. Thats a longer tutorial, but make sure the animation starts on an A or T pose. I grabbed mine from rokoko studio, and applied an IK Rig and IK Regtargeter in Unreal.

Unreal - make sure your body deforms correctly

Enable the Metahuman plugin
Content > Metahumans > Common > Common > Open the metahuman preview mesh that corresponds with your body type
This folder contains all preview meshes with heads, download the one that matches your body. Import, selecting “metahuman_base” for your skeleton.
Open that blueprint. In the “asset details” tab, find “Skeletal Mesh > Post Process Animation Blueprint”, and load the character that matches your body type. Save.
Open your animation blueprint and set your preview mesh to be the preview mesh you just made. You’re looking for a green warning telling you that the post process animation blueprint is running. Apply to asset.
Export Asset (Top) > Preview Mesh. Make sure export preview mesh is true.
If any body type comes too close to the cloth in a way you don’t want simulated, you can delete it in Maya and reexport before importing into Marvelous Designer.

In Marvelous Designer

File > Import > FBX, and apply the following settings: Scale - CM Daz. Joint and Cache Animation: True. Adjust the bounding box so it fits around your characters A or T Pose.
I grabbed the pattern for the Tamarind Dress from https://www.moodfabrics.com/
and imported it as a pattern reference. (Right Click in 2D Window > Add Background Image). I found that when doing the simulation, deleting any body parts not driving any motion yielded better results. Go into the animation tab, set simulation quality animation to stable. You’ll need to change the time warp to 2 if you’re exporting at 60 FPS. File > Export > Alembic

In Unreal

Import into Unreal. Make sure you’re on Geometric Cache, and set orientation to 3DSMax.
Animate. Drag your outfit into the level sequencer. Track > Geometry Cache. You can crop the start and end position by right clicking the track in the LS and editing the properties. Move the clothing on top of your animated character. (Shift+RMB, Shift+LMB to copy paste values quickly)

Unreal Editor Updates

Annie Drake — Mon, 04 Mar 2024 16:26:25 GMT

Small post, but some ease of life things that are new to Unreal

Make Navigation feel sane (like all other CG programs we’re used to)

Editor > Editor Preferences

Search: Invert

Invert Middle Mouse Pan - TRUE

Search: Rotate

Enable Archball Rotate - TRUE
Enable Screen Rotate - TRUE

New Animation Hotkey Options:

Search: Viewport

Jump to end - END
Jump to start - HOME
Scrub Time (with mouse) - B
Step Backwards - X
Step Forward - C
Step to Next Key - V
Step to Previous Key - Z
Toggle Play - Spacebar

Unreal 5.3.2 and Metahumans

Annie Drake — Mon, 04 Mar 2024 16:25:42 GMT

This is the process notes to get a metahuman animating with facial and body animation, and rendering into the level sequence.

Create and import your metahuman:

Create metahuman character with MetaHuman Creator (unrealengine.com)
In Unreal > Window > Quixel Bridge
Sign in and hit the down arrow in the upper right hand corner of your avatar picture to download.

Applying Facial Animation

In Unreal Launcher go to Marketplace and get/install Metahuman Plugin
If you have a good computer, go to Edit > Project Settings > Plugins | IMG Media > Search caching, use global cache, and at least 2+ GB of system memory
Make sure the metahuman plugin is enabled
Make a new folder under content in the Content Drawer, if you right click you should now see Metahuman Animator as a type.
We will use the Capture Source to import footage recorded on Iphone, Metahuman Identity to calibrate a new metahuman face based on the actor. This is only done once per actor.
Metahuman Performance is used to process the actual take.
Create a capture source, and double click to edit blueprint. Here are 2 connection methods:
To connect to Iphone: Choose LiveLink Face Connection. Make sure computer and iphone are on the same network. In live link app, choose settings gear. Choose OSC Server, and copy the IP Address into the Device Address in Unreal. Save
To Source your captures from a local directory where you’ve saved the data: Choose Live Link Face Archives, and set the directory to the root of where your saves are. Save.
Tools > Capture Manager, if you can see your takes, you were successful.
Select the takes you want, add to the queue, and import now.
Calibration: In the content drawer, right click > Metahuman Animator > Metahuman Identity. Create component > From footage, and choose your calibration take
Scrub the timeline till you are at a front view, and click plus to add. Click the camera button to unlock, and repeat for left and right. Now click Metahuman Identity Solve. Select body, body type, then Mesh to Metahuman > Auto Rig Metahuman Identity (Skeletal Mesh + Full Metahuman)
Add teeth by clicking Poses, Add Pose > Add Teeth. Scrub the timeline to where your teeth are showing, and the upper and lower teeth are not overlapping, and promote the frame. Click Fit Teeth, and then Prepare for performance.
Process the Main Animation: Right Click in Content Drawer > Metahuman Animator > Metahuman Performance, Double click to enter blueprint. Top Right : Footage Capture Data > Select your main take. For Metahuman Identity, choose your calibration take. Scroll Down, Identity > Head Movement Mode > Choose Control Rig. Process to solve. Export Level Sequence (top), Create, using default values.
Switch Calibrated metahuman head to match main metahuman: Click the calibrated metahuman head. To the right, with all selected, navigate to Animation > Mesh, and switch the Skeletal Mesh Asset to the metahuman head you wish to import to.
Add your metahuman character you want to port to to the scene and add him or her to the sequencer. In sequencer, Track > Actor to Sequencer > Add “name”
In sequencer: Right click the layer containing your original metahuman head, and bake animation sequence to the MHA folder. Name it in a way that you can identify it as a character line later.
The new metahuman will now be loaded in the sequencer. (right) On the face subgroup, hit plus to track, Animation > and select your baked animation. If the facial animation is not playing you have to delete the control rig.
Adding Body Animations: Open Content Drawer, and with MHA folder selected, Add > Add Feature. Third Person Mode, add to project. This imports the Characters folder, which includes default animations that come with the third person character pack.
Retarget these animations to the metahuman skeleton: Content Drawer: Characters > Mannequins > Animations > Manny. Select all animations, Right Click > Retarget Animation Assets > Duplicate …. At the top of the IK Retargeter, choose RTG_Mannequin. Set Source to SKM_Manny, and go with basic metahuman body for target. (f_med_nrw_body), Retarget.
Back in sequencer, next to your metahuman’s body click track and add one of the motion capture animations. We now have an animated body and head, but they are moving independently. If body animation is not showing in timeline, just restart engine.
Connect head and body: In sequencer select Body. In right side, under Animation, set a keyframe on Animation mode (with dropdown set to Use Custom Mode), and turn on “Disable post process blueprint”. If it doesn’t work try saving and restarting.
Allow face to control neck movement: Click on face tab in sequencer. Animation > Anim Class > Click folder. Find faceAnim_BP and double click to open blueprint. (Left) Animation Graphs > AnimGraph > Doubleclick to frame. Find “Layered Blend per Bone” Click on it, and in inspector change Blend Mode to Blend Mask.
Define your anim mask: Top click the skeleton button, then in outline, Settings > Blend Profiles > Add Blend Mask. Rename it. In search bar, look for “head”. Drag the value to 1 and save. Go back to the “face Anim BP” tab, and in the layered blend per bone, change Blend Mode to “blend mask”, expand blend masks rollout, and select your blendmask. Compile and close.

Retarget Mocap

Import your motion capture
Right Click: Animation > Retargeting > IK Rig. Drag in your skeletal Mesh for your mocap, and then create a new IK Rig node for your metahuman body.
Create Chains: Right click your root node, and select Set Retarget Root. Select all spine bones, right click > New Retarget Chain. Do this for Spine, Neck, Head, Right Arm, Left Arm, Right Leg, and Left Leg. Do this again for your other IK group (if you did your mocap do your metahuman definition), making sure that the names and order match your last profile.
Content Browser: Right Click > Animation > Retargeting > IK Retargeter. Drag your IK Definitions into your source (Mocap) and target (Metahuman) fields. Move the bones on the metahuman so that it matches the TPose of the mocap as closely as possible, and then hit Create > Export Pose Asset.
Switch from Edit Retarget to Run Retargeter, and in the (bottom right) asset browser, double click your animation. It should play on both skeletons.
At the top of the asset browser, select Export Selected Animations.

Modify Body Animation

Create a new Level Sequence
Drag in your camera, character, and any props you want to animate
Under the body tab, Delete the Metahuman Control Rig for now
Next to body hit Track > Animation, and find the new retargeted motion capture you just created. You can drag in multiple animations, and blend them together as you would in Maya’s Time Editor.
When you’re happy with the blend, right click body > Bake to Control Rig : Choose your metahuman rig
Click + to create an additive layer
Turn on auto Keyframe (top Diamond with key inside)
The Animation Tab (window) becomes available if you are in the Animation Mode (Like Maya, top left). Under the Animation tab: Unreal added “constraints”, which can be animated on and off, and animated on top of. They also have pivot, which you can animate.
In level sequence, under “eyeball”, you can click “Auto Expand Nodes on Selection”, if you’re animating in the LS this can get annoying. (But auto keyframe won’t work unless you set your first keyframe). The Grid with the squiggle gives you your curve editor.

Rendering

Add Post Process Volume

You can add things here like Bloom or Exposure if you want to add post effects to your render
You can bump up the raytracing values to 32 to get a better render (in theory, but I didn’t see that it made a huge difference) by searching “sample”

Level Sequence

Hit the Movie Icon to pull up render settings
Make note of where your output is and change if need be
All sources suggest adding anti-aliasing. I’ve heard 4 and 4 are good settings, I’ve also heard 1 and 32. Turn on “Override Anti Aliasing”
Render Local

Tell Me

Annie Drake — Mon, 04 Mar 2024 16:23:24 GMT

When I was looking for potential startup ideas, this is one I invested some time into - it was essentially the idea of embedding a camera, screen and internet connected device into a children’s toy, so that the toy could “look” at objects in the world, recognize what they were, and slowly walk the child through language learning via that interface.

The idea was based on the premise that children’s minds are more plastic in regards to language, but a lot of places which do not border another country don’t have the access to foreign languages that many in Europe enjoy.

In the end, I did not pursue it, but in retrospect I think that was a mistake - this could have been seriously cool! Publishing my research notes.

Design notes for a playful method of learning language, using image recognition on a camera - tied into children’s toys.

Google Translate API

- Content of page under Creative Commons Attribution 3.0 Liense (Share and Adapt allowed, even for commercial purposes, as long as credit is given)
- Code under Apache 2.0 License

Bing API

Only offers for windows 8, web and windows phone. Hm. Not sure about that, it sounded like Eric really favored the Linex / Mac operating system for computer vision. Ask the guys about that.

Image Recognition APIS

List of 14 Image Recognition APIS

Gizmodo Article on Google’s Image Recognition API

Google’s prediction API

Learn from multiple people.

“When you are exposed to a lot of people you get a much better sense of what the sound of a word is supposed to be,” says Davidson. “You avoid exposing yourself to what could be idiosyncrasies in one individual’s speech patterns.”

Learn as much vocabulary as you can.

“Learning loads of vocabulary is really much more useful than learning grammar,” says Simcott. “Learning grammar is good too, but with a lot of vocabulary you can successfully describe anything you need to.”

Translate the Web

Duolingo places the skill level of the user and has them translate from another language. Other users can correct if they’re wrong. The cool thing about this is that it incentives deep learning by forcing the user to solve problems

Aniki is a flash card memorization program, which reminds me of Nolan’s company

What are the most common words and phrases? Can we focus on those first somehow?

Pimsleur method is an audio based program which focuses on the basic building blocks of the language

the cool thing about this is that you’re setting a story in english, and then saying the dialogue in spanish. Good use of imagination and memory castles

Has you repeat parts of the word backwards and imitate accents. Repeats the parts of the words individually, then strings them together

Make sounds at each other? Gabe constantly skats because a video game character does it

change the word order of what youre having them repeat in more and more complex patterns. Excuse me, sinorita. Excuse me, pardon. Excuse me.

How do children acquire language?

Media (consumption vs playing together)

- Card games using learned words. Competing game hook is seeing who has collected more words, and then having those words show up enough times that it is practiced

- Karaoke songs. Automatically increase required pronunciation based on learned skill at pronunciation. Offer new words at the beginning of song that user might not know

- Hand puppet plays, dictation and mood setting while letting the child handle dialogue however they feel

Crossing Patterns

But suppose now one child in the group replies ‘moo’ to your question. Before you start worrying about this child’s linguistic (or cognitive) abilities, try to think about your question and the child’s answer on the child’s own terms, not yours. You are expecting a word that sounds like 'banana’, but how does the child know that? And how do you know what prompted the child to give you this answer? In particular, why should the sound of the word be more relevant to the child than, say, the shape of the object you’re holding? It may well be that this child has recently been fascinated by the night sky, and all shiny things in it whose names he’s just learned. And a banana does look like a waning or waxing moon. This child is also generalising, though in a different way from his friends. He is besides showing you that he knows how to relate what he learned before to whatever activity is required of him now, which is a very good thing to have mastered indeed. (On a side note, it is this kind of generalization that makes young children, sometimes very embarrassingly, call all adult males 'daddy’.)

Books

David Crystal’s book Listen to your Child: A Parent’s Guide to Children’s Language (Penguin, 1989) offers a very accessible and very entertaining account of what children do with their own language learning.
Eve Clark’s book First Language Acquisition (Cambridge University Press, 2003) is a comprehensive – and more technical – account of child language development.

Thoughts

setup expectation for play, so that people don’t find “looking ridiculous” to be a barrier.

A Thesaurus tie in might be helpful

Random APIS

Natural language processing

Natural Language Processing 2

smart responses to natural language questions

Sentence Recognition

text to speech Really good!

camfind- image recognition

question answering

Stained Glass Window in Unreal

Annie Drake — Mon, 04 Mar 2024 13:55:42 GMT

One day, our manager Ravjiv walked in like Santa Clause with a couple full body transparent touch monitors. We never got a project to do anything with them, so with some downtime I decided to make an interactive stained glass window, which a depth enabled interface.

Sadly I never completed this project and don’t have a video of it playing on the monitor, the background was just an Unreal ocean - in the intended final product you would just see through it to the world.

title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen>

Rachel designed a variety of beautiful window patterns, cut them all apart in 3d Max, and did the fine detail sculpting on the foam. Seth integrated the Perceptual SDK’s finger tracking into Unreal, and connected it to a fadecandy to drive the lights.

I built the physical skeleton, and the Unreal Components. Here’s a breakdown:

Skeleton

The first thing I did was weld a stand, which could hold the television. I did it with a MIG welder, and steel.

I got eyeballed it (like making a sewing pattern) and it came off slightly angled, though the TV fit in snugly when I took some of its frame off.

My plan was to build a polystyrene frame (a sculpt-able foam insulation you can get at Home Depot, Home Depot Pro if you want it in 2″ x 4′ x 8′ sheets like I did). But in order for it to fit, it had to compensate for that strange angle my weld made. In the future when welding strait angles, I plan on making a frame to hold my metal in at the correct angle!!!

To get it right, I ended up hanging a needle off thread from different points, and then measuring their XY distance from center bottom. The rest of the measurements (length and width of metal cuts) were really straightforward. I was worried it won’t work, but to my surprise, my foam mold came out really accurately.

With that, I made a 3d file for what I wanted my exterior wall to look like, and made it hollow around where I thought the internal skeleton would be.

I broke it into 2″ thick 3d files and then fed that into the ShopBot Alpha at TechShop. I exported my slices to .STL, and then fed them into Cut3d, which was a strange program to get used to, but worked fine once I figured it out.

Then it was just a waiting game, which I used to knit. It took about 2 hours per print, of which I had 7. Slice 6 had to be cut on both the front and back which made it 16 hours. I knocked it all out in one night, because I only had one shot at borrowing a truck.

I realized last minute that I needed arrows to move from one scene to the other, so I just cut them out by hand with an exacto blade. You can get nice sculpting results with a Stanley Surfoam Shaver and sandpaper.

lights

Unreal

I downloaded this beautiful ocean scene and used that as my background, deleting all the extras.

I won’t go over all the details of putting it together, you can download it and look it over in Github. Note- its big and unedited for human consumption!

Here are some interesting things I discovered along the way:

You can’t make a public array of mesh components. You can add them into the array at the construction script using “make array”, and then promote that to a variable. I used that to create a changeable script on the buttons.
You can promote a series of calls to a function, when things are starting to repeat for cleaner “code”
If you need to fake a mouseover without using the actual mouse (in my case I was planning on replacing mouseover with an event generated by the depth camera) you can use “line trace component”. It acts like a raytrace. Give it the starting point of “World Location”. For “Trace End”, multiply “World Direction” with some large number (I used 10,000), and add it’s output to World Location, and feed that into “Trace End”
Creating a state machine to handle individual mesh components using “Add Timeline”, even when using unique Timelines, gets REALLY difficult. I gave up and just made each of the GUI items their own separate object. (Though Switch on Int was really helpful, if you have an active index)
It seems better to Create Dynamic Material Instances in Blueprint, rather than actually making them as part of your local assets. That way unreal gets rid of them when you’re done- and takes care of the memory management for you.

Photogrammetry Porting Pipeline for VR

Annie Drake — Mon, 04 Mar 2024 13:46:50 GMT

This is an old pipeline I wrote for a job many years ago - when photogrammetry was around but the libraries were not fleshed out, and the advancements made by Metahuman and Reallusion were not available. In addition to that, I was limited by a razor thin development budget. Here’s what I came up with:

Generate a Photogrammetry Mesh

Start with a Mixamo character - this spits out a rigged model already skinned, which plugs directly into Lip Sync Pro.

Using a photogrammetry scan, morph the geometry of the starter character, and port over the textures. To make this faster, I wrote a pymel script for speeding up the process.

title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen>

Create Facial Capture

Autodesk Recap is what I was using for the model photogrammetry scan, and it worked great for the initial portrait. It did not work well for capturing blendshapes, however, due to how many photos it needs. It’s just impossible for a model to stay still that long.

For this I used a camera from a defunkt startup called Fuel3D. They were originally aiming to serve optometrists for virtual eyeglass fitting and do a very good job of a single photo capture by simulating this research method. The camera itself combines 2 RGB cameras and three flashes, setting them all off in a quick succession - gathering two points of view lit at three different angles. The software then processes and generates a fairly high-resolution mesh which doesn’t take too long to capture.

Once blendshapes were created based on the Fuel3D capture, I rigged my model using IClone and exported it.

Create Deformation Blendshapes

These characters were to be used in VR - where realistic hands are very important. Since my process was cheap photogrammetry and speed oriented (I did not have a license to Zbrush, or the computer/tablet to handle it), I created scans of muscles deforming at the angles I needed.

I then went into maya and rotated the model so it would be in the position which would trigger that deformation, lined up a reference scan, and then used this series of tools to create a blendshape for that rotational angle

CaptureMirroredState-2.py and MirrorVerts.py are a two part series of pymel scripts which work together. CaptureMirroredState_2 scrolls through a list of selected vertices, finds its mirror vertex, and saves both to a file for later access. This is important, because if the vertex ID is altered, it can break the blendshape system. MirrorVerts copies the vertex positions in said saved group to one side or the other.

SnapToNearbyVerts.py scrolls through a list of selected vertices and snaps to the nearest vertex, regardless of ID.

CopyVerts.py takes two models with the same set of vertex ID configurations and copies the position of each vertex from one to the other.

MirrorJoints.py copies the rotation of joints from one side to the other.

I would then take note of the joint rotation values, skin the new deformed mesh to the skeleton (enabling multiple bind poses) and then reset the rotation of the skeleton. This became my new blendshape morph target.

Fingernails, caruncula, outer eye, and hair needed to be manually created using good ol’ artistic elbow grease. I did leverage the hair in mixamo as much as possible to get around creating hair cards by hand.

Interactive IK

This character pipeline was meant to generate characters for both first and third person use in VR, which meant they had to work as NPCs and embodied VR characters in 6DOF.

In order to drive both control methods, I set them up using Final IK.

For the first-person setup I set it to VRIK with the following values:

Under the spine, set the head target to the VR headset position, and set position and rotation weight to 1.
Load the left- and right-hand position to the handset positions.
Under Locomotion, set Foot Distance to 0.11, Step Threshold to 0.21, Root Speed to 32, and Step Speed to 3.75.

For the third person (NPC) controls I used a biped IK, and had the look IK controller follow the speaker (in multi character scenarios), or the camera (in 1:1 scenarios)

Animating the Hands

Download HandController.cs, and HandStates.fbx HandStates.controller, LeftHand.mask, and RightHand.mask.

Add the HandStates.controller as the animator, and HandController.cs. The script will listen for input from the VR controllers (like trigger press or thumb up) and send signals to the model to animate the hands accordingly. The Animator runs through several Blend Trees to approximate which hand position will most closely match the user’s motion.

Drive Muscles Based on Rotation

Forearms were a special case, and I drove them using a script (ForearmTwist.cs) which simulated the way the radius and ulna rotate around each other. This script gauges the rotation of the hand and drives the rotation of the intermediate forearm bones a percentage of the hand rotation value, so as to create a more gradient twist. It also blends between a series of corrective blendshapes to morph the forearms to a more realistic shape at each 90° of rotation.

The other muscle deformations (like neck) could be handled by this more generic script (GenericRotation.cs). It is less specific, and simply drives a blendshape based on the value of a bone’s rotation.

Capture In-Scene Eye Reflections

I was using Ansel to capture a 360° photo of the Unity scene, from the position I wanted the characters to congregate. I set its values to only capture in black and white, with the levels set that the white threshold was fairly high. I then converted the black parts to transparent, and this became loaded into a cutout shader, which was applied to the outer eye. The outer eye object was linked in its translation, but not rotation to the eye bones, so that when the character moved, there was an accurate simulation of the reflection of the world, and the secularity moved to match if the head rotated, but stayed still if only the eyes rotated.

Next Steps

This was as far as I got, but had I continued my next steps would have been to

Generate body animations using a VR headset and hand controllers, allowing a person to quickly act out what they wanted the characters to do
Capture verbal performance of the person acting (from the oculus microphone) and run that through OVR to automatically generate facial animation

Events

Annie Drake — Mon, 04 Mar 2024 13:39:19 GMT

An event is a message sent to the whole scene. The trumpeter plays taps, everyone goes to bed. Unity has its own custom events - or you can write your own.

Unity Events

Super simple. Call an event as a variable, and then invoke it wherever you want it to be called.

public UnityEvent OnStart;
void Start(){
OnStart.Invoke();
}

Custom Events

First, I’m going to make a GameEvent script, which will sit in our scene on an empty gameobject. (Or anywhere we want really)

using System;
public class GameEvents : Monobehavior{
public static GameEvents current;
private void Awake(){
current = this;
}
public event Action onMessageBlast;

public void Message()
{
if(onDoorwayTriggerEnter != null){
onDoorwayTriggerEnter;
}
}
}

Next I will create a script to listen for this message and then respond

public class Listener : Monobehavior
{
void Start(){
GameEvents.current.onMessageBlast += onTriggeredEvent;
}
private void onTriggeredEvent(){
print(”I heard your message and my name is “+this.name);
}
void Update(){
if(Input.GetKeyDown(KeyCode.Space)){
GameEvents.current.onTriggeredEvent();
}
}
}

you want to make sure there’s something calling it (the update loop) and, and utilize += to subscribe to the message event action. To unsubscribe (do this to avoid clutter if something is deleted) use -=

private void OnDestroy(){
GameEvents.current.onMessageBlast -= onTriggeredEvent;
}

Unity Editor Scripts

Annie Drake — Mon, 04 Mar 2024 13:37:25 GMT

Editor scripts consist of two different scripts which work together. One which handles our functionality, let’s call ours MyScript, and another which handles the interface- MyScript_Editor. In our folder where our functionality script is held, add a folder called “Editor”, and add our editor script in that.

To connect them, make sure our editor script is using UnityEditor. Above our class declaration, make it inheret from Editor, instead of monodevelop, and inside declare [CustomEditor(typeof(MyScript))]

In our editor script, create a function called
public override void OnInspectorGUI(){} - this gets called each time the editor is drawn.

MyScript localMyScript = (MyScript)target;

will create an instance which you can use to access the variables in your main script.

Optimizing Unity for Mobile

Annie Drake — Mon, 04 Mar 2024 13:36:21 GMT

High Level

Keep Vertex count below 100,000
Reduce Shaders - utilize texture atlases
Reduce thing that need multi-pass renders (reflections, shadows, per pixel lights, transparent objects)
Set any non-moving object to static and bake lights wherever possible.
Combine all meshes into a single mesh wherever possible (combining meshes which don’t share the same material is useless)
Use Object Pooling rather than instantiate and destroy, and avoid Find() in your code.
Avoid creating code that is not re-usable, as it becomes something the garbage collector has to handle, which is CPU intensive. For mobile, a common strategy for managing garbage collector is to ask it to run more frequently, which means its handling less, but you have to run the profiler to make sure this is even helping. Another tactic is to front load your collection at natural gameplay pauses. Incremental garbage collection spreads the work over multiple frames, but in the case that garbage is being constantly created, it can create loops where the GC never turns off.
Automate that the artists are adhering to best practices by using the AssetPostprocessor() (enforcing texture limitations, setting your read/write, optimizing game objects ect)

Debugging

Use the profiler. Run the game for a time to gather data, and then start turning on and off various things to identify where the bottlenecks are.
The GPU is limited by fillrate - number of pixels that can be written to memory per second. Lower display resolution and run game again.
The CPU is limited by number of batches to be rendered. You can check your batches using the Rendering Statistics window.

Batching

Static gives the best performance - combine all materials into 1 texture. Bake lighting, and set all non-moving objects to static.
Follow up with Dynamic. Minimize number of objects and vert count. Don’t use scale, everything should be at default of 1,1,1. Multipass shaders (like forward and legacy vertex) break batching.

Audio

Short Clips (SFX) - Native
Longer (looping) clips - compress in memory
Music - Stream from disc
Files which constantly cause CPU spikes - decompress on load.

Android

Run your app on the device, while its connected to the computer, where you can run the profiler from.
Test on multiple devices.
Avoid putting things in the update loop - put temporary things in coroutines.
Reduce UI canvases, and for those you keep, if you do not need to interact remove the graphics raycaster, uncheck Pixel Perfect, and uncheck rich text.
Player Settings > Other settings, enable multithreaded rendering. This sends all rendering to another thread.
In Quality Settings:
- Limit your max high performing calls
- lower pixel light count to 1 (or 0 if you don’t have lights)
- Disable antialiasing
- Disable soft particles
- Use hard shadows
- Set shadow projection to close fit (to avoid hard edges)
- Set shadow cascades to no cascades
- lower your shadow distance until is the minimum you can get away with

Transferring Texture Maps in Maya

Annie Drake — Mon, 04 Mar 2024 13:33:46 GMT

Sometimes you’re in a position where you want to transfer texture maps from one mesh to another. It’s fairly simple to do, but requires the materials in Maya to be setup correctly in order to avoid any shading issues.

Rendering Window | Lighting/Shading > Transfer

Load your target mesh and source mesh, changing the target mesh’s search envelope % to 0.5.

Add whichever maps you want to render, I usually just choose the diffuse, if I’m transferring texture, although sometimes I’ll also make a normal map.

Choose “use maya common settings” and then in the Maya common output tab, World Space, Filter Size 3, and for the best detail map set Map width and height to 4096 and then manipulate it in Photoshop. I always set my sampling quality to high, but I’ve looked at it on low and high and can’t see too much difference.

Now for the maps. In your Hypershade, create a Lambert. Load your texture into the incandescence and diffuse slots and set your Color to black. Change Translucence, Translucence Depth, and Translucence Focus to 0. Open up Matte opacity and change it to Solid Matte. Apply this new material to your source object.

RealSense SDK and Runtime Libraries

Annie Drake — Mon, 04 Mar 2024 13:32:20 GMT

I’m refactoring some code, where all the components were individually working. Everything was working great, until I tried to add the Perceptual Init calls back in. Then I started to get errors saying things were already defined in MSVCRT.lib.

Seth says that when the compiler is complaining about MS***.lib what’s going on is that you have multiple libraries which were compiled against different runtime libraries.

If you go into C/C++ tab of the property pages, under Runtime Library you see the option for multi-threaded and multi-threaded DLL. There’s really only two options- changing those around should fix it.

Sometimes you get lucky and your libraries are labled– in this case with MD, which refers to Multi-threaded DLL (/MD)

Pair Arrays

Annie Drake — Mon, 04 Mar 2024 13:30:27 GMT

I needed to have access to the same [ i ] value across 2 arrays, and was having trouble understanding char* // std::string in C++, so seth shared with me a few different ways to streamline it.

#include
#include
#include
// similar to…HashTable in C# or dictionary in python
map AnimFileMap{ {“file1”, 5} };
//accessing map:
auto timeInMillis = AnimFileMap[“file1”];
//or…
vector> AnimFilePair{ { “file1”, 5 } };
//accessing pair:
auto fileName = AnimFilePair[0].first;
auto timeInMillies = AnimFilePair[0].second;
//fun with pairs and typedef (makes things a bit more readable)
typedef pair fileinfo_t;
//so now
//vector myfiles;
//is the same as
//vector> myfiles;
//
//but can be accessed the same way, i.e.
// .first and .second

Building for x64 and win32

Annie Drake — Mon, 04 Mar 2024 13:29:23 GMT

I ran into a problem where I was trying to combine from two different sample projects, but one was setup to run on x64 and the other on win32. Sterling explained some rules of thumb when setting up your project properties in Visual Studio.

In the pulldown tag, you can select for Win32, x64, or all configurations. Here are the general rulesets for the most hit areas:

C/C++ -> Additional Include Directories

These are the same for x64 or win32, you want to put your include directory here.

For all these, you want “Inherit from parent or project defaults” to be checked.

Linker -> General -> Additional Library Directories

Here’s where you list the directories where the .lib belongs. There is often projects where the lib is the same name, but stored in 2 different locations, one named win32 and the other x64. In this case, you can put $(PlatformTarget) instead of which directory you want, and visual studio will figure out which one you mean.

Linker -> Input -> Additional Dependencies

Here’s where you list against the actual lib files that you’re linking against. Often, if there’s a two different .libs, one with a _d after it, the _d version is for debug mode and the other is for release.

Editing with *.vcxproj

You can also just open up the *.vcxproj file in Notepad++, and that’s basically an xml file listing all the specifics on the includes. Sterling says that if you take out the conditions, it will just run on all platforms, but that that’s not an option if you’re working through the Visual Studio project interface.

Notations

If you right click your project and say open in explorer, it will show you what $(ProjectDir) links to. In some cases, you might need to go up a directory with ..\

The RealSense SDK builds into Visual Studio that if you want to include its filepath, you can just put $(RSSDK_DIR)

GitIgnore

Annie Drake — Mon, 04 Mar 2024 13:26:40 GMT

Super simple, just writing it down so I don’t have to ask Sterling a third time.

When uploading to git, make sure to edit the .gitignore file with notepad++, and add the files you want to leave out. Its a good idea to exclude Build and Intermediate, because those each get remade each build.

If a .gitignore isn’t readily available (because you’re uploading for the first time) then when you make your first commit right click something disposable (a .pbt or anything with /debug or /release in the file name) and say ignore, add to .pbt. Once you do that it’ll make a gitignore file, and then you can open it and add your logic.

Visual Studio to Arduino

Annie Drake — Mon, 04 Mar 2024 13:25:34 GMT

Here I have a signal going from Visual Studio to an Arduino using an Ateml programmer.

title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen>

I just wanted a basic setup ready to go so I could jump in and use it anytime I wanted. Here’s the GITHUB repository.

Here is the physical setup we’re going to be looking for, and a few things to be aware of.

Startup Settings

The computer needs to be reset with Disable driver signature enforcement. Reset your computer with shift held down. Go to Startup Settings, and type ‘7′
Connect the Programmer and the Arduino with cables to your computer.
The programmer needs to be connected so it can upload the program, and the Arduino needs to be connected so it can receive data.
The Anode (long pin) of the LED needs to be in pin 12, not 13.
Pin 13 shares functionality with some of the internal mechanisms of the board.
Once you use a programmer with your board, it is now flashed and needs a programmer in order to upload.

I didn’t realize that before, and when I tried to go back to normal serial communication it caused a lot of frustration.

You need a 6 pin Ateml programmer, not a 12 pin