keenanwoodall

public class CCDIKConstraint : RigConstraint<CCDIKConstraint.Job, CCDIKConstraint.Data, CCDIKConstraint.Binder>
{
    public struct Job : IWeightedAnimationJob
    {
        public FloatProperty jobWeight { get; set; }
        public ReadOnlyTransformHandle target;
        public NativeArray<ReadWriteTransformHandle> chain;
        public NativeArray<Vector3> bindPositions;
        public NativeArray<Quaternion> bindRotations;
        public NativeArray<float> weights;

keenanwoodall

public class DistanceConstraint : RigConstraint<DistanceConstraint.Job, DistanceConstraint.Data, DistanceConstraint.Binder>
{
    public struct Job : IWeightedAnimationJob
    {
        public FloatProperty jobWeight { get; set; }
        public ReadOnlyTransformHandle source;
        public ReadWriteTransformHandle target;
        public Vector3 initialTargetLocalPos;
        public float distance;
        public void ProcessRootMotion(AnimationStream stream){}

keenanwoodall

package rlmui

import "core:fmt"
import "core:unicode/utf8"
import mu "vendor:microui"
import rl "vendor:raylib"

@(private) Color32 :: [4]u8

State :: struct {

keenanwoodall

// Source: http://allenchou.net/2015/04/game-math-precise-control-over-numeric-springing/
public void Spring(ref float x, ref float v, float xt, float zeta, float omega, float h)
{
	float f = 1.0f + 2.0f * h * zeta * omega;
	float oo = omega * omega;
	float hoo = h * oo;
	float hhoo = h * hoo;
	float detInv = 1.0f / (f + hhoo);
	float detX = f * x + h * v + hhoo * xt;
	float detV = v + hoo * (xt - x);

keenanwoodall

using UnityEngine;
using Unity.Jobs;
using Unity.Burst;
using Unity.Collections;
using Unity.Mathematics;
using static Unity.Mathematics.math;
using Beans.Unity.Mathematics;

namespace Deform
{

keenanwoodall

// read this article for more info: https://blogs.unity3d.com/2014/05/16/custom-operator-should-we-keep-it/
using UnityEngine;

public class UnityObjectOperatorOverloadTest : MonoBehaviour
{
    	[RuntimeInitializeOnLoadMethod]
	public static void Test()
	{
		var gameObject = new GameObject("UnityEngine.Object Operator Overload Test");

keenanwoodall

I think using scopes greatly improves readability. Here's an example of converting a larger section of code. The indenting makes it immediately clear when a scopes begins and ends. Both snippets of code draw the exact same controls.

Before:

EditorGUILayout.BeginVertical("box");
disable = EditorGUILayout.Toggle("Disable Sliders", disable);
indent = EditorGUILayout.IntSlider("Indent Sliders", indent, 1, 4);

keenanwoodall

using UnityEngine;
using UnityEditor;

public static class PrefabUtilityMenuItems
{
	[MenuItem("Tools/Prefab Utility/Create Prefabs From Selection")]
	public static void CreateFromSelection()
	{
		var selections = Selection.gameObjects;
		if (selections == null || selections.Length == 0)

keenanwoodall

using UnityEngine;
using UnityEditor;
using Unity.Jobs;
using Deform;

public class AutomatedDeformationTestWindow : EditorWindow
{
	private Mesh mesh;

	[MenuItem("Tools/Automated Deformation Window")]

keenanwoodall

using System;
using System.Reflection;
using UnityEngine;
using UnityEditor;

public static class CustomFloatField
{
	private static readonly int Hint = "EditorTextField".GetHashCode ();
	private static readonly Type EditorGUIType = typeof (EditorGUI);
	private static readonly Type RecycledTextEditorType = Assembly.GetAssembly (EditorGUIType).GetType ("UnityEditor.EditorGUI+RecycledTextEditor");