private void GenerateTerrain(List<HEU_LoadBufferVolume> terrainBuffers)
{
Transform parent = this.gameObject.transform;
// Directory to store generated terrain files.
string outputTerrainpath = GetOutputCacheDirectory();
outputTerrainpath = HEU_Platform.BuildPath(outputTerrainpath, "Terrain");
int numVolumes = terrainBuffers.Count;
for(int t = 0; t < numVolumes; ++t)
{
if (terrainBuffers[t]._heightMap != null)
{
GameObject newGameObject = new GameObject("heightfield_" + terrainBuffers[t]._tileIndex);
Transform newTransform = newGameObject.transform;
newTransform.parent = parent;
HEU_GeneratedOutput generatedOutput = new HEU_GeneratedOutput();
generatedOutput._outputData._gameObject = newGameObject;
Terrain terrain = HEU_GeneralUtility.GetOrCreateComponent<Terrain>(newGameObject);
TerrainCollider collider = HEU_GeneralUtility.GetOrCreateComponent<TerrainCollider>(newGameObject);
if (!string.IsNullOrEmpty(terrainBuffers[t]._terrainDataPath))
{
// Load the source TerrainData, then make a unique copy of it in the cache folder
TerrainData sourceTerrainData = HEU_AssetDatabase.LoadAssetAtPath(terrainBuffers[t]._terrainDataPath, typeof(TerrainData)) as TerrainData;
if (sourceTerrainData == null)
{
Debug.LogWarningFormat("TerrainData, set via attribute, not found at: {0}", terrainBuffers[t]._terrainDataPath);
}
terrain.terrainData = HEU_AssetDatabase.CopyUniqueAndLoadAssetAtAnyPath(sourceTerrainData, outputTerrainpath, typeof(TerrainData)) as TerrainData;
if (terrain.terrainData != null)
{
// Store path so that it can be deleted on clean up
AddGeneratedOutputFilePath(HEU_AssetDatabase.GetAssetPath(terrain.terrainData));
}
}
if (terrain.terrainData == null)
{
terrain.terrainData = new TerrainData();
}
TerrainData terrainData = terrain.terrainData;
collider.terrainData = terrainData;
HEU_TerrainUtility.SetTerrainMaterial(terrain, terrainBuffers[t]._specifiedTerrainMaterialName);
#if UNITY_2018_3_OR_NEWER
terrain.allowAutoConnect = true;
// This has to be set after setting material
terrain.drawInstanced = true;
#endif
int heightMapSize = terrainBuffers[t]._heightMapWidth;
terrainData.heightmapResolution = heightMapSize;
if (terrainData.heightmapResolution != heightMapSize)
{
Debug.LogErrorFormat("Unsupported terrain size: {0}", heightMapSize);
continue;
}
// The terrainData.baseMapResolution is not set here, but rather left to whatever default Unity uses
// The terrainData.alphamapResolution is set later when setting the alphamaps.
// 32 is the default for resolutionPerPatch
const int detailResolution = 1024;
const int resolutionPerPatch = 32;
terrainData.SetDetailResolution(detailResolution, resolutionPerPatch);
terrainData.SetHeights(0, 0, terrainBuffers[t]._heightMap);
// Note that Unity uses a default height range of 600 when a flat terrain is created.
// Without a non-zero value for the height range, user isn't able to draw heights.
// Therefore, set 600 as the value if height range is currently 0 (due to flat heightfield).
float heightRange = terrainBuffers[t]._heightRange;
if (heightRange == 0)
{
heightRange = 600;
}
terrainData.size = new Vector3(terrainBuffers[t]._terrainSizeX, heightRange, terrainBuffers[t]._terrainSizeY);
terrain.Flush();
// Set position
HAPI_Transform hapiTransformVolume = new HAPI_Transform(true);
hapiTransformVolume.position[0] += terrainBuffers[t]._position[0];
hapiTransformVolume.position[1] += terrainBuffers[t]._position[1];
hapiTransformVolume.position[2] += terrainBuffers[t]._position[2];
HEU_HAPIUtility.ApplyLocalTransfromFromHoudiniToUnity(ref hapiTransformVolume, newTransform);
// Set layers
Texture2D defaultTexture = HEU_VolumeCache.LoadDefaultSplatTexture();
int numLayers = terrainBuffers[t]._splatLayers.Count;
#if UNITY_2018_3_OR_NEWER
// Create TerrainLayer for each heightfield layer.
// Note that height and mask layers are ignored (i.e. not created as TerrainLayers).
// Since height layer is first, only process layers from 2nd index onwards.
if (numLayers > 1)
{
// Keep existing TerrainLayers, and either update or append to them
TerrainLayer[] existingTerrainLayers = terrainData.terrainLayers;
// Total layers are existing layers + new alpha maps
List<TerrainLayer> finalTerrainLayers = new List<TerrainLayer>(existingTerrainLayers);
for (int m = 1; m < numLayers; ++m)
{
TerrainLayer terrainlayer = null;
int terrainLayerIndex = -1;
bool bSetTerrainLayerProperties = true;
HEU_LoadBufferVolumeLayer layer = terrainBuffers[t]._splatLayers[m];
// Look up TerrainLayer file via attribute if user has set it
if (!string.IsNullOrEmpty(layer._layerPath))
{
terrainlayer = HEU_AssetDatabase.LoadAssetAtPath(layer._layerPath, typeof(TerrainLayer)) as TerrainLayer;
if (terrainlayer == null)
{
Debug.LogWarningFormat("TerrainLayer, set via attribute, not found at: {0}", layer._layerPath);
continue;
}
else
{
// Always check if its part of existing list so as not to add it again
terrainLayerIndex = HEU_TerrainUtility.GetTerrainLayerIndex(terrainlayer, existingTerrainLayers);
}
}
if (terrainlayer == null)
{
terrainlayer = new TerrainLayer();
terrainLayerIndex = finalTerrainLayers.Count;
finalTerrainLayers.Add(terrainlayer);
}
else
{
// For existing TerrainLayer, make a copy of it if it has custom layer attributes
// because we don't want to change the original TerrainLayer.
if (layer._hasLayerAttributes && terrainLayerIndex >= 0)
{
// Copy the TerrainLayer file
TerrainLayer prevTerrainLayer = terrainlayer;
terrainlayer = HEU_AssetDatabase.CopyAndLoadAssetAtAnyPath(terrainlayer, outputTerrainpath, typeof(TerrainLayer), true) as TerrainLayer;
if (terrainlayer != null)
{
// Update the TerrainLayer reference in the list with this copy
finalTerrainLayers[terrainLayerIndex] = terrainlayer;
// Store path for clean up later
AddGeneratedOutputFilePath(HEU_AssetDatabase.GetAssetPath(terrainlayer));
}
else
{
Debug.LogErrorFormat("Unable to copy TerrainLayer '{0}' for generating Terrain. "
+ "Using original TerrainLayer. Will not be able to set any TerrainLayer properties.", layer._layerName);
terrainlayer = prevTerrainLayer;
bSetTerrainLayerProperties = false;
// Again, continuing on to keep proper indexing.
}
}
}
if (bSetTerrainLayerProperties)
{
if (!string.IsNullOrEmpty(layer._diffuseTexturePath))
{
terrainlayer.diffuseTexture = HEU_MaterialFactory.LoadTexture(layer._diffuseTexturePath);
}
if (terrainlayer.diffuseTexture == null)
{
terrainlayer.diffuseTexture = defaultTexture;
}
terrainlayer.diffuseRemapMin = Vector4.zero;
terrainlayer.diffuseRemapMax = Vector4.one;
if (!string.IsNullOrEmpty(layer._maskTexturePath))
{
terrainlayer.maskMapTexture = HEU_MaterialFactory.LoadTexture(layer._maskTexturePath);
}
terrainlayer.maskMapRemapMin = Vector4.zero;
terrainlayer.maskMapRemapMax = Vector4.one;
terrainlayer.metallic = layer._metallic;
if (!string.IsNullOrEmpty(layer._normalTexturePath))
{
terrainlayer.normalMapTexture = HEU_MaterialFactory.LoadTexture(layer._normalTexturePath);
}
terrainlayer.normalScale = layer._normalScale;
terrainlayer.smoothness = layer._smoothness;
terrainlayer.specular = layer._specularColor;
terrainlayer.tileOffset = layer._tileOffset;
if (layer._tileSize.magnitude == 0f && terrainlayer.diffuseTexture != null)
{
// Use texture size if tile size is 0
layer._tileSize = new Vector2(terrainlayer.diffuseTexture.width, terrainlayer.diffuseTexture.height);
}
terrainlayer.tileSize = layer._tileSize;
}
}
terrainData.terrainLayers = finalTerrainLayers.ToArray();
}
#else
// Need to create SplatPrototype for each layer in heightfield, representing the textures.
SplatPrototype[] splatPrototypes = new SplatPrototype[numLayers];
for (int m = 0; m < numLayers; ++m)
{
splatPrototypes[m] = new SplatPrototype();
HEU_LoadBufferVolumeLayer layer = terrainBuffers[t]._splatLayers[m];
Texture2D diffuseTexture = null;
if (!string.IsNullOrEmpty(layer._diffuseTexturePath))
{
diffuseTexture = HEU_MaterialFactory.LoadTexture(layer._diffuseTexturePath);
}
if (diffuseTexture == null)
{
diffuseTexture = defaultTexture;
}
splatPrototypes[m].texture = diffuseTexture;
splatPrototypes[m].tileOffset = layer._tileOffset;
if (layer._tileSize.magnitude == 0f && diffuseTexture != null)
{
// Use texture size if tile size is 0
layer._tileSize = new Vector2(diffuseTexture.width, diffuseTexture.height);
}
splatPrototypes[m].tileSize = layer._tileSize;
splatPrototypes[m].metallic = layer._metallic;
splatPrototypes[m].smoothness = layer._smoothness;
if (!string.IsNullOrEmpty(layer._normalTexturePath))
{
splatPrototypes[m].normalMap = HEU_MaterialFactory.LoadTexture(layer._normalTexturePath);
}
}
terrainData.splatPrototypes = splatPrototypes;
#endif
// Set the splatmaps
if (terrainBuffers[t]._splatMaps != null)
{
// Set the alphamap size before setting the alphamaps to get correct scaling
// The alphamap size comes from the first alphamap layer
int alphamapResolution = terrainBuffers[t]._heightMapWidth;
if (numLayers > 1)
{
alphamapResolution = terrainBuffers[t]._splatLayers[1]._heightMapWidth;
}
terrainData.alphamapResolution = alphamapResolution;
terrainData.SetAlphamaps(0, 0, terrainBuffers[t]._splatMaps);
}
// Set the tree scattering
if (terrainBuffers[t]._scatterTrees != null)
{
HEU_TerrainUtility.ApplyScatterTrees(terrainData, terrainBuffers[t]._scatterTrees);
}
// Set the detail layers
if (terrainBuffers[t]._detailPrototypes != null)
{
HEU_TerrainUtility.ApplyDetailLayers(terrain, terrainData, terrainBuffers[t]._detailProperties,
terrainBuffers[t]._detailPrototypes, terrainBuffers[t]._detailMaps);
}
terrainBuffers[t]._generatedOutput = generatedOutput;
_generatedOutputs.Add(generatedOutput);
SetOutputVisiblity(terrainBuffers[t]);
}
}
}
private void GenerateTerrain(List<HEU_LoadBufferVolume> terrainBuffers)
{
Transform parent = this.gameObject.transform;
int numVolumes = terrainBuffers.Count;
for(int t = 0; t < numVolumes; ++t)
{
if (terrainBuffers[t]._heightMap != null)
{
GameObject newGameObject = new GameObject("heightfield_" + terrainBuffers[t]._tileIndex);
Transform newTransform = newGameObject.transform;
newTransform.parent = parent;
HEU_GeneratedOutput generatedOutput = new HEU_GeneratedOutput();
generatedOutput._outputData._gameObject = newGameObject;
Terrain terrain = HEU_GeneralUtility.GetOrCreateComponent<Terrain>(newGameObject);
TerrainCollider collider = HEU_GeneralUtility.GetOrCreateComponent<TerrainCollider>(newGameObject);
if (!string.IsNullOrEmpty(terrainBuffers[t]._terrainDataPath))
{
terrain.terrainData = HEU_AssetDatabase.LoadAssetAtPath(terrainBuffers[t]._terrainDataPath, typeof(TerrainData)) as TerrainData;
if (terrain.terrainData == null)
{
Debug.LogWarningFormat("TerrainData, set via attribute, not found at: {0}", terrainBuffers[t]._terrainDataPath);
}
}
if (terrain.terrainData == null)
{
terrain.terrainData = new TerrainData();
}
TerrainData terrainData = terrain.terrainData;
collider.terrainData = terrainData;
HEU_TerrainUtility.SetTerrainMaterial(terrain);
#if UNITY_2018_3_OR_NEWER
terrain.allowAutoConnect = true;
// This has to be set after setting material
terrain.drawInstanced = true;
#endif
int heightMapSize = terrainBuffers[t]._heightMapWidth;
terrainData.heightmapResolution = heightMapSize;
if (terrainData.heightmapResolution != heightMapSize)
{
Debug.LogErrorFormat("Unsupported terrain size: {0}", heightMapSize);
continue;
}
// The terrainData.baseMapResolution is not set here, but rather left to whatever default Unity uses
// The terrainData.alphamapResolution is set later when setting the alphamaps.
// 32 is the default for resolutionPerPatch
const int detailResolution = 1024;
const int resolutionPerPatch = 32;
terrainData.SetDetailResolution(detailResolution, resolutionPerPatch);
terrainData.SetHeights(0, 0, terrainBuffers[t]._heightMap);
// Note that Unity uses a default height range of 600 when a flat terrain is created.
// Without a non-zero value for the height range, user isn't able to draw heights.
// Therefore, set 600 as the value if height range is currently 0 (due to flat heightfield).
float heightRange = terrainBuffers[t]._heightRange;
if (heightRange == 0)
{
heightRange = 600;
}
terrainData.size = new Vector3(terrainBuffers[t]._terrainSizeX, heightRange, terrainBuffers[t]._terrainSizeY);
terrain.Flush();
// Set position
HAPI_Transform hapiTransformVolume = new HAPI_Transform(true);
hapiTransformVolume.position[0] += terrainBuffers[t]._position[0];
hapiTransformVolume.position[1] += terrainBuffers[t]._position[1];
hapiTransformVolume.position[2] += terrainBuffers[t]._position[2];
HEU_HAPIUtility.ApplyLocalTransfromFromHoudiniToUnity(ref hapiTransformVolume, newTransform);
// Set layers
Texture2D defaultTexture = HEU_VolumeCache.LoadDefaultSplatTexture();
int numLayers = terrainBuffers[t]._layers.Count;
#if UNITY_2018_3_OR_NEWER
// Create TerrainLayer for each heightfield layer.
// Note that height and mask layers are ignored (i.e. not created as TerrainLayers).
// Since height layer is first, only process layers from 2nd index onwards.
if (numLayers > 1)
{
TerrainLayer[] terrainLayers = new TerrainLayer[numLayers - 1];
for (int m = 1; m < numLayers; ++m)
{
TerrainLayer terrainlayer = null;
HEU_LoadBufferVolumeLayer layer = terrainBuffers[t]._layers[m];
// Look up TerrainLayer file via attribute if user has set it
if (!string.IsNullOrEmpty(layer._layerPath))
{
terrainlayer = HEU_AssetDatabase.LoadAssetAtPath(layer._layerPath, typeof(TerrainLayer)) as TerrainLayer;
if (terrainlayer == null)
{
Debug.LogWarningFormat("TerrainLayer, set via attribute, not found at: {0}", layer._layerPath);
continue;
}
}
if (terrainlayer == null)
{
terrainlayer = new TerrainLayer();
}
if (!string.IsNullOrEmpty(layer._diffuseTexturePath))
{
terrainlayer.diffuseTexture = HEU_MaterialFactory.LoadTexture(layer._diffuseTexturePath);
}
if (terrainlayer.diffuseTexture == null)
{
terrainlayer.diffuseTexture = defaultTexture;
}
terrainlayer.diffuseRemapMin = Vector4.zero;
terrainlayer.diffuseRemapMax = Vector4.one;
if (!string.IsNullOrEmpty(layer._maskTexturePath))
{
terrainlayer.maskMapTexture = HEU_MaterialFactory.LoadTexture(layer._maskTexturePath);
}
terrainlayer.maskMapRemapMin = Vector4.zero;
terrainlayer.maskMapRemapMax = Vector4.one;
terrainlayer.metallic = layer._metallic;
if (!string.IsNullOrEmpty(layer._normalTexturePath))
{
terrainlayer.normalMapTexture = HEU_MaterialFactory.LoadTexture(layer._normalTexturePath);
}
terrainlayer.normalScale = layer._normalScale;
terrainlayer.smoothness = layer._smoothness;
terrainlayer.specular = layer._specularColor;
terrainlayer.tileOffset = layer._tileOffset;
if (layer._tileSize.magnitude == 0f && terrainlayer.diffuseTexture != null)
{
// Use texture size if tile size is 0
layer._tileSize = new Vector2(terrainlayer.diffuseTexture.width, terrainlayer.diffuseTexture.height);
}
terrainlayer.tileSize = layer._tileSize;
// Note index is m - 1 due to skipping height layer
terrainLayers[m - 1] = terrainlayer;
}
terrainData.terrainLayers = terrainLayers;
}
#else
// Need to create SplatPrototype for each layer in heightfield, representing the textures.
SplatPrototype[] splatPrototypes = new SplatPrototype[numLayers];
for (int m = 0; m < numLayers; ++m)
{
splatPrototypes[m] = new SplatPrototype();
HEU_LoadBufferVolumeLayer layer = terrainBuffers[t]._layers[m];
Texture2D diffuseTexture = null;
if (!string.IsNullOrEmpty(layer._diffuseTexturePath))
{
diffuseTexture = HEU_MaterialFactory.LoadTexture(layer._diffuseTexturePath);
}
if (diffuseTexture == null)
{
diffuseTexture = defaultTexture;
}
splatPrototypes[m].texture = diffuseTexture;
splatPrototypes[m].tileOffset = layer._tileOffset;
if (layer._tileSize.magnitude == 0f && diffuseTexture != null)
{
// Use texture size if tile size is 0
layer._tileSize = new Vector2(diffuseTexture.width, diffuseTexture.height);
}
splatPrototypes[m].tileSize = layer._tileSize;
splatPrototypes[m].metallic = layer._metallic;
splatPrototypes[m].smoothness = layer._smoothness;
if (!string.IsNullOrEmpty(layer._normalTexturePath))
{
splatPrototypes[m].normalMap = HEU_MaterialFactory.LoadTexture(layer._normalTexturePath);
}
}
terrainData.splatPrototypes = splatPrototypes;
#endif
// Set the splatmaps
if (terrainBuffers[t]._splatMaps != null)
{
// Set the alphamap size before setting the alphamaps to get correct scaling
// The alphamap size comes from the first alphamap layer
int alphamapResolution = terrainBuffers[t]._heightMapWidth;
if (numLayers > 1)
{
alphamapResolution = terrainBuffers[t]._layers[1]._heightMapWidth;
}
terrainData.alphamapResolution = alphamapResolution;
terrainData.SetAlphamaps(0, 0, terrainBuffers[t]._splatMaps);
}
// Set the tree scattering
if (terrainBuffers[t]._scatterTrees != null)
{
HEU_TerrainUtility.ApplyScatter(terrainData, terrainBuffers[t]._scatterTrees);
}
terrainBuffers[t]._generatedOutput = generatedOutput;
_generatedOutputs.Add(generatedOutput);
SetOutputVisiblity(terrainBuffers[t]);
}
}
}
private void GenerateTerrain(List<HEU_LoadBufferVolume> terrainBuffers)
{
Transform parent = this.gameObject.transform;
int numVolues = terrainBuffers.Count;
for(int t = 0; t < numVolues; ++t)
{
if (terrainBuffers[t]._heightMap != null)
{
GameObject newGameObject = new GameObject("heightfield_" + terrainBuffers[t]._tileIndex);
Transform newTransform = newGameObject.transform;
newTransform.parent = parent;
HEU_GeneratedOutput generatedOutput = new HEU_GeneratedOutput();
generatedOutput._outputData._gameObject = newGameObject;
Terrain terrain = HEU_GeneralUtility.GetOrCreateComponent<Terrain>(newGameObject);
TerrainCollider collider = HEU_GeneralUtility.GetOrCreateComponent<TerrainCollider>(newGameObject);
terrain.terrainData = new TerrainData();
TerrainData terrainData = terrain.terrainData;
collider.terrainData = terrainData;
int heightMapSize = terrainBuffers[t]._heightMapSize;
terrainData.heightmapResolution = heightMapSize;
if (terrainData.heightmapResolution != heightMapSize)
{
Debug.LogErrorFormat("Unsupported terrain size: {0}", heightMapSize);
continue;
}
terrainData.baseMapResolution = heightMapSize;
terrainData.alphamapResolution = heightMapSize;
const int resolutionPerPatch = 128;
terrainData.SetDetailResolution(resolutionPerPatch, resolutionPerPatch);
terrainData.SetHeights(0, 0, terrainBuffers[t]._heightMap);
terrainData.size = new Vector3(terrainBuffers[t]._terrainSizeX, terrainBuffers[t]._heightRange, terrainBuffers[t]._terrainSizeY);
terrain.Flush();
// Set position
HAPI_Transform hapiTransformVolume = new HAPI_Transform(true);
hapiTransformVolume.position[0] += terrainBuffers[t]._position[0];
hapiTransformVolume.position[1] += terrainBuffers[t]._position[1];
hapiTransformVolume.position[2] += terrainBuffers[t]._position[2];
HEU_HAPIUtility.ApplyLocalTransfromFromHoudiniToUnity(ref hapiTransformVolume, newTransform);
// Set layers
Texture2D defaultTexture = HEU_VolumeCache.LoadDefaultSplatTexture();
int numLayers = terrainBuffers[t]._layers.Count;
#if UNITY_2018_3_OR_NEWER
// Create TerrainLayer for each heightfield layer
// Note that at time of this implementation the new Unity terrain
// is still in beta. Therefore, the following layer creation is subject
// to change.
TerrainLayer[] terrainLayers = new TerrainLayer[numLayers];
for (int m = 0; m < numLayers; ++m)
{
terrainLayers[m] = new TerrainLayer();
HEU_LoadBufferVolumeLayer layer = terrainBuffers[t]._layers[m];
if (!string.IsNullOrEmpty(layer._diffuseTexturePath))
{
// Using Resources.Load is much faster than AssetDatabase.Load
//terrainLayers[m].diffuseTexture = HEU_MaterialFactory.LoadTexture(layer._diffuseTexturePath);
terrainLayers[m].diffuseTexture = Resources.Load<Texture2D>(layer._diffuseTexturePath);
}
if (terrainLayers[m].diffuseTexture == null)
{
terrainLayers[m].diffuseTexture = defaultTexture;
}
terrainLayers[m].diffuseRemapMin = Vector4.zero;
terrainLayers[m].diffuseRemapMax = Vector4.one;
if (!string.IsNullOrEmpty(layer._maskTexturePath))
{
// Using Resources.Load is much faster than AssetDatabase.Load
//terrainLayers[m].maskMapTexture = HEU_MaterialFactory.LoadTexture(layer._maskTexturePath);
terrainLayers[m].maskMapTexture = Resources.Load<Texture2D>(layer._maskTexturePath);
}
terrainLayers[m].maskMapRemapMin = Vector4.zero;
terrainLayers[m].maskMapRemapMax = Vector4.one;
terrainLayers[m].metallic = layer._metallic;
if (!string.IsNullOrEmpty(layer._normalTexturePath))
{
terrainLayers[m].normalMapTexture = HEU_MaterialFactory.LoadTexture(layer._normalTexturePath);
}
terrainLayers[m].normalScale = layer._normalScale;
terrainLayers[m].smoothness = layer._smoothness;
terrainLayers[m].specular = layer._specularColor;
terrainLayers[m].tileOffset = layer._tileOffset;
if (layer._tileSize.magnitude == 0f && terrainLayers[m].diffuseTexture != null)
{
// Use texture size if tile size is 0
layer._tileSize = new Vector2(terrainLayers[m].diffuseTexture.width, terrainLayers[m].diffuseTexture.height);
}
terrainLayers[m].tileSize = layer._tileSize;
}
terrainData.terrainLayers = terrainLayers;
#else
// Need to create SplatPrototype for each layer in heightfield, representing the textures.
SplatPrototype[] splatPrototypes = new SplatPrototype[numLayers];
for (int m = 0; m < numLayers; ++m)
{
splatPrototypes[m] = new SplatPrototype();
HEU_LoadBufferVolumeLayer layer = terrainBuffers[t]._layers[m];
Texture2D diffuseTexture = null;
if (!string.IsNullOrEmpty(layer._diffuseTexturePath))
{
diffuseTexture = HEU_MaterialFactory.LoadTexture(layer._diffuseTexturePath);
}
if (diffuseTexture == null)
{
diffuseTexture = defaultTexture;
}
splatPrototypes[m].texture = diffuseTexture;
splatPrototypes[m].tileOffset = layer._tileOffset;
if (layer._tileSize.magnitude == 0f && diffuseTexture != null)
{
// Use texture size if tile size is 0
layer._tileSize = new Vector2(diffuseTexture.width, diffuseTexture.height);
}
splatPrototypes[m].tileSize = layer._tileSize;
splatPrototypes[m].metallic = layer._metallic;
splatPrototypes[m].smoothness = layer._smoothness;
if (!string.IsNullOrEmpty(layer._normalTexturePath))
{
splatPrototypes[m].normalMap = HEU_MaterialFactory.LoadTexture(layer._normalTexturePath);
}
}
terrainData.splatPrototypes = splatPrototypes;
#endif
terrainData.SetAlphamaps(0, 0, terrainBuffers[t]._splatMaps);
//string assetPath = HEU_AssetDatabase.CreateAssetCacheFolder("terrainData");
//AssetDatabase.CreateAsset(terrainData, assetPath);
//Debug.Log("Created asset data at " + assetPath);
terrainBuffers[t]._generatedOutput = generatedOutput;
_generatedOutputs.Add(generatedOutput);
SetOutputVisiblity(terrainBuffers[t]);
}
}
}
public bool GenerateTerrainBuffers(HEU_SessionBase session, HAPI_NodeId nodeID, List<HAPI_PartInfo> volumeParts,
List<HAPI_PartInfo> scatterInstancerParts, out List<HEU_LoadBufferVolume> volumeBuffers)
{
volumeBuffers = null;
if (volumeParts.Count == 0)
{
return true;
}
volumeBuffers = new List<HEU_LoadBufferVolume>();
int numParts = volumeParts.Count;
for (int i = 0; i < numParts; ++i)
{
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(nodeID, volumeParts[i].id, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
SetLog(HEU_LoadData.LoadStatus.ERROR, "This heightfield is not supported. Please check documentation.");
return false;
}
if (volumeInfo.xLength != volumeInfo.yLength)
{
SetLog(HEU_LoadData.LoadStatus.ERROR, "Non-square sized terrain not supported.");
return false;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
bool bHeightPart = volumeName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_HEIGHT);
bool bMaskPart = volumeName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_MASK);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
// Ignoring mask layer because it is Houdini-specific (same behaviour as regular HDA terrain generation)
if (bMaskPart)
{
continue;
}
HEU_LoadBufferVolumeLayer layer = new HEU_LoadBufferVolumeLayer();
layer._layerName = volumeName;
layer._partID = volumeParts[i].id;
layer._heightMapWidth = volumeInfo.xLength;
layer._heightMapHeight = volumeInfo.yLength;
Matrix4x4 volumeTransformMatrix = HEU_HAPIUtility.GetMatrixFromHAPITransform(ref volumeInfo.transform, false);
layer._position = HEU_HAPIUtility.GetPosition(ref volumeTransformMatrix);
Vector3 scale = HEU_HAPIUtility.GetScale(ref volumeTransformMatrix);
// Calculate real terrain size in both Houdini and Unity.
// The height values will be mapped over this terrain size.
float gridSpacingX = scale.x * 2f;
float gridSpacingY = scale.y * 2f;
layer._terrainSizeX = Mathf.Round((volumeInfo.xLength - 1) * gridSpacingX);
layer._terrainSizeY = Mathf.Round((volumeInfo.yLength - 1) * gridSpacingY);
// Get volume bounds for calculating position offset
session.GetVolumeBounds(nodeID, volumeParts[i].id,
out layer._minBounds.x, out layer._minBounds.y, out layer._minBounds.z,
out layer._maxBounds.x, out layer._maxBounds.y, out layer._maxBounds.z,
out layer._center.x, out layer._center.y, out layer._center.z);
// Look up TerrainLayer file via attribute if user has set it
layer._layerPath = HEU_GeneralUtility.GetAttributeStringValueSingle(session, nodeID, volumeParts[i].id,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINLAYER_FILE_ATTR, HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM);
LoadStringFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_DIFFUSE_ATTR, ref layer._diffuseTexturePath);
LoadStringFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_MASK_ATTR, ref layer._maskTexturePath);
LoadStringFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_NORMAL_ATTR, ref layer._normalTexturePath);
LoadFloatFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_NORMAL_SCALE_ATTR, ref layer._normalScale);
LoadFloatFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_METALLIC_ATTR, ref layer._metallic);
LoadFloatFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_SMOOTHNESS_ATTR, ref layer._smoothness);
LoadLayerColorFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_SPECULAR_ATTR, ref layer._specularColor);
LoadLayerVector2FromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TILE_OFFSET_ATTR, ref layer._tileOffset);
LoadLayerVector2FromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TILE_SIZE_ATTR, ref layer._tileSize);
// Get the height values from Houdini along with the min and max height range.
layer._normalizedHeights = HEU_TerrainUtility.GetNormalizedHeightmapFromPartWithMinMax(_session, nodeID, volumeParts[i].id, volumeInfo.xLength, volumeInfo.yLength, ref layer._minHeight, ref layer._maxHeight, ref layer._heightRange);
// Get the tile index, if it exists, for this part
HAPI_AttributeInfo tileAttrInfo = new HAPI_AttributeInfo();
int[] tileAttrData = new int[0];
HEU_GeneralUtility.GetAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.HAPI_HEIGHTFIELD_TILE_ATTR, ref tileAttrInfo, ref tileAttrData, session.GetAttributeIntData);
int tileIndex = 0;
if (tileAttrInfo.exists && tileAttrData.Length == 1)
{
tileIndex = tileAttrData[0];
}
// Add layer based on tile index
if (tileIndex >= 0)
{
HEU_LoadBufferVolume volumeBuffer = null;
for(int j = 0; j < volumeBuffers.Count; ++j)
{
if (volumeBuffers[j]._tileIndex == tileIndex)
{
volumeBuffer = volumeBuffers[j];
break;
}
}
if (volumeBuffer == null)
{
volumeBuffer = new HEU_LoadBufferVolume();
volumeBuffer.InitializeBuffer(volumeParts[i].id, volumeName, false, false);
volumeBuffer._tileIndex = tileIndex;
volumeBuffers.Add(volumeBuffer);
}
if (bHeightPart)
{
// Height layer always first layer
volumeBuffer._layers.Insert(0, layer);
volumeBuffer._heightMapWidth = layer._heightMapWidth;
volumeBuffer._heightMapHeight = layer._heightMapHeight;
volumeBuffer._terrainSizeX = layer._terrainSizeX;
volumeBuffer._terrainSizeY = layer._terrainSizeY;
volumeBuffer._heightRange = (layer._maxHeight - layer._minHeight);
// Look up TerrainData file path via attribute if user has set it
volumeBuffer._terrainDataPath = HEU_GeneralUtility.GetAttributeStringValueSingle(session, nodeID, volumeBuffer._id,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINDATA_FILE_ATTR, HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM);
// Load the TreePrototype buffers
List<HEU_TreePrototypeInfo> treePrototypeInfos = HEU_TerrainUtility.GetTreePrototypeInfosFromPart(session, nodeID, volumeBuffer._id);
if (treePrototypeInfos != null)
{
if (volumeBuffer._scatterTrees == null)
{
volumeBuffer._scatterTrees = new HEU_VolumeScatterTrees();
}
volumeBuffer._scatterTrees._treePrototypInfos = treePrototypeInfos;
}
}
else
{
volumeBuffer._layers.Add(layer);
}
}
Sleep();
}
// Each volume buffer is a self contained terrain tile
foreach(HEU_LoadBufferVolume volumeBuffer in volumeBuffers)
{
List<HEU_LoadBufferVolumeLayer> layers = volumeBuffer._layers;
//Debug.LogFormat("Heightfield: tile={0}, layers={1}", tile._tileIndex, layers.Count);
int heightMapWidth = volumeBuffer._heightMapWidth;
int heightMapHeight = volumeBuffer._heightMapHeight;
int numLayers = layers.Count;
if (numLayers > 0)
{
// Convert heightmap values from Houdini to Unity
volumeBuffer._heightMap = HEU_TerrainUtility.ConvertHeightMapHoudiniToUnity(heightMapWidth, heightMapHeight, layers[0]._normalizedHeights);
Sleep();
// Convert splatmap values from Houdini to Unity.
// Start at 2nd index since height is strictly for height values (not splatmap).
List<float[]> heightFields = new List<float[]>();
for(int m = 1; m < numLayers; ++m)
{
heightFields.Add(layers[m]._normalizedHeights);
}
// The number of maps are the number of splatmaps (ie. non height/mask layers)
int numMaps = heightFields.Count;
if (numMaps > 0)
{
// Using the first splatmap size for all splatmaps
volumeBuffer._splatMaps = HEU_TerrainUtility.ConvertHeightFieldToAlphaMap(layers[1]._heightMapWidth, layers[1]._heightMapHeight, heightFields);
}
else
{
volumeBuffer._splatMaps = null;
}
volumeBuffer._position = new Vector3((volumeBuffer._terrainSizeX + volumeBuffer._layers[0]._minBounds.x), volumeBuffer._layers[0]._minHeight + volumeBuffer._layers[0]._position.y, volumeBuffer._layers[0]._minBounds.z);
}
}
// Process the scatter instancer parts to get the scatter data
for (int i = 0; i < scatterInstancerParts.Count; ++i)
{
// Find the terrain tile (use primitive attr). Assume 0 tile if not set (i.e. not split into tiles)
int terrainTile = 0;
HAPI_AttributeInfo tileAttrInfo = new HAPI_AttributeInfo();
int[] tileAttrData = new int[0];
if (HEU_GeneralUtility.GetAttribute(session, nodeID, scatterInstancerParts[i].id, HEU_Defines.HAPI_HEIGHTFIELD_TILE_ATTR, ref tileAttrInfo, ref tileAttrData, session.GetAttributeIntData))
{
if (tileAttrData != null && tileAttrData.Length > 0)
{
terrainTile = tileAttrData[0];
}
}
// Find the volume layer associated with this part using the terrain tile index
HEU_LoadBufferVolume volumeBuffer = GetLoadBufferVolumeFromTileIndex(terrainTile, volumeBuffers);
if (volumeBuffer == null)
{
continue;
}
HEU_TerrainUtility.PopulateScatterInfo(session, nodeID, scatterInstancerParts[i].id, scatterInstancerParts[i].pointCount, ref volumeBuffer._scatterTrees);
}
return true;
}
public bool GenerateTerrainBuffers(HEU_SessionBase session, HAPI_NodeId nodeID, List<HAPI_PartInfo> volumeParts,
out List<HEU_LoadBufferVolume> volumeBuffers)
{
volumeBuffers = null;
if (volumeParts.Count == 0)
{
return true;
}
volumeBuffers = new List<HEU_LoadBufferVolume>();
int numParts = volumeParts.Count;
for (int i = 0; i < numParts; ++i)
{
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(nodeID, volumeParts[i].id, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
SetLog(HEU_LoadData.LoadStatus.ERROR, "This heightfield is not supported. Please check documentation.");
return false;
}
if (volumeInfo.xLength != volumeInfo.yLength)
{
SetLog(HEU_LoadData.LoadStatus.ERROR, "Non-square sized terrain not supported.");
return false;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
bool bHeightPart = volumeName.Equals("height");
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
HEU_LoadBufferVolumeLayer layer = new HEU_LoadBufferVolumeLayer();
layer._layerName = volumeName;
layer._partID = volumeParts[i].id;
layer._heightMapSize = volumeInfo.xLength;
Matrix4x4 volumeTransformMatrix = HEU_HAPIUtility.GetMatrixFromHAPITransform(ref volumeInfo.transform, false);
layer._position = HEU_HAPIUtility.GetPosition(ref volumeTransformMatrix);
Vector3 scale = HEU_HAPIUtility.GetScale(ref volumeTransformMatrix);
// Calculate real terrain size in both Houdini and Unity.
// The height values will be mapped over this terrain size.
float gridSpacingX = scale.x * 2f;
float gridSpacingY = scale.y * 2f;
layer._terrainSizeX = Mathf.Round((volumeInfo.xLength - 1) * gridSpacingX);
layer._terrainSizeY = Mathf.Round((volumeInfo.yLength - 1) * gridSpacingY);
// Get volume bounds for calculating position offset
session.GetVolumeBounds(nodeID, volumeParts[i].id,
out layer._minBounds.x, out layer._minBounds.y, out layer._minBounds.z,
out layer._maxBounds.x, out layer._maxBounds.y, out layer._maxBounds.z,
out layer._center.x, out layer._center.y, out layer._center.z);
LoadStringFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_DIFFUSE_ATTR, ref layer._diffuseTexturePath);
LoadStringFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_MASK_ATTR, ref layer._maskTexturePath);
LoadStringFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_NORMAL_ATTR, ref layer._normalTexturePath);
LoadFloatFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_NORMAL_SCALE_ATTR, ref layer._normalScale);
LoadFloatFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_METALLIC_ATTR, ref layer._metallic);
LoadFloatFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_SMOOTHNESS_ATTR, ref layer._smoothness);
LoadLayerColorFromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_SPECULAR_ATTR, ref layer._specularColor);
LoadLayerVector2FromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TILE_OFFSET_ATTR, ref layer._tileOffset);
LoadLayerVector2FromAttribute(session, nodeID, volumeParts[i].id, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TILE_SIZE_ATTR, ref layer._tileSize);
// Get the height values from Houdini and find the min and max height range.
if (!HEU_GeometryUtility.GetHeightfieldValues(session, volumeInfo.xLength, volumeInfo.yLength, nodeID, volumeParts[i].id, ref layer._rawHeights, ref layer._minHeight, ref layer._maxHeight))
{
return false;
}
// TODO: Tried to replace above with this, but it flattens the heights
//layer._rawHeights = HEU_GeometryUtility.GetHeightfieldFromPart(_session, nodeID, volumeParts[i].id, "part", volumeInfo.xLength);
// Get the tile index, if it exists, for this part
HAPI_AttributeInfo tileAttrInfo = new HAPI_AttributeInfo();
int[] tileAttrData = new int[0];
HEU_GeneralUtility.GetAttribute(session, nodeID, volumeParts[i].id, "tile", ref tileAttrInfo, ref tileAttrData, session.GetAttributeIntData);
int tileIndex = 0;
if (tileAttrInfo.exists && tileAttrData.Length == 1)
{
tileIndex = tileAttrData[0];
}
// Add layer based on tile index
if (tileIndex >= 0)
{
HEU_LoadBufferVolume volumeBuffer = null;
for(int j = 0; j < volumeBuffers.Count; ++j)
{
if (volumeBuffers[j]._tileIndex == tileIndex)
{
volumeBuffer = volumeBuffers[j];
break;
}
}
if (volumeBuffer == null)
{
volumeBuffer = new HEU_LoadBufferVolume();
volumeBuffer.InitializeBuffer(volumeParts[i].id, volumeName, false, false);
volumeBuffer._tileIndex = tileIndex;
volumeBuffers.Add(volumeBuffer);
}
if (bHeightPart)
{
// Height layer always first layer
volumeBuffer._layers.Insert(0, layer);
volumeBuffer._heightMapSize = layer._heightMapSize;
volumeBuffer._terrainSizeX = layer._terrainSizeX;
volumeBuffer._terrainSizeY = layer._terrainSizeY;
volumeBuffer._heightRange = (layer._maxHeight - layer._minHeight);
}
else
{
volumeBuffer._layers.Add(layer);
}
}
Sleep();
}
// Each volume buffer is a self contained terrain tile
foreach(HEU_LoadBufferVolume volumeBuffer in volumeBuffers)
{
List<HEU_LoadBufferVolumeLayer> layers = volumeBuffer._layers;
//Debug.LogFormat("Heightfield: tile={0}, layers={1}", tile._tileIndex, layers.Count);
int heightMapSize = volumeBuffer._heightMapSize;
int numLayers = layers.Count;
if (numLayers > 0)
{
// Convert heightmap values from Houdini to Unity
volumeBuffer._heightMap = HEU_GeometryUtility.ConvertHeightMapHoudiniToUnity(heightMapSize, layers[0]._rawHeights, layers[0]._minHeight, layers[0]._maxHeight);
Sleep();
// Convert splatmap values from Houdini to Unity.
List<float[]> heightFields = new List<float[]>();
for(int m = 1; m < numLayers; ++m)
{
heightFields.Add(layers[m]._rawHeights);
}
volumeBuffer._splatMaps = HEU_GeometryUtility.ConvertHeightSplatMapHoudiniToUnity(heightMapSize, heightFields);
volumeBuffer._position = new Vector3((volumeBuffer._terrainSizeX + volumeBuffer._layers[0]._minBounds.x), volumeBuffer._layers[0]._minHeight + volumeBuffer._layers[0]._position.y, volumeBuffer._layers[0]._minBounds.z);
}
}
return true;
}
