public static void LoadDefinition(this MyHudBlockInfo blockInfo, MyCubeBlockDefinition definition, DictionaryReader<MyDefinitionId, int> materials, bool merge = true)
        {
            InitBlockInfo(blockInfo, definition);

            foreach (var material in materials)
            {
                var componentDefinition = MyDefinitionManager.Static.GetComponentDefinition(material.Key);
                var info = new MyHudBlockInfo.ComponentInfo();
                if (componentDefinition == null)
                {
                    MyPhysicalItemDefinition physicalDefinition = null;
                    if (!MyDefinitionManager.Static.TryGetPhysicalItemDefinition(material.Key, out physicalDefinition))
                        continue;
                    info.ComponentName = physicalDefinition.DisplayNameText;
                    info.Icon = physicalDefinition.Icon;
                    info.DefinitionId = physicalDefinition.Id;
                    info.TotalCount = 1;
                }
                else
                {
                    info.DefinitionId = componentDefinition.Id;
                    info.ComponentName = componentDefinition.DisplayNameText;
                    info.Icon = componentDefinition.Icon;
                    info.TotalCount = material.Value;
                }
                blockInfo.Components.Add(info);
            }

            if (merge) MergeSameComponents(blockInfo, definition);
        }

 public MyGeneratedBlockLocation(MySlimBlock refBlock, MyCubeBlockDefinition blockDefinition, Vector3I position, Vector3I forward, Vector3I up, ushort? blockIdInCompound = null, MyGridInfo gridInfo = null)
 {
     RefBlock = refBlock;
     BlockDefinition = blockDefinition;
     Position = position;
     Orientation = new MyBlockOrientation(Base6Directions.GetDirection(ref forward), Base6Directions.GetDirection(ref up));
     BlockIdInCompound = blockIdInCompound;
     GridInfo = gridInfo;
     GeneratedBlockType = MyStringId.NullOrEmpty;
 }

 public void Initialize(ref MyBlockBuildArea area, MyCubeBlockDefinition definition)
 {
     m_definition = definition;
     m_orientation = new MyBlockOrientation(area.OrientationForward, area.OrientationUp);
     m_posInGrid = area.PosInGrid;
     m_blockMin = area.BlockMin;
     m_blockMax = area.BlockMax;
     m_stepDelta = area.StepDelta;
     m_lookup.Clear();
 }

 private static void InitBlockInfo(MyHudBlockInfo blockInfo, MyCubeBlockDefinition definition)
 {
     blockInfo.BlockName = definition.DisplayNameText;
     blockInfo.BlockIcon = definition.Icon;
     blockInfo.BlockIntegrity = 0;
     blockInfo.CriticalComponentIndex = -1;
     blockInfo.CriticalIntegrity = 0;
     blockInfo.OwnershipIntegrity = 0;
     blockInfo.MissingComponentIndex = -1;
     blockInfo.Components.Clear();
 }

 public MyCubeBlockDefinitionWithVariants(MyCubeBlockDefinition definition, int variantIndex)
 {
     m_baseDefinition = definition;
     m_variantIndex = variantIndex;
     if (m_baseDefinition.Variants == null || m_baseDefinition.Variants.Count == 0)
     {
         m_variantIndex = -1;
     }
     else if (m_variantIndex != -1)
     {
         m_variantIndex %= m_baseDefinition.Variants.Count;
     }
 }

 private static void AddComponentsForBlock(MyHudBlockInfo blockInfo, MyCubeBlockDefinition definition)
 {
     for (int i = 0; i < definition.Components.Length; ++i)
     {
         var comp = definition.Components[i];
         var info = new MyHudBlockInfo.ComponentInfo();
         info.DefinitionId = comp.Definition.Id;
         info.ComponentName = comp.Definition.DisplayNameText;
         info.Icon = comp.Definition.Icon;
         info.TotalCount = comp.Count;
         blockInfo.Components.Add(info);
     }
 }

        // This function does some modifications to the cube block's object builder before it's built, usually integrity changes, etc...
        public virtual void BeforeCreateBlock(MyCubeBlockDefinition definition, MyEntity builder, MyObjectBuilder_CubeBlock ob, bool buildAsAdmin)
        {
            if (definition.EntityComponents == null) return;

            if (ob.ComponentContainer == null)
            {
                ob.ComponentContainer = new MyObjectBuilder_ComponentContainer();
            }

            foreach (var componentOb in definition.EntityComponents)
            {
                var data = new MyObjectBuilder_ComponentContainer.ComponentData();
                data.TypeId = componentOb.Key.ToString();
                data.Component = componentOb.Value;
                ob.ComponentContainer.Components.Add(data);
            }
        }

        public static void LoadDefinition(this MyHudBlockInfo blockInfo, MyCubeBlockDefinition definition, DictionaryReader<MyDefinitionId, int> materials, bool merge = true)
        {
            InitBlockInfo(blockInfo, definition);

            foreach (var material in materials)
            {
                var componentDefinition = MyDefinitionManager.Static.GetComponentDefinition(material.Key);
                var info = new MyHudBlockInfo.ComponentInfo();
                info.DefinitionId = componentDefinition.Id;
                info.ComponentName = componentDefinition.DisplayNameText;
                info.Icon = componentDefinition.Icon;
                info.TotalCount = material.Value;
                blockInfo.Components.Add(info);
            }

            if (merge) MergeSameComponents(blockInfo, definition);
        }

        public static MyObjectBuilder_BlockNavigationDefinition GetDefaultObjectBuilder(MyCubeBlockDefinition blockDefinition)
        {
            MyObjectBuilder_BlockNavigationDefinition ob = m_tmpDefaultOb;

            m_tmpStringBuilder.Clear();
            m_tmpStringBuilder.Append("Default_");
            m_tmpStringBuilder.Append(blockDefinition.Size.X);
            m_tmpStringBuilder.Append("_");
            m_tmpStringBuilder.Append(blockDefinition.Size.Y);
            m_tmpStringBuilder.Append("_");
            m_tmpStringBuilder.Append(blockDefinition.Size.Z);

            ob.Id = new MyDefinitionId(typeof(MyObjectBuilder_BlockNavigationDefinition), m_tmpStringBuilder.ToString());
            ob.Size = blockDefinition.Size;
            ob.Center = blockDefinition.Center;

            return ob;
        }

        public static void LoadDefinition(this MyHudBlockInfo blockInfo, MyCubeBlockDefinition definition, bool merge = true)
        {
            blockInfo.BlockName = definition.DisplayNameText;
            blockInfo.BlockIcon = definition.Icon;
            blockInfo.BlockIntegrity = 0;
            blockInfo.CriticalComponentIndex = -1;
            blockInfo.CriticalIntegrity = 0;
            blockInfo.OwnershipIntegrity = 0;
            blockInfo.MissingComponentIndex = -1;

            blockInfo.Components.Clear();
            for (int i = 0; i < definition.Components.Length; ++i)
            {
                var comp = definition.Components[i];
                var info = new MyHudBlockInfo.ComponentInfo();
                info.ComponentName = comp.Definition.DisplayNameText;
                info.Icon = comp.Definition.Icon;
                info.TotalCount = comp.Count;
                blockInfo.Components.Add(info);
            }

            // Merge same components
            if (merge)
            {
                for (int i = definition.Components.Length - 1; i >= 0; i--)
                {
                    for (int j = i - 1; j >= 0; j--)
                    {
                        if (definition.Components[i].Definition == definition.Components[j].Definition)
                        {
                            var info = blockInfo.Components[j];
                            info.TotalCount += blockInfo.Components[i].TotalCount;
                            blockInfo.Components[j] = info;
                            blockInfo.Components.RemoveAt(i);
                            break;
                        }
                    }
                }
            }

        }

        private static WeaponDescription CreateFrom(MyCubeBlockDefinition definition)
        {
            if (string.IsNullOrWhiteSpace(definition.DescriptionString))
                return new WeaponDescription();

            WeaponDescription desc = new WeaponDescription();
            try
            {
                XML_Amendments<WeaponDescription> ammender = new XML_Amendments<WeaponDescription>(desc);
                ammender.AmendAll(definition.DescriptionString, true);
                return ammender.Deserialize();
            }
            catch (Exception ex)
            {
                Logger.debugNotify("Failed to load description for a weapon", 10000, Logger.severity.ERROR);
                Logger log = new Logger("WeaponDescription", () => definition.Id.ToString());
                log.alwaysLog("Failed to load description for a weapon", Logger.severity.ERROR);
                log.alwaysLog("Exception: " + ex, Logger.severity.ERROR);
                return new WeaponDescription();
            }
        }

        /// <summary>
        /// Called when block is destroyed before being removed from grid
        /// </summary>
        //public void OnDestroy()
        //{
        //    if (FatBlock != null)
        //    {
        //        Profiler.Begin("MySlimBlock.OnDestroy");
        //        FatBlock.OnDestroy();
        //        Profiler.End();
        //    }
        //}

        public static void ComputeMax(MyCubeBlockDefinition definition, MyBlockOrientation orientation, ref Vector3I min, out Vector3I max)
        {
            Vector3I size = definition.Size - 1;
            MatrixI localMatrix = new MatrixI(orientation);
            Vector3I.TransformNormal(ref size, ref localMatrix, out size);
            Vector3I.Abs(ref size, out size);
            max = min + size;
        }

 // Convention: All these functions will erase the RequiredMaterials first thing when they're called
 public abstract void GetGridSpawnMaterials(MyCubeBlockDefinition definition, MatrixD worldMatrix, bool isStatic);

 public abstract void GetBlockPlacementMaterials(MyCubeBlockDefinition definition, Vector3I position, MyBlockOrientation orientation, MyCubeGrid grid);

        protected static void AddFastBuildModelWithSubparts(ref MatrixD matrix, List<MatrixD> matrices, List<string> models, MyCubeBlockDefinition blockDefinition)
        {
            if (string.IsNullOrEmpty(blockDefinition.Model))
                return;

            matrices.Add(matrix);
            models.Add(blockDefinition.Model);
            var data = new MyEntitySubpart.Data();

            MyCubeBlockDefinition subBlockDefinition;
            MatrixD subBlockMatrix;
            Vector3 dummyPosition;

            MyModel modelData = MyModels.GetModelOnlyData(blockDefinition.Model);
            foreach (var dummy in modelData.Dummies)
            {
                if (MyEntitySubpart.GetSubpartFromDummy(blockDefinition.Model, dummy.Key, dummy.Value, ref data)) 
                {
                    MatrixD mCopy = MatrixD.Multiply(data.InitialTransform, matrix);
                    matrices.Add(mCopy);
                    models.Add(data.File);
                }
                else if (MyFakes.ENABLE_SUBBLOCKS 
                    && MyCubeBlock.GetSubBlockDataFromDummy(blockDefinition, dummy.Key, dummy.Value, false, out subBlockDefinition, out subBlockMatrix, out dummyPosition))
                {
                    if (!string.IsNullOrEmpty(subBlockDefinition.Model)) 
                    {
                        // Repair subblock matrix to have int axes (because preview renderer does not allow such non integer rotation).
                        Vector3I forward = Vector3I.Round(Vector3.DominantAxisProjection(subBlockMatrix.Forward));
                        Vector3I invForward = Vector3I.One - Vector3I.Abs(forward);
                        Vector3I right = Vector3I.Round(Vector3.DominantAxisProjection((Vector3)subBlockMatrix.Right * invForward));
                        Vector3I up;
                        Vector3I.Cross(ref right, ref forward, out up);

                        subBlockMatrix.Forward = forward;
                        subBlockMatrix.Right = right;
                        subBlockMatrix.Up = up;

                        MatrixD mCopy = MatrixD.Multiply(subBlockMatrix, matrix);
                        matrices.Add(mCopy);
                        models.Add(subBlockDefinition.Model);
                    }
                }

            }
        }

 public void Init(MyObjectBuilder_GunBase objectBuilder, MyCubeBlockDefinition cubeBlockDefinition, IMyGunBaseUser gunBaseUser)
 {
     if (cubeBlockDefinition is MyWeaponBlockDefinition)
     {
         MyWeaponBlockDefinition weaponBlockDefinition = cubeBlockDefinition as MyWeaponBlockDefinition;
         Init(objectBuilder, weaponBlockDefinition.WeaponDefinitionId, gunBaseUser);
     }
     else
     {
         // Backward compatibility
         MyDefinitionId weaponDefinitionId = GetBackwardCompatibleDefinitionId(cubeBlockDefinition.Id.TypeId);
         Init(objectBuilder, weaponDefinitionId, gunBaseUser);
     }
 }

        private static InventoryEditorModel ParseInventory(MyObjectBuilder_Inventory inventory, MyCubeBlockDefinition definition = null)
        {
            if (inventory == null)
                return null;
            float volumeMultiplier = 1f; // Unsure if there should be a default of 1 if there isn't a InventorySize defined.

            if (definition == null)
                volumeMultiplier = 0.4f;
            else
            {
                var definitionType = definition.GetType();
                var invSizeField = definitionType.GetField("InventorySize");
                var inventoryMaxVolumeField = definitionType.GetField("InventoryMaxVolume");
                if (invSizeField != null)
                {
                    var invSize = (Vector3)invSizeField.GetValue(definition);
                    volumeMultiplier = invSize.X * invSize.Y * invSize.Z;
                }
                if (inventoryMaxVolumeField != null)
                {
                    var maxSize = (float)inventoryMaxVolumeField.GetValue(definition);
                    volumeMultiplier = MathHelper.Min(volumeMultiplier, maxSize);
                }
            }

            var settings = SpaceEngineersCore.WorldResource.Checkpoint.Settings;
            return new InventoryEditorModel(inventory, volumeMultiplier * 1000 * settings.InventorySizeMultiplier, null) { Name = inventory.InventoryFlags.ToString(), IsValid = true };
        }

 public float GetBlockMass(string model, MyCubeBlockDefinition def)
 {
     var sh = BlockShapePool.GetBreakableShape(model, def);
     var mass = sh.GetMass();
     BlockShapePool.EnqueShape(model, def.Id, sh);
     return mass;
 }

        //public static ObservableCollection<InventoryEditorModel> GetInventory(this MyObjectBuilder_EntityBase objectBuilderBase)
        //{
        //    var inventoryEditors = new ObservableCollection<InventoryEditorModel>();

        //    if (objectBuilderBase.ComponentContainer != null)
        //    {
        //        var inventoryBase = objectBuilderBase.ComponentContainer.Components.FirstOrDefault(e => e.TypeId == "MyInventoryBase");

        //        if (inventoryBase != null)
        //        {
        //            var singleInventory = inventoryBase.Component as MyObjectBuilder_Inventory;
        //            if (singleInventory != null)
        //            {
        //                var iem = ParseInventory(singleInventory);
        //                if (iem != null)
        //                    inventoryEditors.Add(iem);
        //            }

        //            var aggregate = inventoryBase.Component as MyObjectBuilder_InventoryAggregate;
        //            if (aggregate != null)
        //                foreach (var field in aggregate.Inventories)
        //                {
        //                    var iem = ParseInventory(field as MyObjectBuilder_Inventory);
        //                    if (iem != null)
        //                        inventoryEditors.Add(iem);
        //                }
        //        }
        //    }
        //    return inventoryEditors;
        //}

        public static ObservableCollection<InventoryEditorModel> GetInventory(this MyObjectBuilder_ComponentContainer componentContainer, MyCubeBlockDefinition definition = null)
        {
            var inventoryEditors = new ObservableCollection<InventoryEditorModel>();

            if (componentContainer != null)
            {
                var inventoryBase = componentContainer.Components.FirstOrDefault(e => e.TypeId == "MyInventoryBase");

                if (inventoryBase != null)
                {
                    var singleInventory = inventoryBase.Component as MyObjectBuilder_Inventory;
                    if (singleInventory != null)
                    {
                        var iem = ParseInventory(singleInventory, definition);
                        if (iem != null)
                            inventoryEditors.Add(iem);
                    }

                    var aggregate = inventoryBase.Component as MyObjectBuilder_InventoryAggregate;
                    if (aggregate != null)
                        foreach (var field in aggregate.Inventories)
                        {
                            var iem = ParseInventory(field as MyObjectBuilder_Inventory, definition);
                            if (iem != null)
                                inventoryEditors.Add(iem);
                        }
                }
            }
            return inventoryEditors;
        }

 /// <summary>
 /// Checkes whether blocks A and B have matching mount point on one of their sides. Each block is given by its
 /// definition, rotation and position in grid. Position has to be relative to same center. Also, normal relative to block A specifies
 /// wall which is used for checking.
 /// </summary>
 public static bool CheckMountPointsForSide(MyCubeBlockDefinition defA, MyCubeBlockDefinition.MountPoint[] mountPointsA, ref MyBlockOrientation orientationA, ref Vector3I positionA, ref Vector3I normalA,
                                            MyCubeBlockDefinition defB, MyCubeBlockDefinition.MountPoint[] mountPointsB, ref MyBlockOrientation orientationB, ref Vector3I positionB)
 {
     TransformMountPoints(m_cacheMountPointsA, defA, mountPointsA, ref orientationA);
     TransformMountPoints(m_cacheMountPointsB, defB, mountPointsB, ref orientationB);
     return CheckMountPointsForSide(m_cacheMountPointsA, ref orientationA, ref positionA, defA.Id, ref normalA, m_cacheMountPointsB, ref orientationB, ref positionB, defB.Id);
 }