internal void BuildSceneData()
{
if (this.sceneData == null)
{
this.sceneData = new SceneDataInfo(SceneGeometry);
}
this.Vertices = SceneGeometry.Vertices;
this.Triangles = sceneData.Triangles.ToArray();
this.meshes = new List<ITriangleMesh>();
this.meshes.AddRange(sceneData.Meshes);
this.Meshes = meshes.ToArray();
this.volumeIndex = new HashSet<int>();
this.VolumeMats = new List<VolumeMaterialInfo>();
foreach (var triangleMesh in Meshes)
{
if (VolumeSampler.IsVolume(triangleMesh))
{
for (int i = triangleMesh.StartTriangle; i < triangleMesh.EndTriangle; i++)
{
volumeIndex.Add(i);
}
triangleMesh.MeshProfile = new VolumeProfile() { };
}
}
noVolumes = !volumeIndex.Any();
/*
var da = new BvhDataAdapter(this);
foreach (var triangleMesh in Meshes.Cast<TriangleMeshInfo>())
{
triangleMesh.MeshProfile.BvhData = da.BuildData(triangleMesh);
}
var bounds = meshes.Cast<TriangleMeshInfo>().Select(item => item.Bounds).ToArray();
var topLevelData = da.BuildTopData(bounds);
Tracer.TraceLine("TopLevel data", topLevelData.Length);
*/
if (Lights != null)
{
if (!Lights.OfType<MeshLight>().Any())
{
foreach (var triangleMesh in Meshes)
{
if (triangleMesh.MeshProfile is LightsourceProfile)
{
triangleMesh.MeshProfile = new SurfaceProfile() { MaterialName = triangleMesh.MaterialName };
}
}
}
if (AreaLightAsMesh)
{
Tracer.TraceLine("Area Lights treated as meshes");
foreach (var lightsource in Lights.OfType<MeshLight>())
{
lightsource.Initialize(this);
}
}
else
{
var triL = new List<TriangleLight>();
Tracer.TraceLine("Area Lights treated on triangle basis");
var meshLights = Lights.OfType<MeshLight>().ToArray();
foreach (var meshLight in meshLights)
{
MeshLight light = meshLight;
var mesh = Meshes.FirstOrDefault(item => item.MeshName.Equals(light.LightName, StringComparison.InvariantCultureIgnoreCase));
if (mesh != null)
{
for (int st = mesh.StartTriangle; st < mesh.EndTriangle; st++)
{
triL.Add(new TriangleLight(this, st, mesh, light.gain.IsBlack() ? RgbSpectrum.UnitSpectrum() : (RgbSpectrum)light.gain) { Profile = meshLight.Profile });
}
}
}
this.triLights = triL.ToArray();
lightIndex = new HashSet<int>(triLights.Select(item => item.triangleIndex));
this.Lights = this.Lights.Except(meshLights).Union(triLights).ToArray();
}
noMeshLights = !(this.Lights.Any(item => item is MeshLight || item is TriangleLight));
}
lightMeshes = this.Lights.Where(m => m is MeshLight).Cast<MeshLight>().Select(ml => ml.mesh).ToArray();
/*
texMaps = new Dictionary<string, int>();
int index = 0;
foreach (var elem in texturesMap)
{
var mat = MatLib.GetSurfMat(index).Name;
if (!texMaps.ContainsKey(mat))
{
texMaps.Add(mat, index);
index++;
}
}*/
}
private void BuildSceneData() {
int verticesCount = 0;
this.sceneData = new SceneDataInfo(SceneGeometry);
this.Triangles = sceneData.Triangles.ToList();
this.Meshes.AddRange(sceneData.Meshes);
/*
foreach (var geometryInfo in SceneGeometry.Geometry) {
var mesh = new TriangleMesh() {
MeshProfile = this.CreateGeometryProfile(geometryInfo),
MaterialName = geometryInfo.MaterialName,
MeshName = geometryInfo.Name,
Indexes = geometryInfo.IndexData.ToArray()
};
this.Meshes.Add(mesh);
var model = geometryInfo;
var delta = 0;
var index = 0;
var a = -1f;
bool hasNormals = false;
Normal[] norms = null;
int[] ni = null;
bool hasTexCoords = false;
UV[] texs = null;
int[] ti = null;
var startTriangle = Math.Max(0, Triangles.Count);
if (model.IndexData.Any()) {
hasNormals = model.NormalIndexData != null && model.NormalIndexData.Any();
hasTexCoords = model.TextureIndexData != null && model.TextureIndexData.Any();
if (hasTexCoords) {
texs = SceneGeometry.TexCoords.ToUVArray();
if (!texs.Any())
hasTexCoords = false;
ti = model.TextureIndexData.ToArray();
}
if (hasNormals) {
norms = SceneGeometry.Normals.Select(item => new Normal(item)).ToArray();
ni = model.NormalIndexData.ToArray();
}
for (int i = 0; i < model.IndexData.Count; i += 3) {
index++;
var newTriangle = new TriangleInfo(model.IndexData[i] - delta, model.IndexData[i + 1] - delta,
model.IndexData[i + 2] - delta);
Triangles.Add(newTriangle);
//meshIndexes.Add(extMesh);
if (hasTexCoords) {
var triIndex = index;
var t1 = texs[(ti[i] - 1)];
var t2 = texs[(ti[i + 1] - 1)];
var t3 = texs[(ti[i + 2] - 1)];
mesh.texCoords.Add(startTriangle + triIndex-1, new[] {t1, t2, t3});
}
if (hasNormals) {
//Add vertice normal
var triIndex = index;
var norm1 = a*norms[(ni[i] - 1)];
var norm2 = a*norms[(ni[i + 1] - 1)];
var norm3 = a*norms[(ni[i + 2] - 1)];
mesh.normals.Add(startTriangle + triIndex - 1, new[] { norm1, norm2, norm3 });
}
else {
var triIndex = index;
var norm1 = newTriangle.ComputeVerticeNormal(0, SceneGeometry.Vertices);
var norm2 = newTriangle.ComputeVerticeNormal(1, SceneGeometry.Vertices);
var norm3 = newTriangle.ComputeVerticeNormal(2, SceneGeometry.Vertices);
mesh.normals.Add(startTriangle + triIndex - 1, new[] { norm1, norm2, norm3 });
}
}
//extMesh.Indexes = model.IndexBuffer.Select(item => item - (extMesh.StartVertice - 1)).ToArray();
}
else {
for (int i = 0; i <SceneGeometry. Vertices.Length; i += 3) {
var tri = new TriangleInfo(Array.IndexOf(SceneGeometry.Vertices, SceneGeometry.Vertices[i]),
Array.IndexOf(SceneGeometry.Vertices, SceneGeometry.Vertices[i + 1]),
Array.IndexOf(SceneGeometry.Vertices, SceneGeometry.Vertices[i + 2]));
Triangles.Add(tri);
//meshIndexes.Add(extMesh);
index++;
}
}
var endTriangle = Triangles.Count;
verticesCount += (model.IndexData.Max() - model.IndexData.Min());
mesh.StartVertice = model.IndexData.Min();
mesh.EndVertice = model.IndexData.Max();
mesh.StartTriangle = startTriangle;
mesh.EndTriangle = endTriangle;
mesh.VerticesOffset = verticesCount;
for (int n = startTriangle; n < endTriangle; n++)
meshTriangleMap.Add(n, mesh);
}
*/
//Lightsources
if (Lights != null)
{
if (!Lights.OfType<MeshLight>().Any())
{
foreach (var triangleMesh in Meshes)
{
if (triangleMesh.MeshProfile is LightsourceProfile)
{
triangleMesh.MeshProfile = new SurfaceProfile() {MaterialName = triangleMesh.MaterialName};
}
}
}
if (AreaLightAsMesh)
{
foreach (var lightsource in Lights.OfType<MeshLight>())
{
// lightsource.Initialize(this);
}
}
else
{
var triLights = new List<TriangleLight>();
var meshLights = Lights.OfType<MeshLight>().ToArray();
foreach (var meshLight in meshLights)
{
MeshLight light = meshLight;
var mesh = Meshes.FirstOrDefault(item => item.MeshName.Equals(light.LightName));
if (mesh != null)
{
for (int st = mesh.StartTriangle; st < mesh.EndTriangle; st++)
{
//triLights.Add(new TriangleLight(this, st, mesh, light.gain));
}
}
}
this.Lights = this.Lights.Except(meshLights).Union(triLights).ToArray();
}
noMeshLights = !(this.Lights.Any(item => item is MeshLight || item is TriangleLight));
}
//Textures
if (MaterialProvider != null)
this.LoadTextures();
}
public MeshShape(string name, SceneDataInfo scene) : base(scene.Meshes.FirstOrDefault(item => item.MeshName.Equals(name, StringComparison.InvariantCultureIgnoreCase)))
{
}
public TriangleMeshInfo(SceneDataInfo scene)
{
this.scene = scene;
MeshProfile = new SurfaceProfile();
}
