private static void ExportTerrainMesh(Terrain terrain, ExportSettings settings, List <PipelineData> storePipelines = null)
{
TerrainConverter.TerrainInfo terrainInfo = TerrainConverter.CreateTerrainInfo(terrain, settings);
if (terrainInfo == null || ((terrainInfo.diffuseTextureDatas.Count == 0 || terrainInfo.maskTextureDatas.Count == 0) && terrainInfo.customMaterial == null))
{
return;
}
// add stategroup and pipeline for shader
GraphBuilderInterface.unity2vsg_AddStateGroupNode();
PipelineData pipelineData = new PipelineData();
pipelineData.hasNormals = 1;
pipelineData.uvChannelCount = 1;
pipelineData.useAlpha = 0;
if (terrainInfo.customMaterial == null)
{
pipelineData.descriptorBindings = NativeUtils.WrapArray(terrainInfo.descriptorBindings.ToArray());
ShaderStagesInfo shaderStagesInfo = MaterialConverter.GetOrCreateShaderStagesInfo(terrainInfo.shaderMapping.shaders.ToArray(), string.Join(",", terrainInfo.shaderDefines.ToArray()), terrainInfo.shaderConsts.ToArray());
pipelineData.shaderStages = shaderStagesInfo.ToNative();
pipelineData.id = NativeUtils.ToNative(NativeUtils.GetIDForPipeline(pipelineData));
storePipelines.Add(pipelineData);
if (GraphBuilderInterface.unity2vsg_AddBindGraphicsPipelineCommand(pipelineData, 1) == 1)
{
if (terrainInfo.diffuseTextureDatas.Count > 0)
{
DescriptorImageData layerDiffuseTextureArray = MaterialConverter.GetOrCreateDescriptorImageData(terrainInfo.diffuseTextureDatas.ToArray(), 0);
GraphBuilderInterface.unity2vsg_AddDescriptorImage(layerDiffuseTextureArray);
}
if (terrainInfo.diffuseScales.Count > 0)
{
DescriptorVectorArrayUniformData scalesDescriptor = new DescriptorVectorArrayUniformData();
scalesDescriptor.binding = 2;
scalesDescriptor.value = NativeUtils.WrapArray(terrainInfo.diffuseScales.ToArray());
GraphBuilderInterface.unity2vsg_AddDescriptorBufferVectorArray(scalesDescriptor);
}
DescriptorVectorUniformData sizeDescriptor = new DescriptorVectorUniformData();
sizeDescriptor.binding = 3;
sizeDescriptor.value = NativeUtils.ToNative(terrainInfo.terrainSize);
GraphBuilderInterface.unity2vsg_AddDescriptorBufferVector(sizeDescriptor);
if (terrainInfo.maskTextureDatas.Count > 0)
{
DescriptorImageData layerMaskTextureArray = MaterialConverter.GetOrCreateDescriptorImageData(terrainInfo.maskTextureDatas.ToArray(), 1);
GraphBuilderInterface.unity2vsg_AddDescriptorImage(layerMaskTextureArray);
}
GraphBuilderInterface.unity2vsg_CreateBindDescriptorSetCommand(1);
GraphBuilderInterface.unity2vsg_AddVertexIndexDrawNode(MeshConverter.GetOrCreateVertexIndexDrawData(terrainInfo.terrainMesh));
GraphBuilderInterface.unity2vsg_EndNode(); // step out of vertex index draw node
}
}
else
{
pipelineData.descriptorBindings = NativeUtils.WrapArray(terrainInfo.customMaterial.descriptorBindings.ToArray());
pipelineData.shaderStages = terrainInfo.customMaterial.shaderStages.ToNative();
pipelineData.id = NativeUtils.ToNative(NativeUtils.GetIDForPipeline(pipelineData));
storePipelines.Add(pipelineData);
if (GraphBuilderInterface.unity2vsg_AddBindGraphicsPipelineCommand(pipelineData, 1) == 1)
{
BindDescriptors(terrainInfo.customMaterial, true);
GraphBuilderInterface.unity2vsg_AddVertexIndexDrawNode(MeshConverter.GetOrCreateVertexIndexDrawData(terrainInfo.terrainMesh));
GraphBuilderInterface.unity2vsg_EndNode(); // step out of vertex index draw node
}
}
GraphBuilderInterface.unity2vsg_EndNode(); // step out of stategroup node
}
private static void ExportMesh(Mesh mesh, MeshRenderer meshRenderer, Transform gotrans, ExportSettings settings, List <PipelineData> storePipelines = null)
{
bool addedCullGroup = false;
if (settings.autoAddCullNodes)
{
CullData culldata = new CullData();
Vector3 center = meshRenderer.bounds.center - gotrans.position;
CoordSytemConverter.Convert(ref center);
culldata.center = NativeUtils.ToNative(center);
culldata.radius = meshRenderer.bounds.size.magnitude * 0.5f;
GraphBuilderInterface.unity2vsg_AddCullGroupNode(culldata);
addedCullGroup = true;
}
//
Material[] materials = meshRenderer.sharedMaterials;
if (mesh != null && mesh.isReadable && mesh.vertexCount > 0 && mesh.GetIndexCount(0) > 0)
{
int meshid = mesh.GetInstanceID();
MeshInfo meshInfo = MeshConverter.GetOrCreateMeshInfo(mesh);
int subMeshCount = mesh.subMeshCount;
// shader instance id, Material Data, sub mesh indicies
Dictionary <int, Dictionary <MaterialInfo, List <int> > > meshMaterials = new Dictionary <int, Dictionary <MaterialInfo, List <int> > >();
for (int matindex = 0; matindex < materials.Length && matindex < subMeshCount; matindex++)
{
Material mat = materials[matindex];
if (mat == null)
{
continue;
}
MaterialInfo matdata = MaterialConverter.GetOrCreateMaterialData(mat);
int matshaderid = matdata.shaderStages.id;
if (!meshMaterials.ContainsKey(matshaderid))
{
meshMaterials.Add(matshaderid, new Dictionary <MaterialInfo, List <int> >());
}
if (!meshMaterials[matshaderid].ContainsKey(matdata))
{
meshMaterials[matshaderid].Add(matdata, new List <int>());
}
meshMaterials[matshaderid][matdata].Add(matindex);
}
if (subMeshCount > 1)
{
// create mesh data, if the mesh has already been created we only need to pass the ID to the addGeometry function
foreach (int shaderkey in meshMaterials.Keys)
{
List <MaterialInfo> mds = new List <MaterialInfo>(meshMaterials[shaderkey].Keys);
if (mds.Count == 0)
{
continue;
}
// add stategroup and pipeline for shader
GraphBuilderInterface.unity2vsg_AddStateGroupNode();
PipelineData pipelineData = NativeUtils.CreatePipelineData(meshInfo); //WE NEED INFO ABOUT THE SHADER SO WE CAN BUILD A PIPLE LINE
pipelineData.descriptorBindings = NativeUtils.WrapArray(mds[0].descriptorBindings.ToArray());
pipelineData.shaderStages = mds[0].shaderStages.ToNative();
pipelineData.useAlpha = mds[0].useAlpha;
pipelineData.id = NativeUtils.ToNative(NativeUtils.GetIDForPipeline(pipelineData));
storePipelines.Add(pipelineData);
if (GraphBuilderInterface.unity2vsg_AddBindGraphicsPipelineCommand(pipelineData, 1) == 1)
{
GraphBuilderInterface.unity2vsg_AddCommandsNode();
VertexBuffersData vertexBuffersData = MeshConverter.GetOrCreateVertexBuffersData(meshInfo);
GraphBuilderInterface.unity2vsg_AddBindVertexBuffersCommand(vertexBuffersData);
IndexBufferData indexBufferData = MeshConverter.GetOrCreateIndexBufferData(meshInfo);
GraphBuilderInterface.unity2vsg_AddBindIndexBufferCommand(indexBufferData);
foreach (MaterialInfo md in mds)
{
BindDescriptors(md, false);
foreach (int submeshIndex in meshMaterials[shaderkey][md])
{
DrawIndexedData drawIndexedData = MeshConverter.GetOrCreateDrawIndexedData(meshInfo, submeshIndex);
GraphBuilderInterface.unity2vsg_AddDrawIndexedCommand(drawIndexedData);
}
}
GraphBuilderInterface.unity2vsg_EndNode(); // step out of commands node for descriptors and draw indexed commands
}
GraphBuilderInterface.unity2vsg_EndNode(); // step out of stategroup node for shader
}
}
else
{
List <int> sids = new List <int>(meshMaterials.Keys);
if (sids.Count > 0)
{
List <MaterialInfo> mds = new List <MaterialInfo>(meshMaterials[sids[0]].Keys);
if (mds.Count > 0)
{
// add stategroup and pipeline for shader
GraphBuilderInterface.unity2vsg_AddStateGroupNode();
PipelineData pipelineData = NativeUtils.CreatePipelineData(meshInfo); //WE NEED INFO ABOUT THE SHADER SO WE CAN BUILD A PIPLE LINE
pipelineData.descriptorBindings = NativeUtils.WrapArray(mds[0].descriptorBindings.ToArray());
pipelineData.shaderStages = mds[0].shaderStages.ToNative();
pipelineData.useAlpha = mds[0].useAlpha;
pipelineData.id = NativeUtils.ToNative(NativeUtils.GetIDForPipeline(pipelineData));
storePipelines.Add(pipelineData);
if (GraphBuilderInterface.unity2vsg_AddBindGraphicsPipelineCommand(pipelineData, 1) == 1)
{
BindDescriptors(mds[0], true);
VertexIndexDrawData vertexIndexDrawData = MeshConverter.GetOrCreateVertexIndexDrawData(meshInfo);
GraphBuilderInterface.unity2vsg_AddVertexIndexDrawNode(vertexIndexDrawData);
GraphBuilderInterface.unity2vsg_EndNode(); // step out of vertex index draw node
}
GraphBuilderInterface.unity2vsg_EndNode(); // step out of stategroup node
}
}
}
}
else
{
string reason = mesh == null ? "mesh is null." : (!mesh.isReadable ? "mesh '" + mesh.name + "' is not readable. Please enabled read/write in the models import settings." : "mesh '" + mesh.name + "' has an unknown error.");
NativeLog.WriteLine("ExportMesh: Unable to export mesh for gameobject " + gotrans.gameObject.name + ", " + reason);
}
if (addedCullGroup)
{
GraphBuilderInterface.unity2vsg_EndNode();
}
}
public static void Export(GameObject[] gameObjects, string saveFileName, ExportSettings settings)
{
MeshConverter.ClearCaches();
TextureConverter.ClearCaches();
MaterialConverter.ClearCaches();
ShaderMappingIO.ClearCaches();
GraphBuilderInterface.unity2vsg_BeginExport();
List <PipelineData> storePipelines = new List <PipelineData>();
bool insideLODGroup = false;
bool firstNodeAdded = false;
System.Action <GameObject> processGameObject = null;
processGameObject = (GameObject go) =>
{
// determine the gameObject type
Transform gotrans = go.transform;
bool nodeAdded = false;
// does it have a none identiy local matrix
if (gotrans.localPosition != Vector3.zero || gotrans.localRotation != Quaternion.identity || gotrans.localScale != Vector3.one)
{
if (firstNodeAdded || !settings.zeroRootTransform)
{
// add as a transform
TransformData transformdata = TransformConverter.CreateTransformData(gotrans);
GraphBuilderInterface.unity2vsg_AddTransformNode(transformdata);
nodeAdded = true;
}
}
// do we need to insert a group
if (!nodeAdded)// && gotrans.childCount > 0)
{
//add as a group
GraphBuilderInterface.unity2vsg_AddGroupNode();
nodeAdded = true;
}
firstNodeAdded = true;
bool meshexported = false;
// get the meshrender here so we can check if the LOD exports the the mesh
MeshFilter meshFilter = go.GetComponent <MeshFilter>();
MeshRenderer meshRenderer = go.GetComponent <MeshRenderer>();
// does this node have an LOD group
LODGroup lodgroup = go.GetComponent <LODGroup>();
if (lodgroup != null && !insideLODGroup)
{
// rather than process the children we figure out which renderers are in which children and add them as LOD children
LOD[] lods = lodgroup.GetLODs();
if (lods.Length > 0)
{
// get bounds from first renderer
if (lods[0].renderers.Length > 0)
{
CullData lodCullData = new CullData();
Bounds bounds = new Bounds(lods[0].renderers[0].bounds.center, lods[0].renderers[0].bounds.size);
foreach (Renderer boundsrenderer in lods[0].renderers)
{
if (boundsrenderer != null)
{
bounds.Encapsulate(boundsrenderer.bounds);
}
}
Vector3 center = bounds.center - gotrans.position;
CoordSytemConverter.Convert(ref center);
lodCullData.center = NativeUtils.ToNative(center);
lodCullData.radius = bounds.size.magnitude * 0.5f;
GraphBuilderInterface.unity2vsg_AddLODNode(lodCullData);
insideLODGroup = true;
for (int i = 0; i < lods.Length; i++)
{
// for now just support one renderer and assume it's under a seperate child gameObject
if (lods[i].renderers.Length == 0)
{
continue;
}
LODChildData lodChild = new LODChildData();
lodChild.minimumScreenHeightRatio = lods[i].screenRelativeTransitionHeight;
GraphBuilderInterface.unity2vsg_AddLODChild(lodChild);
foreach (Renderer lodrenderer in lods[i].renderers)
{
if (lodrenderer == meshRenderer)
{
meshexported = true;
ExportMesh(meshFilter.sharedMesh, meshRenderer, gotrans, settings, storePipelines);
}
else if (lodrenderer != null)
{
// now process the renderers gameobject, it'll be added to the group we just created by adding an LOD child
processGameObject(lodrenderer.gameObject);
}
}
GraphBuilderInterface.unity2vsg_EndNode();
}
insideLODGroup = false;
GraphBuilderInterface.unity2vsg_EndNode(); // end the lod node
}
}
}
else
{
// transverse any children
for (int i = 0; i < gotrans.childCount; i++)
{
processGameObject(gotrans.GetChild(i).gameObject);
}
}
// does it have a mesh
if (!meshexported && meshFilter && meshFilter.sharedMesh && meshRenderer)
{
Mesh mesh = meshFilter.sharedMesh;
ExportMesh(mesh, meshRenderer, gotrans, settings, storePipelines);
}
// does this node have a terrain
Terrain terrain = go.GetComponent <Terrain>();
if (terrain != null)
{
ExportTerrainMesh(terrain, settings, storePipelines);
}
// if we added a group or transform step out
if (nodeAdded)
{
GraphBuilderInterface.unity2vsg_EndNode();
}
};
foreach (GameObject go in gameObjects)
{
processGameObject(go);
}
//GraphBuilderInterface.unity2vsg_EndNode(); // step out of convert coord system node
GraphBuilderInterface.unity2vsg_EndExport(saveFileName);
NativeLog.PrintReport();
}
public static TerrainInfo CreateTerrainInfo(Terrain terrain, GraphBuilder.ExportSettings settings)
{
TerrainInfo terrainInfo = new TerrainInfo();
bool usingCustomMaterial = false;
if (terrain.materialType == Terrain.MaterialType.Custom)
{
// try and load a shader mapping file to match the custom terrain material
terrainInfo.shaderMapping = ShaderMappingIO.ReadFromJsonFile(terrain.materialTemplate.shader);
if (terrainInfo.shaderMapping != null)
{
usingCustomMaterial = true;
}
}
else
{
// load the default terrain shader mapping file
terrainInfo.shaderMapping = ShaderMappingIO.ReadFromJsonFile(ShaderMappingIO.GetPathForShaderMappingFile("DefaultTerrain"));
}
if (terrainInfo.shaderMapping == null)
{
// no mapping loaded, use a default shader so we can at least export and render the terrain mesh
NativeLog.WriteLine("GraphBuilder: Failed to load Terrain Shader Mapping file for terrain '" + terrain.name + "'.");
terrainInfo.shaderMapping = ShaderMappingIO.ReadFromJsonFile(ShaderMappingIO.GetPathForShaderMappingFile("Default"));
usingCustomMaterial = true;
return(null);
}
terrainInfo.shaderDefines.Add("VSG_LIGHTING");
// build mesh
int samplew = terrain.terrainData.heightmapWidth;
int sampleh = terrain.terrainData.heightmapHeight;
int cellw = terrain.terrainData.heightmapWidth - 1;
int cellh = terrain.terrainData.heightmapHeight - 1;
Vector3 size = terrain.terrainData.size;
Vector2 cellsize = new Vector3(size.x / cellw, size.z / cellh);
Vector2 uvcellsize = new Vector2(1.0f / cellw, 1.0f / cellh);
float[,] terrainHeights = terrain.terrainData.GetHeights(0, 0, samplew, sampleh);
int vertcount = samplew * sampleh;
Vector3[] verts = new Vector3[vertcount];
Vector3[] normals = new Vector3[vertcount];
Vector2[] uvs = new Vector2[vertcount];
int[] indicies = new int[(cellw * cellh) * 6];
// vertices and UVs
for (int y = 0; y < samplew; y++)
{
for (int x = 0; x < sampleh; x++)
{
verts[y * samplew + x].Set(x * cellsize.x, terrainHeights[y, x] * size.y, y * cellsize.y);
normals[y * samplew + x] = terrain.terrainData.GetInterpolatedNormal((float)x / (float)samplew, (float)y / (float)sampleh);
uvs[y * samplew + x].Set(x * uvcellsize.x, y * uvcellsize.y);
}
}
CoordSytemConverter.Convert(verts);
CoordSytemConverter.Convert(normals);
// triangles
int index = 0;
for (int y = 0; y < cellw; y++)
{
for (int x = 0; x < cellh; x++)
{
indicies[index++] = (y * samplew) + x;
indicies[index++] = ((y + 1) * samplew) + x;
indicies[index++] = (y * samplew) + x + 1;
indicies[index++] = ((y + 1) * samplew) + x;
indicies[index++] = ((y + 1) * samplew) + x + 1;
indicies[index++] = (y * samplew) + x + 1;
}
}
CoordSytemConverter.FlipTriangleFaces(indicies);
// convert to meshinfo
MeshInfo mesh = null;
if (!MeshConverter.GetMeshInfoFromCache(terrain.GetInstanceID(), out mesh))
{
mesh = new MeshInfo
{
id = terrain.GetInstanceID(),
verticies = NativeUtils.WrapArray(verts),
normals = NativeUtils.WrapArray(normals),
uv0 = NativeUtils.WrapArray(uvs),
triangles = NativeUtils.WrapArray(indicies),
use32BitIndicies = 1
};
MeshConverter.AddMeshInfoToCache(mesh, terrain.GetInstanceID());
}
terrainInfo.terrainMesh = mesh;
terrainInfo.terrainSize = size;
// gather material info
if (!usingCustomMaterial)
{
// use standard terrain layers
TerrainLayer[] layers = terrain.terrainData.terrainLayers;
for (int i = 0; i < layers.Length; i++)
{
ImageData layerData = TextureConverter.GetOrCreateImageData(layers[i].diffuseTexture);
terrainInfo.diffuseTextureDatas.Add(layerData);
terrainInfo.diffuseScales.Add(new Vector4(1.0f / layers[i].tileSize.x, 1.0f / layers[i].tileSize.y));
}
for (int i = 0; i < terrain.terrainData.alphamapTextureCount; i++)
{
Texture2D srcmask = terrain.terrainData.GetAlphamapTexture(i);
ImageData splatData = TextureConverter.GetOrCreateImageData(srcmask);
terrainInfo.maskTextureDatas.Add(splatData);
}
if (terrainInfo.diffuseTextureDatas.Count > 0)
{
terrainInfo.descriptorBindings.Add(new VkDescriptorSetLayoutBinding()
{
binding = 0, descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT, descriptorCount = (uint)terrainInfo.diffuseTextureDatas.Count
});
terrainInfo.descriptorBindings.Add(new VkDescriptorSetLayoutBinding()
{
binding = 2, descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT, descriptorCount = (uint)terrainInfo.diffuseScales.Count
});
terrainInfo.shaderConsts.Add(terrainInfo.diffuseTextureDatas.Count);
terrainInfo.shaderDefines.Add("VSG_TERRAIN_LAYERS");
}
terrainInfo.descriptorBindings.Add(new VkDescriptorSetLayoutBinding()
{
binding = 3, descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT, descriptorCount = 1
});
if (terrainInfo.maskTextureDatas.Count > 0)
{
terrainInfo.descriptorBindings.Add(new VkDescriptorSetLayoutBinding()
{
binding = 1, descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT, descriptorCount = (uint)terrainInfo.maskTextureDatas.Count
});
terrainInfo.shaderConsts.Add(terrainInfo.maskTextureDatas.Count);
}
}
else
{
Material customMaterial = terrain.materialTemplate;
terrainInfo.customMaterial = MaterialConverter.CreateMaterialData(customMaterial, terrainInfo.shaderMapping);
terrainInfo.customMaterial.customDefines = terrainInfo.shaderDefines;
}
return(terrainInfo);
}
