public void UpdateWMOControl()
{
Container3D activeObject = previewControl.activeObject;
if (activeObject != null && activeObject is WMOContainer wmoObject)
{
var wmo = wmoObject.WorldModel;
activeDoodadSets.Clear();
for (uint i = 0; i < wmo.doodadSets.Length; i++)
{
activeDoodadSets.Add(new WMODoodadSet()
{
Object = wmoObject, Name = wmo.doodadSets[i], Index = i
});
}
activeGroups.Clear();
for (uint j = 0; j < wmo.groupBatches.Length; j++)
{
activeGroups.Add(new WMOGroup()
{
Object = wmoObject, Name = wmo.groupBatches[j].groupName, Index = j
});
}
//wmo.groupBatches;
//wmo.doodads
}
}
public void UpdateModelControl()
{
Container3D activeObject = previewControl.activeObject;
if (activeObject != null && activeObject is M2Container m2Object)
{
activeModelGeosets.Clear();
var model = m2Object.DoodadBatch;
for (uint i = 0; i < model.submeshes.Length; i++)
{
var mesh = model.submeshes[i];
string name = "Unknown";
if (geosetMaps.ContainsKey(m2Object.FileName))
{
var map = geosetMaps[m2Object.FileName];
if (map.ContainsKey(i))
{
name = map[i];
}
}
activeModelGeosets.Add(new ModelGeoset()
{
Object = m2Object, Name = name, Index = i
});
}
}
}
private static SpriteComponent Create3DUIPage(WindowImpl window)
{
var entity = new Entity("Avalonia Screen Page " + window.RenderGroup);
var sprite = new SpriteComponent
{
RenderGroup = window.RenderGroup,
SpriteProvider = window.RenderingElement.Source
};
WorldPages.Add(window, sprite);
entity.Add(sprite);
Container3D.AddChild(entity);
return(sprite);
}
private IAlgorithm Create3DAlgorithm(AlgorithmProperties properties, Container3D initialContainer)
{
switch (properties.Family)
{
case (AlgorithmFamily.Shelf):
return(Create3DShelfAlgorithm(properties.AlgorithmType, initialContainer));
case (AlgorithmFamily.GuillotineCut):
return(Create3DGuillotineAlgorithm(properties.AlgorithmType, properties.SplittingStrategy, initialContainer));
default:
throw new NotSuchAlgorithmException();
}
}
private void StartAlgorithm_Execute()
{
try
{
IAlgorithm algorithm;
if (!CheckContainerSize())
{
throw new InvalidContainerSizeException("Container is not big enough to contain biggest object. Enlarge the container.");
}
if (Dimensionality == AlgorithmDimensionality.TwoDimensional)
{
Container2D startingContainer = containerFactory.Create(algorithmProperties, ContainerWidth, ContainerHeight);
algorithm = factory.Create(algorithmProperties, startingContainer);
}
else
{
Container3D startingContainer = containerFactory.Create(algorithmProperties, ContainerWidth, ContainerHeight, ContainerDepth);
algorithm = factory.Create(algorithmProperties, startingContainer);
}
stopwatch.Reset();
var sortedObjects = SortingHelper.Sort(objectsToPack, ObjectOrdering);
stopwatch.Start();
algorithm.Execute(sortedObjects);
stopwatch.Stop();
var endResults = algorithm.CreateResults();
ExecutionTime = stopwatch.ElapsedMilliseconds;
Quality = endResults.Quality;
ContainersUsed = endResults.ContainersUsed;
ObjectAmount = endResults.ObjectCount;
ObjectTotalFullfilment = endResults.ObjectsTotalFulfillment;
ContainerFulfillment = endResults.ContainerFulfillment;
AverageFulfillmentRatio = endResults.AverageFulfillmentRatio;
FulfillmentRatioStandardDeviation = endResults.FulfillmentRatioStandardDeviation;
WorstFulfillment = endResults.WorstFulfillment;
System.Windows.MessageBox.Show("Program successfully packed input object set.", "End of packing.");
}
catch (Exception err)
{
System.Windows.MessageBox.Show("Error during executing algorithm: " + err.Message, "Error");
}
}
public static void RemoveWindow(WindowImpl window)
{
if (window.Is2D)
{
var uiPage = GetUIPage(window.RenderGroup);
var canvas = (Canvas)uiPage.Page.RootElement;
canvas.Children.Remove(window.RenderingElement);
}
else
{
var uiPage = GetSprite(window);
WorldPages.Remove(window);
Container3D.RemoveChild(uiPage.Entity);
uiPage.Entity.Dispose();
}
}
public void LoadModel(string fileName)
{
GL.ActiveTexture(TextureUnit.Texture0);
try
{
if (fileName.EndsWith(".m2"))
{
var m2 = M2Loader.LoadM2(fileName, m2ShaderProgram);
activeObject = new M2Container(m2, fileName);
ActiveCamera.Pos = new Vector3((m2.boundingBox.max.Z) + 11.0f, 0.0f, 4.0f);
}
else if (fileName.EndsWith(".wmo"))
{
activeObject = new WMOContainer(WMOLoader.LoadWMO(fileName, wmoShaderProgram), fileName);
}
}
catch (Exception e)
{
Logger.WriteLine("Error occured when loading model " + fileName + ": " + e.StackTrace);
}
ActiveCamera.ResetCamera();
}
public NextFitShelf3DAlgorithm(Container3D initialContainer) : base(initialContainer)
{
}
public MaxVolumeGuillotineCut3DAlgorithm(Container3D initialContainer, AbstractFittingStrategy3D strategy) : base(initialContainer, strategy)
{
containers = new List <Container3D>();
containers.Add(new GuillotineCutMaxVolumeContainer3D(initialContainer.Width, initialContainer.Height, initialContainer.Depth));
}
public AbstractShelf3DAlgorithm(Container3D initialContainer) : base(initialContainer)
{
containers = new List <Container3D>();
containers.Add(new ShelfContainer3D(initialContainer.Width, initialContainer.Height, initialContainer.Depth));
}
public Algorithm3D(Container3D initialContainer)
{
}
public ShorterLeftoverAxisGuillotineCut3DAlgorithm(Container3D initialContainer, AbstractFittingStrategy3D strategy) : base(initialContainer, strategy)
{
containers = new List <Container3D>();
containers.Add(new GuillotineCutShorterLeftoverAxisContainer3D(initialContainer.Width, initialContainer.Height, initialContainer.Depth));
}
public AbstractGuillotineCut3DAlgorithm(Container3D initialContainer, AbstractFittingStrategy3D strategy) : base(initialContainer)
{
FittingStrategy = strategy;
}
private IAlgorithm Create3DShelfAlgorithm(ObjectFittingStrategy fittingStrategy, Container3D initialContainer)
{
switch (fittingStrategy)
{
case (ObjectFittingStrategy.NextFit):
return(new NextFitShelf3DAlgorithm(initialContainer));
case (ObjectFittingStrategy.FirstFit):
return(new FirstFitShelf3DAlgorithm(initialContainer));
default:
throw new NotSuchAlgorithmException();
}
}
private IAlgorithm Create3DGuillotineAlgorithm(ObjectFittingStrategy fittingStrategy, ContainerSplittingStrategy splittingStrategy, Container3D initialContainer)
{
var strategyInstance = objectFittingStrategyFactory.Create3D(fittingStrategy) as AbstractFittingStrategy3D;
switch (splittingStrategy)
{
case (ContainerSplittingStrategy.MaxVolumeSplitRule):
return(new MaxVolumeGuillotineCut3DAlgorithm(initialContainer, strategyInstance));
case (ContainerSplittingStrategy.MinVolumeSplitRule):
return(new MinVolumeGuillotineCut3DAlgorithm(initialContainer, strategyInstance));
case (ContainerSplittingStrategy.LongerAxisSplitRule):
return(new LongerAxisGuillotineCut3DAlgorithm(initialContainer, strategyInstance));
case (ContainerSplittingStrategy.LongerLeftoverAxisSplitRule):
return(new LongerLeftoverAxisGuillotineCut3DAlgorithm(initialContainer, strategyInstance));
case (ContainerSplittingStrategy.ShorterAxisSplitRule):
return(new ShorterAxisGuillotineCut3DAlgorithm(initialContainer, strategyInstance));
case (ContainerSplittingStrategy.ShorterLeftoverAxisSplitRule):
return(new ShorterLeftoverAxisGuillotineCut3DAlgorithm(initialContainer, strategyInstance));
default:
throw new NotSuchAlgorithmException();
}
}
