public LodLevel AddLodLevel(Object3dInfo info, GenericMaterial material, float distStart, float distEnd)
{
var i = new LodLevel(info, material, distStart, distEnd);
LodLevels.Add(i);
return(i);
}
public static Mesh3d Create(Object3dInfo objectInfo, GenericMaterial material)
{
var m = new Mesh3d();
m.AddLodLevel(objectInfo, material, 0, 99999);
m.AddInstance(new Mesh3dInstance(new TransformationManager(Vector3.Zero), ""));
return m;
}
public static Mesh3d Create(Object3dInfo objectInfo, GenericMaterial material)
{
var m = new Mesh3d();
m.AddLodLevel(objectInfo, material, 0, 99999);
m.AddInstance(new Mesh3dInstance(new TransformationManager(Vector3.Zero), ""));
return(m);
}
public LodLevel(Object3dInfo o3i, GenericMaterial gm, float distStart, float distEnd)
{
DistanceStart = distStart;
DistanceEnd = distEnd;
Info3d = o3i;
Material = gm;
ModelMatricesBuffer = new ShaderStorageBuffer();
RotationMatricesBuffer = new ShaderStorageBuffer();
Ids = new ShaderStorageBuffer();
}
public InstancedMesh3d(Object3dInfo objectInfo, GenericMaterial material)
{
ModelMatricesBuffer = new ShaderStorageBuffer();
RotationMatricesBuffer = new ShaderStorageBuffer();
Randomizer = new Random();
Transformations = new List<TransformationManager>();
Instances = 0;
ObjectInfo = objectInfo;
Material = material;
UpdateMatrix();
}
public Mesh3d(Object3dInfo objectInfo, GenericMaterial material)
{
// ModelMatricesBuffer = new ShaderStorageBuffer();
// RotationMatricesBuffer = new ShaderStorageBuffer();
DisableDepthWrite = false;
Instances = 1;
MainObjectInfo = objectInfo;
MainMaterial = material;
Transformation = new TransformationManager(Vector3.Zero, Quaternion.Identity, 1.0f);
UpdateMatrix();
MeshColoredID = new Vector3((float)Randomizer.NextDouble(), (float)Randomizer.NextDouble(), (float)Randomizer.NextDouble());
}
public void AddLodLevel(float distance, Object3dInfo info, GenericMaterial material)
{
if(LodLevels == null)
LodLevels = new List<LodLevelData>();
LodLevels.Add(new LodLevelData()
{
Info3d = info,
Material = material,
Distance = distance
});
LodLevels.Sort((a, b) => (int)((a.Distance - b.Distance) * 100.0)); // *100 to preserve precision
}
public static void CompressAndSave(Object3dInfo data, string outfile)
{
MemoryStream memstream = new MemoryStream();
memstream.Write(BitConverter.GetBytes(data.VBO.Count), 0, 4);
memstream.Write(BitConverter.GetBytes(data.Indices.Count), 0, 4);
foreach(float v in data.VBO)
memstream.Write(BitConverter.GetBytes(v), 0, 4);
foreach(uint v in data.Indices)
memstream.Write(BitConverter.GetBytes(v), 0, 4);
memstream.Flush();
if(File.Exists(outfile + ".o3i"))
File.Delete(outfile + ".o3i");
File.WriteAllBytes(outfile + ".o3i", memstream.ToArray());
}
public LodLevel(Object3dInfo o3i, GenericMaterial gm, float distStart, float distEnd)
{
DistanceStart = distStart;
DistanceEnd = distEnd;
Info3d = o3i;
if (Info3d != null)
{
BoundingBoxInfo3d = Generators.Object3dGenerator.CreateCube(o3i.BoundingBoxMin, o3i.BoundingBoxMax, Vector2.One).AsObject3dInfo();
}
else
{
BoundingBoxInfo3d = Object3dInfo.Empty;
}
Material = gm;
ModelInfosBuffer = new ShaderStorageBuffer();
}
public Renderer(int initialWidth, int initialHeight)
{
CubeMap = new CubeMapTexture(Media.Get("posx.jpg"), Media.Get("posy.jpg"), Media.Get("posz.jpg"),
Media.Get("negx.jpg"), Media.Get("negy.jpg"), Media.Get("negz.jpg"));
Width = initialWidth;
Height = initialHeight;
// initialWidth *= 4; initialHeight *= 4;
MRT = new MRTFramebuffer(initialWidth, initialHeight);
DistanceFramebuffer = new Framebuffer(initialWidth / 1, initialHeight / 1)
{
ColorOnly = false,
ColorInternalFormat = PixelInternalFormat.R32f,
ColorPixelFormat = PixelFormat.Red,
ColorPixelType = PixelType.Float
};
HDRShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "HDR.fragment.glsl");
PostProcessingMesh = new Object3dInfo(VertexInfo.FromFloatArray(postProcessingPlaneVertices));
}
/*
public Object3dInfo[] Knife(float xmult, float ymult)
{
var vbo1 = new List<float>();
var vbo2 = new List<float>();
var ind1 = new List<uint>();
var ind2 = new List<uint>();
List<Vector3> vectors = new List<Vector3>();
for(int i = 0; i < Indices.Count; i++)
{
int vboIndex = i * 8;1
vectors.Add(new Vector3(VBO[vboIndex] * scale, VBO[vboIndex + 1] * scale, VBO[vboIndex + 2] * scale));
}
return new Object3dInfo(VBO.ToArray(), Indices.ToArray());
}*/
public void Append(Object3dInfo info)
{
VBO.AddRange(info.VBO);
int startIndex = Indices.Count;
Indices.AddRange(info.Indices.Select(a => (uint)(a + startIndex)));
}
public static List<Mesh3d> LoadSceneFromObj(string objfile, string mtlfile, float scale = 1.0f)
{
string[] lines = File.ReadAllLines(objfile);
var objs = ParseOBJString(lines);
var mtllib = LoadMaterialsFromMtl(mtlfile);
List<Mesh3d> meshes = new List<Mesh3d>();
Dictionary<string, GenericMaterial> texCache = new Dictionary<string, GenericMaterial>();
Dictionary<Color, GenericMaterial> colorCache = new Dictionary<Color, GenericMaterial>();
Dictionary<GenericMaterial, MaterialInfo> mInfos = new Dictionary<GenericMaterial, MaterialInfo>();
Dictionary<GenericMaterial, List<Object3dInfo>> linkCache = new Dictionary<GenericMaterial, List<Object3dInfo>>();
var colorPink = new GenericMaterial(Color.Pink);
mInfos = new Dictionary<GenericMaterial, MaterialInfo>();
foreach(var obj in objs)
{
var mat = mtllib.ContainsKey(obj.MaterialName) ? mtllib[obj.MaterialName] : null;
GenericMaterial material = null;
if(mat != null && mat.TextureName.Length > 0)
{
if(texCache.ContainsKey(mat.TextureName + mat.AlphaMask))
{
material = texCache[mat.TextureName + mat.AlphaMask];
mInfos[material] = mat;
}
else
{
var m = GenericMaterial.FromMedia(Path.GetFileName(mat.TextureName));
m.NormalMapScale = 10;
material = m;
mInfos[material] = mat;
texCache.Add(mat.TextureName + mat.AlphaMask, material);
// material = colorPink;
}
//material = new GenericMaterial(Color.Pink);
}
else if(mat != null)
{
if(colorCache.ContainsKey(mat.DiffuseColor))
{
material = colorCache[mat.DiffuseColor];
mInfos[material] = mat;
}
else
{
material = new GenericMaterial(Color.White);
mInfos[material] = mat;
colorCache.Add(mat.DiffuseColor, material);
}
}
else
{
material = colorPink;
mInfos[material] = mat;
}
for(int i = 0; i < obj.VBO.Count; i += 8)
{
obj.VBO[i] *= scale;
obj.VBO[i + 1] *= scale;
obj.VBO[i + 2] *= scale;
}
var o3di = new Object3dInfo(obj.VBO, obj.Indices);
if(!linkCache.ContainsKey(material))
linkCache.Add(material, new List<Object3dInfo> { o3di });
else
linkCache[material].Add(o3di);
}
foreach(var kv in linkCache)
{
Object3dInfo o3di = kv.Value[0];
if(kv.Value.Count > 1)
{
foreach(var e in kv.Value.Skip(1))
o3di.Append(e);
}
var trans = o3di.GetAverageTranslationFromZero();
o3di.OriginToCenter();
//o3di.CorrectFacesByNormals();
// o3di.CorrectFacesByNormals();
Mesh3d mesh = new Mesh3d(o3di, kv.Key);
kv.Key.SpecularComponent = 1.0f - mInfos[kv.Key].SpecularStrength + 0.01f;
kv.Key.Roughness = (mInfos[kv.Key].SpecularStrength);
kv.Key.ReflectionStrength = 1.0f - (mInfos[kv.Key].SpecularStrength);
kv.Key.DiffuseComponent = mInfos[kv.Key].DiffuseColor.GetBrightness() + 0.01f;
if(mInfos[kv.Key].AlphaMask.Length > 1)
(kv.Key as GenericMaterial).SetAlphaMaskFromMedia(mInfos[kv.Key].AlphaMask);
if(mInfos[kv.Key].BumpMapName.Length > 1)
((GenericMaterial)kv.Key).SetBumpMapFromMedia(mInfos[kv.Key].BumpMapName);
// mesh.SpecularComponent = kv.Key.SpecularStrength;
mesh.Transformation.Translate(trans);
// mesh.SetCollisionShape(o3di.GetConvexHull(mesh.Transformation.GetPosition(), 1.0f, 1.0f));
meshes.Add(mesh);
}
return meshes;
}
public static List<Mesh3d> LoadSceneFromCollada(string infile)
{
List<Mesh3d> infos = new List<Mesh3d>();
XDocument xml = XDocument.Load(infile);
var colladaNode = xml.Elements().First();
var lib = colladaNode.SelectSingle("library_geometries");
var geometries = lib.SelectMany("geometry");
foreach(var geom in geometries)
{
try
{
string geoID = geom.Attribute("id").Value;
string geoName = geom.Attribute("name").Value;
List<float> xyzs = geom.SelectSingle("mesh").SelectMany("source").ElementAt(0).SelectSingle("float_array").Value.Split(new char[] { ' ' }).Select<string, float>((a) => float.Parse(a, System.Globalization.NumberFormatInfo.InvariantInfo)).ToList();
List<float> normals = geom.SelectSingle("mesh").SelectMany("source").ElementAt(1).SelectSingle("float_array").Value.Trim().Split(new char[] { ' ' }).Select<string, float>((a) => float.Parse(a, System.Globalization.NumberFormatInfo.InvariantInfo)).ToList();
List<float> uvs = null;
try
{
uvs = geom.SelectSingle("mesh").SelectMany("source").ElementAt(2).SelectSingle("float_array").Value.Trim().Split(new char[] { ' ' }).Select<string, float>((a) => float.Parse(a, System.Globalization.NumberFormatInfo.InvariantInfo)).ToList();
}
catch
{
uvs = new List<float>();
}
List<int> indices = geom.SelectSingle("mesh").SelectSingle("polylist").SelectSingle("p").Value.Trim().Split(new char[] { ' ' }).Select<string, int>((a) => int.Parse(a)).ToList();
List<float> VBO = new List<float>();
List<uint> indicesNew = new List<uint>();
uint vcount = 0;
for(int i = 0; i < indices.Count; )
{
int vid = indices[i] * 3;
int nid = indices[i + 1] * 3;
int uid = indices[i + 2] * 2;
indicesNew.Add(vcount++);
VBO.AddRange(new float[] { -xyzs[vid + 1], xyzs[vid + 2], -xyzs[vid] });
if(uvs.Count > 0)
{
VBO.AddRange(new float[] { uvs[uid], uvs[uid + 1] });
i += 3;
}
else
{
VBO.AddRange(new float[] { 0, 0 });
i += 2;
}
VBO.AddRange(new float[] { -normals[nid + 1], normals[nid + 2], -normals[nid] });
}
var objinfo = new Object3dInfo(VBO, indicesNew);
var transformationNode = colladaNode.SelectSingle("library_visual_scenes").SelectSingle("visual_scene").SelectMany("node").First((a) => a.SelectSingle("instance_geometry").Attribute("url").Value == "#" + geoID);
var mesh = new Mesh3d(objinfo, new GenericMaterial(Color.White));
List<float> transVector = transformationNode.SelectMany("translate").First((a) => a.Attribute("sid").Value == "location").Value.Trim().Split(new char[] { ' ' }).Select<string, float>((a) => float.Parse(a, System.Globalization.NumberFormatInfo.InvariantInfo)).ToList();
List<List<float>> rots = transformationNode.SelectMany("rotate").Select<XElement, List<float>>((a) => a.Value.Trim().Split(new char[] { ' ' }).Select<string, float>((ax) => float.Parse(ax, System.Globalization.NumberFormatInfo.InvariantInfo)).ToList()).ToList();
List<float> scale = transformationNode.SelectMany("scale").First((a) => a.Attribute("sid").Value == "scale").Value.Trim().Split(new char[] { ' ' }).Select<string, float>((a) => float.Parse(a, System.Globalization.NumberFormatInfo.InvariantInfo)).ToList();
mesh.Translate(-transVector[1], transVector[2], -transVector[0]);
foreach(var r in rots)
mesh.Rotate(Quaternion.FromAxisAngle(new Vector3(-r[1], r[2], -r[0]), MathHelper.DegreesToRadians(r[3])));
mesh.Scale(scale[1], scale[2], scale[0]);
infos.Add(mesh);
}
catch
{
}
}
return infos;
}
public static void CompressAndSaveSingle(Object3dInfo element, string outfile)
{
if(File.Exists(outfile + ".o3i"))
File.Delete(outfile + ".o3i");
FileStream memstream = File.Create(outfile + ".o3i");
memstream.Write(BitConverter.GetBytes(element.VBO.Count), 0, 4);
memstream.Write(BitConverter.GetBytes(element.Indices.Count), 0, 4);
foreach(float v in element.VBO)
memstream.Write(BitConverter.GetBytes(v), 0, 4);
foreach(uint v in element.Indices)
memstream.Write(BitConverter.GetBytes(v), 0, 4);
memstream.Flush();
memstream.Close();
//File.WriteAllBytes(outfile + ".o3i", memstream.ToArray());
}
public Renderer(int initialWidth, int initialHeight, int samples)
{
GlareTexture = new Texture(Media.Get("glaretex.png"));
Voxelizer = new Voxel3dTextureWriter(256, 256, 256, new Vector3(22, 22, 22), new Vector3(0, 8, 0));
CubeMapSphere = new Object3dInfo(Object3dManager.LoadFromObjSingle(Media.Get("cubemapsphere.obj")).Vertices);
var cubeMapTexDefault = new CubeMapTexture(Media.Get("posx.jpg"), Media.Get("posy.jpg"), Media.Get("posz.jpg"),
Media.Get("negx.jpg"), Media.Get("negy.jpg"), Media.Get("negz.jpg"));
CubeMaps.Add(new CubeMapInfo()
{
Texture = cubeMapTexDefault,
FalloffScale = 99999999.0f,
Position = Vector3.Zero
});
Width = initialWidth;
Height = initialHeight;
Samples = samples;
CreateBuffers();
HDRShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "HDR.fragment.glsl");
HDRShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
HDRShader.SetGlobal("USE_MSAA", "");
}
VXGIShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "VXGI.fragment.glsl");
VXGIShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
VXGIShader.SetGlobal("USE_MSAA", "");
}
AmbientOcclusionShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "AmbientOcclusion.fragment.glsl");
AmbientOcclusionShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
AmbientOcclusionShader.SetGlobal("USE_MSAA", "");
}
FogShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Fog.fragment.glsl");
FogShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
FogShader.SetGlobal("USE_MSAA", "");
}
DeferredShader = ShaderProgram.Compile("PostProcessPerspective.vertex.glsl", "Deferred.fragment.glsl");
DeferredShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
DeferredShader.SetGlobal("USE_MSAA", "");
}
EnvLightShader = ShaderProgram.Compile("PostProcessPerspective.vertex.glsl", "EnvironmentLight.fragment.glsl");
EnvLightShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
EnvLightShader.SetGlobal("USE_MSAA", "");
}
CombinerShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Combiner.fragment.glsl");
CombinerShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
CombinerShader.SetGlobal("USE_MSAA", "");
}
CombinerSecondShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "CombinerSecond.fragment.glsl");
CombinerSecondShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
CombinerSecondShader.SetGlobal("USE_MSAA", "");
}
MotionBlurShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "MotionBlur.fragment.glsl");
MotionBlurShader.SetGlobal("MSAA_SAMPLES", samples.ToString());
if (samples > 1)
{
MotionBlurShader.SetGlobal("USE_MSAA", "");
}
BloomShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Bloom.fragment.glsl");
PostProcessingMesh = new Object3dInfo(VertexInfo.FromFloatArray(postProcessingPlaneVertices));
PostProcessingMesh.DrawMode = PrimitiveType.TriangleStrip;
}
public PostProcessing(int initialWidth, int initialHeight)
{
//FullScene3DTexture = new Texture3D(new Vector3(64, 64, 64));
TestBuffer = new ShaderStorageBuffer();
NumbersTexture = new Texture(Media.Get("numbers.png"));
CShader = new ComputeShader("Blur.compute.glsl");
GLThread.Invoke(() =>
{
TestBuffer.MapData(new Vector3[4]{
new Vector3(1, 0.25f, 1), new Vector3(0, 0.55f, 0.75f),
new Vector3(1, 0.25f, 0), new Vector3(0.55f, 0, 0.75f)
});
});
Width = initialWidth;
Height = initialHeight;
MSAAResolvingFrameBuffer = new Framebuffer(initialWidth, initialHeight);
MSAAResolvingFrameBuffer.SetMultiSample(true);
MRT = new MRTFramebuffer(initialWidth, initialHeight);
BackMRT = new MRTFramebuffer(initialWidth / 4, initialHeight / 4);
Pass1FrameBuffer = new Framebuffer(initialWidth, initialHeight);
Pass2FrameBuffer = new Framebuffer(initialWidth, initialHeight);
LightPointsFrameBuffer = new Framebuffer(initialWidth / 6, initialHeight / 6);
BloomFrameBuffer = new Framebuffer(initialWidth / 4, initialHeight / 4);
FogFramebuffer = new Framebuffer(initialWidth, initialHeight);
SmallFrameBuffer = new Framebuffer(initialWidth / 10, initialHeight / 10);
LastWorldPositionFramebuffer = new Framebuffer(initialWidth / 1, initialHeight / 1);
RSMFramebuffer = new Framebuffer(initialWidth / 1, initialHeight / 1);
SSReflectionsFramebuffer = new Framebuffer(initialWidth / 1, initialHeight / 1);
VDAOFramebuffer = new Framebuffer(initialWidth / 1, initialHeight / 1);
GlobalIlluminationFrameBuffer = new Framebuffer(initialWidth, initialHeight);
//GlobalIlluminationFrameBuffer.ColorInternalFormat = PixelInternalFormat.R8;
//GlobalIlluminationFrameBuffer.ColorPixelFormat = PixelFormat.Red;
//GlobalIlluminationFrameBuffer.ColorPixelType = PixelType.UnsignedByte;
GlobalIlluminationFrameBuffer.Use();
//BackDiffuseFrameBuffer = new Framebuffer(initialWidth / 2, initialHeight / 2);
//BackNormalsFrameBuffer = new Framebuffer(initialWidth / 2, initialHeight / 2);
ScreenSpaceNormalsWriterShader = ShaderProgram.Compile("Generic.vertex.glsl", "ScreenSpaceNormalsWriter.fragment.glsl");
BackDepthWriterShader = ShaderProgram.Compile("Generic.vertex.glsl", "BackDepthWriter.fragment.glsl");
BloomShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Bloom.fragment.glsl");
MSAAShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "MSAA.fragment.glsl");
SSAOShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "SSAO.fragment.glsl");
FogShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Fog.fragment.glsl");
LightPointsShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "LightPoints.fragment.glsl");
LensBlurShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "LensBlur.fragment.glsl");
HDRShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "HDR.fragment.glsl");
BlitShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Blit.fragment.glsl");
DeferredShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Deferred.fragment.glsl");
CombinerShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Combiner.fragment.glsl");
PathTracerOutputShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "Output.fragment.glsl");
GlobalIlluminationShaderX = ShaderProgram.Compile("PostProcess.vertex.glsl", "GlobalIllumination.fragment.glsl");
GlobalIlluminationShaderX.SetGlobal("SEED", "gl_FragCoord.x");
GlobalIlluminationShaderY = ShaderProgram.Compile("PostProcess.vertex.glsl", "GlobalIllumination.fragment.glsl");
GlobalIlluminationShaderY.SetGlobal("SEED", "gl_FragCoord.y");
RSMShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "RSM.fragment.glsl");
SSReflectionsShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "SSReflections.fragment.glsl");
VDAOShader = ShaderProgram.Compile("PostProcess.vertex.glsl", "VDAO.fragment.glsl");
//ReflectShader = ShaderProgram.Compile(Media.ReadAllText("PostProcess.vertex.glsl"), Media.ReadAllText("Reflect.fragment.glsl"));
Object3dInfo postPlane3dInfo = new Object3dInfo(postProcessingPlaneVertices, postProcessingPlaneIndices);
PostProcessingMesh = new Mesh3d(postPlane3dInfo, new GenericMaterial(Color.Pink));
}
public LodLevel AddLodLevel(Object3dInfo info, GenericMaterial material, float distStart, float distEnd)
{
var i = new LodLevel(info, material, distStart, distEnd);
LodLevels.Add(i);
return i;
}
public OldCityScene()
{
/* var scene = Object3dInfo.LoadSceneFromObj(Media.Get("desertcity.obj"), Media.Get("desertcity.mtl"), 1.0f);
foreach(var ob in scene)
{
ob.SetMass(0);
this.Add(ob);
}*/
// var scene = Object3dInfo.LoadSceneFromObj(Media.Get("cryteksponza.obj"),
// Media.Get("cryteksponza.mtl"), 0.03f);
var scene = new GameScene("Scene.scene");
scene.Load();
var cnt = scene.Meshes.Count;
var sc = new Vector3(2.0f, 2.0f, 2.0f);
for(var i = 0; i < cnt; i++)
{
var o = scene.Meshes[i];
var b = o.GetInstance(0).GetPosition();
b = new Vector3(b.X * 0.25f, b.Y * 0.25f, b.Z * 0.25f);
o.GetInstance(0).SetPosition(b);
o.GetInstance(0).Scale(0.25f);
// var bdshape = o.GetLodLevel(0).Info3d.GetConvexHull();
// var bd = Game.World.Physics.CreateBody(0, o.GetInstance(0), bdshape);
// bd.Enable();
Game.World.Scene.Add(o);
o.GetLodLevel(0).Info3d.Manager = null;
// bd.Enable();
}
var hbal = Object3dManager.LoadFromRaw(Media.Get("statue2.raw"));
/*int hbalc = hbal.Vertices.Count;
for(int i = 0; i < hbalc; i += 3)
{
var v1 = hbal.Vertices[i].Position;
var v2 = hbal.Vertices[i + 1].Position;
var v3 = hbal.Vertices[i + 2].Position;
var n = Vector3.Cross(v2 - v1, v3 - v1).Normalized();
hbal.Vertices[i].Normal = n;
hbal.Vertices[i + 1].Normal = n;
hbal.Vertices[i + 2].Normal = n;
}*/
var lucy2 = Mesh3d.Create(new Object3dInfo(hbal.Vertices), new GenericMaterial());
lucy2.GetInstance(0).Scale(0.5f);
lucy2.GetInstance(0).Translate(0, 0, 0);
lucy2.GetLodLevel(0).Material.Roughness = 0.06f;
lucy2.GetLodLevel(0).Material.DiffuseColor = new Vector3(0, 0, 0);
lucy2.GetLodLevel(0).Material.SpecularColor = new Vector3(1, 1, 1);
Game.World.Scene.Add(lucy2);
GC.Collect();
// var sss = Object3dManager.LoadSceneFromObj("sintel.obj", "sintel.mtl");
// sss.ForEach((a) => Game.World.Scene.Add(a));
/*
SimplePointLight spl = new SimplePointLight(new Vector3(0, 2, 0), new Vector3(12, 12, 12));
spl.Angle = 90;
spl.SetOrientation(new Vector3(1, -1, 0).ToQuaternion(Vector3.UnitY));
float t = 0;
Game.OnUpdate += (z, xx) =>{
spl.SetPosition((float)Math.Sin(t), 2, 0);
t += (float)0.01;
};
Game.World.Scene.Add(spl);*/
/*
var lss = new List<SimplePointLight>();
for(int x = 0; x < 500; x++)
{
SimplePointLight light = new SimplePointLight(new Vector3(-4 + (8 * (x/100.0f)), 1, 0), new Vector4((float)Math.Sin(x * 0.1), (float)Math.Cos(x*0.6), (float)Math.Tan(x * 0.9), 1.0f));
Game.World.Scene.Add(light);
lss.Add(light);
}
Game.OnBeforeDraw += (oo, ee) =>
{
float a = (float)(DateTime.Now - Game.StartTime).TotalMilliseconds / 1000;
for(int x = 0; x < 100; x++)
{
lss[x].SetPosition(new Vector3(-4 + (8 * (x / 100.0f)), 1 + (float)Math.Sin(x * 0.1 + a), (float)Math.Cos(x * 0.6 + a)));
}
};*/
// var viperobj = Object3dManager.LoadSceneFromObj(Media.Get("viper.obj"), Media.Get("viper.mtl"), 0.1f);
// viperobj.ForEach((a) => a.GetInstance(0).Rotate(Quaternion.FromAxisAngle(Vector3.UnitY, MathHelper.DegreesToRadians(90))));
// viperobj.ForEach((a) => Game.World.Scene.Add(a));
/* var lucy2 = Mesh3d.Create(new Object3dInfo(Object3dManager.LoadFromRaw(Media.Get("lucy.vbo.raw")).Vertices), GenericMaterial.FromColor(Color.Gold));
lucy2.GetInstance(0).Scale(0.2f);
lucy2.GetLodLevel(0).Material.Roughness = 0.2f;
lucy2.GetLodLevel(0).Material.Metalness = 0.01f;
Game.World.Scene.Add(lucy2);*/
var testScene = new Scene();
//var lucyobj = Object3dInfo.LoadFromRaw(Media.Get("lucy.vbo.raw"), Media.Get("lucy.indices.raw"));
var lucyobj = new Object3dInfo(Object3dManager.LoadFromObjSingle(Media.Get("sph1.obj")).Vertices);
var bbmaterial = new GenericMaterial();
var lucy = Mesh3d.Create(lucyobj, bbmaterial);
lucy.GetInstance(0).Scale(0.3f);
testScene.Add(lucy);
Game.World.Scene.Add(testScene);
Commons.PickedMesh = lucy;
Commons.Picked = lucy.GetInstance(0);
Renderer pp = new Renderer(512, 512);
CubeMapFramebuffer cubens = new CubeMapFramebuffer(512, 512);
var tex = new CubeMapTexture(cubens.TexColor);
Game.DisplayAdapter.MainRenderer.CubeMap = tex;
cubens.SetPosition(new Vector3(0, 1, 0));
Game.OnKeyPress += (o, e) =>
{
if(e.KeyChar == 'z')
cubens.SetPosition(Camera.MainDisplayCamera.GetPosition());
};
Game.OnBeforeDraw += (od, dsd) =>
{
if((lucy.GetInstance(0).GetPosition() - cubens.GetPosition()).Length > 0.01f)
{
cubens.SetPosition(lucy.GetInstance(0).GetPosition());
pp.RenderToCubeMapFramebuffer(cubens);
Game.DisplayAdapter.MainRenderer.CubeMap = tex;
tex.Handle = cubens.TexColor;
}
};
var barrelmanager = Object3dManager.LoadFromObjSingle(Media.Get("barrel.obj"));
var barrelinfo = new Object3dInfo(barrelmanager.Vertices);
var barrelshape = Physics.CreateConvexCollisionShape(barrelmanager);
var barrels = Mesh3d.Create(barrelinfo, new GenericMaterial());
barrels.AutoRecalculateMatrixForOver16Instances = true;
barrels.GetLodLevel(0).Material.Roughness = 0.0f;
barrels.ClearInstances();
Game.OnKeyUp += (ox, oe) =>
{
if(oe.Key == OpenTK.Input.Key.Keypad0)
{
var instance = barrels.AddInstance(new TransformationManager(Camera.MainDisplayCamera.GetPosition()));
var phys = Game.World.Physics.CreateBody(0.7f, instance, barrelshape);
phys.Enable();
phys.Body.LinearVelocity += Camera.MainDisplayCamera.GetDirection() * 6;
}
};
Game.World.Scene.Add(barrels);
/*
List<Mesh3d> cubes = new List<Mesh3d>();
for(int i = 0; i < 80; i++)
cubes.Add(new Mesh3d(Object3dInfo.LoadFromObjSingle(Media.Get("normalizedcube.obj")), new GenericMaterial(Color.White)));
cubes.ForEach((a) => Game.World.Scene.Add(a));
List<SimplePointLight> lights = new List<SimplePointLight>();
for(int i = 0; i < 80; i++)
{
lights.Add(new SimplePointLight(new Vector3(0), Vector4.Zero));
Game.World.Scene.Add(lights[i]);
}
Game.OnBeforeDraw += (o, e) =>
{
float timeadd = (float)(DateTime.Now - Game.StartTime).TotalMilliseconds * 0.00001f;
for(int x = 0; x < 80; x++)
{
var center = new Vector3((x - 40) * 0.1f, (float)Math.Cos(x+ timeadd * x), (float)Math.Sin(x + timeadd * x));
lights[x].SetPosition(center);
lights[x].Color = new Vector4((float)Math.Sin(x + timeadd * x), (float)Math.Cos(x + timeadd * x), (float)Math.Cos(x + timeadd * 3 * x), 0.1f);
cubes[x].MainMaterial.Color = lights[x].Color;
cubes[x].Transformation.SetPosition(center);
cubes[x].Transformation.SetScale(0.05f);
}
};*/
/*
var scene = new VEngine.FileFormats.GameScene("home1.scene");
//var instances = InstancedMesh3d.FromMesh3dList(testroom);
scene.OnObjectFinish += (o, a) =>
{
if(!(a is Mesh3d))
return;
var ob = a as Mesh3d;
ob.SetOrientation(ob.GetPosition());
//ob.SetCollisionShape(ob.MainObjectInfo.GetAccurateCollisionShape());
//ob.SpecularComponent = 0.1f;
//ob.MainMaterial.ReflectionStrength = ob.MainMaterial.SpecularComponent;
//ob.SetCollisionShape(ob.ObjectInfo.GetAccurateCollisionShape());
// ob.Material = new SolidColorMaterial(new Vector4(1, 1, 1, 0.1f));
//(ob.MainMaterial as GenericMaterial).Type = GenericMaterial.MaterialType.WetDrops;
//(ob.MainMaterial as GenericMaterial).BumpMap = null;
this.Add(ob);
};
scene.Load();
SimplePointLight p = new SimplePointLight(new Vector3(0, 3, 0), new Vector4(-2.2f, -2.2f, -2.2f, 2.6f));
//LightPool.Add(p);
Game.OnKeyPress += (o, e) =>
{
if(e.KeyChar == 'o')
p.Color = new Vector4(p.Color.X + 1.1f, p.Color.Y + 1.1f, p.Color.Z + 1.1f, p.Color.W);
if(e.KeyChar == 'l')
p.Color = new Vector4(p.Color.X - 1.1f, p.Color.Y - 1.1f, p.Color.Z - 1.1f, p.Color.W);
if(e.KeyChar == 'i')
p.Color = new Vector4(p.Color.X, p.Color.Y, p.Color.Z, p.Color.W + 1);
if(e.KeyChar == 'k')
p.Color = new Vector4(p.Color.X, p.Color.Y, p.Color.Z, p.Color.W - 1);
};*/
// var s = VEngine.FileFormats.GameScene.FromMesh3dList(scene);
// System.IO.File.WriteAllText("Scene.scene", s); Object3dInfo[] skydomeInfo =
// Object3dInfo.LoadFromObj(Media.Get("sponza_verysimple.obj")); var sponza =
// Object3dInfo.LoadSceneFromObj(Media.Get("cryteksponza.obj"),
// Media.Get("cryteksponza.mtl"), 0.03f); List<Mesh3d> meshes = new List<Mesh3d>();
/* List<GenericMaterial> mats = new List<GenericMaterial>
{
new GenericMaterial(new Vector4(1f, 0.6f, 0.6f, 1.0f)) {Roughness = 0.2f },
new GenericMaterial(new Vector4(0.9f, 0.9f, 0.9f, 1.0f)) {Roughness = 0.5f },
new GenericMaterial(new Vector4(0.6f, 0.6f, 1f, 1.0f)) {Roughness = 0.2f },
new GenericMaterial(new Vector4(1, 1, 2.05f, 1.0f)) {Roughness = 0.8f },
new GenericMaterial(new Vector4(0.6f, 1f, 1f, 1.0f)) {Roughness = 0.2f },
new GenericMaterial(new Vector4(1f, 0.6f, 1f, 1.0f)),
new GenericMaterial(new Vector4(1, 0, 0.1f, 1.0f)),
new GenericMaterial(new Vector4(1, 0, 0.1f, 1.0f)),
new GenericMaterial(new Vector4(1, 0, 0.1f, 1.0f)),
new GenericMaterial(new Vector4(1, 0, 0.1f, 1.0f)),
};
int ix = 0;
foreach(var sd in skydomeInfo)
{
var skydomeMaterial = mats[ix++ % mats.Count];
var skydome = new Mesh3d(sd, skydomeMaterial);
skydome.Scale(3);
meshes.Add(skydome);
}*/
// var Tracer = new PathTracer(); Tracer.PrepareTrianglesData(meshes);
/* List<Triangle> triangles = new List<Triangle>();
foreach(var mesh in scene)
{
var Triangle = new Triangle();
Triangle.Tag = mesh;
var vertices = mesh.MainObjectInfo.GetOrderedVertices();
var normals = mesh.MainObjectInfo.GetOrderedNormals();
for(int i = 0; i < vertices.Count; i++)
{
var vertex = new Vertex()
{
Position = vertices[i],
Normal = normals[i],
Albedo = mesh.MainMaterial.Color.Xyz
};
vertex.Tranform(mesh.Matrix);
Triangle.Vertices.Add(vertex);
if(Triangle.Vertices.Count == 3)
{
triangles.Add(Triangle);
Triangle = new Triangle();
Triangle.Tag = mesh;
}
}
}
SceneOctalTree tree = new SceneOctalTree();
Triangle[] trcopy = new Triangle[triangles.Count];
triangles.CopyTo(trcopy);
tree.CreateFromTriangleList(trcopy.ToList());
var TriangleCount = triangles.Count;
// lets prepare byte array layout posx, posy, poz, norx, nory, norz, albr, albg, albz
List<byte> bytes = new List<byte>();
foreach(var triangle in triangles)
{
foreach(var vertex in triangle.Vertices)
{
bytes.AddRange(BitConverter.GetBytes(vertex.Position.X));
bytes.AddRange(BitConverter.GetBytes(vertex.Position.Y));
bytes.AddRange(BitConverter.GetBytes(vertex.Position.Z));
bytes.AddRange(BitConverter.GetBytes((float)(triangle.Tag as Mesh3d).MainMaterial.Roughness));
bytes.AddRange(BitConverter.GetBytes(vertex.Normal.X));
bytes.AddRange(BitConverter.GetBytes(vertex.Normal.Y));
bytes.AddRange(BitConverter.GetBytes(vertex.Normal.Z));
bytes.AddRange(BitConverter.GetBytes(0.0f));
bytes.AddRange(BitConverter.GetBytes(vertex.Albedo.X));
bytes.AddRange(BitConverter.GetBytes(vertex.Albedo.Y));
bytes.AddRange(BitConverter.GetBytes(vertex.Albedo.Z));
bytes.AddRange(BitConverter.GetBytes(0.0f));
}
}
var octree = new SceneOctalTree();
octree.CreateFromTriangleList(triangles);
InstancedMesh3d ims = new InstancedMesh3d(Object3dInfo.LoadFromObjSingle(Media.Get("normalizedcube.obj")), new GenericMaterial(Color.White));
Action<SceneOctalTree.Box> a = null;
a = new Action<SceneOctalTree.Box>((box) =>
{
if(box.Children.Count == 0)
ims.Transformations.Add(new TransformationManager(new Vector3(box.Center), Quaternion.Identity, box.Radius));
else
foreach(var b in box.Children)
a(b);
});
foreach(var b in octree.BoxTree.Children)
{
a(b);
}
ims.UpdateMatrix();
Add(ims);
*/
// PostProcessing.Tracer = Tracer;
//var protagonist = Object3dInfo.LoadSceneFromObj(Media.Get("protagonist.obj"), Media.Get("protagonist.mtl"), 1.0f);
//foreach(var o in protagonist)
// Add(o);
/*
var fountainWaterObj = Object3dInfo.LoadFromObjSingle(Media.Get("turbinegun.obj"));
var water = new Mesh3d(fountainWaterObj, new GenericMaterial(new Vector4(1, 1, 1, 1)));
water.Transformation.Scale(1.0f);
water.Translate(0, 10, 0);
Add(water);*/
/*
Object3dInfo waterInfo = Object3dGenerator.CreateTerrain(new Vector2(-200, -200), new Vector2(200, 200), new Vector2(30, 30), Vector3.UnitY, 333, (x, y) => 0);
var color = new GenericMaterial(Color.SkyBlue);
color.SetBumpMapFromMedia("cobblestone.jpg");
// color.Type = GenericMaterial.MaterialType.Water;
Mesh3d water2 = new Mesh3d(waterInfo, color);
water2.SetMass(0);
color.Roughness = 0.8f;
water2.Translate(0, 0.1f, 0);
water2.MainMaterial.ReflectionStrength = 1;
//water.SetCollisionShape(new BulletSharp.StaticPlaneShape(Vector3.UnitY, 0));
Add(water2);
var dragon3dInfo = Object3dInfo.LoadFromObjSingle(Media.Get("apple.obj"));
dragon3dInfo.ScaleUV(0.1f);
var mat = GenericMaterial.FromMedia("skin.jpg");
var dragon = new Mesh3d(dragon3dInfo, mat);
//mat.Type = GenericMaterial.MaterialType.WetDrops;
//dragon.Scale(5);
dragon.SetMass(0);
dragon.SetCollisionShape(dragon3dInfo.GetAccurateCollisionShape());
Add(dragon);
/*
Object3dInfo waterInfo = Object3dGenerator.CreateTerrain(new Vector2(-200, -200), new Vector2(200, 200), new Vector2(100, 100), Vector3.UnitY, 333, (x, y) => 0);
var color = new GenericMaterial(Color.Green);
color.SetBumpMapFromMedia("grassbump.png");
color.Type = GenericMaterial.MaterialType.Grass;
Mesh3d water = new Mesh3d(waterInfo, color);
water.SetMass(0);
water.Translate(0, 1, 0);
water.SetCollisionShape(new BulletSharp.StaticPlaneShape(Vector3.UnitY, 0));
Add(water);
var dragon3dInfo = Object3dInfo.LoadFromRaw(Media.Get("lucymidres.vbo.raw"), Media.Get("lucymidres.indices.raw"));
dragon3dInfo.ScaleUV(0.1f);
var dragon = new Mesh3d(dragon3dInfo, new GenericMaterial(Color.White));
//dragon.Translate(0, 0, 20);
dragon.Scale(80);
Add(dragon);
*/
}
public List <Voxel> Voxelize(Object3dManager objinfo, int gridSize)
{
List <Voxel> voxels = new List <Voxel>();
List <byte> bytes = new List <byte>();
var dv3 = new Vector3(gridSize, gridSize, gridSize);
for (int x = 0; x < gridSize; x++)
{
for (int y = 0; y < gridSize; y++)
{
for (int z = 0; z < gridSize; z++)
{
var voxel = new Voxel();
voxel.Minimum = (Vector3.Divide(new Vector3(x, y, z), (float)gridSize) - new Vector3(0.5f)) * 2.0f;
voxel.Maximum = (Vector3.Divide(new Vector3(x + 1, y + 1, z + 1), (float)gridSize) - new Vector3(0.5f)) * 2.0f;
voxels.Add(voxel);
bytes.AddRange(BitConverter.GetBytes((uint)0));
bytes.AddRange(BitConverter.GetBytes((int)0));
bytes.AddRange(BitConverter.GetBytes((int)0));
bytes.AddRange(BitConverter.GetBytes((int)0));
}
}
}
BoxesSSBO.MapData(bytes.ToArray());
// yay
Vector3 transFromCenter = objinfo.GetAverageTranslationFromZero();
objinfo.OriginToCenter();
float divisor = objinfo.GetNormalizeDivisor();
var v3aabb = objinfo.GetAxisAlignedBox();
//objinfo.Normalize();
objinfo.AxisDivide(v3aabb);
DrawingFramebuffer.Use();
GL.Disable(EnableCap.DepthTest);
GL.Disable(EnableCap.CullFace);
GL.ColorMask(true, false, false, false);
VoxelizerShader.Use();
//VoxelizerShader.SetUniform("NormalizationDivisor", 1.0f / divisor);
// VoxelizerShader.SetUniform("CenterToZero", transFromCenter);
BoxesSSBO.Use(9);
var ob3d = new Object3dInfo(objinfo.Vertices);
VoxelizerShader.SetUniform("Grid", gridSize);
VoxelizerShader.SetUniform("Pass", 0);
ob3d.Draw();/*
* VoxelizerShader.SetUniform("Pass", 1);
* ob3d.Draw();
* VoxelizerShader.SetUniform("Pass", 2);
* ob3d.Draw();*/
GL.MemoryBarrier(MemoryBarrierFlags.ShaderStorageBarrierBit);
var resultBytes = BoxesSSBO.Read(0, bytes.Count);
int cursor = 0;
int i = 0;
var newVoxels = new List <Voxel>();
for (int x = 0; x < gridSize; x++)
{
for (int y = 0; y < gridSize; y++)
{
for (int z = 0; z < gridSize; z++)
{
uint hit = BitConverter.ToUInt32(resultBytes, cursor);
int nrx = BitConverter.ToInt32(resultBytes, cursor + 4);
int nry = BitConverter.ToInt32(resultBytes, cursor + 8);
int nrz = BitConverter.ToInt32(resultBytes, cursor + 12);
cursor += 4 * 4;
if (hit > 0)
{
float fnrx = (float)nrx / (float)hit;
float fnry = (float)nry / (float)hit;
float fnrz = (float)nrz / (float)hit;
if (hit > 65536)
{
hit = 65536;
}
float dens = (float)hit / (float)65536;
voxels[i].Maximum *= v3aabb;
voxels[i].Minimum *= v3aabb;
voxels[i].Maximum += transFromCenter;
voxels[i].Minimum += transFromCenter;
voxels[i].Density = dens;
voxels[i].Normal = new Vector3(fnrx / 128.0f, fnry / 128.0f, fnrz / 128.0f);
newVoxels.Add(voxels[i]);
}
i++;
}
}
}
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
GL.ColorMask(true, true, true, true);
return(newVoxels);
}
public void SetInfo3d(Object3dInfo o3i)
{
Info3d = o3i;
BoundingBoxInfo3d = Generators.Object3dGenerator.CreateCube(o3i.BoundingBoxMin, o3i.BoundingBoxMax, Vector2.One).AsObject3dInfo();
}
public static List <Mesh3d> LoadSceneFromObj(string objfile, string mtlfile, float scale = 1.0f)
{
string[] lines = File.ReadAllLines(Media.Get(objfile));
var objs = ParseOBJString(lines);
var mtllib = LoadMaterialsFromMtl(Media.Get(mtlfile));
List <Mesh3d> meshes = new List <Mesh3d>();
Dictionary <string, GenericMaterial> texCache = new Dictionary <string, GenericMaterial>();
Dictionary <Vector3, GenericMaterial> colorCache = new Dictionary <Vector3, GenericMaterial>();
Dictionary <GenericMaterial, MaterialInfo> mInfos = new Dictionary <GenericMaterial, MaterialInfo>();
Dictionary <GenericMaterial, Object3dManager> linkCache = new Dictionary <GenericMaterial, Object3dManager>();
var colorPink = new GenericMaterial(Color.White);
foreach (var obj in objs)
{
Console.WriteLine("Loading " + obj.Name);
Console.WriteLine("GC MEMORY USED {0} MB", GC.GetTotalMemory(true) / 1024.0 / 1024);
var mat = mtllib.ContainsKey(obj.MaterialName) ? mtllib[obj.MaterialName] : new MaterialInfo();
GenericMaterial material = colorPink;
if (mat != null && mat.TextureName.Length > 0)
{
var m = new GenericMaterial();
m.SetDiffuseTexture(Path.GetFileName(mat.TextureName));
m.SpecularTexture = m.DiffuseTexture;
// m.NormalMapScale = 10;
material = m;
material.Name = obj.MaterialName;
mInfos[material] = mat;
// texCache.Add(mat.TextureName + mat.AlphaMask, material);
// material = colorPink;
}
else if (mat != null)
{
material = new GenericMaterial(mat.DiffuseColor);
mInfos[material] = mat;
}
else
{
material = colorPink;
mInfos[material] = mat;
}
for (int i = 0; i < obj.VBO.Count; i++)
{
obj.VBO[i].Position *= scale;
}
var o3di = new Object3dManager(obj.VBO);
o3di.Name = obj.Name;
// if(!linkCache.ContainsKey(material))
linkCache.Add(material, o3di);
// else
// linkCache[material].Add(o3di);
}
foreach (var kv in linkCache)
{
Object3dManager o3di = kv.Value;
// var trans = o3di.GetAverageTranslationFromZero();
// o3di.OriginToCenter();
//o3di.CorrectFacesByNormals();
// o3di.CorrectFacesByNormals();
var oi = new Object3dInfo(o3di.Vertices);
oi.Manager = o3di;
// GC.Collect();
Mesh3d mesh = Mesh3d.Create(oi, kv.Key);
//kv.Key.SpecularComponent = 1.0f - mInfos[kv.Key].SpecularStrength + 0.01f;
kv.Key.Roughness = mInfos[kv.Key].SpecularStrength;
kv.Key.DiffuseColor = mInfos[kv.Key].DiffuseColor;
kv.Key.SpecularColor = mInfos[kv.Key].SpecularColor;
// kv.Key.ReflectionStrength = 1.0f - (mInfos[kv.Key].SpecularStrength);
//kv.Key.DiffuseComponent = mInfos[kv.Key].DiffuseColor.GetBrightness() + 0.01f;
var kva = kv.Key;
if (!mInfos.ContainsKey(kva))
{
kva = mInfos.Keys.First();
}
if (mInfos[kva].BumpMapName.Length > 1)
{
((GenericMaterial)kv.Key).SetBumpTexture(mInfos[kv.Key].BumpMapName);
}
if (mInfos[kva].RoughnessMapName.Length > 1)
{
((GenericMaterial)kv.Key).SetRoughnessTexture(mInfos[kv.Key].RoughnessMapName);
}
if (mInfos[kva].NormapMapName.Length > 1)
{
((GenericMaterial)kv.Key).SetNormalsTexture(mInfos[kv.Key].NormapMapName);
}
if (mInfos[kva].TextureName.Length > 1)
{
((GenericMaterial)kv.Key).SetDiffuseTexture(mInfos[kv.Key].TextureName);
}
// mesh.SpecularComponent = kv.Key.SpecularStrength;
// mesh.GetInstance(0).Translate(trans);
// mesh.SetCollisionShape(o3di.GetConvexHull(mesh.Transformation.GetPosition(),
// 1.0f, 1.0f));
meshes.Add(mesh);
}
return(meshes);
}
