public void SettingMaterialsInstances(MaterialsManager m)
{
this.gameObject.name = m.name;
thisBreakForce = m.breakForce;
this.gameObject.GetComponent <Rigidbody2D> ().mass = m.weight;
this.gameObject.GetComponent <Rigidbody2D> ().angularVelocity = m.spiningSpeed;
}
public ActionResult EditMaterial(MaterialModel model)
{
using (var mm = new MaterialsManager())
{
// TODO: Refactor into an extention method that uses generics
var material = new Material
{
Name = model.Name,
SubName = model.SubName,
Measurement = model.Measurement,
CreatedOn = model.CreatedOn,
ModifiedOn = model.ModifiedOn,
UnitCost = model.UnitCost,
IsActive = model.IsActive,
ManufacturerID = model.ManufacturerID,
Height = model.Height,
Width = model.Width,
Thickness = model.Thickness,
Texture = model.Texture,
Finish = model.Finish,
Overlap = model.Overlap,
SKU = model.SKU,
ID = model.ID
};
material = mm.EditMaterial(material);
}
return(RedirectToAction("Materials"));
}
public ActionResult Products()
{
ProductHouseModel model = new ProductHouseModel();
List <ProductToProductLineModel> phModel = new List <ProductToProductLineModel>();
using (var mm = new MaterialsManager())
{
List <Product> products = mm.ActiveProducts().ToList();
List <ProductLine> partsOfHouse = mm.ActiveProductLines().ToList();
List <ProductToLine> prodHouses = mm.AllProductToProductLine().ToList();
model.Products = products.AsEnumerable();
model.PartsOfHouse = partsOfHouse.AsEnumerable();
// create the list based on our product and part list
foreach (var partOfHouse in partsOfHouse)
{
foreach (var product in products)
{
phModel.Add(new ProductToProductLineModel
{
IsActive = prodHouses.Any(ph => ph.ProductID == product.ID && ph.ProductLineID == partOfHouse.ID) && prodHouses.First(ph => ph.ProductID == product.ID && ph.ProductLineID == partOfHouse.ID).IsActive,
ProductID = product.ID,
ProductLineID = partOfHouse.ID,
ProductName = product.Name,
ProductLineName = partOfHouse.Name
});
}
}
model.ProductPartHouse = phModel.AsEnumerable();
}
return(View("Products", model));
}
private void LoadMaterials()
{
if (isMaterialTabFocused && !hasLoadedMaterials)
{
MatViewPanel.Controls.Clear();
currentMaterials.Clear();
if (FrameResource.IsFrameType(currentObject))
{
if (currentObject is FrameObjectSingleMesh)
{
var entry = (currentObject as FrameObjectSingleMesh);
MaterialStruct[] materialAssignments = entry.Material.Materials[LODComboBox.SelectedIndex];
for (int x = 0; x != materialAssignments.Length; x++)
{
TextureEntry textEntry = new TextureEntry();
var mat = materialAssignments[x];
IMaterial material = MaterialsManager.LookupMaterialByHash(mat.MaterialHash);
textEntry.OnEntrySingularClick += MatViewPanel_TextureEntryOnSingularClick;
textEntry.OnEntryDoubleClick += MatViewPanel_TextureEntryOnDoubleClick;
textEntry.SetMaterial(material);
currentMaterials.Add(textEntry, mat);
MatViewPanel.Controls.Add(textEntry);
}
}
}
hasLoadedMaterials = true;
}
}
public ActionResult WasteFactors(int companyID)
{
var wasteFactors = new List <WasteFactor>();
var model = new List <WasteFactorModel>();
var prodParts = new List <ProductToLine>();
List <Product> products = new List <Product>();
List <ProductLine> partsOfHouse = new List <ProductLine>();
using (var mm = new MaterialsManager())
{
prodParts = mm.AllProductToProductLine().ToList();
products = mm.AllProducts().ToList();
partsOfHouse = mm.ActiveProductLines().ToList();
}
using (var wfm = new WasteFactorManager())
{
wasteFactors = wfm.ByCompany(companyID).ToList();
}
foreach (var pph in prodParts)
{
if (!wasteFactors.Any(wf => wf.ProductID == pph.ProductID && wf.ProductLineID == pph.ProductLineID))
{
model.Add(new WasteFactorModel
{
CompanyID = companyID,
CreatedOn = DateTime.Now,
ModifiedOn = DateTime.Now,
ModifiedBy = User.Identity.Name,
ProductLineID = pph.ProductLineID,
ProductID = pph.ProductID,
ProductName = products.FirstOrDefault(p => p.ID == pph.ProductID).Name,
ProductLineName = partsOfHouse.FirstOrDefault(p => p.ID == pph.ProductID).Name
});
}
else
{
var fact =
wasteFactors.FirstOrDefault(
wf => wf.ProductID == pph.ProductID && wf.ProductLineID == pph.ProductLineID);
model.Add(new WasteFactorModel
{
ID = fact.ID,
CompanyID = companyID,
CreatedOn = fact.CreatedOn,
ModifiedOn = fact.CreatedOn,
ModifiedBy = fact.ModifiedBy,
ProductLineID = pph.ProductLineID,
ProductID = pph.ProductID,
ProductName = products.FirstOrDefault(p => p.ID == pph.ProductID).Name,
ProductLineName = partsOfHouse.FirstOrDefault(p => p.ID == pph.ProductID).Name,
Factor = fact.WasteFactor1.GetValueOrDefault()
});
}
}
return(View("WasteFactors", model));
}
public void ConvertMTKToRenderModel(M2TStructure structure)
{
List <Vertex[]> vertices = new List <Vertex[]>();
LODs = new LOD[structure.Lods.Length];
for (int i = 0; i != structure.Lods.Length; i++)
{
M2TStructure.Lod lod = structure.Lods[i];
vertices.Add(lod.Vertices);
LOD lod2 = new LOD();
lod2.Indices = lod.Indices;
lod2.ModelParts = new ModelPart[lod.Parts.Length];
for (int y = 0; y != lod.Parts.Length; y++)
{
ModelPart part = new ModelPart();
part.NumFaces = lod.Parts[y].NumFaces;
part.StartIndex = lod.Parts[y].StartIndex;
part.MaterialHash = lod.Parts[y].Hash;
switch (part.MaterialHash)
{
case 1337:
part.Material = RenderStorageSingleton.Instance.Prefabs.GizmoRed;
break;
case 1338:
part.Material = RenderStorageSingleton.Instance.Prefabs.GizmoBlue;
break;
case 1339:
part.Material = RenderStorageSingleton.Instance.Prefabs.GizmoGreen;
break;
default:
part.Material = MaterialsManager.LookupMaterialByHash(part.MaterialHash);
break;
}
lod2.ModelParts[y] = part;
}
lod2.Vertices = new VertexLayouts.NormalLayout.Vertex[lod.Vertices.Length];
for (int y = 0; y != lod.Vertices.Length; y++)
{
var vertice = new VertexLayouts.NormalLayout.Vertex();
vertice.Position = lod.Vertices[y].Position;
vertice.Normal = lod.Vertices[y].Normal;
vertice.TexCoord0 = lod.Vertices[y].UVs[0];
vertice.TexCoord7 = lod.Vertices[y].UVs[3];
lod2.Vertices[y] = vertice;
}
LODs[i] = lod2;
}
BoundingBox = new RenderBoundingBox();
BoundingBox.Init(BoundingBoxExtenders.CalculateBounds(vertices));
BoundingBox.SetTransform(Transform);
BoundingBox.DoRender = false;
SetupShaders();
}
public ActionResult CreateProduct(Product product)
{
using (var mm = new MaterialsManager())
{
product = mm.CreateProduct(product);
}
return(RedirectToAction("Products"));
}
public ActionResult EditMaterial(int id)
{
using (var mm = new MaterialsManager())
{
var material = mm.SingleMaterial(id);
var model = new MaterialModel(material);
return(View("EditMaterial", model));
}
}
public ActionResult EditProduct(int id)
{
using (var mm = new MaterialsManager())
{
var product = mm.SingleProduct(id);
ViewBag.Product = product;
return(View("EditProduct"));
}
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
public ActionResult SupplierMaterials(int supplierID)
{
List <Material> materials;
using (var mm = new MaterialsManager())
{
materials = mm.BySupplier(supplierID).ToList();
}
ViewBag.Materials = materials;
return(View("MaterialList"));
}
public ActionResult AllMaterials()
{
List <Material> materials;
using (var mm = new MaterialsManager())
{
materials = mm.AllMaterials().ToList();
}
ViewBag.Materials = materials;
return(View("MaterialList"));
}
public ActionResult AllProducts()
{
List <Product> products;
using (var mm = new MaterialsManager())
{
products = mm.AllProducts().ToList();
}
ViewBag.Products = products;
return(View("ProductList"));
}
public MaterialsManager CombinationsMaterials(MaterialsManager m, MaterialsManager n)
{
MaterialsManager c = new MaterialsManager();
//New material's weight
c.weight = CompareWeight(m.weight, n.weight);
//New material's breakForce
c.breakForce = CompareBreakForce(m.breakForce, n.breakForce);
return(c);
}
public void UpdateMaterials(FrameMaterial mats)
{
for (int i = 0; i != LODs.Length; i++)
{
for (int z = 0; z != LODs[i].ModelParts.Length; z++)
{
ulong hash = mats.Materials[i][z].MaterialHash;
LODs[i].ModelParts[z].MaterialHash = hash;
LODs[i].ModelParts[z].Material = MaterialsManager.LookupMaterialByHash(hash);
}
}
isUpdatedNeeded = true;
}
public ActionResult AvailableProducts(int materialID)
{
List <Product> products;
List <MaterialToProduct> materialProducts;
using (var mm = new MaterialsManager())
{
products = mm.ActiveProducts().OrderBy(p => p.Name).ToList();
materialProducts = mm.ByMaterialID(materialID).ToList();
}
ViewBag.Products = products;
ViewBag.MaterialToProducts = materialProducts;
return(View("AvailableProducts"));
}
public static void Load()
{
MaterialsManager.ClearLoadedMTLs();
try
{
MaterialsManager.ReadMatFiles(ToolkitSettings.MaterialLibs.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
HasLoaded = true;
}
catch (Exception ex)
{
MessageBox.Show(Language.GetString("$ERROR_DIDNT_FIND_MTL") + ex.Message, Language.GetString("$ERROR_TITLE"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void OnImpJoined(GroupManager sender, GameObject demon)
{
if (_groupManager.ThisGroupName != GroupsInRangeDetector.MostRepresentedGroupInRange)
{
return;
}
MaterialsManager materialsManager = demon.GetComponent <MaterialsManager>();
if (materialsManager != null)
{
materialsManager.ChangeMaterials(outlineMaterial);
}
}
public ActionResult AddQuoteItem(QuoteItem item)
{
Material material;
List <WasteFactor> wasteFactors = new List <WasteFactor>();
using (var mm = new MaterialsManager())
{
material = mm.SingleMaterial(item.MaterialID.GetValueOrDefault());
}
using (var qm = new QuoteManager())
{
var quote = qm.Single(item.QuoteID);
using (var wfm = new WasteFactorManager())
{
wasteFactors = wfm.ByCompany(quote.CompanyID.GetValueOrDefault()).ToList();
}
decimal wasteFactor =
wasteFactors.Any(
wf => wf.ProductID == item.ProductID && wf.ProductLineID == item.ProductLineID)
? wasteFactors.First(
wf => wf.ProductID == item.ProductID && wf.ProductLineID == item.ProductLineID)
.WasteFactor1.GetValueOrDefault() : 0M;
// calculate the amount and save
switch (item.Measurement)
{
case (Measurement.SquareFeet):
if (item.SquareFt.GetValueOrDefault() == 0)
{
item.SquareFt = item.Height * item.Width;
}
var pieceSqFt = (material.Height - material.Overlap.GetValueOrDefault()) * (1M / 12M) * material.Width;
var pieces = Math.Ceiling((decimal)(item.SquareFt.GetValueOrDefault() * (1M + wasteFactor) / pieceSqFt));
item.Amount = pieces * material.UnitCost;
break;
case (Measurement.LinearFeet):
item.Amount = item.LinearFt * (1M + wasteFactor) * material.UnitCost / material.Width;
break;
case (Measurement.Constant):
item.Amount = item.Dollars;
break;
}
item = qm.CreateItem(item);
}
return(RedirectToAction("Edit", new { id = item.QuoteID }));
}
public void CreateProduct()
{
Product product = new Product();
product.CreatedOn = DateTime.Now;
product.Measurement = Measurement.SquareFeet;
product.ModifiedOn = DateTime.Now;
product.Name = "Siding";
using (var mm = new MaterialsManager())
{
product = mm.CreateProduct(product);
Assert.IsTrue(product.ID > 0);
}
}
/// <summary>
/// Build Lods from retrieved data.
/// </summary>
public void BuildLods(FrameGeometry frameGeometry, FrameMaterial frameMaterial, VertexBuffer[] vertexBuffers, IndexBuffer[] indexBuffers)
{
lods = new Lod[frameGeometry.NumLods];
for (int i = 0; i != lods.Length; i++)
{
FrameLOD frameLod = frameGeometry.LOD[i];
lods[i] = new Lod
{
VertexDeclaration = frameGeometry.LOD[i].VertexDeclaration
};
IndexBuffer indexBuffer = indexBuffers[i];
VertexBuffer vertexBuffer = vertexBuffers[i];
int vertexSize;
Dictionary <VertexFlags, FrameLOD.VertexOffset> vertexOffsets = frameLod.GetVertexOffsets(out vertexSize);
lods[i].Vertices = new Vertex[frameLod.NumVerts];
if (vertexSize * frameLod.NumVerts != vertexBuffer.Data.Length)
{
throw new System.Exception();
}
for (int v = 0; v != lods[i].Vertices.Length; v++)
{
//declare data required and send to decompresser
byte[] data = new byte[vertexSize];
Array.Copy(vertexBuffers[i].Data, (v * vertexSize), data, 0, vertexSize);
lods[i].Vertices[v] = VertexTranslator.DecompressVertex(data, frameGeometry.LOD[i].VertexDeclaration, frameGeometry.DecompressionOffset, frameGeometry.DecompressionFactor, vertexOffsets);
}
lods[i].Indices = indexBuffer.GetData();
MaterialStruct[] materials = frameMaterial.Materials[i];
lods[i].Parts = new ModelPart[materials.Length];
for (int x = 0; x != materials.Length; x++)
{
if (string.IsNullOrEmpty(materials[x].MaterialName))
{
var material = MaterialsManager.LookupMaterialByHash(materials[x].MaterialHash);
materials[x].MaterialName = material.GetMaterialName();
}
ModelPart modelPart = new ModelPart();
modelPart.Material = materials[x].MaterialName;
modelPart.StartIndex = (uint)materials[x].StartIndex;
modelPart.NumFaces = (uint)materials[x].NumFaces;
lods[i].Parts[x] = modelPart;
}
}
}
public void CreateMaterialTest()
{
Material material = new Material();
material.CreatedOn = DateTime.Now;
material.Measurement = Measurement.SquareFeet;
material.ModifiedOn = DateTime.Now;
material.Name = "Wood Siding";
material.SubName = "Light Blue";
using (var mm = new MaterialsManager())
{
material = mm.CreateMaterial(material);
Assert.IsTrue(material.ID > 0);
}
}
public void DeliverMinerals(ref int amount)
{
MaterialsManager mM = MaterialsManager.Instance;
int deliver = amount;
if (mM.actualMinerals < mM.maxMinerals)
{
if (mM.actualMinerals + amount > mM.maxMinerals)
{
deliver = mM.maxMinerals - mM.actualMinerals;
}
amount -= deliver;
mM.actualMinerals += deliver;
}
}
public ActionResult Edit2(int id)
{
Quote quote;
List <QuoteOption> options;
using (var qm = new QuoteManager())
{
quote = qm.Single(id);
options = qm.QuoteOptions(id).ToList();
ViewBag.Quote = quote;
}
// determine the supplier and materials available
List <CompanyToSupplier> companySuppliers;
using (var sm = new SupplierManager())
{
companySuppliers = sm.ByCompanyID(quote.CompanyID.GetValueOrDefault()).ToList();
}
List <Product> products;
using (var mm = new MaterialsManager())
{
List <Material> allMaterials = new List <Material>();
foreach (var companyToSupplier in companySuppliers)
{
allMaterials.AddRange(mm.BySupplier(companyToSupplier.SupplierID));
}
ViewBag.AvailableMaterials = allMaterials;
products = mm.ActiveProducts(quote.CompanyID.GetValueOrDefault()).ToList();
var productLines = mm.ActiveProductLines().ToList();
ViewBag.PartsOfHouse = productLines.AsEnumerable();
ViewBag.ProductToProductLine = mm.AllProductToProductLine().ToList();
ViewBag.MaterialToProducts = mm.AllMaterialToProducts().ToList();
}
ViewBag.Products = products;
return(View("Edit"));
}
public void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
numFaces = reader.ReadInt32(isBigEndian);
startIndex = reader.ReadInt32(isBigEndian);
materialHash = reader.ReadUInt64(isBigEndian);
unk3 = reader.ReadInt32(isBigEndian);
IMaterial mat = MaterialsManager.LookupMaterialByHash(materialHash);
if (mat != null)
{
materialName = mat.GetMaterialName();
}
else
{
materialName = "UNABLE TO GET FROM MTLs";
}
}
public ActionResult MaterialProductsGrid(int?supplierID)
{
using (var um = new UserManager())
{
var currentUser = um.ByUsername(User.Identity.Name);
if (currentUser.SupplierID != null)
{
supplierID = currentUser.SupplierID.GetValueOrDefault();
}
}
var model = new MaterialProductGridModel();
var materialToProductModels = new List <MaterialToProductModel>();
using (var mm = new MaterialsManager())
{
var products = mm.ActiveProducts().ToList();
var materials = mm.BySupplier(supplierID.GetValueOrDefault()).ToList();
var materialToProducts = mm.ByManufacturerID(supplierID.GetValueOrDefault()).ToList();
model.Products = products.AsEnumerable();
model.Materials = materials.AsEnumerable();
// create the list based on our product and material list
foreach (var material in materials)
{
foreach (var product in products)
{
materialToProductModels.Add(new MaterialToProductModel
{
IsActive = materialToProducts.Any(mp => mp.ProductID == product.ID && mp.MaterialID == material.ID),
ProductID = product.ID,
MaterialID = material.ID,
ProductName = product.Name,
MaterialName = material.Name,
MaterialToProductID = materialToProducts.Any(mp => mp.ProductID == product.ID && mp.MaterialID == material.ID) ? materialToProducts.First(mp => mp.ProductID == product.ID && mp.MaterialID == material.ID).ID : 0
});
}
}
model.MaterialProducts = materialToProductModels.AsEnumerable();
}
return(View("MaterialProductsGrid", model));
}
public void InstantiateMaterial(MaterialsManager m)
{
if (m.numbOfMaterials > 0)
{
m.numbOfMaterials--;
if (m.name == "Glass")
{
Instantiate(glassPrefab);
}
else if (m.name == "Wood")
{
Instantiate(woodPrefab);
}
else if (m.name == "Iron")
{
Instantiate(ironPrefab);
}
}
}
private void Awake()
{
int gameManagerCount = FindObjectsOfType <MaterialsManager>().Length;
if (gameManagerCount > 1)
{
Destroy(gameObject);
}
else
{
DontDestroyOnLoad(gameObject);
}
if (instance != null)
{
Debug.LogError("More than one Materials Manager");
}
instance = this;
}
public ActionResult Products(ProductHouseModel model)
{
List <ProductToLine> parts = new List <ProductToLine>();
// loop through to create a list and then save
foreach (var part in model.ProductPartHouse.Where(m => m.IsActive))
{
parts.Add(new ProductToLine {
IsActive = true, ProductLineID = part.ProductLineID, ProductID = part.ProductID
});
}
// first delete all of the existing ones
using (var mm = new MaterialsManager())
{
mm.DeleteProductToProductLine();
mm.CreateProductToProductLine(parts);
}
return(RedirectToAction("Index", "Home"));
}
public List <string> CollectAllTextureNames()
{
List <string> TextureNames = new List <string>();
for (int i = 0; i != materials.Count; i++)
{
for (int d = 0; d != materials[i].Length; d++)
{
IMaterial FoundMaterial = MaterialsManager.LookupMaterialByHash(materials[i][d].MaterialHash);
if (FoundMaterial != null)
{
List <string> CollectedFromMaterial = FoundMaterial.CollectTextures();
if (CollectedFromMaterial != null)
{
TextureNames.AddRange(CollectedFromMaterial);
}
}
}
}
return(TextureNames);
}
