public async Task <IModel> LoadModel(IFile file)
{
return(await Task.Factory.StartNew(() =>
{
var mdl = MdlFile.FromFile(file);
mdl.WriteFakePrecalculatedChromeCoordinates();
return new MdlModel(mdl);
}));
}
public Solver(string targetFile, string sourceFile)
{
var targetData = (targetFile != null ? MdlFile.LoadModel(targetFile) : ((byte, BitArray)?)null);
// load source
var sourceData = (sourceFile != null ? MdlFile.LoadModel(sourceFile) : ((byte, BitArray)?)null);
// create system
MatterSystem = new MatterSystem(targetData?.Item1 ?? sourceData?.Item1 ?? 0, targetData?.Item2, sourceData?.Item2);
}
/// <summary>
/// Creates a new Model instance using the provided MdlFile, level of detail,
/// and variant ID, without resolving any game data.
/// </summary>
/// <param name="mdlFile">The MdlFile to back this Model.</param>
/// <param name="lod">The quality of the loaded Model.</param>
/// <param name="variantId">The variant ID of the Model to load. This will be used
/// to specify a Material variant, and may be used by the caller to limit attributes
/// depending on data from an ImcFile.</param>
/// <exception cref="ArgumentException">The specified MdlFile does not contain
/// the specified ModelLod.</exception>
public Model(MdlFile mdlFile, ModelLod lod = ModelLod.High, int variantId = 1)
{
if ((uint)lod > mdlFile.FileHeader.LodCount)
{
throw new ArgumentException("The given model does not have the requested LoD.", nameof(lod));
}
File = mdlFile;
Lod = lod;
VariantId = variantId;
BuildModel();
}
public MdlFile LoadMdl(string filename)
{
MdlFile loaded;
if (_sLoadedMdls.TryGetValue(filename, out loaded))
{
return(loaded);
}
loaded = new MdlFile(this, filename);
_sLoadedMdls.Add(filename, loaded);
return(loaded);
}
private void LoadModels(BspFile bsp, Environment env)
{
var loadedModels = new Dictionary <string, MdlFile>(StringComparer.InvariantCultureIgnoreCase);
foreach (var ent in bsp.Entities.Where(x => EntityModelMap.ContainsKey(x.ClassName)))
{
var model = EntityModelMap[ent.ClassName];
if (model == "")
{
// Use model from the entity
if (!ent.KeyValues.ContainsKey("model"))
{
continue;
}
model = ent.KeyValues["model"];
}
if (ent.KeyValues.ContainsKey("targetname"))
{
var targetters = bsp.Entities.Where(x => x.KeyValues.ContainsKey("target") && x.KeyValues["target"] == ent.KeyValues["targetname"]).ToList();
}
var file = env.GetFile(model);
if (file != null)
{
file = file.Replace('/', '\\'); // normalise path
try
{
MdlFile mdl;
if (loadedModels.ContainsKey(file))
{
mdl = loadedModels[file];
}
else
{
mdl = MdlFile.FromFile(file);
loadedModels[file] = mdl;
}
_scene.AddRenderable(new MdlRenderable(mdl, ent.GetVector3("origin", Vector3.Zero)));
}
catch
{
continue;
}
}
}
}
public MdlRenderable(MdlFile mdl, Vector3 origin)
{
_mdl = mdl;
_origin = origin;
_transforms = new Matrix4x4[128];
for (var i = 0; i < _transforms.Length; i++)
{
_transforms[i] = Matrix4x4.Identity;
}
_currentFrame = 0;
_interframePercent = 0;
RenderSettings = new ModelRenderSettings(mdl);
}
public ModelRenderSettings(MdlFile mdl)
{
RenderFlags = ModelRenderFlags.Model;
Skin = 0;
Sequence = 0;
_bodyParts = new Dictionary <int, int>();
for (var i = 0; i < mdl.BodyParts.Count; i++)
{
_bodyParts[i] = 0;
}
_controllerValues = new Dictionary <int, float>();
for (var i = 0; i < mdl.BoneControllers.Count; i++)
{
_controllerValues[i] = mdl.BoneControllers[i].Rest;
}
}
public void Test()
{
var solver = new Deconstructor((byte)50);
for (int x = 1; x < 50; x++)
{
for (int y = 0; y < 10; y++)
{
for (int z = 1; z < 50; z++)
{
solver.MatterSystem.Matrix.Get(x, y, z).Filled = true;
}
}
}
MdlFile.SaveModel(@"c:\users\tstivers\source\repos\icfp2018\problems\test\dst.mdl", solver.MatterSystem.Matrix);
solver.Solve(@"c:\users\tstivers\source\repos\icfp2018\problems\test\dst.nbt");
}
public void Open(Environment environment, string path)
{
var options = new GraphicsDeviceOptions()
{
HasMainSwapchain = false,
ResourceBindingModel = ResourceBindingModel.Improved,
SwapchainDepthFormat = PixelFormat.R32_Float,
};
//_graphicsDevice = GraphicsDevice.CreateVulkan(options);
_graphicsDevice = GraphicsDevice.CreateD3D11(options);
_view = new VeldridControl(_graphicsDevice, options)
{
Dock = DockStyle.Fill,
};
_panel.Controls.Add(_view);
_panel.Controls.Add(_settingsPanel);
_camera = new RotationCamera(_view.Width, _view.Height);
_view.Camera = _camera;
_sc = new SceneContext(_graphicsDevice);
_sc.AddRenderTarget(_view);
_scene = new Scene();
_mdl = MdlFile.FromFile(path);
var(min, max) = GetBbox(_mdl, 0);
_camera.SetBoundingBox(min, max);
_renderable = new MdlRenderable(_mdl, Vector3.Zero);
_scene.AddRenderable(_renderable);
_sc.Scene = _scene;
_sc.Start();
_settingsPanel.SetModel(_mdl);
_settingsPanel.BodyPartModelSelected += BodyPartSelected;
_settingsPanel.SequenceSelected += SequenceSelected;
}
public bool CanLoadModel(IFile file)
{
return(file.Exists && MdlFile.CanRead(file));
}
protected override Mesh OnGetMesh(MdlFile mdl, int lod)
{
return(mdl.GetMesh(lod, VertexLighting));
}
protected virtual Mesh OnGetMesh(MdlFile mdl, int lod)
{
return(mdl.GetMesh(lod, null));
}
public void MatrixTest()
{
var target = MdlFile.LoadModel(@"problems/full/FA110_tgt.mdl");
}
public MdlModel(MdlFile model)
{
Model = model;
_guid = Guid.NewGuid();
}
static void Main(string[] args)
{
var file = @"F:\Steam\SteamApps\common\Half-Life\valve\models\hgrunt.mdl";
var mdl = MdlFile.FromFile(file);
}
