public void CreateBabylonMaterial(BabylonScene scene)
{
var babylonMaterial = new BabylonMaterial();
scene.MaterialsList.Add(babylonMaterial);
// Guid
babylonMaterial.id = ID.ToString();
// Name
babylonMaterial.name = Name;
// Data
babylonMaterial.backFaceCulling = BackFaceCulling;
babylonMaterial.diffuse = Diffuse.ToArray();
babylonMaterial.emissive = Emissive.ToArray();
babylonMaterial.specular = Specular.ToArray();
babylonMaterial.specularPower = SpecularPower;
babylonMaterial.alpha = Alpha;
if (string.IsNullOrEmpty(DiffuseTexture))
{
babylonMaterial.diffuseTexture = null;
return;
}
babylonMaterial.diffuseTexture = new BabylonTexture();
babylonMaterial.diffuseTexture.name = Path.GetFileName(DiffuseTexture);
scene.AddTexture(DiffuseTexture);
}
void DumpMaterials(BabylonScene babylonScene)
{
var count = 0;
foreach (NovaMaterial material in materialsToExport)
{
var stdMaterial = material as NovaStandardMaterial;
if (stdMaterial != null)
{
DumpStandardMaterial(stdMaterial, babylonScene);
continue;
}
var perPixelShader = material as NovaPerPixelShader;
if (perPixelShader != null)
{
DumpPerPixelShader(perPixelShader, babylonScene);
continue;
}
var multiMaterial = material as NovaMultiMaterial;
if (multiMaterial != null)
{
DumpMultiMaterial(multiMaterial, babylonScene);
}
ReportProgressChanged(75 + (count++ * 25) / materialsToExport.Count);
}
}
public static Guid CreateBabylonMesh(string name, BabylonScene scene)
{
var babylonMesh = new BabylonMesh();
scene.MeshesList.Add(babylonMesh);
// Guid
var id = Guid.NewGuid();
babylonMesh.id = id.ToString();
// Name
babylonMesh.name = name;
// Parent
babylonMesh.parentId = "";
// Visible
babylonMesh.isVisible = false;
// Material ID
babylonMesh.materialId = "";
// Position
babylonMesh.position = Vector3.Zero.ToArray();
// Vertices
babylonMesh.positions = null;
// Faces
babylonMesh.indices = null;
return id;
}
void ImportMaterialLibraries(ObjLine materialLine, BabylonScene scene)
{
for (int i = 1; i < materialLine.Tokens.Length; i++)
{
string fileName = materialLine.Tokens[i];
var mtlDocument = new Document<MtlLine>(File.ReadAllText(fileName));
StandardMaterial currentMaterial = null;
foreach (var lines in mtlDocument.Blocks)
{
foreach (MtlLine line in lines)
{
switch (line.Header)
{
case MtlHeader.Material:
currentMaterial = new StandardMaterial(line.Tokens[1]);
currentMaterial.BackFaceCulling = false;
materials.Add(currentMaterial);
break;
case MtlHeader.DiffuseColor:
currentMaterial.Diffuse = line.ToColor();
break;
case MtlHeader.DiffuseTexture:
currentMaterial.Diffuse = new Color3(1, 1, 1);
currentMaterial.DiffuseTexture = line.Tokens[1].Replace("//", @"\");
break;
case MtlHeader.Alpha:
currentMaterial.Alpha = line.ToFloat();
break;
case MtlHeader.EmissiveColor:
currentMaterial.Emissive = line.ToColor();
break;
case MtlHeader.SpecularColor:
currentMaterial.Specular = line.ToColor();
break;
case MtlHeader.SpecularPower:
currentMaterial.SpecularPower = line.ToFloat();
break;
}
}
}
}
foreach (var material in materials)
{
material.CreateBabylonMaterial(scene);
}
}
void DumpStandardMaterial(NovaStandardMaterial stdMaterial, BabylonScene babylonScene)
{
var babylonMaterial = new BabylonMaterial();
babylonScene.MaterialsList.Add(babylonMaterial);
babylonMaterial.name = stdMaterial.Name;
babylonMaterial.id = stdMaterial.ID.ToString();
babylonMaterial.alpha = stdMaterial.Alpha;
babylonMaterial.ambient = (stdMaterial.Ambient * (1.0f - stdMaterial.SelfIllumination)).ToArray();
babylonMaterial.diffuse = (stdMaterial.Diffuse * (1.0f - stdMaterial.SelfIllumination)).ToArray();
babylonMaterial.emissive = (stdMaterial.Emissive * stdMaterial.SelfIllumination).ToArray();
babylonMaterial.specular = stdMaterial.Specular.ToArray();
babylonMaterial.specularPower = stdMaterial.SpecularSharpness;
babylonMaterial.backFaceCulling = (stdMaterial.CullMode == NovaCull.CounterClockwise);
if (stdMaterial.DiffuseTexture != null && stdMaterial.DiffuseTexture.HasTextureData && stdMaterial.OpacityTexture != null && stdMaterial.OpacityTexture.HasTextureData)
{
if (stdMaterial.DiffuseTexture.LoadedTexture == stdMaterial.OpacityTexture.LoadedTexture)
{
stdMaterial.DiffuseTexture = stdMaterial.OpacityTexture;
stdMaterial.OpacityTexture = null;
}
}
if (stdMaterial.DiffuseTexture != null && stdMaterial.DiffuseTexture.HasTextureData && !stdMaterial.DiffuseTexture.IsVideo && !stdMaterial.DiffuseTexture.IsCubeRender)
{
babylonMaterial.diffuseTexture = new BabylonTexture();
DumpTexture(stdMaterial.DiffuseTexture, babylonMaterial.diffuseTexture, babylonScene);
}
if (stdMaterial.AmbientTexture != null && stdMaterial.AmbientTexture.HasTextureData && !stdMaterial.AmbientTexture.IsVideo && !stdMaterial.AmbientTexture.IsCubeRender)
{
babylonMaterial.ambientTexture = new BabylonTexture();
DumpTexture(stdMaterial.AmbientTexture, babylonMaterial.ambientTexture, babylonScene);
}
if (stdMaterial.OpacityTexture != null && stdMaterial.OpacityTexture.HasTextureData && !stdMaterial.OpacityTexture.IsVideo && !stdMaterial.OpacityTexture.IsCubeRender)
{
babylonMaterial.opacityTexture = new BabylonTexture();
DumpTexture(stdMaterial.OpacityTexture, babylonMaterial.opacityTexture, babylonScene);
}
if (mirrorsMaterials.ContainsKey(stdMaterial))
{
babylonMaterial.reflectionTexture = new BabylonTexture();
var novaObject = mirrorsMaterials[stdMaterial];
DumpRenderTargetTexture(stdMaterial.ReflectionTexture, babylonMaterial.reflectionTexture, novaObject.MirrorMapSize, novaObject.MirrorLevel, novaObject.MirroredObjects);
AttachMirrorPlane(babylonMaterial.reflectionTexture, novaObject);
}
else if (stdMaterial.ReflectionTexture != null && stdMaterial.ReflectionTexture.HasTextureData && !stdMaterial.ReflectionTexture.IsVideo && !stdMaterial.ReflectionTexture.IsCubeRender)
{
babylonMaterial.reflectionTexture = new BabylonTexture();
DumpTexture(stdMaterial.ReflectionTexture, babylonMaterial.reflectionTexture, babylonScene);
}
if (stdMaterial.EmissiveTexture != null && stdMaterial.EmissiveTexture.HasTextureData && !stdMaterial.EmissiveTexture.IsVideo && !stdMaterial.EmissiveTexture.IsCubeRender)
{
babylonMaterial.emissiveTexture = new BabylonTexture();
DumpTexture(stdMaterial.EmissiveTexture, babylonMaterial.emissiveTexture, babylonScene);
}
if (stdMaterial.SpecularTexture != null && stdMaterial.SpecularTexture.HasTextureData && !stdMaterial.SpecularTexture.IsVideo && !stdMaterial.SpecularTexture.IsCubeRender)
{
babylonMaterial.specularTexture = new BabylonTexture();
DumpTexture(stdMaterial.SpecularTexture, babylonMaterial.specularTexture, babylonScene);
}
if (stdMaterial.BumpTexture != null && stdMaterial.BumpTexture.HasTextureData && !stdMaterial.BumpTexture.IsVideo && !stdMaterial.BumpTexture.IsCubeRender)
{
babylonMaterial.bumpTexture = new BabylonTexture();
DumpTexture(stdMaterial.BumpTexture, babylonMaterial.bumpTexture, babylonScene);
babylonMaterial.bumpTexture.level /= 2.0f;
}
}
string CopyTexture(NovaTexture texture, BabylonScene babylonScene)
{
string name = texture.Name;
// Data
if (!alreadyExportedTextures.Contains(texture.Name + texture.HasAlpha))
{
alreadyExportedTextures.Add(texture.Name + texture.HasAlpha);
if (Path.GetExtension(texture.Name).ToLower() == ".dds" || Path.GetExtension(texture.Name).ToLower() == ".bmp")
{
name = Path.GetFileNameWithoutExtension(texture.Name) + ".png";
var alreadyExists = File.Exists(Path.Combine(babylonScene.OutputPath, name));
texture.LoadedTexture.SaveToPNG(Path.Combine(babylonScene.OutputPath, name));
if (!texture.HasAlpha)
{
var oldPath = Path.Combine(babylonScene.OutputPath, name);
var bmp = Image.FromFile(oldPath);
name = Path.GetFileNameWithoutExtension(texture.Name) + ".jpg";
bmp.Save(Path.Combine(babylonScene.OutputPath, name), ImageFormat.Jpeg);
bmp.Dispose();
if (!alreadyExists)
{
File.Delete(oldPath);
}
}
}
else
{
var sourceFile = Path.Combine(texture.Directory, texture.Filename);
File.Copy(sourceFile, Path.Combine(babylonScene.OutputPath, Path.GetFileName(sourceFile)), true);
}
}
else
{
if (Path.GetExtension(texture.Name).ToLower() == ".dds" ||
Path.GetExtension(texture.Name).ToLower() == ".bmp")
{
name = Path.GetFileNameWithoutExtension(texture.Name) + (texture.HasAlpha ? ".png" : ".jpg");
}
}
return name;
}
void DumpTexture(NovaTexture texture, BabylonTexture babylonTexture, BabylonScene babylonScene)
{
babylonTexture.level = texture.Level;
babylonTexture.hasAlpha = texture.HasAlpha;
babylonTexture.coordinatesMode = (int)texture.MapType;
if (texture.LoadedTexture.IsCube)
{
DumpCubeTexture(texture, babylonTexture, babylonScene);
return;
}
babylonTexture.name = texture.Name;
babylonTexture.uOffset = texture.UOffset;
babylonTexture.vOffset = texture.VOffset;
babylonTexture.uScale = texture.UScale;
babylonTexture.vScale = texture.VScale;
babylonTexture.uAng = texture.UAng;
babylonTexture.vAng = texture.VAng;
babylonTexture.wAng = texture.WAng;
switch (texture.UAddressMode)
{
case NovaTextureAddress.Wrap:
babylonTexture.wrapU = 1;
break;
case NovaTextureAddress.Mirror:
babylonTexture.wrapU = 2;
break;
case NovaTextureAddress.Clamp:
babylonTexture.wrapU = 0;
break;
}
switch (texture.VAddressMode)
{
case NovaTextureAddress.Wrap:
babylonTexture.wrapV = 1;
break;
case NovaTextureAddress.Mirror:
babylonTexture.wrapV = 2;
break;
case NovaTextureAddress.Clamp:
babylonTexture.wrapV = 0;
break;
}
babylonTexture.coordinatesIndex = texture.MapCoordinateIndex;
DumpTextureAnimation(texture, babylonTexture);
babylonTexture.name = CopyTexture(texture, babylonScene);
}
private void DumpCubeTexture(NovaTexture texture, BabylonTexture babylonTexture, BabylonScene babylonScene)
{
var textureFilename = Path.Combine(texture.LoadedTexture.Directory, texture.LoadedTexture.Filename);
var baseName = Path.GetFileNameWithoutExtension(texture.LoadedTexture.Filename);
babylonTexture.isCube = true;
babylonTexture.name = baseName;
baseName = Path.Combine(babylonScene.OutputPath, baseName);
if (!File.Exists(textureFilename))
{
texture.LoadedTexture.SaveToDDS(false, textureFilename);
}
if (!alreadyExportedTextures.Contains(textureFilename))
{
alreadyExportedTextures.Add(textureFilename);
// Use SharpDX to extract face images
var form = new Form { ClientSize = new Size(64, 64) };
var device = new Device(new Direct3D(), 0, DeviceType.Hardware, form.Handle,
CreateFlags.HardwareVertexProcessing,
new PresentParameters(form.ClientSize.Width, form.ClientSize.Height));
var cubeTexture = CubeTexture.FromFile(device, textureFilename);
using (var surface = cubeTexture.GetCubeMapSurface(CubeMapFace.PositiveX, 0))
{
Surface.ToFile(surface, baseName + "_px.jpg", ImageFileFormat.Jpg);
}
using (var surface = cubeTexture.GetCubeMapSurface(CubeMapFace.PositiveY, 0))
{
Surface.ToFile(surface, baseName + "_py.jpg", ImageFileFormat.Jpg);
}
using (var surface = cubeTexture.GetCubeMapSurface(CubeMapFace.PositiveZ, 0))
{
Surface.ToFile(surface, baseName + "_pz.jpg", ImageFileFormat.Jpg);
}
using (var surface = cubeTexture.GetCubeMapSurface(CubeMapFace.NegativeX, 0))
{
Surface.ToFile(surface, baseName + "_nx.jpg", ImageFileFormat.Jpg);
}
using (var surface = cubeTexture.GetCubeMapSurface(CubeMapFace.NegativeY, 0))
{
Surface.ToFile(surface, baseName + "_ny.jpg", ImageFileFormat.Jpg);
}
using (var surface = cubeTexture.GetCubeMapSurface(CubeMapFace.NegativeZ, 0))
{
Surface.ToFile(surface, baseName + "_nz.jpg", ImageFileFormat.Jpg);
}
cubeTexture.Dispose();
device.Dispose();
form.Dispose();
}
}
static void DumpMultiMaterial(NovaMultiMaterial multiMaterial, BabylonScene babylonScene)
{
var babylonMultiMaterial = new BabylonMultiMaterial();
babylonScene.MultiMaterialsList.Add(babylonMultiMaterial);
babylonMultiMaterial.name = multiMaterial.Name;
babylonMultiMaterial.id = multiMaterial.ID.ToString();
babylonMultiMaterial.materials = multiMaterial.Materials.Select(material => (material != null ? material.ID.ToString() : "")).ToArray();
}
void DumpPerPixelShader(NovaPerPixelShader ppShader, BabylonScene babylonScene)
{
var babylonMaterial = new BabylonMaterial();
babylonScene.MaterialsList.Add(babylonMaterial);
babylonMaterial.name = ppShader.Name;
babylonMaterial.id = ppShader.ID.ToString();
babylonMaterial.alpha = ppShader.Alpha;
babylonMaterial.ambient = (ppShader.Ambient * (1.0f - ppShader.SelfIllumination)).ToArray();
babylonMaterial.diffuse = (ppShader.Diffuse * (1.0f - ppShader.SelfIllumination)).ToArray();
babylonMaterial.emissive = (ppShader.Emissive * ppShader.SelfIllumination).ToArray();
babylonMaterial.specular = ppShader.Specular.ToArray();
babylonMaterial.specularPower = ppShader.SpecularSharpness;
babylonMaterial.backFaceCulling = (ppShader.CullMode == NovaCull.CounterClockwise);
if (ppShader.DiffuseTexture != null && ppShader.DiffuseTexture.HasTextureData && ppShader.OpacityTexture != null && ppShader.OpacityTexture.HasTextureData)
{
if (ppShader.DiffuseTexture.LoadedTexture == ppShader.OpacityTexture.LoadedTexture)
{
ppShader.DiffuseTexture = ppShader.OpacityTexture;
ppShader.OpacityTexture = null;
}
}
if (ppShader.DiffuseTexture != null && ppShader.DiffuseTexture.HasTextureData && !ppShader.DiffuseTexture.IsVideo && !ppShader.DiffuseTexture.IsCubeRender)
{
babylonMaterial.diffuseTexture = new BabylonTexture();
DumpTexture(ppShader.DiffuseTexture, babylonMaterial.diffuseTexture, babylonScene);
}
if (ppShader.AmbientTexture != null && ppShader.AmbientTexture.HasTextureData && !ppShader.AmbientTexture.IsVideo && !ppShader.AmbientTexture.IsCubeRender)
{
babylonMaterial.ambientTexture = new BabylonTexture();
DumpTexture(ppShader.AmbientTexture, babylonMaterial.ambientTexture, babylonScene);
}
if (ppShader.OpacityTexture != null && ppShader.OpacityTexture.HasTextureData && !ppShader.OpacityTexture.IsVideo && !ppShader.OpacityTexture.IsCubeRender)
{
babylonMaterial.opacityTexture = new BabylonTexture();
DumpTexture(ppShader.OpacityTexture, babylonMaterial.opacityTexture, babylonScene);
}
if (mirrorsMaterials.ContainsKey(ppShader))
{
babylonMaterial.reflectionTexture = new BabylonTexture();
var novaObject = mirrorsMaterials[ppShader];
DumpRenderTargetTexture(ppShader.ReflectionTexture, babylonMaterial.reflectionTexture, novaObject.MirrorMapSize, novaObject.MirrorLevel, novaObject.MirroredObjects);
AttachMirrorPlane(babylonMaterial.reflectionTexture, novaObject);
}
else if (ppShader.ReflectionTexture != null && ppShader.ReflectionTexture.HasTextureData && !ppShader.ReflectionTexture.IsVideo && !ppShader.ReflectionTexture.IsCubeRender)
{
babylonMaterial.reflectionTexture = new BabylonTexture();
DumpTexture(ppShader.ReflectionTexture, babylonMaterial.reflectionTexture, babylonScene);
}
// Refraction
if (ppShader.RefractionLevel > 0)
{
babylonMaterial.alpha = 1.0f - ppShader.RefractionLevel;
}
if (ppShader.EmissiveTexture != null && ppShader.EmissiveTexture.HasTextureData && !ppShader.EmissiveTexture.IsVideo && !ppShader.EmissiveTexture.IsCubeRender)
{
babylonMaterial.emissiveTexture = new BabylonTexture();
DumpTexture(ppShader.EmissiveTexture, babylonMaterial.emissiveTexture, babylonScene);
}
if (ppShader.SpecularTexture != null && ppShader.SpecularTexture.HasTextureData && !ppShader.SpecularTexture.IsVideo && !ppShader.SpecularTexture.IsCubeRender)
{
babylonMaterial.specularTexture = new BabylonTexture();
DumpTexture(ppShader.SpecularTexture, babylonMaterial.specularTexture, babylonScene);
}
if (ppShader.BumpTexture != null && ppShader.BumpTexture.HasTextureData && !ppShader.BumpTexture.IsVideo && !ppShader.BumpTexture.IsCubeRender)
{
babylonMaterial.bumpTexture = new BabylonTexture();
DumpTexture(ppShader.BumpTexture, babylonMaterial.bumpTexture, babylonScene);
babylonMaterial.bumpTexture.level /= 2.0f;
}
}
public void GenerateBabylonFile(string file, string outputFile, bool skinned)
{
var text = File.ReadAllText(file);
Environment.CurrentDirectory = Path.GetDirectoryName(file);
// Scene
var scene = new BabylonScene(Path.GetDirectoryName(outputFile));
// Loading
var objDocument = new Document<ObjLine>(text);
materials.Clear();
int currentProgression = 0;
int total = objDocument.Blocks.Sum(lines => lines.Count);
string currentName = "";
StandardMaterial currentMaterial = null;
foreach (var lines in objDocument.Blocks)
{
if (lines[0].Tokens[0] == lines[0].BlockSperator)
{
AppendNewPart(currentName, currentMaterial);
}
foreach (ObjLine line in lines)
{
currentProgression++;
ReportProgressChanged((currentProgression * 100) / total);
switch (line.Header)
{
case ObjHeader.Vertices:
positions.Add(line.ToVector3());
break;
case ObjHeader.TextureCoordinates:
Vector2 tv = line.ToVector2();
textureCoordinates.Add(tv);
break;
case ObjHeader.Normals:
normals.Add(line.ToVector3());
break;
case ObjHeader.Group:
currentName = line.Tokens[1];
break;
case ObjHeader.Faces:
AppendFace(line);
break;
case ObjHeader.MaterialLibrary:
ImportMaterialLibraries(line, scene);
break;
case ObjHeader.Material:
string materialName = line.Tokens[1];
currentMaterial = materials.FirstOrDefault(e => e.Name == materialName);
break;
}
}
}
if (positions.Count > 0)
{
AppendNewPart(currentName, currentMaterial);
}
if (meshParts.Count > 1)
{
var proxyID = ProxyMesh.CreateBabylonMesh(currentName, scene);
foreach (Mesh<PositionNormalTextured> part in meshParts.Values)
{
part.CreateBabylonMesh(scene, proxyID);
}
}
else
{
meshParts.Values.First().CreateBabylonMesh(scene);
}
// Output
scene.Prepare();
using (var outputStream = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
var ser = new DataContractJsonSerializer(typeof (BabylonScene));
ser.WriteObject(outputStream, scene);
}
}
string CopyTexture(NovaTexture texture, BabylonScene babylonScene)
{
string name = texture.Name;
// Data
if (!alreadyExportedTextures.Contains(texture.Name))
{
alreadyExportedTextures.Add(texture.Name);
if (Path.GetExtension(texture.Name).ToLower() == ".dds" || Path.GetExtension(texture.Name).ToLower() == ".bmp")
{
name = Path.GetFileNameWithoutExtension(texture.Name) + ".png";
texture.LoadedTexture.SaveToPNG(Path.Combine(babylonScene.OutputPath, name));
}
else
{
var sourceFile = Path.Combine(texture.Directory, texture.Filename);
File.Copy(sourceFile, Path.Combine(babylonScene.OutputPath, Path.GetFileName(sourceFile)), true);
}
}
else
{
if (Path.GetExtension(texture.Name).ToLower() == ".dds" ||
Path.GetExtension(texture.Name).ToLower() == ".bmp")
{
name = Path.GetFileNameWithoutExtension(texture.Name) + ".png";
}
}
return name;
}
