public void PartCostTest()
{
PartWrapper partWrapper = new PartWrapper(new Part());
//при пустом списке себистоимости ловим ошибку
try
{
partWrapper.GetPrice();
}
catch (ArgumentException e)
{
Assert.AreSame(e.Message, "Нет себистоимости для этой даты (или для более ранней даты)");
}
//берем себестоимость для ближайшей ранней даты
partWrapper.Prices.Add(new CostOnDateWrapper(new CostOnDate {
Date = DateTime.Today.AddDays(-5), Cost = 10
}));
partWrapper.Prices.Add(new CostOnDateWrapper(new CostOnDate {
Date = DateTime.Today.AddDays(-7), Cost = 15
}));
partWrapper.Prices.Add(new CostOnDateWrapper(new CostOnDate {
Date = DateTime.Today.AddDays(10), Cost = 20
}));
Assert.AreEqual(partWrapper.GetPrice(), 10);
//берем себистоимость соответствующей даты
partWrapper.Prices.Add(new CostOnDateWrapper(new CostOnDate {
Date = DateTime.Today, Cost = 25
}));
Assert.AreEqual(partWrapper.GetPrice(), 25);
Assert.AreEqual(partWrapper.GetPrice(DateTime.Today.AddDays(10)), 20);
}
/// <summary>
/// Get/create part from save
/// </summary>
/// <param name="factory">part factory</param>
/// <typeparam name="TPart">part type</typeparam>
/// <typeparam name="TSerial">part serializable object type</typeparam>
/// <returns>existing/new part</returns>
/// <exception cref="IOException"></exception>
public TPart GetPart <TPart, TSerial>(ISaveDataPartFactory <TPart, TSerial> factory)
where TPart : ISaveDataPart <TSerial>
{
if (_parts.ContainsKey(factory.GetId()))
{
return(_parts[factory.GetId()].Get <TPart>());
}
if (_partList.Contains(factory.GetId()) && PartWrapper.Exists(_file, factory.GetId()))
{
var version = _versionMap.GetVersion(factory.GetId());
if (version != null)
{
var wrapper = PartWrapper.Load(_file, factory, (double)version);
if (!Equals(version, factory.GetVersion()))
{
wrapper.Save();
_versionMap.SetVersion(factory.GetId(), factory.GetVersion());
}
_parts.Add(factory.GetId(), wrapper);
return(wrapper.Get <TPart>());
}
}
var w = new PartWrapper((ISaveDataPart <object>)factory.Create(), _file, factory.GetId());
w.Save();
_partList.Add(factory.GetId());
_versionMap.SetVersion(factory.GetId(), factory.GetVersion());
_parts.Add(factory.GetId(), w);
return(w.Get <TPart>());
}
private static void DifferencialRebuild(CancellationToken ct)
{
foreach (var brickInfo in Bricks)
{
if (ChangedParts.Contains(brickInfo.PartId))
{
brickInfo.Validated = false;
}
}
CurrentProgress = new ProgressInfo(ChangedParts.Count, 0);
foreach (int partID in ChangedParts)
{
if (ct.IsCancellationRequested)
{
break;
}
var brickInfo = GetBrick(partID);
PartWrapper partInfo = null;
try
{
partInfo = PartWrapper.GetPartFromDirectory(SourcePath, partID, false);
}
catch { }
if (brickInfo != null && partInfo == null)
{
Bricks.Remove(brickInfo);
continue;
}
else if (partInfo != null)
{
if (brickInfo == null)
{
brickInfo = new BrickInfo(partInfo)
{
LastUpdate = DateTime.Now,
Validated = true
};
Bricks.Add(brickInfo);
}
else
{
brickInfo.UpdateInfo(partInfo);
brickInfo.LastUpdate = DateTime.Now;
brickInfo.Validated = true;
}
}
CurrentProgress.TotalValidated++;
}
ChangedParts.Clear();
}
private void ExportSelectedPart(MeshExportOptions exportOptions, string filepath)
{
var partInfo = PartWrapper.LoadPart(LDDEnvironment.Current, PartToExport.PartId, true);
var assimpScene = MeshConverter.LddPartToAssimp(partInfo, exportOptions);
AssimpContext.ExportFile(assimpScene, filepath,
exportOptions.FileFormatID,
Assimp.PostProcessSteps.FlipUVs);
assimpScene.Clear();
}
public PartWrapper GetPart(int partID)
{
if (Lif != null)
{
return(PartWrapper.GetPartFromLif(Lif, partID, false));
}
else
{
return(PartWrapper.GetPartFromDirectory(PrimitiveDir.FullName, partID, false));
}
}
/// <summary>
/// Remove part from the save and delete all files linked to it
/// </summary>
/// <param name="factory">part factory</param>
/// <typeparam name="TPart">part type</typeparam>
/// <typeparam name="TSerial">part serializable object type</typeparam>
/// <exception cref="IOException"></exception>
public void Remove <TPart, TSerial>(ISaveDataPartFactory <TPart, TSerial> factory)
where TPart : ISaveDataPart <TSerial>
{
var id = factory.GetId();
_partList.Remove(id);
_versionMap.Remove(id);
if (_parts.ContainsKey(id))
{
_parts.Remove(id);
}
PartWrapper.Delete(_file, id);
}
public async Task LoadAsync(int partID)
{
//DetailPart = await _partService.GetPart(partID);
var part = await _partService.GetPart(partID);
DetailPart = new PartWrapper(part);
// Load Resources---------------------------------------
var result = await _partService.GetPartResources(partID);
if (result != null)
{
PartResources.Clear();
foreach (var item in result)
{
PartResources.Add(item);
}
}
// Load Orders------------------------------------------
var orders = await _partService.GetPartOrders(partID);
if (orders != null)
{
PartOrders.Clear();
foreach (var order in orders)
{
PartOrders.Add(order);
}
}
// Load Inventory History --------------------------------
var trans = await _partService.GetPartTransactionAsync(partID);
if (trans != null)
{
PartTransactions.Clear();
foreach (var tran in trans)
{
PartTransactions.Add(tran);
}
}
}
public void PartSameParametersTest()
{
TestData testData = new TestData();
//список параметров различен
PartWrapper partWrapper1 = new PartWrapper(testData.PartVeb110);
PartWrapper partWrapper2 = new PartWrapper(testData.PartZng110);
Assert.IsFalse(partWrapper1.HasSameParameters(partWrapper2));
//уравниваем списки параметров
var pl1 = new List <ParameterWrapper>(partWrapper1.Parameters);
var pl2 = new List <ParameterWrapper>(partWrapper2.Parameters);
pl2.ForEach(partWrapper1.Parameters.Add);
pl1.ForEach(partWrapper2.Parameters.Add);
//теперь списки схожи
Assert.IsTrue(partWrapper1.HasSameParameters(partWrapper2));
}
private Models.BrickInfo FindPartInfo(int partID)
{
try
{
var brickInfo = BrickListCache.GetBrick(partID);
if (brickInfo != null)
{
return(brickInfo);
}
var part = PartWrapper.LoadPart(LDDEnvironment.Current, partID, false);
if (part != null)
{
return(new BrickInfo(part));
}
}
catch { }
return(null);
}
public ProjectBuildEventArgs(PartWrapper result, bool successful, IEnumerable <ValidationMessage> messages)
{
Result = result;
Successful = successful;
Messages = messages.ToList().AsReadOnly();
}
public static Scene LddPartToAssimp(PartWrapper part, MeshExportOptions exportOptions = null)
{
if (exportOptions == null)
{
exportOptions = new MeshExportOptions();
}
var scene = new Scene()
{
RootNode = new Node("Root")
};
scene.Materials.Add(new Material()
{
Name = "BaseMaterial"
});
var meshNodes = new List <Node>();
foreach (var surface in part.Surfaces)
{
string nodeName = "MainSurface";
if (surface.SurfaceID > 0)
{
nodeName = $"Decoration{surface.SurfaceID}";
}
var createdNodes = CreateSurfaceMeshNodes(surface, scene, nodeName, exportOptions);
meshNodes.AddRange(createdNodes);
}
//meshNodes.AddRange(scene.GetNodeHierarchy().Where(x => x.MeshCount > 0));
if (exportOptions.IncludeBones && part.IsFlexible)
{
var armatureNode = CreateArmatureNodeHierarchy(part, scene);
foreach (var node in meshNodes)
{
armatureNode.Children.Add(node);
}
scene.RootNode.Children.Add(armatureNode);
}
else if (meshNodes.Count > 1)
{
var groupNode = new Node()
{
Name = "Part"
};
foreach (var node in meshNodes)
{
groupNode.Children.Add(node);
}
scene.RootNode.Children.Add(groupNode);
}
else
{
scene.RootNode.Children.Add(meshNodes[0]);
}
if (exportOptions.IncludeConnections && part.Primitive.Connectors.Any())
{
var connectionsNode = new Node("Connections");
scene.RootNode.Children.Add(connectionsNode);
foreach (var connGroup in part.Primitive.Connectors.GroupBy(x => x.Type))
{
int connectionIdx = 0;
foreach (var conn in connGroup)
{
var connNode = new Node($"{connGroup.Key.ToString()}{connectionIdx++}_Type_{conn.SubType}")
{
Transform = conn.Transform.ToMatrix4().ToAssimp()
};
//connNode.Metadata.Add("Type", new Assimp.Metadata.Entry(Assimp.MetaDataType.String, conn.Type.ToString()));
connectionsNode.Children.Add(connNode);
}
}
}
if (exportOptions.IncludeCollisions && part.Primitive.Collisions.Any())
{
var collisionsNode = new Node("Collisions");
scene.RootNode.Children.Add(collisionsNode);
var sphereMesh = ResourceHelper.GetResourceModel("Models.Sphere.obj", "obj").Meshes[0];
var boxMesh = ResourceHelper.GetResourceModel("Models.Cube.obj", "obj").Meshes[0];
foreach (var collGroup in part.Primitive.Collisions.GroupBy(x => x.CollisionType))
{
int collisionIdx = 0;
foreach (var collision in collGroup)
{
var collNode = new Node($"{collGroup.Key.ToString()}{collisionIdx++}");
var meshTransform =
Simple3D.Matrix4d.FromScale(collision.GetSize() * 2f) * collision.Transform.ToMatrix4d();
if (collision.CollisionType == LDD.Primitives.Collisions.CollisionType.Box)
{
collNode.MeshIndices.Add(scene.MeshCount);
scene.Meshes.Add(boxMesh.Clone());
}
else
{
collNode.MeshIndices.Add(scene.MeshCount);
scene.Meshes.Add(sphereMesh.Clone());
}
//connNode.Metadata.Add("Type", new Assimp.Metadata.Entry(Assimp.MetaDataType.String, conn.Type.ToString()));
collNode.Transform = ((Simple3D.Matrix4)meshTransform).ToAssimp();
collisionsNode.Children.Add(collNode);
}
}
}
//if (exportOptions.IncludeRoundEdgeData)
//{
// foreach (var mat in scene.Materials)
// {
// }
//}
return(scene);
}
private static Node CreateArmatureNodeHierarchy(PartWrapper part, Scene scene)
{
var armatureNode = new Node()
{
Name = "Armature"
};
armatureNode.Transform = Assimp.Matrix4x4.Identity;
var allBoneNodes = new List <Node>();
Matrix4x4 lastMatrix = Assimp.Matrix4x4.Identity;
Node lastBoneNode = null;
var boneMatrixes = new Dictionary <string, Matrix4x4>();
var primitive = part.Primitive;
for (int i = 0; i < primitive.FlexBones.Count; i++)
{
var flexBone = primitive.FlexBones[i];
var bonePosMat = flexBone.Transform.ToMatrix4().ToAssimp();
var localPosMat = bonePosMat;
if (!lastMatrix.IsIdentity)
{
var inv = lastMatrix;
inv.Inverse();
localPosMat = bonePosMat * inv;
}
var boneNode = new Node()
{
Name = GetBoneName(flexBone),
Transform = localPosMat
};
var boneOrientation = bonePosMat;
boneOrientation.Inverse();
boneMatrixes.Add(boneNode.Name, boneOrientation);
allBoneNodes.Add(boneNode);
if (lastBoneNode == null)
{
armatureNode.Children.Add(boneNode);
}
else
{
lastBoneNode.Children.Add(boneNode);
}
lastBoneNode = boneNode;
lastMatrix = bonePosMat;
}
foreach (var mesh in scene.Meshes)
{
foreach (var b in mesh.Bones)
{
b.OffsetMatrix = boneMatrixes[b.Name];
}
}
return(armatureNode);
}
public ExtractedPart(PartWrapper part, string extractedFileName, ExtractedPackage package)
{
this.Part = part;
this.ExtractedFileName = extractedFileName;
this.package = package;
}
/// <summary>
/// Check if this save has the part
/// </summary>
/// <param name="factory">part factory</param>
/// <typeparam name="TPart">part type</typeparam>
/// <typeparam name="TSerial">part serializable object type</typeparam>
/// <returns><code>true</code> - save contains the part,otherwise - <code>false</code></returns>
public bool Contains <TPart, TSerial>(ISaveDataPartFactory <TPart, TSerial> factory)
where TPart : ISaveDataPart <TSerial>
{
return(_partList.Contains(factory.GetId()) && _versionMap.GetVersion(factory.GetId()) != null &&
PartWrapper.Exists(_file, factory.GetId()));
}
public void UpdateInfo(PartWrapper part)
{
UpdateInfo(part.Primitive);
MeshFilenames = part.Surfaces.Select(x => x.GetFileName()).ToArray();
Decorated = MeshFilenames.Length > 1;
}
public BrickInfo(PartWrapper part) : this(
part.Primitive,
$"{part.PartID}.xml",
part.Surfaces.Select(x => x.GetFileName()).ToArray())
{
}
