Computationally quickly project 3d object onto 2d plane and get surface area of that (for aerodynamic drag)?

I never figured out a way to speed up the calculations, but the simulation works great as long as the voxel count is low.

The simulation calculates drag based on the velocity of each voxel. It checks whether it's on the leading edge of the object, and if so applies its drag force.

The code is probably a bit difficult to follow but should at least get you started if you want to try it out. Let me know if you have any questions or need clarifications.

This code is a slightly cleaned up version from my Update#3 above.

In action: At start of simulation (object moving in straight line towards bottom right of screen)

you can see the force arrows added for visualization and the circles representing the voxels. The force is correctly proportional to the surface area the voxels roughly represent. and only leading edges of the shapes are contributing drag

As the simulation continues, the shape correctly rotates into the most aerodynamic position because of the drag, and the rear sections stop contributing drag.

Drag Enabled Shape Class

this is dragged on main objet (rigidbody) to enable drag. You can either have it create voxels in a spread around a sphere shape. Or load in your own custom Voxels which are game objects with the Voxel Script attached, and are children of this object.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;

[RequireComponent (typeof(Rigidbody))]
public class DragEnabledShape : MonoBehaviour {

    const float EPSILON = 0.0001f;

    public Voxel voxelPrefab;
    public float C = 1f;
    public float d = 0.5f;
    public int resolutionFactor = 2;
    public float maxDistanceFromCenter = 10f;
    public bool displayDragVisualization = false;
    public float forceVisualizationMultiplier = 1f;
    public bool displayVoxels = false;
    public bool loadCustomVoxels = false;

    List<Voxel> voxels;
    Rigidbody rb;


    // Use this for initialization
    void Awake () {
        voxels = new List<Voxel> ();
        rb = GetComponent<Rigidbody> ();
    }

    void OnEnable () {

        if (loadCustomVoxels) {
            var customVoxels = GetComponentsInChildren<Voxel> ();
            voxels.AddRange (customVoxels);
            if (displayDragVisualization) {
                foreach (Voxel voxel in customVoxels) {
                    voxel.DisplayDrag (forceVisualizationMultiplier);
                }
            }
            if (displayVoxels) {
                foreach (Voxel voxel in customVoxels) {
                    voxel.Display ();
                }
            }
        }
        else {
            foreach (Transform child in GetComponentsInChildren<Transform> ()) {
                if (child.GetComponent<Collider> ()) {
                    //print ("creating voxels of " + child.gameObject.name);
                    CreateSurfaceVoxels (child);
                }
            }
        }
    }

    void CreateSurfaceVoxels (Transform body) {
        List<Vector3> directionList = new List<Vector3> ();
        for (float i = -1; i <= 1 + EPSILON; i += 2f / resolutionFactor) {
            for (float j = -1; j <= 1 + EPSILON; j += 2f / resolutionFactor) {
                for (float k = -1; k <= 1 + EPSILON; k += 2f / resolutionFactor) {
                    Vector3 v = new Vector3 (i, j, k);
                    directionList.Add (v);
                }
            }
        }
        //float runningTotalVoxelArea = 0;
        foreach (Vector3 direction in directionList) {
            Ray upRay = new Ray (body.position, direction).Reverse (maxDistanceFromCenter);
            RaycastHit[] hits = Physics.RaycastAll (upRay, maxDistanceFromCenter);
            if (hits.Length > 0) {
                //print ("Aiming for " + body.gameObject.name + "and hit count: " + hits.Length); 
                foreach (RaycastHit hit in hits) {

                    if (hit.collider == body.GetComponent<Collider> ()) {
                        //if (GetComponentsInParent<Transform> ().Contains (hit.transform)) {
                        //print ("hit " + body.gameObject.name);  
                        GameObject empty = new GameObject ();
                        empty.name = "Voxels";
                        empty.transform.parent = body;
                        empty.transform.localPosition = Vector3.zero;
                        GameObject newVoxelObject = Instantiate (voxelPrefab.gameObject, empty.transform);
                        Voxel newVoxel = newVoxelObject.GetComponent<Voxel> ();
                        voxels.Add (newVoxel);
                        newVoxel.transform.position = hit.point;
                        newVoxel.transform.rotation = Quaternion.LookRotation (hit.normal);
                        newVoxel.DetermineTotalSurfaceArea (hit.distance - maxDistanceFromCenter, resolutionFactor);
                        newVoxel.attachedToCollider = body.GetComponent<Collider> ();
                        if (displayDragVisualization) {
                            newVoxel.DisplayDrag (forceVisualizationMultiplier);
                        }
                        if (displayVoxels) {
                            newVoxel.Display ();
                        }
                        //runningTotalVoxelArea += vox.TotalSurfaceArea;
                        //newVoxel.GetComponent<FixedJoint> ().connectedBody = shape.GetComponent<Rigidbody> ();
                    }
                    else {
                        //print ("missed " + body.gameObject.name + "but hit " + hit.transform.gameObject.name); 
                    }
                }


            }

        }

    }

    void FixedUpdate () {
        foreach (Voxel voxel in voxels) {
            rb.AddForceAtPosition (voxel.GetDrag (), voxel.transform.position);
        }
    }



}

Voxel class

