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 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 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);
}
}
}
