private void GetPartLayerAttributes(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_NodeId partID, HEU_VolumeLayer layer)
{
// 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, geoID, partID, HEU_Defines.HAPI_HEIGHTFIELD_TILE_ATTR, ref tileAttrInfo, ref tileAttrData, session.GetAttributeIntData);
if (tileAttrData != null && tileAttrData.Length > 0)
{
layer._tile = tileAttrData[0];
//Debug.LogFormat("Tile: {0}", tileAttrData[0]);
}
else
{
layer._tile = 0;
}
layer._hasLayerAttributes = HEU_TerrainUtility.VolumeLayerHasAttributes(session, geoID, partID);
}
public void GenerateTerrainWithAlphamaps(HEU_SessionBase session, HEU_HoudiniAsset houdiniAsset, bool bRebuild)
{
if(_layers == null || _layers.Count == 0)
{
Debug.LogError("Unable to generate terrain due to lack of heightfield layers!");
return;
}
HEU_VolumeLayer heightLayer = _layers[0];
HAPI_VolumeInfo heightVolumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(_ownerNode.GeoID, heightLayer._part.PartID, ref heightVolumeInfo);
if (!bResult)
{
Debug.LogErrorFormat("Unable to get volume info for height layer: {0}!", heightLayer._layerName);
return;
}
// Special handling of volume cache presets. It is applied here (if exists) because it might pertain to TerrainData that exists
// in the AssetDatabase. If we don't apply here but rather create a new one, the existing file will get overwritten.
// Applying the preset here for terrain ensures the TerrainData is reused.
// Get the volume preset for this part
HEU_VolumeCachePreset volumeCachePreset = houdiniAsset.GetVolumeCachePreset(_ownerNode.ObjectNode.ObjectName, _ownerNode.GeoName, TileIndex);
if (volumeCachePreset != null)
{
ApplyPreset(volumeCachePreset);
// Remove it so that it doesn't get applied when doing the recook step
houdiniAsset.RemoveVolumeCachePreset(volumeCachePreset);
}
// The TerrainData and TerrainLayer files needs to be saved out if we create them. This creates the relative folder
// path from the Asset's cache folder: {assetCache}/{geo name}/Terrain/Tile{tileIndex}/...
string relativeFolderPath = HEU_Platform.BuildPath(_ownerNode.GeoName, HEU_Defines.HEU_FOLDER_TERRAIN, HEU_Defines.HEU_FOLDER_TILE + TileIndex);
if (bRebuild)
{
// For full rebuild, re-create the TerrainData instead of using previous
_terrainData = null;
}
//Debug.Log("Generating Terrain with AlphaMaps: " + (_terrainData != null ? _terrainData.name : "NONE"));
TerrainData terrainData = _terrainData;
Vector3 terrainOffsetPosition = Vector3.zero;
// Look up TerrainData file via attribute if user has set it
string terrainDataFile = HEU_GeneralUtility.GetAttributeStringValueSingle(session, _ownerNode.GeoID, heightLayer._part.PartID,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINDATA_FILE_ATTR, HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM);
if (!string.IsNullOrEmpty(terrainDataFile))
{
TerrainData loadedTerrainData = HEU_AssetDatabase.LoadAssetAtPath(terrainDataFile, typeof(TerrainData)) as TerrainData;
if (loadedTerrainData == null)
{
Debug.LogWarningFormat("TerrainData, set via attribute, not found at: {0}", terrainDataFile);
}
else
{
// In the case that the specified TerrainData belongs to another Terrain (i.e. input Terrain),
// make a copy of it and store it in our cache. Note that this overwrites existing TerrainData in our cache
// because the workflow is such that attributes will always override local setting.
string bakedTerrainPath = houdiniAsset.GetValidAssetCacheFolderPath();
bakedTerrainPath = HEU_Platform.BuildPath(bakedTerrainPath, relativeFolderPath);
terrainData = HEU_AssetDatabase.CopyAndLoadAssetAtAnyPath(loadedTerrainData, bakedTerrainPath, typeof(TerrainData), true) as TerrainData;
if (terrainData == null)
{
Debug.LogErrorFormat("Unable to copy TerrainData from {0} for generating Terrain.", terrainDataFile);
}
}
}
// Generate the terrain and terrain data from the height layer. This applies height values.
bResult = HEU_TerrainUtility.GenerateTerrainFromVolume(session, ref heightVolumeInfo, heightLayer._part.ParentGeoNode.GeoID,
heightLayer._part.PartID, heightLayer._part.OutputGameObject, ref terrainData, out terrainOffsetPosition);
if (!bResult || terrainData == null)
{
return;
}
if (_terrainData != terrainData)
{
_terrainData = terrainData;
heightLayer._part.SetTerrainData(terrainData, relativeFolderPath);
}
heightLayer._part.SetTerrainOffsetPosition(terrainOffsetPosition);
int terrainSize = terrainData.heightmapResolution;
// Now process TerrainLayers and alpha maps
// First, preprocess all layers to get heightfield arrays, converted to proper size
List<float[]> heightFields = new List<float[]>();
// Corresponding list of HF volume layers to process as splatmaps
List<HEU_VolumeLayer> volumeLayersToProcess = new List<HEU_VolumeLayer>();
int numLayers = _layers.Count;
float minHeight = 0;
float maxHeight = 0;
float heightRange = 0;
// This skips the height layer, and processes all other layers.
// Note that mask shouldn't be part of _layers at this point.
for(int i = 1; i < numLayers; ++i)
{
float[] normalizedHF = HEU_TerrainUtility.GetNormalizedHeightmapFromPartWithMinMax(session, _ownerNode.GeoID, _layers[i]._part.PartID,
_layers[i]._xLength, _layers[i]._yLength, ref minHeight, ref maxHeight, ref heightRange);
if (normalizedHF != null && normalizedHF.Length > 0)
{
heightFields.Add(normalizedHF);
volumeLayersToProcess.Add(_layers[i]);
}
}
int numVolumeLayers = volumeLayersToProcess.Count;
HAPI_NodeId geoID;
HAPI_PartId partID;
Texture2D defaultTexture = LoadDefaultSplatTexture();
#if UNITY_2018_3_OR_NEWER
// Create or update the terrain layers based on heightfield layers.
// 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);
// This holds the alpha map indices for each layer that will be added to the TerrainData.
// The alpha maps could be a mix of existing and new values, so need to know which to use
// Initially set to use existing alpha maps, then override later on if specified via HF layers
List<int> alphaMapIndices = new List<int>();
for (int a = 0; a < existingTerrainLayers.Length; ++a)
{
// Negative indices for existing alpha map (offset by -1)
alphaMapIndices.Add(-a - 1);
}
bool bNewTerrainLayer = false;
HEU_VolumeLayer layer = null;
TerrainLayer terrainLayer = null;
bool bSetTerrainLayerProperties = true;
for (int m = 0; m < numVolumeLayers; ++m)
{
bNewTerrainLayer = false;
bSetTerrainLayerProperties = true;
layer = volumeLayersToProcess[m];
geoID = _ownerNode.GeoID;
partID = layer._part.PartID;
terrainLayer = null;
int terrainLayerIndex = -1;
// The TerrainLayer attribute overrides existing TerrainLayer. So if its set, load and use it.
string terrainLayerFile = HEU_GeneralUtility.GetAttributeStringValueSingle(session, geoID, partID,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINLAYER_FILE_ATTR, HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM);
if (!string.IsNullOrEmpty(terrainLayerFile))
{
terrainLayer = HEU_AssetDatabase.LoadAssetAtPath(terrainLayerFile, typeof(TerrainLayer)) as TerrainLayer;
if (terrainLayer == null)
{
Debug.LogWarningFormat("TerrainLayer, set via attribute, not found at: {0}", terrainLayerFile);
// Not earlying out or skipping this layer due to error because we want to keep proper indexing
// by creating a new TerrainLayer.
}
else
{
// TerrainLayer loaded from attribute.
// It could be an existing TerrainLayer that is already part of finalTerrainLayers
// or could be a new one which needs to be added.
// If its a different TerrainLayer than existing, update the finalTerrainLayers, and index.
if (layer._terrainLayer != null && layer._terrainLayer != terrainLayer)
{
terrainLayerIndex = HEU_TerrainUtility.GetTerrainLayerIndex(layer._terrainLayer, existingTerrainLayers);
if (terrainLayerIndex >= 0)
{
finalTerrainLayers[terrainLayerIndex] = terrainLayer;
}
}
if (terrainLayerIndex == -1)
{
// Always check if its part of existing list so as not to add it again
terrainLayerIndex = HEU_TerrainUtility.GetTerrainLayerIndex(terrainLayer, existingTerrainLayers);
}
}
}
// No terrain layer specified, so try using existing if we have it
if (terrainLayer == null)
{
terrainLayerIndex = HEU_TerrainUtility.GetTerrainLayerIndex(layer._terrainLayer, existingTerrainLayers);
if (terrainLayerIndex >= 0)
{
// Note the terrainLayerIndex is same for finalTerrainLayers as existingTerrainLayers
terrainLayer = existingTerrainLayers[terrainLayerIndex];
}
}
// Still not found, so just create a new one
if (terrainLayer == null)
{
terrainLayer = new TerrainLayer();
terrainLayer.name = layer._layerName;
//Debug.LogFormat("Created new TerrainLayer with name: {0} ", terrainLayer.name);
bNewTerrainLayer = true;
}
if (terrainLayerIndex == -1)
{
// Adding to the finalTerrainLayers if this is indeed a newly created or loaded TerrainLayer
// (i.e. isn't already part of the TerrainLayers for this Terrain).
// Save this layer's index for later on if we make a copy.
terrainLayerIndex = finalTerrainLayers.Count;
finalTerrainLayers.Add(terrainLayer);
// Positive index for alpha map from heightfield (starting at 1)
alphaMapIndices.Add(m + 1);
}
else
{
// Positive index for alpha map from heightfield (starting at 1)
alphaMapIndices[terrainLayerIndex] = m + 1;
}
// 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 (!bNewTerrainLayer && layer._hasLayerAttributes)
{
string bakedTerrainPath = houdiniAsset.GetValidAssetCacheFolderPath();
bakedTerrainPath = HEU_Platform.BuildPath(bakedTerrainPath, relativeFolderPath);
TerrainLayer prevTerrainLayer = terrainLayer;
terrainLayer = HEU_AssetDatabase.CopyAndLoadAssetAtAnyPath(terrainLayer, bakedTerrainPath, typeof(TerrainLayer), true) as TerrainLayer;
if (terrainLayer != null)
{
// Update the TerrainLayer reference in the list with this copy
finalTerrainLayers[terrainLayerIndex] = 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.
}
}
// Now override layer properties if they have been set via attributes
if (bSetTerrainLayerProperties)
{
LoadLayerPropertiesFromAttributes(session, geoID, partID, terrainLayer, bNewTerrainLayer, defaultTexture);
}
if (bNewTerrainLayer)
{
// In order to retain the new TerrainLayer, it must be saved to the AssetDatabase.
Object savedObject = null;
string layerFileNameWithExt = terrainLayer.name;
if (!layerFileNameWithExt.EndsWith(HEU_Defines.HEU_EXT_TERRAINLAYER))
{
layerFileNameWithExt += HEU_Defines.HEU_EXT_TERRAINLAYER;
}
houdiniAsset.AddToAssetDBCache(layerFileNameWithExt, terrainLayer, relativeFolderPath, ref savedObject);
}
// Store reference
layer._terrainLayer = terrainLayer;
}
// Get existing alpha maps so we can reuse the values if needed
float[,,] existingAlphaMaps = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight);
terrainData.terrainLayers = finalTerrainLayers.ToArray();
int numTotalAlphaMaps = finalTerrainLayers.Count;
#else
// Create or update the SplatPrototype based on heightfield layers.
// Need to create or reuse SplatPrototype for each layer in heightfield, representing the textures.
SplatPrototype[] existingSplats = terrainData.splatPrototypes;
// A full rebuild clears out existing splats, but a regular cook keeps them.
List<SplatPrototype> finalSplats = new List<SplatPrototype>(existingSplats);
// This holds the alpha map indices for each layer that will be added to the TerrainData
// The alpha maps could be a mix of existing and new values, so need to know which to use
List<int> alphaMapIndices = new List<int>();
// Initially set to use existing alpha maps, then override later on if specified via HF layers.
for (int a = 0; a < existingSplats.Length; ++a)
{
// Negative indices for existing alpha map (offset by -1)
alphaMapIndices.Add(-a - 1);
}
bool bNewSplat = false;
HEU_VolumeLayer layer = null;
SplatPrototype splatPrototype = null;
for (int m = 0; m < numVolumeLayers; ++m)
{
bNewSplat = false;
layer = volumeLayersToProcess[m];
geoID = _ownerNode.GeoID;
partID = layer._part.PartID;
// Try to find existing SplatPrototype for reuse. But not for full rebuild.
splatPrototype = null;
if (layer._splatPrototypeIndex >= 0 && layer._splatPrototypeIndex < existingSplats.Length)
{
splatPrototype = existingSplats[layer._splatPrototypeIndex];
// Positive index for alpha map from heightfield (starting at 1)
alphaMapIndices[layer._splatPrototypeIndex] = m + 1;
}
if (splatPrototype == null)
{
splatPrototype = new SplatPrototype();
layer._splatPrototypeIndex = finalSplats.Count;
finalSplats.Add(splatPrototype);
// Positive index for alpha map from heightfield (starting at 1)
alphaMapIndices.Add(m + 1);
}
// Now override splat properties if they have been set via attributes
LoadLayerPropertiesFromAttributes(session, geoID, partID, splatPrototype, bNewSplat, defaultTexture);
}
// On regular cook, get existing alpha maps so we can reuse the values if needed.
float[,,] existingAlphaMaps = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight);
terrainData.splatPrototypes = finalSplats.ToArray();
int numTotalAlphaMaps = finalSplats.Count;
#endif
// Set alpha maps by combining with existing alpha maps, and appending new heightfields
float[,,] alphamap = null;
if (numTotalAlphaMaps > 0 && volumeLayersToProcess.Count > 0)
{
// Convert the heightfields into alpha maps with layer strengths
float[] strengths = new float[volumeLayersToProcess.Count];
for (int m = 0; m < volumeLayersToProcess.Count; ++m)
{
strengths[m] = volumeLayersToProcess[m]._strength;
}
alphamap = HEU_TerrainUtility.AppendConvertedHeightFieldToAlphaMap(
volumeLayersToProcess[0]._xLength, volumeLayersToProcess[0]._yLength, existingAlphaMaps,
heightFields, strengths, alphaMapIndices);
// Update the alphamap resolution to the actual size of the first
// heightfield layer used for the alphamaps.
// Setting the size before setting the alphamas applies proper scaling.
int alphamapResolution = volumeLayersToProcess[0]._xLength;
terrainData.alphamapResolution = alphamapResolution;
terrainData.SetAlphamaps(0, 0, alphamap);
}
// Tree instances for scattering
HEU_TerrainUtility.ApplyScatter(terrainData, _scatterTrees);
// If the layers were writen out, this saves the asset DB. Otherwise user has to save it themselves.
// Not 100% sure this is needed, but without this the editor doesn't know the terrain asset has been updated
// and therefore doesn't import and show the terrain layer.
HEU_AssetDatabase.SaveAssetDatabase();
}
public void UpdateLayerFromPart(HEU_SessionBase session, HEU_PartData part)
{
HEU_GeoNode geoNode = part.ParentGeoNode;
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(geoNode.GeoID, part.PartID, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
return;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
part.SetVolumeLayerName(volumeName);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
bool bHeightPart = volumeName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_HEIGHT);
bool bMaskPart = volumeName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_MASK);
HEU_VolumeLayer layer = GetLayer(volumeName);
if (layer == null)
{
layer = new HEU_VolumeLayer();
layer._layerName = volumeName;
if (bHeightPart)
{
_layers.Insert(0, layer);
}
else if(!bMaskPart)
{
_layers.Add(layer);
}
}
layer._part = part;
layer._xLength = volumeInfo.xLength;
layer._yLength = volumeInfo.yLength;
if (!bMaskPart)
{
GetPartLayerAttributes(session, geoNode.GeoID, part.PartID, layer);
}
if (!bHeightPart)
{
// Non-height parts don't have any outputs as they are simply layers carrying info
part.DestroyAllData();
}
else
{
// Height part
List<HEU_TreePrototypeInfo> treePrototypeInfos = HEU_TerrainUtility.GetTreePrototypeInfosFromPart(session, geoNode.GeoID, part.PartID);
if (treePrototypeInfos != null)
{
if (_scatterTrees == null)
{
_scatterTrees = new HEU_VolumeScatterTrees();
}
_scatterTrees._treePrototypInfos = treePrototypeInfos;
}
}
if (!_updatedLayers.Contains(layer))
{
if (bHeightPart)
{
_updatedLayers.Insert(0, layer);
}
else if (!bMaskPart)
{
_updatedLayers.Add(layer);
}
}
}
public void PopulateScatterInfo(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, int pointCount)
{
HEU_TerrainUtility.PopulateScatterInfo(session, geoID, partID, pointCount, ref _scatterTrees);
}
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;
// 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]);
}
}
}
public void UpdateLayerFromPart(HEU_SessionBase session, HEU_PartData part)
{
HEU_GeoNode geoNode = part.ParentGeoNode;
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(geoNode.GeoID, part.PartID, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
return;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
part.SetVolumeLayerName(volumeName);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
HFLayerType layerType = HEU_TerrainUtility.GetHeightfieldLayerType(session, geoNode.GeoID, part.PartID, volumeName);
HEU_VolumeLayer layer = GetLayer(volumeName);
if (layer == null)
{
layer = new HEU_VolumeLayer();
layer._layerName = volumeName;
if (layerType == HFLayerType.HEIGHT)
{
_layers.Insert(0, layer);
}
else if (layerType != HFLayerType.MASK)
{
_layers.Add(layer);
}
}
layer._part = part;
layer._xLength = volumeInfo.xLength;
layer._yLength = volumeInfo.yLength;
layer._layerType = layerType;
if (layerType != HFLayerType.MASK)
{
GetPartLayerAttributes(session, geoNode.GeoID, part.PartID, layer);
}
if (layerType != HFLayerType.HEIGHT)
{
// Non-height parts don't have any outputs as they are simply layers carrying info
part.DestroyAllData();
}
else
{
// Height part
// Might contain terrain properties via attributes (i.e. not layer specific, but for entire terrain)
// Scatter Tree Prototypes
List<HEU_TreePrototypeInfo> treePrototypeInfos = HEU_TerrainUtility.GetTreePrototypeInfosFromPart(session, geoNode.GeoID, part.PartID);
if (treePrototypeInfos != null)
{
if (_scatterTrees == null)
{
_scatterTrees = new HEU_VolumeScatterTrees();
}
_scatterTrees._treePrototypInfos = treePrototypeInfos;
}
HEU_TerrainUtility.PopulateDetailProperties(session, geoNode.GeoID,
part.PartID, ref _detailProperties);
}
if (!_updatedLayers.Contains(layer))
{
if (layerType == HFLayerType.HEIGHT)
{
_updatedLayers.Insert(0, layer);
}
else if (layerType != HFLayerType.MASK)
{
_updatedLayers.Add(layer);
}
}
}
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 void PopulateDetailPrototype(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID,
HEU_VolumeLayer layer)
{
HEU_TerrainUtility.PopulateDetailPrototype(session, geoID, partID, ref layer._detailPrototype);
}
internal void ProcessVolumeParts(HEU_SessionBase session, List <HEU_PartData> volumeParts, bool bRebuild)
{
if (ParentAsset == null)
{
return;
}
int numVolumeParts = volumeParts.Count;
if (numVolumeParts == 0)
{
DestroyVolumeCache();
}
else if (_volumeCaches == null)
{
_volumeCaches = new List <HEU_VolumeCache>();
}
// First update volume caches. Each volume cache represents a set of terrain layers grouped by tile index.
// Therefore each volume cache represents a potential Unity Terrain (containing layers)
_volumeCaches = HEU_VolumeCache.UpdateVolumeCachesFromParts(session, this, volumeParts, _volumeCaches);
// Heightfield scatter nodes come in as mesh-type parts with attribute instancing.
// So process them here to get all the tree/detail instance scatter information.
int numParts = _parts.Count;
for (int i = 0; i < numParts; ++i)
{
// Find the terrain tile (use primitive attr). Assume 0 tile if not set (i.e. not split into tiles)
int terrainTile = 0;
HEU_TerrainUtility.GetAttributeTile(session, GeoID, _parts[i].PartID, out terrainTile);
// Find the volumecache associated with this part using the terrain tile index
HEU_VolumeCache volumeCache = GetVolumeCacheByTileIndex(terrainTile);
if (volumeCache == null)
{
continue;
}
HEU_VolumeLayer volumeLayer = volumeCache.GetLayer(_parts[i].GetVolumeLayerName());
if (volumeLayer != null && volumeLayer._layerType == HFLayerType.DETAIL)
{
// Clear out outputs since it might have been created when the part was created.
_parts[i].DestroyAllData();
volumeCache.PopulateDetailPrototype(session, GeoID, _parts[i].PartID, volumeLayer);
}
else if (_parts[i].IsAttribInstancer())
{
HAPI_AttributeInfo treeInstAttrInfo = new HAPI_AttributeInfo();
if (HEU_GeneralUtility.GetAttributeInfo(session, GeoID, _parts[i].PartID, HEU_Defines.HEIGHTFIELD_TREEINSTANCE_PROTOTYPEINDEX, ref treeInstAttrInfo))
{
if (treeInstAttrInfo.exists && treeInstAttrInfo.count > 0)
{
// Clear out outputs since it might have been created when the part was created.
_parts[i].DestroyAllData();
// Mark the instancers as having been created so that the object instancer step skips this.
_parts[i]._objectInstancesGenerated = true;
bool throwWarningIfNoTileAttribute = _volumeCaches.Count > 1;
// Now populate scatter trees based on attributes on this part
// Note: Might do redudant work for each volume and might need refactoring for performance.
foreach (HEU_VolumeCache cache in _volumeCaches)
{
cache.PopulateScatterTrees(session, GeoID, _parts[i].PartID, treeInstAttrInfo.count, throwWarningIfNoTileAttribute);
}
}
}
}
}
// Now generate the terrain for each volume cache
foreach (HEU_VolumeCache cache in _volumeCaches)
{
cache.GenerateTerrainWithAlphamaps(session, ParentAsset, bRebuild);
cache.IsDirty = false;
}
}
public void UpdateLayerFromPart(HEU_SessionBase session, HEU_PartData part)
{
HEU_GeoNode geoNode = part.ParentGeoNode;
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(geoNode.GeoID, part.PartID, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
return;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
part.SetVolumeLayerName(volumeName);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
HEU_VolumeLayer.HFLayerType layerType = GetHeightfieldLayerType(session, geoNode.GeoID, part.PartID, volumeName);
HEU_VolumeLayer layer = GetLayer(volumeName);
if (layer == null)
{
layer = new HEU_VolumeLayer();
layer._layerName = volumeName;
if (layerType == HEU_VolumeLayer.HFLayerType.HEIGHT)
{
_layers.Insert(0, layer);
}
else if(layerType != HEU_VolumeLayer.HFLayerType.MASK)
{
_layers.Add(layer);
}
}
layer._part = part;
layer._xLength = volumeInfo.xLength;
layer._yLength = volumeInfo.yLength;
layer._layerType = layerType;
if (layerType != HEU_VolumeLayer.HFLayerType.MASK)
{
GetPartLayerAttributes(session, geoNode.GeoID, part.PartID, layer);
}
if (layerType != HEU_VolumeLayer.HFLayerType.HEIGHT)
{
// Non-height parts don't have any outputs as they are simply layers carrying info
part.DestroyAllData();
}
else
{
// Height part
// Might contain terrain properties via attributes (i.e. not layer specific, but for entire terrain)
// Scatter Tree Prototypes
List<HEU_TreePrototypeInfo> treePrototypeInfos = HEU_TerrainUtility.GetTreePrototypeInfosFromPart(session, geoNode.GeoID, part.PartID);
if (treePrototypeInfos != null)
{
if (_scatterTrees == null)
{
_scatterTrees = new HEU_VolumeScatterTrees();
}
_scatterTrees._treePrototypInfos = treePrototypeInfos;
}
// Detail distance
HAPI_AttributeInfo detailDistanceAttrInfo = new HAPI_AttributeInfo();
int[] detailDistances = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoNode.GeoID, part.PartID,
HEU_Defines.HEIGHTFIELD_DETAIL_DISTANCE, ref detailDistanceAttrInfo, ref detailDistances,
session.GetAttributeIntData);
// Scatter Detail Resolution Per Patch (note that Detail Resolution comes from HF layer size)
HAPI_AttributeInfo resolutionPatchAttrInfo = new HAPI_AttributeInfo();
int[] resolutionPatches = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoNode.GeoID, part.PartID,
HEU_Defines.HEIGHTFIELD_DETAIL_RESOLUTION_PER_PATCH, ref resolutionPatchAttrInfo,
ref resolutionPatches, session.GetAttributeIntData);
if (_detailProperties == null)
{
_detailProperties = new HEU_DetailProperties();
}
// Unity only supports 1 set of detail resolution properties per terrain
int arraySize = 1;
if (detailDistanceAttrInfo.exists && detailDistances.Length >= arraySize)
{
_detailProperties._detailDistance = detailDistances[0];
}
if (resolutionPatchAttrInfo.exists && resolutionPatches.Length >= arraySize)
{
_detailProperties._detailResolutionPerPatch = resolutionPatches[0];
}
}
if (!_updatedLayers.Contains(layer))
{
if (layerType == HEU_VolumeLayer.HFLayerType.HEIGHT)
{
_updatedLayers.Insert(0, layer);
}
else if (layerType != HEU_VolumeLayer.HFLayerType.MASK)
{
_updatedLayers.Add(layer);
}
}
}
/// <summary>
/// Upload the alphamaps (TerrainLayers) into heightfield network.
/// </summary>
/// <param name="session"></param>
/// <param name="idt"></param>
/// <param name="baseVolumeInfo">The valid base height HAPI_VolumeInfo</param>
/// <param name="bMaskSet">This is set to true if a mask layer was uploaded</param>
/// <returns>True if successfully uploaded all layers</returns>
public bool UploadAlphaMaps(HEU_SessionBase session, HEU_InputDataTerrain idt, ref HAPI_VolumeInfo baseVolumeInfo, out bool bMaskSet)
{
bool bResult = true;
bMaskSet = false;
int alphaLayers = idt._terrainData.alphamapLayers;
if (alphaLayers < 1)
{
return(bResult);
}
int sizeX = idt._terrainData.alphamapWidth;
int sizeY = idt._terrainData.alphamapHeight;
int totalSize = sizeX * sizeY;
float[,,] alphaMaps = idt._terrainData.GetAlphamaps(0, 0, sizeX, sizeY);
float[][] alphaMapsConverted = new float[alphaLayers][];
// Convert the alphamap layers to double arrays.
for (int m = 0; m < alphaLayers; ++m)
{
alphaMapsConverted[m] = new float[totalSize];
for (int j = 0; j < sizeY; j++)
{
for (int i = 0; i < sizeX; i++)
{
// Flip for coordinate system change
float h = alphaMaps[i, (sizeY - j - 1), m];
alphaMapsConverted[m][i + j * sizeX] = h;
}
}
}
// Create volume layers for all alpha maps and upload values.
bool bMaskLayer = false;
int inputLayerIndex = 1;
for (int m = 0; m < alphaLayers; ++m)
{
#if UNITY_2018_3_OR_NEWER
string layerName = idt._terrainData.terrainLayers[m].name;
#else
string layerName = "unity_alphamap_" + m + 1;
#endif
// The Unity layer name could contain '.terrainlayer' and spaces. Remove them because Houdini doesn't allow
// spaces, and the extension isn't necessary.
layerName = layerName.Replace(" ", "_");
int extIndex = layerName.LastIndexOf(HEU_Defines.HEU_EXT_TERRAINLAYER);
if (extIndex > 0)
{
layerName = layerName.Remove(extIndex);
}
//HEU_Logger.Log("Processing terrain layer: " + layerName);
HAPI_NodeId alphaLayerID = HEU_Defines.HEU_INVALID_NODE_ID;
if (layerName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_HEIGHT))
{
// Skip height (base) layer (since it has been uploaded already)
continue;
}
else if (layerName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_MASK))
{
//HEU_Logger.Log("Mask layer found! Skipping creating the HF.");
bMaskSet = true;
bMaskLayer = true;
alphaLayerID = idt._maskNodeID;
float[,] heights = idt._terrainData.GetHeights(0, 0, idt._terrainData.heightmapResolution, idt._terrainData.heightmapResolution);
int heightsSizeX = heights.GetLength(0);
int heightsSizeY = heights.GetLength(1);
alphaMapsConverted[m] = HEU_TerrainUtility.ResampleData(alphaMapsConverted[m], sizeX, sizeY, heightsSizeX, heightsSizeY);
}
else
{
bMaskLayer = false;
if (!session.CreateHeightfieldInputVolumeNode(idt._heightfieldNodeID, out alphaLayerID, layerName,
Mathf.RoundToInt(sizeX * idt._voxelSize), Mathf.RoundToInt(sizeY * idt._voxelSize), idt._voxelSize))
{
bResult = false;
HEU_Logger.LogError("Failed to create input volume node for layer " + layerName);
break;
}
}
//HEU_Logger.Log("Uploading terrain layer: " + layerName);
if (!SetHeightFieldData(session, alphaLayerID, 0, alphaMapsConverted[m], layerName, ref baseVolumeInfo))
{
bResult = false;
break;
}
#if UNITY_2018_3_OR_NEWER
SetTerrainLayerAttributesToHeightField(session, alphaLayerID, 0, idt._terrainData.terrainLayers[m]);
#endif
if (!session.CommitGeo(alphaLayerID))
{
bResult = false;
HEU_Logger.LogError("Failed to commit volume layer " + layerName);
break;
}
if (!bMaskLayer)
{
// Connect to the merge node but starting from index 1 since index 0 is height layer
if (!session.ConnectNodeInput(idt._mergeNodeID, inputLayerIndex + 1, alphaLayerID, 0))
{
bResult = false;
HEU_Logger.LogError("Unable to connect new volume node for layer " + layerName);
break;
}
inputLayerIndex++;
}
}
return(bResult);
}
/// <summary>
/// Upload the base height layer into heightfield network.
/// </summary>
/// <param name="session"></param>
/// <param name="idt"></param>
/// <returns></returns>
public bool UploadHeightValuesWithTransform(HEU_SessionBase session, HEU_InputDataTerrain idt, ref HAPI_VolumeInfo volumeInfo)
{
// Get Geo, Part, and Volume infos
HAPI_GeoInfo geoInfo = new HAPI_GeoInfo();
if (!session.GetGeoInfo(idt._heightNodeID, ref geoInfo))
{
HEU_Logger.LogError("Unable to get geo info from heightfield node!");
return(false);
}
HAPI_PartInfo partInfo = new HAPI_PartInfo();
if (!session.GetPartInfo(geoInfo.nodeId, 0, ref partInfo))
{
HEU_Logger.LogError("Unable to get part info from heightfield node!");
return(false);
}
volumeInfo = new HAPI_VolumeInfo();
if (!session.GetVolumeInfo(idt._heightNodeID, 0, ref volumeInfo))
{
HEU_Logger.LogError("Unable to get volume info from heightfield node!");
return(false);
}
if ((volumeInfo.xLength - 1) != Mathf.RoundToInt(idt._numPointsX / idt._voxelSize) ||
(volumeInfo.yLength - 1) != Mathf.RoundToInt(idt._numPointsY / idt._voxelSize) ||
idt._terrainData.heightmapResolution != volumeInfo.xLength ||
idt._terrainData.heightmapResolution != volumeInfo.yLength)
{
HEU_Logger.LogWarning("Created heightfield in Houdini differs in voxel size from input terrain! Terrain may require resampling.");
}
// Update volume infos, and set it. This is required.
volumeInfo.tileSize = 1;
volumeInfo.type = HAPI_VolumeType.HAPI_VOLUMETYPE_HOUDINI;
volumeInfo.storage = HAPI_StorageType.HAPI_STORAGETYPE_FLOAT;
volumeInfo.transform = idt._transform;
volumeInfo.minX = 0;
volumeInfo.minY = 0;
volumeInfo.minZ = 0;
volumeInfo.tupleSize = 1;
volumeInfo.tileSize = 1;
volumeInfo.hasTaper = false;
volumeInfo.xTaper = 0f;
volumeInfo.yTaper = 0f;
if (!session.SetVolumeInfo(idt._heightNodeID, partInfo.id, ref volumeInfo))
{
HEU_Logger.LogError("Unable to set volume info on input heightfield node!");
return(false);
}
// Now set the height data
float[,] heights = idt._terrainData.GetHeights(0, 0, idt._terrainData.heightmapResolution, idt._terrainData.heightmapResolution);
int sizeX = heights.GetLength(0);
int sizeY = heights.GetLength(1);
int totalSize = sizeX * sizeY;
// Convert to single array
float[] heightsArr = new float[totalSize];
for (int j = 0; j < sizeY; j++)
{
for (int i = 0; i < sizeX; i++)
{
// Flip for coordinate system change
float h = heights[i, (sizeY - j - 1)];
heightsArr[i + j * sizeX] = h * idt._heightScale;
}
}
if (volumeInfo.xLength != volumeInfo.yLength)
{
HEU_Logger.LogError("Error: Houdini heightmap must be square!");
return(false);
}
if (idt._terrainData.heightmapResolution != volumeInfo.xLength)
{
// Resize heightsArr to idt._terrainData.heightmapResolution
HEU_Logger.LogWarningFormat("Attempting to resize landscape from ({0}x{1}) to ({2}x{3})", idt._terrainData.heightmapResolution, idt._terrainData.heightmapResolution, volumeInfo.xLength, volumeInfo.xLength);
heightsArr = HEU_TerrainUtility.ResampleData(heightsArr, idt._terrainData.heightmapResolution, idt._terrainData.heightmapResolution, volumeInfo.xLength, volumeInfo.xLength);
sizeX = volumeInfo.xLength;
sizeY = volumeInfo.yLength;
totalSize = sizeX * sizeY;
}
// Set the base height layer
if (!session.SetHeightFieldData(idt._heightNodeID, 0, HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_HEIGHT, heightsArr, 0, totalSize))
{
HEU_Logger.LogError("Unable to set height values on input heightfield node!");
return(false);
}
SetTerrainDataAttributesToHeightField(session, geoInfo.nodeId, 0, idt._terrainData);
SetTreePrototypes(session, geoInfo.nodeId, 0, idt._terrainData);
if (!session.CommitGeo(idt._heightNodeID))
{
HEU_Logger.LogError("Unable to commit geo on input heightfield node!");
return(false);
}
return(true);
}