This script is attached to small gameObjects placed around a shape. They represent the locations at which drag is computed. SO for complex shapes these should be at any extremities, and should be fairly spread out over the object. The voxel object's rigid body's mass should approximate the portion of the object this voxel represents.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Voxel : MonoBehaviour {

    Vector3 velocity;


    public Collider attachedToCollider;

    Vector3 drag;

    public Vector3 Drag {
        get {
            return drag;
        }
    }

    float dragMagnitude;

    public float DragMagnitude {
        get {
            return dragMagnitude;
        }
    }

    bool leadingEdge;

    public bool LeadingEdge {
        get {
            return leadingEdge;
        }
    }

    bool firstUpdate = true;
    public float localSurfaceArea;

    Vector3 prevPos;
    public VoxelForceVisualizer forceVisualizer;
    public VoxelVisualizer voxelVisualizer;

    const float AREA_COEFFICIENT = 1.1f;
    const float EPSILON = 0.001f;
    const float FAR_DISTANCE = 5f;
    const float MAX_FORCE = 100f;



    public void DetermineTotalSurfaceArea (float distanceFromCenter, float resolution) {
        float theta = (Mathf.PI / 4) / resolution;
        float localR = distanceFromCenter * Mathf.Tan (theta) * AREA_COEFFICIENT;// * (resolution / 0.01f);
        localSurfaceArea = Mathf.PI * localR * localR;
    }


    bool IsVisibleFromPlane () {
        if (attachedToCollider == null) {
            throw new MissingReferenceException ("attached to collider not set");
        }
        bool visibleFromPlane = false;

        //checks if this is leading edge of this part of object.
        Ray justOutsideSurface = new Ray (this.transform.position, velocity).Reverse (EPSILON);
        RaycastHit hit;
        if (Physics.Raycast (justOutsideSurface, out hit, EPSILON * 2f)) {
            if (hit.collider == attachedToCollider) {

                //checks if other parts of this object are in front, blocking airflow.
                //Ray wayOutsideSurface = new Ray (this.transform.position, velocity).Reverse (FAR_DISTANCE);
                //RaycastHit firstHit;
                //if (Physics.Raycast (wayOutsideSurface, out firstHit, FAR_DISTANCE * 2f)) {
                //if (firstHit.collider == attachedToCollider) {
                visibleFromPlane = true;
                //}
                //}

            }
        }

        //}
        leadingEdge = visibleFromPlane;
        return visibleFromPlane;
    }

    void FixedUpdate () {
        if (firstUpdate) {
            prevPos = transform.position;
            firstUpdate = false;
        }

        velocity = (transform.position - prevPos) / Time.deltaTime;
        prevPos = transform.position;
    }

    public Vector3 GetDrag () {
        if (IsVisibleFromPlane ()) {
            float alignment = Vector3.Dot (velocity, this.transform.forward);
            float A = alignment * localSurfaceArea;
            dragMagnitude = DragForce.Calculate (velocity.sqrMagnitude, A);

            //This clamp is necessary for imperfections in velocity calculation, especially with joint limits!
            //dragMagnitude = Mathf.Clamp (dragMagnitude, 0f, MAX_FORCE);

            drag = -velocity * dragMagnitude;
        }
        return drag;
    }

    public void Display () {
        voxelVisualizer.gameObject.SetActive (true);
    }

    public void TurnOffDisplay () {
        voxelVisualizer.gameObject.SetActive (false);
    }

    public void DisplayDrag (float forceMultiplier) {
        forceVisualizer.gameObject.SetActive (true);
        forceVisualizer.multiplier = forceMultiplier;
    }

    public void TurnOffDragDisplay () {
        forceVisualizer.gameObject.SetActive (false);
    }


}

VoxelForceVisualizer

This is a attached to prefab of a thin arrow that I put as a child of the voxels to allow force arrows to be drawn during debugging the drag force.

using UnityEngine;

public class VoxelForceVisualizer : MonoBehaviour {

    const float TINY_NUMBER = 0.00000001f;

    public Voxel voxel;
    public float drag;
    public float multiplier;

    void Start () {
        voxel = this.GetComponentInParent<Voxel> ();
    }
    // Update is called once per frame
    void Update () {
        Vector3 rescale;
        if (voxel.LeadingEdge && voxel.Drag != Vector3.zero) {
            this.transform.rotation = Quaternion.LookRotation (voxel.Drag);
            rescale = new Vector3 (1f, 1f, voxel.DragMagnitude * multiplier);

        }
        else {
            rescale = Vector3.zero;
        }
        this.transform.localScale = rescale;
        drag = voxel.DragMagnitude;
    }

}

VoxelVisualizer

this is attached to a small sphere object as a child of the voxel empty. It's just to see where the voxels are, and let the above scripts show/hide the voxels without disabling the drag force calculations.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class VoxelVisualizer : MonoBehaviour {


}

DragForce

This calculates the drag force

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public static class DragForce {

    const float EPSILON = 0.000001f;


    public static float Calculate (float coefficient, float density, float vsq, float A) {
        float f = coefficient * density * vsq * A;
        return f;
    }

    public static float Calculate (float vsq, float A) {
        return Calculate (1f, 1f, vsq, A);
    }


}