/// <summary>
/// Creates terrain from given volumeInfo for the given gameObject.
/// If gameObject has a valid Terrain component, then it is reused.
/// Similarly, if the Terrain component has a valid TerrainData, or if the given terrainData is valid, then it is used.
/// Otherwise a new TerrainData is created and set to the Terrain.
/// Populates the volumePositionOffset with the heightfield offset position.
/// Returns true if successfully created the terrain, otherwise false.
/// </summary>
/// <param name="session">Houdini Engine session to query heightfield data from</param>
/// <param name="volumeInfo">Volume info pertaining to the heightfield to generate the Terrain from</param>
/// <param name="geoID">The geometry ID</param>
/// <param name="partID">The part ID (height layer)</param>
/// <param name="gameObject">The target GameObject containing the Terrain component</param>
/// <param name="terrainData">A valid TerrainData to use, or if empty, a new one is created and populated</param>
/// <param name="volumePositionOffset">Heightfield offset</param>
/// <returns>True if successfully popupated the terrain</returns>
public static bool GenerateTerrainFromVolume(HEU_SessionBase session, ref HAPI_VolumeInfo volumeInfo, HAPI_NodeId geoID, HAPI_PartId partID,
GameObject gameObject, ref TerrainData terrainData, out Vector3 volumePositionOffset, ref Terrain terrain)
{
volumePositionOffset = Vector3.zero;
if (volumeInfo.zLength == 1 && volumeInfo.tupleSize == 1)
{
// Heightfields will be converted to terrain in Unity.
// Unity requires terrainData.heightmapResolution to be square power of two plus 1 (eg. 513, 257, 129, 65).
// Houdini gives volumeInfo.xLength and volumeInfo.yLength which are the number of height values per dimension.
// Note that volumeInfo.xLength and volumeInfo.yLength is equal to Houdini heightfield size / grid spacing.
// The heightfield grid spacing is given as volumeTransformMatrix.scale but divided by 2 (grid spacing / 2 = volumeTransformMatrix.scale).
// It is recommended to use grid spacing of 2.
// Use the volumeInfo.transform to get the actual heightfield position and size.
Matrix4x4 volumeTransformMatrix = HEU_HAPIUtility.GetMatrixFromHAPITransform(ref volumeInfo.transform, false);
Vector3 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;
float terrainSizeX = Mathf.Round((volumeInfo.xLength - 1) * gridSpacingX);
float terrainSizeY = Mathf.Round((volumeInfo.yLength - 1) * gridSpacingY);
// Test size
//float terrainSizeX = Mathf.Round((volumeInfo.xLength) * gridSpacingX);
//float terrainSizeY = Mathf.Round((volumeInfo.yLength) * gridSpacingY);
//Debug.LogFormat("GS = {0},{1},{2}. SX = {1}. SY = {2}", gridSpacingX, gridSpacingY, terrainSizeX, terrainSizeY);
//Debug.LogFormat("HeightField Pos:{0}, Scale:{1}", position, scale.ToString("{0.00}"));
//Debug.LogFormat("HeightField tileSize:{0}, xLength:{1}, yLength:{2}", volumeInfo.tileSize.ToString("{0.00}"), volumeInfo.xLength.ToString("{0.00}"), volumeInfo.yLength.ToString("{0.00}"));
//Debug.LogFormat("HeightField Terrain Size x:{0}, y:{1}", terrainSizeX.ToString("{0.00}"), terrainSizeY.ToString("{0.00}"));
//Debug.LogFormat("HeightField minX={0}, minY={1}, minZ={2}", volumeInfo.minX.ToString("{0.00}"), volumeInfo.minY.ToString("{0.00}"), volumeInfo.minZ.ToString("{0.00}"));
const int UNITY_MINIMUM_HEIGHTMAP_RESOLUTION = 33;
if (terrainSizeX < UNITY_MINIMUM_HEIGHTMAP_RESOLUTION || terrainSizeY < UNITY_MINIMUM_HEIGHTMAP_RESOLUTION)
{
Debug.LogWarningFormat("Unity Terrain has a minimum heightmap resolution of {0}. This HDA heightmap size is {1}x{2}."
+ "\nPlease resize the terrain to a value higher than this.",
UNITY_MINIMUM_HEIGHTMAP_RESOLUTION, terrainSizeX, terrainSizeY);
return false;
}
bool bNewTerrain = false;
bool bNewTerrainData = false;
terrain = gameObject.GetComponent<Terrain>();
if (terrain == null)
{
terrain = gameObject.AddComponent<Terrain>();
bNewTerrain = true;
}
#if !HEU_TERRAIN_COLLIDER_DISABLED
TerrainCollider collider = HEU_GeneralUtility.GetOrCreateComponent<TerrainCollider>(gameObject);
#endif
// Look up terrain material, if specified, on the height layer
string specifiedTerrainMaterialName = HEU_GeneralUtility.GetMaterialAttributeValueFromPart(session,
geoID, partID);
// This ensures to reuse existing terraindata, and only creates new if none exist or none provided
if (terrain.terrainData == null)
{
if (terrainData == null)
{
terrainData = new TerrainData();
bNewTerrainData = true;
}
terrain.terrainData = terrainData;
SetTerrainMaterial(terrain, specifiedTerrainMaterialName);
}
terrainData = terrain.terrainData;
#if !HEU_TERRAIN_COLLIDER_DISABLED
collider.terrainData = terrainData;
#endif
if (bNewTerrain)
{
#if UNITY_2018_3_OR_NEWER
terrain.allowAutoConnect = true;
// This has to be set after setting material
terrain.drawInstanced = true;
#endif
}
// Heightmap resolution must be square power-of-two plus 1.
// Unity will automatically resize terrainData.heightmapResolution so need to handle the changed size (if Unity changed it).
int heightMapResolution = volumeInfo.xLength;
terrainData.heightmapResolution = heightMapResolution;
int terrainResizedDelta = terrainData.heightmapResolution - heightMapResolution;
if (terrainResizedDelta < 0)
{
Debug.LogWarningFormat("Note that Unity automatically resized terrain resolution to {0} from {1}. Use terrain size of power of two plus 1, and grid spacing of 2.", heightMapResolution, terrainData.heightmapResolution);
heightMapResolution = terrainData.heightmapResolution;
}
else if (terrainResizedDelta > 0)
{
Debug.LogErrorFormat("Unsupported terrain size. Use terrain size of power of two plus 1, and grid spacing of 2. Given size is {0} but Unity resized it to {1}.", heightMapResolution, terrainData.heightmapResolution);
return false;
}
int mapWidth = volumeInfo.xLength;
int mapHeight = volumeInfo.yLength;
// Get the converted height values from Houdini and find the min and max height range.
float minHeight = 0;
float maxHeight = 0;
float heightRange = 0;
bool bUseHeightRangeOverride = true;
float[] normalizedHeights = GetNormalizedHeightmapFromPartWithMinMax(session, geoID, partID,
volumeInfo.xLength, volumeInfo.yLength, ref minHeight, ref maxHeight, ref heightRange,
bUseHeightRangeOverride);
float[,] unityHeights = ConvertHeightMapHoudiniToUnity(heightMapResolution, heightMapResolution, normalizedHeights);
// 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.
if (bNewTerrainData)
{
// 32 is the default for resolutionPerPatch
const int detailResolution = 1024;
const int resolutionPerPatch = 32;
terrainData.SetDetailResolution(detailResolution, resolutionPerPatch);
}
// Note SetHeights must be called before setting size in next line, as otherwise
// the internal terrain size will not change after setting the size.
terrainData.SetHeights(0, 0, unityHeights);
// 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).
if (heightRange == 0)
{
heightRange = terrainData.size.y > 1 ? terrainData.size.y : 600;
}
terrainData.size = new Vector3(terrainSizeX, heightRange, terrainSizeY);
terrain.Flush();
// Unity Terrain has origin at bottom left, whereas Houdini uses centre of terrain.
// Use volume bounds to set position offset when using split tiles
float xmin, xmax, zmin, zmax, ymin, ymax, xcenter, ycenter, zcenter;
session.GetVolumeBounds(geoID, partID, out xmin, out ymin, out zmin, out xmax, out ymax, out zmax, out xcenter,
out ycenter, out zcenter);
//Debug.LogFormat("xmin: {0}, xmax: {1}, ymin: {2}, ymax: {3}, zmin: {4}, zmax: {5}, xc: {6}, yc: {7}, zc: {8}",
// xmin, xmax, ymin, ymax, zmin, zmax, xcenter, ycenter, zcenter);
// Offset position is based on size of heightfield
float offsetX = (float)heightMapResolution / (float)mapWidth;
float offsetZ = (float)heightMapResolution / (float)mapHeight;
//Debug.LogFormat("offsetX: {0}, offsetZ: {1}", offsetX, offsetZ);
// Use y position from attribute if user has set it
float ypos = position.y + minHeight;
float userYPos;
if (HEU_GeneralUtility.GetAttributeFloatSingle(session, geoID, partID,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_YPOS, out userYPos))
{
ypos = userYPos;
}
// TODO: revisit how the position is calculated
volumePositionOffset = new Vector3((terrainSizeX + xmin) * offsetX, ypos, zmin * offsetZ);
// Test position
//volumePositionOffset = new Vector3(xcenter + mapWidth, ycenter, zcenter - mapHeight);
return true;
}
else
{
Debug.LogWarning("Non-heightfield volume type not supported!");
}
return false;
}
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 detailResolution = 0;
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);
HFLayerType layerType = HEU_TerrainUtility.GetHeightfieldLayerType(session, nodeID, volumeParts[i].id, volumeName);
//Debug.LogFormat("Index: {0}, Part id: {1}, Part Name: {2}, Volume Name: {3}", i, volumeParts[i].id, HEU_SessionManager.GetString(volumeParts[i].nameSH), volumeName);
// Ignoring mask layer because it is Houdini-specific (same behaviour as regular HDA terrain generation)
if (layerType == HFLayerType.MASK)
{
continue;
}
HEU_LoadBufferVolumeLayer layer = new HEU_LoadBufferVolumeLayer();
layer._layerName = volumeName;
layer._partID = volumeParts[i].id;
layer._heightMapWidth = volumeInfo.xLength;
layer._heightMapHeight = volumeInfo.yLength;
layer._layerType = layerType;
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);
if (layerType != HFLayerType.DETAIL)
{
layer._hasLayerAttributes = HEU_TerrainUtility.VolumeLayerHasAttributes(session, nodeID, volumeParts[i].id);
if (layer._hasLayerAttributes)
{
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,
(layerType == HFLayerType.HEIGHT));
}
// 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 (layerType == HFLayerType.HEIGHT)
{
// Height layer always first layer
volumeBuffer._splatLayers.Insert(0, layer);
volumeBuffer._heightMapWidth = layer._heightMapWidth;
volumeBuffer._heightMapHeight = layer._heightMapHeight;
volumeBuffer._terrainSizeX = layer._terrainSizeX;
volumeBuffer._terrainSizeY = layer._terrainSizeY;
volumeBuffer._heightRange = layer._heightRange;
// The terrain heightfield position in y requires offset of min height
layer._position.y += layer._minHeight;
// Use y position from attribute if user has set it
float userYPos;
if (HEU_GeneralUtility.GetAttributeFloatSingle(session, nodeID, volumeParts[i].id,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_YPOS, out userYPos))
{
layer._position.y = userYPos;
}
// 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);
// Look up TerrainData export file path via attribute if user has set it
volumeBuffer._terrainDataExportPath = HEU_GeneralUtility.GetAttributeStringValueSingle(session, nodeID, volumeBuffer._id,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINDATA_EXPORT_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;
}
HEU_TerrainUtility.PopulateDetailProperties(session, nodeID,
volumeBuffer._id, ref volumeBuffer._detailProperties);
// Get specified material if any
volumeBuffer._specifiedTerrainMaterialName = HEU_GeneralUtility.GetMaterialAttributeValueFromPart(session,
nodeID, volumeBuffer._id);
}
else if(layer._layerType == HFLayerType.DETAIL)
{
// Get detail prototype
HEU_DetailPrototype detailPrototype = null;
HEU_TerrainUtility.PopulateDetailPrototype(session, nodeID, volumeParts[i].id, ref detailPrototype);
int[,] detailMap = HEU_TerrainUtility.GetDetailMapFromPart(session, nodeID,
volumeParts[i].id, out detailResolution);
volumeBuffer._detailPrototypes.Add(detailPrototype);
volumeBuffer._detailMaps.Add(detailMap);
// Set the detail resolution which is formed from the detail layer
if (volumeBuffer._detailProperties == null)
{
volumeBuffer._detailProperties = new HEU_DetailProperties();
}
volumeBuffer._detailProperties._detailResolution = detailResolution;
}
else
{
volumeBuffer._splatLayers.Add(layer);
}
}
Sleep();
}
// Each volume buffer is a self contained terrain tile
foreach(HEU_LoadBufferVolume volumeBuffer in volumeBuffers)
{
List<HEU_LoadBufferVolumeLayer> layers = volumeBuffer._splatLayers;
//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)
{
// Ignore Detail layers as they are handled differently
if(layers[m]._layerType != HFLayerType.DETAIL)
{
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;
}
// TODO: revisit how the position is calculated
volumeBuffer._position = new Vector3(
volumeBuffer._terrainSizeX + volumeBuffer._splatLayers[0]._minBounds.x,
volumeBuffer._splatLayers[0]._position.y,
volumeBuffer._splatLayers[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))
{
// Try part 0 (the height layer) to get the tile index.
// For scatter points merged with HF, in some cases the part ID doesn't have the tile attribute.
HEU_GeneralUtility.GetAttribute(session, nodeID, 0, 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.PopulateScatterTrees(session, nodeID, scatterInstancerParts[i].id, scatterInstancerParts[i].pointCount, ref volumeBuffer._scatterTrees);
}
return true;
}
