Use freight animations in auto size and auto center

Author: SteelFill

Source/Documentation/Manual/features-rollingstock.rst

@@ -741,9 +741,7 @@ To simplify this process, and produce more reasonable dimensions for rolling sto
 automatically calculate the dimensions of rolling stock based on the shape file used. Enter
 ``ORTSAutoSize`` in the Wagon section of an engine or wagon to allow OR to determine
 the width, height, and length of the rolling stock based on the dimensions of the main shape file,
-ignoring any values entered manually in the MSTS Size parameter. Note that this process is
-not aware of any :ref:`shape descriptor overrides <features-shape-manipulation>` so any changes made
-to the shape there will not be reflected in the automatically calculated size.
+ignoring any values entered manually in the MSTS Size parameter.
 
 ``ORTSAutoSize`` accepts 3 (optional) arguments, default units in meters, corresponding to offsets from the
 shape's width, height, and length respectively. For example, ``ORTSAutoSize ( 0.1m, -0.2m, -0.18m )``
@@ -754,11 +752,12 @@ arguments can be set to 0, and the length argument adjusted to produce the desir
 no arguments are specified (ie: ``ORTSAutoSize ()`` was entered in the Wagon section) then all three
 offsets are assumed to be 0 meters.
 
-Note that automatic sizing uses the nearest LOD of the main shape file. LODs for further distances
-and freight animation shape files have no effect on the automatic sizing. This method also works best for rolling
-stock with standard buffers/couplers on each end. Automatic sizing generally can't produce reasonable results
-for articulated rolling stock. And should something go wrong with the shape file causing automatic sizing to fail,
-OR will revert to the values entered in the ``Size`` parameter.
+Note that automatic sizing uses the nearest LOD of the main shape file and attached freight animations. LODs for further
+distances have no effect on the automatic sizing. :ref:`Shape descriptor overrides <features-shape-manipulation>`
+are also not considered at this phase, so if any changes are made in the .sd file, this feature may not provide
+good results. This method also works best for rolling stock with standard buffers/couplers on each end.
+Automatic sizing generally can't produce reasonable results for articulated rolling stock. And should something go
+wrong with the shape file causing automatic sizing to fail, OR will revert to the values entered in the ``Size`` parameter.
 
 Improved wagon alignment tools
 ------------------------------
@@ -800,9 +799,9 @@ not change the X or Y components. Should no re-centering be required, none will
 Some rolling stock will not align correctly when auto-centered. As with ``ORTSAutoSize``, this
 feature should be employed on rolling stock with standard buffers or couplers, and will
 not produce suitable results for articulated rolling stock or stock with different coupler
-types at each end. Only the highest detail LOD of the main shape is used to auto-center the
-rolling stock, other LODs and freight animations are ignored. If the process fails, a warning
-will be written to the log and the automatic calculation will be skipped.
+types at each end. Only the highest detail LOD of the main shape and freight animations are
+used, the .sd file is not checked. If the process fails, a warning will be written to the
+log and the automatic calculation will be skipped.
 
 Advanced articulation control
 -----------------------------

Source/Orts.Formats.Msts/ShapeFile.cs

@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Open Rails.  If not, see <http://www.gnu.org/licenses/>.
 
+using Microsoft.Xna.Framework;
 using Orts.Parsers.Msts;
 using System;
 using System.Collections.Generic;
@@ -109,7 +110,99 @@ public void ReadAnimationBlock(string orFileName)
             file.VerifyEndOfBlock();
         }
 
+        /// <summary>
+        /// Determines the corners of the 'bounding box' for the shape
+        /// </summary>
+        /// <returns>Two Vector3s, the first measuring the minimum extent of the shape,
+        /// the second measuring the maximum extent of the shape</returns>
+        public (Vector3, Vector3) GetBoundingLimits()
+        {
+            Vector3 mins = new Vector3(float.PositiveInfinity);
+            Vector3 maxes = new Vector3(float.NegativeInfinity);
+
+            // Determine size specifically for LOD0's (nearest LOD) sub objects
+            foreach (sub_object subObj in shape.lod_controls[0].distance_levels[0].sub_objects)
+            {
+                // Use vertex sets in the sub object to determine which vertices to check
+                foreach (vertex_set vSet in subObj.vertex_sets)
+                {
+                    // Use the vertex state used by this vertex set to determine the matrix used
+                    vtx_state vState = shape.vtx_states[vSet.VtxStateIdx];
+
+                    // The index of the matrix used by this vertex state
+                    int mIndex = vState.imatrix;
+
+                    // The 'actual' XNA matrix used to determine the vertex transformation
+                    Matrix mat = Matrix.Identity;
+
+                    // How deep are we in the hierarchy? Set a limit to prevent infinite loops
+                    int depth = 0;
 
+                    // Determine the overall transformation matrix from the root to the current matrix by following the hierarchy
+                    do
+                    {
+                        matrix m = shape.matrices[mIndex];
+
+                        // Convert the shape file matrix to an XNA matrix
+                        Matrix matTransform = new Matrix
+                        {
+                            M11 = m.AX,
+                            M12 = m.AY,
+                            M13 = m.AZ, //
+                            M14 = 0,
+                            M21 = m.BX,
+                            M22 = m.BY,
+                            M23 = m.BZ, //
+                            M24 = 0,
+                            M31 = m.CX, //
+                            M32 = m.CY, //
+                            M33 = m.CZ,
+                            M34 = 0,
+                            M41 = m.DX,
+                            M42 = m.DY,
+                            M43 = m.DZ, //
+                            M44 = 1.0f
+                        };
+
+                        // Add the effect of this transformation to the overall transformation 
+                        mat = mat * matTransform;
+
+                        // Determine the index of the next highest matrix in the hierarchy
+                        mIndex = shape.lod_controls[0].distance_levels[0].distance_level_header.hierarchy[mIndex];
+
+                        depth++;
+                    } // Keep calculating until we have calculated the root, or until a loop is encountered
+                    while (mIndex > -1 && mIndex != vState.imatrix && mIndex < shape.matrices.Count && depth < 32);
+
+                    // Determine position of every vertex in this set from point position and tranformed by the matrix
+                    for (int i = vSet.StartVtxIdx; i < vSet.StartVtxIdx + vSet.VtxCount; i++)
+                    {
+                        // Determine vertex position from vertex index and point index
+                        point p = shape.points[subObj.vertices[i].ipoint];
+                        Vector3 pPos = new Vector3(p.X, p.Y, p.Z);
+
+                        pPos = Vector3.Transform(pPos, mat);
+
+                        if (pPos.X < mins.X)
+                            mins.X = pPos.X;
+                        if (pPos.X > maxes.X)
+                            maxes.X = pPos.X;
+
+                        if (pPos.Y < mins.Y)
+                            mins.Y = pPos.Y;
+                        if (pPos.Y > maxes.Y)
+                            maxes.Y = pPos.Y;
+
+                        if (pPos.Z < mins.Z)
+                            mins.Z = pPos.Z;
+                        if (pPos.Z > maxes.Z)
+                            maxes.Z = pPos.Z;
+                    }
+                }
+            }
+
+            return (mins, maxes);
+        }
     }
 
     public class shape