public void T06_OBJParserIgnoring()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\Gibberish.obj");
Assert.AreEqual(5, loader.GetLinesIgnored());
}
private void btnAddNewMaterial_Click(object sender, EventArgs e)
{
string accessoryPath;
string sampleImagePath;
using (var ofd = new OpenFileDialogEx("Select new accessory..", "OBJ files|*.obj"))
{
ofd.Multiselect = false;
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
accessoryPath = ofd.FileName;
}
using (var ofd = new OpenFileDialogEx("Select accessory image..", "Image files|*.jpg"))
{
ofd.Multiselect = false;
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
sampleImagePath = ofd.FileName;
}
var directoryPath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), "Libraries", "Accessory");
var oldFileName = Path.GetFileNameWithoutExtension(accessoryPath);
var newFileName = oldFileName;
var filePath = Path.Combine(directoryPath, newFileName + ".obj");
var index = 0;
while (File.Exists(filePath))
{
newFileName = oldFileName + string.Format("_{0}", index);
filePath = Path.Combine(directoryPath, newFileName + ".obj");
++index;
}
File.Copy(accessoryPath, filePath, false);
var mtl = oldFileName + ".mtl";
var newMtlName = newFileName + ".mtl";
ObjLoader.CopyMtl(mtl, newMtlName, Path.GetDirectoryName(accessoryPath), "", directoryPath, ProgramCore.Project.TextureSize);
if (mtl != newMtlName) // situation, when copy attribute and can change mtl filename. so, we need to rename link to this mtl in main obj file
{
string lines;
using (var sd = new StreamReader(filePath, Encoding.Default))
{
lines = sd.ReadToEnd();
lines = lines.Replace(mtl, newMtlName);
}
using (var sw = new StreamWriter(filePath, false, Encoding.Default))
sw.Write(lines);
}
var samplePath = Path.Combine(directoryPath, newFileName + ".jpg");
File.Copy(sampleImagePath, samplePath, false);
InitializeListView();
}
public Scene1()
{
loader = new ObjLoader();
//Scene.AddModel(CreateSurface());
//Scene.AddModel(CreateSphere());
//Scene.FogDestiny = (dist) =>
//{
// Scene.FogParameters = 1e-4f;
// return 1 - (float)Math.Exp(-Scene.FogParameters * dist);
//};
//SceneFaceHandlerParams loadParams = new SceneFaceHandlerParams(Scene,
// // scale:
// 80f,
// // move dx, dy, dz:
// 0, 50, 0,
// // rotate around axises x, y, z:
// 0, 0, (float)Math.PI / 4f + 0.01f,
// // color
// new Color(255, 255, 255),
// // surface params
// new Material(5, 10, 5, 7, 0, 10)
//);
//loader.LoadObj("./models/figure1.obj", loader.SceneFaceHandler, loadParams);
//Scene.AddLightSource(new LightSource3d(new Point3d(300, -300, 300), new Color(255, 255, 255)));
}
static void Main(string[] args)
{
Window window = new Window(1024, 576, "castle");
window.EnableDepthTest();
Mesh3[] meshes = ObjLoader.Load("Assets/Castle.obj", Vector3.One * 5);
PerspectiveCamera camera = new PerspectiveCamera(new Vector3(0, 250, 750), new Vector3(10, 180, 0), 60, 0.1f, 1000);
Console.WriteLine(meshes.Length);
DirectionalLight sun = new DirectionalLight(new Vector3(-0.5f, 0, -1).Normalized());
float rot = 0;
while (window.IsOpened)
{
rot += 10 * window.deltaTime;
foreach (Mesh3 mesh in meshes)
{
mesh.EulerRotation3 = new Vector3(0, rot, 0);
//mesh.DrawWireframe(new Vector4(1, 0, 0, 1));
mesh.DrawPhong(new Vector4(1, 0, 0, 1), sun, new Vector3(0.1f, 0.1f, 0.1f));
}
window.Update();
}
}
private void GetObjFace(ObjFace face, ObjItem objModel,
ref List <float> vertexPositions, ref List <float> vertexNormals, ref List <float> vertexTextureCoordinates, ref List <float> vertexBoneWeights, ref List <float> vertexBoneIndices, ref List <uint> indeces)
{
if (face.Count == 3)
{
for (var i = 0; i < face.Count; i++)
{
var faceVertex = face[i];
ObjLoader.AppendObjTriangle(objModel, faceVertex, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
}
SetFaceTriangleIndex(face, objModel);
}
else if (face.Count == 4)
{
var faceVertex0 = face[0];
var faceVertex1 = face[1];
var faceVertex2 = face[2];
var faceVertex3 = face[3];
ObjLoader.AppendObjTriangle(objModel, faceVertex0, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
ObjLoader.AppendObjTriangle(objModel, faceVertex1, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
ObjLoader.AppendObjTriangle(objModel, faceVertex2, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
ObjLoader.AppendObjTriangle(objModel, faceVertex2, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
ObjLoader.AppendObjTriangle(objModel, faceVertex3, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
ObjLoader.AppendObjTriangle(objModel, faceVertex0, ref vertexPositions, ref vertexNormals, ref vertexTextureCoordinates, ref vertexBoneWeights, ref vertexBoneIndices, ref indeces);
SetFaceTriangleIndex(face, objModel);
}
}
public override void create()
{
Gdx.app.log("Game", "Create");
_batch = new ModelBatch();
_camera = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
_camera.position = new Vector3(10f, 10f, 100f);
_camera.lookAt(0f, 0f, 0f);
_camera.near = 1;
_camera.far = 300;
_camera.update();
var loader = new ObjLoader();
var data = loader.loadModelData("brown_wall.obj");
_model = new Model(data);
for (int i = -10; i < 10; i++)
{
var modelInstance = new ModelInstance(_model, Matrix4.Identity, null);
_modelInstances.Add(modelInstance);
}
Gdx.app.debug("TestModel", $"V: {Gdx.graphics.getWidth()}:{Gdx.graphics.getHeight()} Models: {_modelInstances.Count}");
}
public void T10_OBJToGroup()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\Groups.obj");
Assert.AreEqual(2, loader.root.GetChildren().Count);
}
public WavefrontObjFiles(ResourceManager resource_manager, ObjLoader obj_loader = null)
: base(resource_manager)
{
ObjLoader = null == obj_loader
? new ObjLoader()
: obj_loader;
}
/// <summary>
/// Update method performs actions each frame.
/// </summary>
void Update()
{
if (buildMinimap)
{
buildMinimap = false;
yUp = true;
foreach (Transform child in mapObject.transform)
{
Transform miniChild = Instantiate(child, miniMapObject.transform);
miniChild.gameObject.AddComponent <BoxCollider>();
}
}
if (manipulationModeCountdown >= 1)
{
manipulationModeCountdown--;
if (manipulationModeCountdown == 0)
{
enterManipulate();
}
}
if (save)
{
save = false;
ObjSaver.Save(SpatialMappingManager.Instance.GetMeshFilters(), saveStream);
spatialMappingObject.SetActive(SpatialMappingActive);
txt.text = "Spatial mapping saved to " + saveFileDisplayName;
}
if (load)
{
load = false;
miniMapObject.transform.localScale = initialMiniMapScale;
// empty map and mini map
foreach (Transform child in mapObject.transform)
{
Destroy(child.gameObject);
}
foreach (Transform child in miniMapObject.transform)
{
Destroy(child.gameObject);
}
Material material = Resources.Load("defaultMat", typeof(Material)) as Material;
ObjLoader.LoadOBJFile(loadFileDisplayName, material, loadStream, mapObject);
buildMinimap = true;
leaveManipulate();
enterModelOverlay();
rdd.enabled = false;
txt.text = "Mesh \"" + loadFileDisplayName + "\" loaded.";
}
}
public void T17_VertexNormalOBJ()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\VertexNormal.obj");
Assert.AreEqual(new Vector(0, 0, 1), loader.n[0]);
Assert.AreEqual(new Vector(0.707, 0, -0.707), loader.n[1]);
Assert.AreEqual(new Vector(1, 2, 3), loader.n[2]);
}
public Dictionary <Guid, PartMorphInfo> LoadPartsMorphInfo(string path, RenderMesh renderMesh)
{
var vertexPositions = new List <float>();
List <float> tmp = null;
List <uint> uitmp = null;
var vertices = new List <Vector3>();
var objModel = ObjLoader.LoadObjFile(path);
if (objModel == null)
{
ProgramCore.EchoToLog(string.Format("Can't load obj model '{0}'", path), EchoMessageType.Error);
return(null);
}
var a = new Vector3(99999.0f, 99999.0f, 99999.0f);
var b = new Vector3(-99999.0f, -99999.0f, -99999.0f);
var result = new Dictionary <Guid, PartMorphInfo>();
foreach (var modelGroup in objModel.Groups) // one group - one mesh
{
vertexPositions.Clear();
foreach (var face in modelGroup.Value.Faces) // combine all meshes in group - to one mesh.
{
GetObjFace(face, objModel, ref vertexPositions, ref tmp, ref tmp,
ref tmp, ref tmp, ref uitmp);
}
vertices.Clear();
for (int i = 0; i < vertexPositions.Count; i += 3)
{
vertices.Add(new Vector3(vertexPositions[i], vertexPositions[i + 1], vertexPositions[i + 2]));
}
PartMorphInfo morphInfo = null;
float scale = ProgramCore.PluginMode &&
ProgramCore.MainForm.ctrlRenderControl.pickingController.ObjExport != null
? ProgramCore.MainForm.ctrlRenderControl.pickingController.ObjExport.Scale
: 1.0f;
var part =
renderMesh.Parts.FirstOrDefault(
p =>
(p.Name.ToLower().Contains(modelGroup.Value.Name.ToLower()) || modelGroup.Value.Name.ToLower().Contains(p.Name.ToLower())) &&
PartMorphInfo.CreatePartMorphInfo(vertices, p, scale, out morphInfo));
if (part != null)
{
result.Add(part.Guid, morphInfo);
GetAABB(ref a, ref b, vertices);
}
}
foreach (var r in result)
{
MoveToPosition(ref r.Value.PointsMorph, a, b, Vector3.Zero);
}
return(result);
}
public Program()
{
WriteSystemInformation();
Window = new GameWindow(1600, 900, new OpenTK.Graphics.GraphicsMode(32, 24, 0, 8), "Rubix Cube", GameWindowFlags.Default);
Window.VSync = VSyncMode.Off;
Window.Resize += Window_Resize;
Window.TargetRenderFrequency = 60;
Window.TargetUpdateFrequency = 60;
Window.UpdateFrame += Window_UpdateFrame;
Window.RenderFrame += Window_RenderFrame;
Window.MouseDown += Window_MouseDown;
Window.MouseUp += Window_MouseUp;
Window.MouseMove += Window_MouseMove;
Window.MouseWheel += Window_MouseWheel;
Window.KeyDown += Window_KeyDown;
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.Texture2D);
ObjLoader loader = new ObjLoader();
var vao = loader.loadVBOS("Content/cube-part.obj", 3);
Matrix4 proj = Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(80), 108f / 72, .1f, 100);
shader = new ShaderProgram("Shaders/shader.vert", "Shaders/shader.frag", "default");
shader.Use();
shader.setUniform("proj", proj);
pickShader = new ShaderProgram("Shaders/pick.vert", "Shaders/pick.frag", "pick");
pickShader.Use();
pickShader.setUniform("proj", proj);
Texture txt = new Texture("Content/txt.bmp");
addCubes(vao, txt, shader);
camera = new Camera(10);
camera.Projection = proj;
camera.setDepth(0, 20);
cubeState = new CubeState();
Texture cubeTexture = new Texture();
cubeTexture.loadAsCubeMap("Content/Cubemap/");
skybox = new SkyBox(cubeTexture.Id);
animationManager = new AnimationManager(60, AnimaitonDuration, CubeDistance, parts, cubeState);
animationManager.AnimationSequenceFinished += animationManager_AnimationSequenceFinished;
animationManager.AnimationFinished += AnimationManager_AnimationFinished;
Window.Run(60);
}
public static void Teapot(Camera camera, Scene scene)
{
AddSkybox(scene);
AddFloor(scene);
AddLight(scene);
var path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "..\\..\\Meshes\\teapot.obj");
var teapot = ObjLoader.Load(path, Vector3.Zero, Material.Metal);
scene.Add(teapot);
}
public void T07_OBJParserVertices()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\Vertices.obj");
Assert.AreEqual(new Point(-1, 1, 0), loader.v[0]);
Assert.AreEqual(new Point(-1, 0.5, 0), loader.v[1]);
Assert.AreEqual(new Point(1, 0, 0), loader.v[2]);
Assert.AreEqual(new Point(1, 1, 0), loader.v[3]);
}
public Bullet()
{
obj = true;
movement = new Movement();
texture = new Texture("Recursos/negro2.jpg");
objLoader = new ObjLoader("Recursos/Bowling.obj");
BulletPart bulletPart = new BulletPart();
init();
addPart("bulletPart", bulletPart);
}
static void Main(string[] args)
{
//Object scale
float size = 4f;
#region InstanceWindow
//Instance new window
Window window = new Window(1024, 768, "Test", false, 16, 4);
#endregion
#region DecompressTexture
/*
* Decompress Texture from single file
* This method has to be called only once,
* because it could slows down the game,
* do decompression in single project which is not
* a part of your own working project.
*/
TextureHelper.GenerateDecompressedTextureFromFile("Assets/drum1_ambient.png", "NewAssets");
//Decompress Textures from list of files (Has to be called only once)
//bool bRecursive = false;
//string sExtension = "tex";
//TextureHelper.GenerateDecompressedTexturesFromFolder("Assets", "NewAssets", bRecursive, sExtension);
#endregion
#region LoadDecompressedTexture
//Return decompressed texture and save it.
Texture loadedTexture = TextureHelper.LoadDecompressedTexture("GasFuel.txt");
#endregion
#region LoadOBJModel
//Create a Mesh3[] to load custo ".obj"'s model
Mesh3 mesh = ObjLoader.Load("Assets/GasFuel.obj", Vector3.One * size)[0];
#endregion
#region GameLoop
while (window.opened)
{
//draw the mesh
mesh.DrawTexture(loadedTexture);
//Break while loop
if (window.GetKey(KeyCode.Esc))
{
break;
}
window.Update();
}
#endregion
}
public Tank(float x, float z)
{
obj = true;
this.x = x;
this.z = z;
movement = new Movement();
objLoader = new ObjLoader("Recursos/T-34.obj");
tankPart = new TankPart();
tankPart.key = "tankPart";
init();
addPart(tankPart);
}
public static IModelLoader GetModelLoader(string modelPath)
{
IModelLoader modelLoader = null;
var extension = Path.GetExtension(modelPath);
switch (extension)
{
case ".obj": modelLoader = new ObjLoader();
break;
}
return(modelLoader);
}
private void LoadAndPlaceModel(string url, Vector3 pos)
{
GameObject parent = new GameObject("Model Anchor");
GameObject model = new GameObject("Model");
model.transform.SetParent(parent.transform);
parent.transform.position = pos;
ObjLoader objLoader = model.AddComponent <ObjLoader>();
model.transform.Rotate(-90, 0, 0);
model.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
objLoader.Load(url);
}
void Start()
{
Instance = this;
objLoader = FindObjectOfType <ObjLoader>();
faceVisualizer = FindObjectOfType <FaceVisualizer>();
previewArea = GameObject.Find("Preview Area");
distortionArea = GameObject.Find("Distortion Area");
projectionFace = GameObject.Find("Projection Face");
faceLabel = GameObject.Find("Face Label").GetComponent <TextMesh>();
projectionCamera = GameObject.Find("Projection Camera").GetComponent <Camera>();
syncUIFromState();
}
public VAO LoadVao(string name)
{
if (_shaders.ContainsKey(name))
{
return(_meshes[name]);
}
else
{
var mesh = ObjLoader.LoadAsVAO(ContentDirectory + MeshFolder + name + ".obj");
_meshes.Add(name, mesh);
return(mesh);
}
}
//private void UpdateFaceRect()
//{
// var indicies = ProgramCore.Project.RenderMainHelper.headController.GetFaceIndexes();
// List<MirroredHeadPoint> faceDots;
// switch (ProgramCore.MainForm.ctrlRenderControl.Mode)
// {
// // case Mode.HeadShapedots:
// case Mode.HeadLine:
// case Mode.HeadShapeFirstTime:
// case Mode.HeadShape:
// faceDots = ProgramCore.Project.RenderMainHelper.headController.GetSpecialShapedots(indicies);
// break;
// default:
// faceDots = ProgramCore.Project.RenderMainHelper.headController.GetSpecialAutodots(indicies);
// break;
// }
// if (faceDots.Count == 0)
// return;
// {
// var minX1 = faceDots.Min(point => point.ValueMirrored.X);
// var maxX1 = faceDots.Max(point => point.ValueMirrored.X);
// var minY1 = faceDots.Min(point => point.ValueMirrored.Y);
// var maxY1 = faceDots.Max(point => point.ValueMirrored.Y);
// var rrr = new RectangleF((float)minX1, (float)minY1, (float)(maxX1 - minX1), (float)(maxY1 - minY1));
// }
// var minX = faceDots.Min(point => point.ValueMirrored.X) * ImageTemplateWidth + ImageTemplateOffsetX;
// var maxX = faceDots.Max(point => point.ValueMirrored.X) * ImageTemplateWidth + ImageTemplateOffsetX;
// var minY = faceDots.Min(point => point.ValueMirrored.Y) * ImageTemplateHeight + ImageTemplateOffsetY;
// var maxY = faceDots.Max(point => point.ValueMirrored.Y) * ImageTemplateHeight + ImageTemplateOffsetY;
// FaceRectTransformed = new Rectangle((int)minX, (int)minY, (int)(maxX - minX), (int)(maxY - minY));
// CentralFacePoint = new Vector2(minX + (maxX - minX) * 0.5f, minY + (maxY - minY) / 3f);
//}
//private void RecalcUserCenters()
//{
// MouthTransformed = new Vector2(ProgramCore.Project.MouthUserCenter.X * ImageTemplateWidth + ImageTemplateOffsetX,
// ProgramCore.Project.MouthUserCenter.Y * ImageTemplateHeight + ImageTemplateOffsetY);
// LeftEyeTransformed = new Vector2(ProgramCore.Project.LeftEyeUserCenter.X * ImageTemplateWidth + ImageTemplateOffsetX,
// ProgramCore.Project.LeftEyeUserCenter.Y * ImageTemplateHeight + ImageTemplateOffsetY);
// RightEyeTransformed = new Vector2(ProgramCore.Project.RightEyeUserCenter.X * ImageTemplateWidth + ImageTemplateOffsetX,
// ProgramCore.Project.RightEyeUserCenter.Y * ImageTemplateHeight + ImageTemplateOffsetY);
// NoseTransformed = new Vector2(ProgramCore.Project.NoseUserCenter.X * ImageTemplateWidth + ImageTemplateOffsetX,
// ProgramCore.Project.NoseUserCenter.Y * ImageTemplateHeight + ImageTemplateOffsetY);
//}
public void AttachHair(string hairObjPath, string materialPath, ManType manType)
{
var objModel = ObjLoader.LoadObjFile(hairObjPath, false);
if (objModel == null)
{
return;
}
var temp = 0;
var meshes = PickingController.LoadHairMeshes(objModel, null, true, manType, MeshType.Hair, ref temp);
foreach (var mesh in meshes)
{
if (mesh == null || mesh.vertexArray.Length == 0) //ТУТ!
{
continue;
}
mesh.Material.DiffuseTextureMap = materialPath;
}
var objName = Path.GetFileNameWithoutExtension(hairObjPath);
if (HairPositions.ContainsKey(objName))
{
var meshSize = HairPositions[objName].Item2;
var s = HairPositions[objName].Item1 * ProgramCore.Project.RenderMainHelper.headMeshesController.RenderMesh.MorphScale; // домножаем на 8 для веб версии. все на 8 домножаем! любим 8!
for (var i = 0; i < meshes.Count; i++)
{
var mesh = meshes[i];
if (mesh == null || mesh.vertexArray.Length == 0) //ТУТ!
{
continue;
}
mesh.Position += new Vector3(s[0], s[1], s[2]);
mesh.Transform[3, 0] += s[0];
mesh.Transform[3, 1] += s[1];
mesh.Transform[3, 2] += s[2];
if (!float.IsNaN(meshSize))
{
mesh.InterpolateMesh(meshSize);
}
}
}
ProgramCore.Project.RenderMainHelper.pickingController.HairMeshes.Clear();
ProgramCore.Project.RenderMainHelper.pickingController.HairMeshes.AddRange(meshes);
}
public void T08_OBJParserFaces()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\TriangleFaces.obj");
Assert.AreEqual(loader.v[0], loader.t[0].GetP1());
Assert.AreEqual(loader.v[1], loader.t[0].GetP2());
Assert.AreEqual(loader.v[2], loader.t[0].GetP3());
Assert.AreEqual(loader.v[0], loader.t[1].GetP1());
Assert.AreEqual(loader.v[2], loader.t[1].GetP2());
Assert.AreEqual(loader.v[3], loader.t[1].GetP3());
}
public void AttachAccessory(string accessoryObjPath, string accessoryMaterialPath, ManType manType)
{
var objModel = ObjLoader.LoadObjFile(accessoryObjPath, false);
if (objModel == null)
{
return;
}
var mesh = PickingController.LoadAccessoryMesh(objModel);
if (string.IsNullOrEmpty(accessoryMaterialPath))
{
mesh.Material.DiffuseColor = new Vector4(0.5f, 0.4f, 0.3f, 1);
}
else
{
mesh.Material.DiffuseTextureMap = accessoryMaterialPath;
}
var objName = Path.GetFileNameWithoutExtension(accessoryObjPath);
if (AccessoryPositions.ContainsKey(objName))
{
var meshSize = AccessoryPositions[objName].Item2;
var s = AccessoryPositions[objName].Item1 * ProgramCore.Project.RenderMainHelper.headMeshesController.RenderMesh.MorphScale; // домножаем на 8 для веб версии. все на 8 домножаем! любим 8!
mesh.Position += new Vector3(s[0], s[1], s[2]);
mesh.Transform[3, 0] += s[0];
mesh.Transform[3, 1] += s[1];
mesh.Transform[3, 2] += s[2];
if (!float.IsNaN(meshSize))
{
mesh.Transform[3, 0] -= s[0]; // применяем изменение размера
mesh.Transform[3, 1] -= s[1];
mesh.Transform[3, 2] -= s[2];
mesh.Transform *= Matrix4.CreateScale(meshSize / mesh.MeshSize);
mesh.Transform[3, 0] += s[0];
mesh.Transform[3, 1] += s[1];
mesh.Transform[3, 2] += s[2];
mesh.IsChanged = true;
mesh.MeshSize = meshSize;
}
}
ProgramCore.Project.RenderMainHelper.pickingController.AccesoryMeshes.Add(mesh);
}
public Scene CreateScene()
{
loader = new ObjLoader();
Scene = new Scene(new Color(255, 255, 255));
Scene.AddModel(CreateSurface());
Scene.AddLightSource(new LightSource3d(new Point3d(300, -300, 300),
new Color(255, 255, 255)));
Scene.FogDestiny = (dist) =>
{
Scene.FogParameters = 1e-4f;
return(1 - (float)Math.Exp(-Scene.FogParameters * dist));
};
return(Scene);
}
public static Dictionary <string, Mesh> Load(string filename)
{
Debug.Assert(File.Exists(Paths.Meshes + filename), $"Missing mesh '{filename}'.");
if (filename.EndsWith(".obj"))
{
return(ObjLoader.Load(filename));
}
var mesh = DaeLoader.Load(filename);
return(new Dictionary <string, Mesh>
{
{ "", mesh }
});
}
public static RenderMesh LoadFromFile(string filePath)
{
var result = new RenderMesh();
var objData = ObjLoader.LoadObjFile(filePath);
var lastTriangle = 0;
var meshPartsInfo = LoadHeadMeshes(objData, 1.0f, ref lastTriangle);
Vector3 A = new Vector3(99999.0f, 99999.0f, 99999.0f);
Vector3 B = new Vector3(-99999.0f, -99999.0f, -99999.0f);
foreach (var meshPartInfo in meshPartsInfo)
{
foreach (var p in meshPartInfo.VertexPositions)
{
A.X = Math.Min(A.X, p.X);
A.Y = Math.Min(A.Y, p.Y);
A.Z = Math.Min(A.Z, p.Z);
B.X = Math.Max(B.X, p.X);
B.Y = Math.Max(B.Y, p.Y);
B.Z = Math.Max(B.Z, p.Z);
}
}
Vector3 Center = (A + B) * 0.5f;
foreach (var meshPartInfo in meshPartsInfo)
{
var meshPart = new MeshPart();
if (meshPart.Create(meshPartInfo, -Center))
{
result.UpdateAABB(meshPart);
result.Parts.Add(meshPart);
}
}
foreach (var part in result.Parts)
{
part.UpdateBuffers();
}
return(result);
}
public void T09_TriangulatingPolygons()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\PolygonData.obj");
Assert.AreEqual(loader.v[0], loader.t[0].GetP1());
Assert.AreEqual(loader.v[1], loader.t[0].GetP2());
Assert.AreEqual(loader.v[2], loader.t[0].GetP3());
Assert.AreEqual(loader.v[0], loader.t[1].GetP1());
Assert.AreEqual(loader.v[2], loader.t[1].GetP2());
Assert.AreEqual(loader.v[3], loader.t[1].GetP3());
Assert.AreEqual(loader.v[0], loader.t[2].GetP1());
Assert.AreEqual(loader.v[3], loader.t[2].GetP2());
Assert.AreEqual(loader.v[4], loader.t[2].GetP3());
}
public void T18_FacesWithNormalVectors()
{
ObjLoader loader = new ObjLoader();
loader.Load(@"ObjFiles\FacesVertexNormal.obj");
List <RayObject> g = loader.root.GetChildren();
Triangle t1 = ((Triangle)g[0]);
Triangle t2 = ((Triangle)g[1]);
Assert.AreEqual(new Vector(0, 1, 0), t1.n1);
Assert.AreEqual(new Vector(-1, 0, 0), t1.n2);
Assert.AreEqual(new Vector(1, 0, 0), t1.n3);
Assert.AreEqual(new Vector(0, 1, 0), t2.n1);
Assert.AreEqual(new Vector(-1, 0, 0), t2.n2);
Assert.AreEqual(new Vector(1, 0, 0), t2.n3);
}
public override bool ImportAsset(string path, string ext)
{
ModelGeometry[] MG = new ModelGeometry[1];
if (ext == "obj")
{
MG[0] = ObjLoader.Load(path);
}
else if (ext == "fbx")
{
MG = FbxLoader.Load(path);
if (MG.Length > 1)
{
subAssets = new MeshAsset[MG.Length - 1];
for (int i = 1; i < MG.Length; i++)
{
subAssets[i - 1] = new MeshAsset()
{
Name = this.Name + "_" + i,
FileScale = FileScale,
Pivot = Vector3.Zero,
Vertices = MG[i].Points,
Indexes = MG[i].Indexes,
BoundingMinimum = MG[i].BoundingMinimum,
BoundingMaximum = MG[i].BoundingMaximum,
};
}
}
}
else
{
Console.WriteLine("Unknown mesh extension: {0}", ext);
return(false);
}
Pivot = Vector3.Zero;
Vertices = MG[0].Points;
Indexes = MG[0].Indexes;
BoundingMinimum = MG[0].BoundingMinimum;
BoundingMaximum = MG[0].BoundingMaximum;
return(true);
}
