Andron666
2191 lines
62 KiB
C++
2191 lines
62 KiB
C++
/*
|
|
* Copyright (c) <2017> Side Effects Software Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* Produced by:
|
|
* Mykola Konyk
|
|
* Side Effects Software Inc
|
|
* 123 Front Street West, Suite 1401
|
|
* Toronto, Ontario
|
|
* Canada M5J 2M2
|
|
* 416-504-9876
|
|
*
|
|
*/
|
|
|
|
#include "HoudiniGeoPartObject.h"
|
|
|
|
#include "HoudiniApi.h"
|
|
#include "HoudiniEngineRuntimePrivatePCH.h"
|
|
#include "HoudiniEngineUtils.h"
|
|
#include "HoudiniEngine.h"
|
|
#include "HoudiniPluginSerializationVersion.h"
|
|
#include "HoudiniEngineString.h"
|
|
|
|
uint32
|
|
GetTypeHash( const FHoudiniGeoPartObject & HoudiniGeoPartObject )
|
|
{
|
|
return HoudiniGeoPartObject.GetTypeHash();
|
|
}
|
|
|
|
FArchive &
|
|
operator<<( FArchive & Ar, FHoudiniGeoPartObject & HoudiniGeoPartObject )
|
|
{
|
|
HoudiniGeoPartObject.Serialize( Ar );
|
|
return Ar;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObjectSortPredicate::operator()( const FHoudiniGeoPartObject & A, const FHoudiniGeoPartObject & B ) const
|
|
{
|
|
if ( !A.IsValid() || !B.IsValid() )
|
|
return false;
|
|
|
|
if ( A.ObjectId == B.ObjectId )
|
|
{
|
|
if ( A.GeoId == B.GeoId )
|
|
{
|
|
if ( A.PartId == B.PartId )
|
|
return A.SplitId < B.SplitId;
|
|
else
|
|
return A.PartId < B.PartId;
|
|
}
|
|
else
|
|
{
|
|
return A.GeoId < B.GeoId;
|
|
}
|
|
}
|
|
|
|
return A.ObjectId < B.ObjectId;
|
|
}
|
|
|
|
FHoudiniGeoPartObject::FHoudiniGeoPartObject()
|
|
: TransformMatrix( FMatrix::Identity )
|
|
, ObjectName( TEXT("Empty" ) )
|
|
, PartName( TEXT( "Empty" ) )
|
|
, SplitName( TEXT( "" ) )
|
|
, InstancerMaterialName( TEXT( "" ) )
|
|
, InstancerAttributeMaterialName( TEXT( "" ) )
|
|
, AssetId( -1 )
|
|
, ObjectId( -1 )
|
|
, GeoId( -1 )
|
|
, PartId( -1 )
|
|
, SplitId( 0 )
|
|
, bIsVisible( true )
|
|
, bIsInstancer( false )
|
|
, bIsCurve( false )
|
|
, bIsEditable( false )
|
|
, bHasGeoChanged( false )
|
|
, bIsCollidable( false )
|
|
, bIsRenderCollidable( false )
|
|
, bIsLoaded( false )
|
|
, bPlaceHolderFlags( 0 )
|
|
, bIsTransacting( false )
|
|
, bHasCustomName( false )
|
|
, bIsBox( false )
|
|
, bIsSphere( false )
|
|
, bInstancerMaterialAvailable( false )
|
|
, bIsVolume( false )
|
|
, bInstancerAttributeMaterialAvailable( false )
|
|
, bIsPackedPrimitiveInstancer( false )
|
|
, bIsUCXCollisionGeo( false )
|
|
, bIsSimpleCollisionGeo( false )
|
|
, bHasCollisionBeenAdded( false )
|
|
, bHasSocketBeenAdded( false )
|
|
, UnusedFlagsSpace( 0u )
|
|
, HoudiniGeoPartObjectVersion( VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BASE )
|
|
{}
|
|
|
|
FHoudiniGeoPartObject::FHoudiniGeoPartObject(
|
|
HAPI_NodeId InAssetId, HAPI_NodeId InObjectId, HAPI_NodeId InGeoId, HAPI_PartId InPartId )
|
|
: TransformMatrix( FMatrix::Identity )
|
|
, ObjectName( TEXT( "Empty" ) )
|
|
, PartName( TEXT( "Empty" ) )
|
|
, SplitName( TEXT( "" ) )
|
|
, InstancerMaterialName( TEXT( "" ) )
|
|
, AssetId( InAssetId )
|
|
, ObjectId( InObjectId )
|
|
, GeoId( InGeoId )
|
|
, PartId( InPartId )
|
|
, SplitId( 0 )
|
|
, bIsVisible( true )
|
|
, bIsInstancer( false )
|
|
, bIsCurve( false )
|
|
, bIsEditable( false )
|
|
, bHasGeoChanged( false )
|
|
, bIsCollidable( false )
|
|
, bIsRenderCollidable( false )
|
|
, bIsLoaded( false )
|
|
, bPlaceHolderFlags( 0 )
|
|
, bIsTransacting( false )
|
|
, bHasCustomName( false )
|
|
, bIsBox( false )
|
|
, bIsSphere( false )
|
|
, bInstancerMaterialAvailable( false )
|
|
, bIsVolume( false )
|
|
, bInstancerAttributeMaterialAvailable( false )
|
|
, bIsPackedPrimitiveInstancer( false )
|
|
, bIsUCXCollisionGeo( false )
|
|
, bIsSimpleCollisionGeo( false )
|
|
, bHasCollisionBeenAdded( false )
|
|
, bHasSocketBeenAdded( false )
|
|
, UnusedFlagsSpace( 0u )
|
|
, HoudiniGeoPartObjectVersion( VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BASE )
|
|
{}
|
|
|
|
FHoudiniGeoPartObject::FHoudiniGeoPartObject(
|
|
const FTransform & InTransform, HAPI_NodeId InAssetId,
|
|
const HAPI_ObjectInfo & ObjectInfo, const HAPI_GeoInfo & GeoInfo, const HAPI_PartInfo & PartInfo )
|
|
: TransformMatrix( InTransform )
|
|
, ObjectName( TEXT( "Empty" ) )
|
|
, PartName( TEXT( "Empty" ) )
|
|
, SplitName( TEXT( "" ) )
|
|
, InstancerMaterialName( TEXT( "" ) )
|
|
, AssetId( InAssetId )
|
|
, ObjectId( ObjectInfo.nodeId )
|
|
, GeoId( GeoInfo.nodeId )
|
|
, PartId( PartInfo.id )
|
|
, SplitId( 0 )
|
|
, bIsVisible( ObjectInfo.isVisible )
|
|
, bIsInstancer( ObjectInfo.isInstancer )
|
|
, bIsCurve( PartInfo.type == HAPI_PARTTYPE_CURVE )
|
|
, bIsEditable( GeoInfo.isEditable )
|
|
, bHasGeoChanged( GeoInfo.hasGeoChanged )
|
|
, bIsCollidable( false )
|
|
, bIsRenderCollidable( false )
|
|
, bIsLoaded( false )
|
|
, bPlaceHolderFlags( 0 )
|
|
, bIsTransacting( false )
|
|
, bHasCustomName( false )
|
|
, bIsBox( PartInfo.type == HAPI_PARTTYPE_BOX )
|
|
, bIsSphere( PartInfo.type == HAPI_PARTTYPE_SPHERE )
|
|
, bInstancerMaterialAvailable( false )
|
|
, bIsVolume( PartInfo.type == HAPI_PARTTYPE_VOLUME )
|
|
, bInstancerAttributeMaterialAvailable( false )
|
|
, bIsPackedPrimitiveInstancer( PartInfo.type == HAPI_PARTTYPE_INSTANCER )
|
|
, bIsUCXCollisionGeo( false )
|
|
, bIsSimpleCollisionGeo( false )
|
|
, bHasCollisionBeenAdded( false )
|
|
, bHasSocketBeenAdded( false )
|
|
, UnusedFlagsSpace( 0u )
|
|
, HoudiniGeoPartObjectVersion( VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BASE )
|
|
{}
|
|
|
|
FHoudiniGeoPartObject::FHoudiniGeoPartObject(
|
|
const FTransform & InTransform, const FString & InObjectName,
|
|
const FString & InPartName, HAPI_NodeId InAssetId,
|
|
HAPI_NodeId InObjectId, HAPI_NodeId InGeoId,
|
|
HAPI_PartId InPartId )
|
|
: TransformMatrix( InTransform )
|
|
, ObjectName( InObjectName )
|
|
, PartName( InPartName )
|
|
, SplitName( TEXT( "" ) )
|
|
, InstancerMaterialName( TEXT( "" ) )
|
|
, AssetId( InAssetId )
|
|
, ObjectId( InObjectId )
|
|
, GeoId( InGeoId )
|
|
, PartId( InPartId )
|
|
, SplitId( 0 )
|
|
, bIsVisible( true )
|
|
, bIsInstancer( false )
|
|
, bIsCurve( false )
|
|
, bIsEditable( false )
|
|
, bHasGeoChanged( false )
|
|
, bIsCollidable( false )
|
|
, bIsRenderCollidable( false )
|
|
, bIsLoaded( false )
|
|
, bPlaceHolderFlags( 0 )
|
|
, bIsTransacting( false )
|
|
, bHasCustomName( false )
|
|
, bIsBox( false )
|
|
, bIsSphere( false )
|
|
, bInstancerMaterialAvailable( false )
|
|
, bIsVolume( false )
|
|
, bInstancerAttributeMaterialAvailable( false )
|
|
, bIsPackedPrimitiveInstancer( false )
|
|
, bIsUCXCollisionGeo( false )
|
|
, bIsSimpleCollisionGeo( false )
|
|
, bHasCollisionBeenAdded( false )
|
|
, bHasSocketBeenAdded( false )
|
|
, UnusedFlagsSpace( 0u )
|
|
, HoudiniGeoPartObjectVersion( VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BASE )
|
|
{}
|
|
|
|
FHoudiniGeoPartObject::FHoudiniGeoPartObject( const FHoudiniGeoPartObject & GeoPartObject, bool bCopyLoaded )
|
|
: TransformMatrix( GeoPartObject.TransformMatrix )
|
|
, ObjectName( GeoPartObject.ObjectName )
|
|
, PartName( GeoPartObject.PartName )
|
|
, SplitName( GeoPartObject.SplitName )
|
|
, InstancerMaterialName( GeoPartObject.InstancerMaterialName )
|
|
, AssetId( GeoPartObject.AssetId )
|
|
, ObjectId( GeoPartObject.ObjectId )
|
|
, GeoId( GeoPartObject.GeoId )
|
|
, PartId( GeoPartObject.PartId )
|
|
, SplitId( GeoPartObject.SplitId )
|
|
, bIsVisible( GeoPartObject.bIsVisible )
|
|
, bIsInstancer( GeoPartObject.bIsInstancer )
|
|
, bIsCurve( GeoPartObject.bIsCurve )
|
|
, bIsEditable( GeoPartObject.bIsEditable )
|
|
, bHasGeoChanged( GeoPartObject.bHasGeoChanged )
|
|
, bIsCollidable( GeoPartObject.bIsCollidable )
|
|
, bIsRenderCollidable( GeoPartObject.bIsRenderCollidable )
|
|
, bIsLoaded( GeoPartObject.bIsLoaded )
|
|
, bPlaceHolderFlags( GeoPartObject.bPlaceHolderFlags )
|
|
, bIsTransacting( GeoPartObject.bIsTransacting )
|
|
, bHasCustomName( GeoPartObject.bHasCustomName )
|
|
, bIsBox( GeoPartObject.bIsBox )
|
|
, bIsSphere( GeoPartObject.bIsSphere )
|
|
, bInstancerMaterialAvailable( GeoPartObject.bInstancerMaterialAvailable )
|
|
, bIsVolume( GeoPartObject.bIsVolume )
|
|
, bInstancerAttributeMaterialAvailable( GeoPartObject.bInstancerAttributeMaterialAvailable )
|
|
, bIsPackedPrimitiveInstancer( GeoPartObject.bIsPackedPrimitiveInstancer )
|
|
, bIsUCXCollisionGeo( GeoPartObject.bIsUCXCollisionGeo )
|
|
, bIsSimpleCollisionGeo( GeoPartObject.bIsSimpleCollisionGeo )
|
|
, bHasCollisionBeenAdded( GeoPartObject.bHasCollisionBeenAdded )
|
|
, bHasSocketBeenAdded( GeoPartObject.bHasSocketBeenAdded )
|
|
, UnusedFlagsSpace( 0u )
|
|
, HoudiniGeoPartObjectVersion( VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BASE )
|
|
{
|
|
if ( bCopyLoaded )
|
|
bIsLoaded = true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsVisible() const
|
|
{
|
|
return bIsVisible;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsInstancer() const
|
|
{
|
|
return bIsInstancer;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsCurve() const
|
|
{
|
|
return bIsCurve;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsBox() const
|
|
{
|
|
return bIsBox;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsSphere() const
|
|
{
|
|
return bIsSphere;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsVolume() const
|
|
{
|
|
return bIsVolume;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsEditable() const
|
|
{
|
|
return bIsEditable;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HasGeoChanged() const
|
|
{
|
|
return bHasGeoChanged;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsCollidable() const
|
|
{
|
|
return bIsCollidable;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsRenderCollidable() const
|
|
{
|
|
return bIsRenderCollidable;
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::GetObjectId() const
|
|
{
|
|
return ObjectId;
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::GetGeoId() const
|
|
{
|
|
return GeoId;
|
|
}
|
|
|
|
HAPI_PartId
|
|
FHoudiniGeoPartObject::GetPartId() const
|
|
{
|
|
return PartId;
|
|
}
|
|
|
|
const FString&
|
|
FHoudiniGeoPartObject::GetNodePath() const
|
|
{
|
|
// query on first-use
|
|
if ( NodePath.IsEmpty() )
|
|
{
|
|
FString NodePathTemp;
|
|
if ( AssetId == GeoId )
|
|
{
|
|
// This is a SOP asset, just return the asset name in this case
|
|
HAPI_AssetInfo AssetInfo;
|
|
FHoudiniApi::AssetInfo_Init(&AssetInfo);
|
|
if ( FHoudiniApi::GetAssetInfo(
|
|
FHoudiniEngine::Get().GetSession(), AssetId, &AssetInfo ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
HAPI_NodeInfo AssetNodeInfo;
|
|
FHoudiniApi::NodeInfo_Init(&AssetNodeInfo);
|
|
if ( FHoudiniApi::GetNodeInfo(
|
|
FHoudiniEngine::Get().GetSession(), AssetInfo.nodeId, &AssetNodeInfo ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
FHoudiniEngineString AssetPathHEString( AssetNodeInfo.nameSH );
|
|
if ( AssetPathHEString.ToFString( NodePathTemp ) )
|
|
{
|
|
NodePath = FString::Printf( TEXT( "%s_%d" ), *NodePathTemp, PartId );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This is an OBJ asset, return the path to this geo relative to the asset
|
|
if ( FHoudiniEngineUtils::HapiGetNodePath( GeoId, AssetId, NodePathTemp ) )
|
|
{
|
|
NodePath = FString::Printf( TEXT( "%s_%d" ), *NodePathTemp, PartId );
|
|
}
|
|
}
|
|
|
|
if ( NodePath.IsEmpty() )
|
|
{
|
|
NodePath = TEXT( "Empty" );
|
|
}
|
|
}
|
|
return NodePath;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::operator==( const FHoudiniGeoPartObject & GeoPartObject ) const
|
|
{
|
|
// Object/Geo/Part IDs must match
|
|
if (ObjectId != GeoPartObject.ObjectId || GeoId != GeoPartObject.GeoId || PartId != GeoPartObject.PartId)
|
|
return false;
|
|
|
|
// If split ID and name match, we're equal...
|
|
if (SplitId == GeoPartObject.SplitId && SplitName == GeoPartObject.SplitName )
|
|
return true;
|
|
|
|
// ... if not we should compare our names
|
|
return CompareNames(GeoPartObject);
|
|
}
|
|
|
|
uint32
|
|
FHoudiniGeoPartObject::GetTypeHash() const
|
|
{
|
|
int32 HashBuffer[ 4 ] = { ObjectId, GeoId, PartId, SplitId };
|
|
int32 Hash = FCrc::MemCrc32( (void *) &HashBuffer[ 0 ], sizeof( HashBuffer ) );
|
|
return FCrc::StrCrc32(*SplitName, Hash);
|
|
}
|
|
|
|
void
|
|
FHoudiniGeoPartObject::Serialize( FArchive & Ar )
|
|
{
|
|
Ar.UsingCustomVersion( FHoudiniCustomSerializationVersion::GUID );
|
|
|
|
HoudiniGeoPartObjectVersion = VER_HOUDINI_PLUGIN_SERIALIZATION_AUTOMATIC_VERSION;
|
|
Ar << HoudiniGeoPartObjectVersion;
|
|
|
|
Ar << TransformMatrix;
|
|
|
|
Ar << ObjectName;
|
|
Ar << PartName;
|
|
Ar << SplitName;
|
|
|
|
// Serialize instancer material.
|
|
if ( HoudiniGeoPartObjectVersion >= VER_HOUDINI_ENGINE_GEOPARTOBJECT_INSTANCER_MATERIAL_NAME )
|
|
Ar << InstancerMaterialName;
|
|
|
|
// Serialize instancer attribute material.
|
|
if ( HoudiniGeoPartObjectVersion >= VER_HOUDINI_ENGINE_GEOPARTOBJECT_INSTANCER_ATTRIBUTE_MATERIAL_NAME )
|
|
Ar << InstancerAttributeMaterialName;
|
|
|
|
Ar << AssetId;
|
|
Ar << ObjectId;
|
|
Ar << GeoId;
|
|
|
|
// Node id values can change between saving and loading a level
|
|
if ( Ar.IsLoading() && !Ar.IsTransacting() )
|
|
{
|
|
AssetId = -1;
|
|
// Although Object and Geo ids are invalid, we don't -1 them so that our parts can
|
|
// still be hashed into a map on the component. This will be dropped after the next cook
|
|
// anyway.
|
|
}
|
|
|
|
Ar << PartId;
|
|
Ar << SplitId;
|
|
|
|
Ar << HoudiniGeoPartObjectFlagsPacked;
|
|
|
|
if ( HoudiniGeoPartObjectVersion < VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BASE )
|
|
{
|
|
// Prior to this version the unused flags space was not zero-initialized, so
|
|
// zero them out now to prevent misinterpreting any 1s
|
|
HoudiniGeoPartObjectFlagsPacked &= 0x3FFFF;
|
|
}
|
|
|
|
if ( HoudiniGeoPartObjectVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_GEO_PART_NODE_PATH )
|
|
{
|
|
if ( Ar.IsSaving() && !Ar.IsTransacting() )
|
|
{
|
|
// If we are saving to level - make sure node path is present
|
|
(void) GetNodePath();
|
|
Ar << NodePath;
|
|
}
|
|
else
|
|
{
|
|
Ar << NodePath;
|
|
}
|
|
}
|
|
|
|
if ( Ar.IsLoading() )
|
|
bIsLoaded = true;
|
|
|
|
if ( Ar.IsTransacting() )
|
|
bIsTransacting = true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::IsValid() const
|
|
{
|
|
return ( ObjectId >= 0 && GeoId >= 0 && PartId >= 0 );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::CompareNames( const FHoudiniGeoPartObject & HoudiniGeoPartObject ) const
|
|
{
|
|
// Object and part names must match
|
|
if (ObjectName != HoudiniGeoPartObject.ObjectName || PartName != HoudiniGeoPartObject.PartName)
|
|
return false;
|
|
|
|
// Split names must match...
|
|
if (SplitName == HoudiniGeoPartObject.SplitName)
|
|
return true;
|
|
|
|
//... or we can tolerate them to be different if they both start with LOD
|
|
// and just the lod number is different
|
|
if (SplitName.StartsWith("LOD") && HoudiniGeoPartObject.SplitName.StartsWith("LOD"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HasParameters() const
|
|
{
|
|
return HasParameters(AssetId);
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HasParameters( HAPI_NodeId InAssetId ) const
|
|
{
|
|
HAPI_NodeId NodeId = HapiGeoGetNodeId( InAssetId );
|
|
if ( NodeId == -1 )
|
|
return false;
|
|
|
|
HAPI_NodeInfo NodeInfo;
|
|
FHoudiniApi::NodeInfo_Init(&NodeInfo);
|
|
FHoudiniApi::GetNodeInfo( FHoudiniEngine::Get().GetSession(), NodeId, &NodeInfo );
|
|
|
|
return NodeInfo.parmCount > 0;
|
|
}
|
|
|
|
bool FHoudiniGeoPartObject::IsPackedPrimitiveInstancer() const
|
|
{
|
|
return bIsPackedPrimitiveInstancer;
|
|
}
|
|
|
|
bool FHoudiniGeoPartObject::IsAttributeInstancer() const
|
|
{
|
|
return HapiCheckAttributeExistance( HAPI_UNREAL_ATTRIB_INSTANCE, HAPI_ATTROWNER_POINT );
|
|
}
|
|
|
|
bool FHoudiniGeoPartObject::IsAttributeOverrideInstancer() const
|
|
{
|
|
// Check if this is an attribute override instancer (on detail or point).
|
|
return HapiCheckAttributeExistance( HAPI_UNREAL_ATTRIB_INSTANCE_OVERRIDE, HAPI_ATTROWNER_DETAIL)
|
|
| HapiCheckAttributeExistance( HAPI_UNREAL_ATTRIB_INSTANCE_OVERRIDE, HAPI_ATTROWNER_POINT );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HasCustomName() const
|
|
{
|
|
return bHasCustomName;
|
|
}
|
|
|
|
void
|
|
FHoudiniGeoPartObject::SetCustomName( const FString & CustomName )
|
|
{
|
|
PartName = CustomName;
|
|
bHasCustomName = true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::UpdateCustomName()
|
|
{
|
|
TArray< FString > GeneratedMeshNames;
|
|
HAPI_AttributeInfo AttribGeneratedMeshName;
|
|
FHoudiniApi::AttributeInfo_Init(&AttribGeneratedMeshName);
|
|
//FMemory::Memzero< HAPI_AttributeInfo >(AttribGeneratedMeshName);
|
|
|
|
bHasCustomName = false;
|
|
if ( FHoudiniEngineUtils::HapiGetAttributeDataAsString(
|
|
AssetId, ObjectId, GeoId, PartId, HAPI_UNREAL_ATTRIB_GENERATED_MESH_NAME, AttribGeneratedMeshName, GeneratedMeshNames ) )
|
|
{
|
|
if ( GeneratedMeshNames.Num() > 0 )
|
|
SetCustomName( GeneratedMeshNames[0] );
|
|
}
|
|
|
|
return HasCustomName();
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiCheckAttributeExistance(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiCheckAttributeExistance( OtherAssetId, AttributeNameRaw, AttributeOwner );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiCheckAttributeExistance(
|
|
const FString& AttributeName, HAPI_AttributeOwner AttributeOwner ) const
|
|
{
|
|
return HapiCheckAttributeExistance( AssetId, AttributeName, AttributeOwner );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiCheckAttributeExistance(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner ) const
|
|
{
|
|
return HapiCheckAttributeExistance( AttributeName.c_str(), AttributeOwner );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiCheckAttributeExistance(
|
|
const std::string & AttributeName, HAPI_AttributeOwner AttributeOwner ) const
|
|
{
|
|
return HapiCheckAttributeExistance( AssetId, AttributeName, AttributeOwner );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiCheckAttributeExistance(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner ) const
|
|
{
|
|
HAPI_AttributeInfo AttributeInfo;
|
|
FHoudiniApi::AttributeInfo_Init(&AttributeInfo);
|
|
//FMemory::Memset< HAPI_AttributeInfo >( AttributeInfo, 0 );
|
|
|
|
if ( FHoudiniApi::GetAttributeInfo(
|
|
FHoudiniEngine::Get().GetSession(), GeoId, PartId, AttributeName,
|
|
AttributeOwner, &AttributeInfo ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return AttributeInfo.exists;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiCheckAttributeExistance(
|
|
const char * AttributeName, HAPI_AttributeOwner AttributeOwner ) const
|
|
{
|
|
return HapiCheckAttributeExistance( AssetId, AttributeName, AttributeOwner );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetInstanceTransforms( HAPI_NodeId OtherAssetId, TArray< FTransform > & AllTransforms ) const
|
|
{
|
|
AllTransforms.Empty();
|
|
int32 PointCount = HapiPartGetPointCount( OtherAssetId );
|
|
|
|
if ( PointCount > 0 )
|
|
{
|
|
TArray< HAPI_Transform > InstanceTransforms;
|
|
InstanceTransforms.SetNumUninitialized( PointCount );
|
|
for (int32 Idx = 0; Idx < InstanceTransforms.Num(); Idx++)
|
|
FHoudiniApi::Transform_Init(&(InstanceTransforms[Idx]));
|
|
|
|
if ( FHoudiniApi::GetInstanceTransformsOnPart(
|
|
FHoudiniEngine::Get().GetSession(), GeoId, PartId, HAPI_SRT, &InstanceTransforms[ 0 ],
|
|
0, PointCount) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
for ( int32 PointIdx = 0; PointIdx < PointCount; ++PointIdx )
|
|
{
|
|
FTransform TempTransformMatrix;
|
|
|
|
const HAPI_Transform & HapiInstanceTransform = InstanceTransforms[ PointIdx ];
|
|
FHoudiniEngineUtils::TranslateHapiTransform( HapiInstanceTransform, TempTransformMatrix );
|
|
|
|
AllTransforms.Add( TempTransformMatrix );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetInstanceTransforms( TArray< FTransform > & AllTransforms ) const
|
|
{
|
|
return HapiGetInstanceTransforms( AssetId, AllTransforms );
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::HapiObjectGetToInstanceId( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_NodeId ObjectToInstance = -1;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
ObjectToInstance = ObjectInfo.objectToInstanceId;
|
|
|
|
return ObjectToInstance;
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::HapiObjectGetToInstanceId() const
|
|
{
|
|
return HapiObjectGetToInstanceId( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectGetInfo( HAPI_ObjectInfo & ObjectInfo ) const
|
|
{
|
|
return HapiObjectGetInfo( AssetId, ObjectInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectGetInfo( HAPI_NodeId OtherAssetId, HAPI_ObjectInfo & ObjectInfo ) const
|
|
{
|
|
//FMemory::Memset< HAPI_ObjectInfo >( ObjectInfo, 0 );
|
|
FHoudiniApi::ObjectInfo_Init(&ObjectInfo);
|
|
|
|
HAPI_Result Result = FHoudiniApi::GetObjectInfo(
|
|
FHoudiniEngine::Get().GetSession(), ObjectId, &ObjectInfo );
|
|
if ( Result != HAPI_RESULT_SUCCESS )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiObjectGetName( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_StringHandle StringHandle = -1;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
StringHandle = ObjectInfo.nameSH;
|
|
|
|
return FHoudiniEngineString( StringHandle );
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiObjectGetName() const
|
|
{
|
|
return HapiObjectGetName( AssetId );
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiObjectGetInstancePath( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_StringHandle StringHandle = -1;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
StringHandle = ObjectInfo.objectInstancePathSH;
|
|
|
|
return FHoudiniEngineString( StringHandle );
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiObjectGetInstancePath() const
|
|
{
|
|
return HapiObjectGetInstancePath( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectIsVisible( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bIsObjectVisible = false;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
bIsObjectVisible = ObjectInfo.isVisible;
|
|
|
|
return bIsObjectVisible;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectIsVisible() const
|
|
{
|
|
return HapiObjectIsVisible( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectIsInstancer( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bIsObjectInstancer = false;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
bIsObjectInstancer = ObjectInfo.isInstancer;
|
|
|
|
return bIsObjectInstancer;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectIsInstancer() const
|
|
{
|
|
return HapiObjectIsInstancer( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectHasTransformChanged( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bObjectTransformHasChanged = false;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
bObjectTransformHasChanged = ObjectInfo.hasTransformChanged;
|
|
|
|
return bObjectTransformHasChanged;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectHasTransformChanged() const
|
|
{
|
|
return HapiObjectHasTransformChanged( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectHaveGeosChanged( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bGeosChanged = false;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
bGeosChanged = ObjectInfo.haveGeosChanged;
|
|
|
|
return bGeosChanged;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectHaveGeosChanged() const
|
|
{
|
|
return HapiObjectHaveGeosChanged( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiObjectGetGeoCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 GeoCount = 0;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
GeoCount = ObjectInfo.geoCount;
|
|
|
|
return GeoCount;
|
|
}
|
|
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiObjectGetGeoCount() const
|
|
{
|
|
return HapiObjectGetGeoCount( AssetId );
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::HapiObjectGetNodeId() const
|
|
{
|
|
HAPI_NodeId NodeId = -1;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if (HapiObjectGetInfo(ObjectInfo))
|
|
NodeId = ObjectInfo.nodeId;
|
|
|
|
return NodeId;
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::HapiObjectGetNodeId( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_NodeId NodeId = -1;
|
|
HAPI_ObjectInfo ObjectInfo;
|
|
|
|
if ( HapiObjectGetInfo( OtherAssetId, ObjectInfo ) )
|
|
NodeId = ObjectInfo.nodeId;
|
|
|
|
return NodeId;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoGetInfo( HAPI_GeoInfo & GeoInfo ) const
|
|
{
|
|
return HapiGeoGetInfo( AssetId, GeoInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoGetInfo( HAPI_NodeId OtherAssetId, HAPI_GeoInfo & GeoInfo ) const
|
|
{
|
|
FMemory::Memset< HAPI_GeoInfo >( GeoInfo, 0 );
|
|
|
|
if ( FHoudiniApi::GetGeoInfo(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
GeoId, &GeoInfo ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
HAPI_GeoType
|
|
FHoudiniGeoPartObject::HapiGeoGetType( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_GeoType GeoType = HAPI_GEOTYPE_INVALID;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
GeoType = GeoInfo.type;
|
|
|
|
return GeoType;
|
|
}
|
|
|
|
HAPI_GeoType
|
|
FHoudiniGeoPartObject::HapiGeoGetType() const
|
|
{
|
|
return HapiGeoGetType( AssetId );
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiGeoGetName( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_StringHandle StringHandle = -1;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
StringHandle = GeoInfo.nameSH;
|
|
|
|
return FHoudiniEngineString( StringHandle );
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiGeoGetName() const
|
|
{
|
|
return HapiGeoGetName( AssetId );
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::HapiGeoGetNodeId() const
|
|
{
|
|
HAPI_NodeId NodeId = -1;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( GeoInfo ) )
|
|
NodeId = GeoInfo.nodeId;
|
|
|
|
return NodeId;
|
|
}
|
|
|
|
HAPI_NodeId
|
|
FHoudiniGeoPartObject::HapiGeoGetNodeId( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_NodeId NodeId = -1;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
NodeId = GeoInfo.nodeId;
|
|
|
|
return NodeId;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoIsEditable( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bLocalIsEditable = false;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
bLocalIsEditable = GeoInfo.isEditable;
|
|
|
|
return bLocalIsEditable;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoIsEditable() const
|
|
{
|
|
return HapiGeoIsEditable( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoIsTemplated( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bIsTemplated = false;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
bIsTemplated = GeoInfo.isTemplated;
|
|
|
|
return bIsTemplated;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoIsTemplated() const
|
|
{
|
|
return HapiGeoIsTemplated( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoIsDisplayGeo( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bIsDisplayGeo = false;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
bIsDisplayGeo = GeoInfo.isDisplayGeo;
|
|
|
|
return bIsDisplayGeo;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoIsDisplayGeo() const
|
|
{
|
|
return HapiGeoIsDisplayGeo( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoHasChanged( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bGeoChanged = false;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
bGeoChanged = GeoInfo.hasGeoChanged;
|
|
|
|
return bGeoChanged;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoHasChanged() const
|
|
{
|
|
return HapiGeoHasChanged( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoHasMaterialChanged( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bHasMaterialChanged = false;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
bHasMaterialChanged = GeoInfo.hasMaterialChanged;
|
|
|
|
return bHasMaterialChanged;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGeoHasMaterialChanged() const
|
|
{
|
|
return HapiGeoHasMaterialChanged( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiGeoGetPointGroupCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 PointGroupCount = 0;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
PointGroupCount = GeoInfo.pointGroupCount;
|
|
|
|
return PointGroupCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiGeoGetPointGroupCount() const
|
|
{
|
|
return HapiGeoGetPointGroupCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiGeoGetPrimitiveGroupCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 PrimitiveGroupCount = 0;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
PrimitiveGroupCount = GeoInfo.primitiveGroupCount;
|
|
|
|
return PrimitiveGroupCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiGeoGetPrimitiveGroupCount() const
|
|
{
|
|
return HapiGeoGetPrimitiveGroupCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiGeoGetPartCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 PartCount = 0;
|
|
HAPI_GeoInfo GeoInfo;
|
|
|
|
if ( HapiGeoGetInfo( OtherAssetId, GeoInfo ) )
|
|
PartCount = GeoInfo.partCount;
|
|
|
|
return PartCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiGeoGetPartCount() const
|
|
{
|
|
return HapiGeoGetPartCount( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiPartGetInfo( HAPI_PartInfo & PartInfo ) const
|
|
{
|
|
return HapiPartGetInfo( AssetId, PartInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiPartGetInfo( HAPI_NodeId OtherAssetId, HAPI_PartInfo & PartInfo ) const
|
|
{
|
|
FMemory::Memset< HAPI_PartInfo >( PartInfo, 0 );
|
|
|
|
if ( FHoudiniApi::GetPartInfo(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
GeoId, PartId, &PartInfo ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiPartGetName( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_StringHandle StringHandle = -1;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
StringHandle = PartInfo.nameSH;
|
|
|
|
return FHoudiniEngineString( StringHandle );
|
|
}
|
|
|
|
FHoudiniEngineString
|
|
FHoudiniGeoPartObject::HapiPartGetName() const
|
|
{
|
|
return HapiPartGetName( AssetId );
|
|
}
|
|
|
|
HAPI_PartType
|
|
FHoudiniGeoPartObject::HapiPartGetType( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
HAPI_PartType PartType = HAPI_PARTTYPE_INVALID;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
PartType = PartInfo.type;
|
|
|
|
return PartType;
|
|
}
|
|
|
|
HAPI_PartType
|
|
FHoudiniGeoPartObject::HapiPartGetType() const
|
|
{
|
|
return HapiPartGetType( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetFaceCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 FaceCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
FaceCount = PartInfo.faceCount;
|
|
|
|
return FaceCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetFaceCount() const
|
|
{
|
|
return HapiPartGetFaceCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetVertexCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 VertexCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
VertexCount = PartInfo.vertexCount;
|
|
|
|
return VertexCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetVertexCount() const
|
|
{
|
|
return HapiPartGetVertexCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetPointCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 PointCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
PointCount = PartInfo.pointCount;
|
|
|
|
return PointCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetPointCount() const
|
|
{
|
|
return HapiPartGetPointCount( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiPartIsInstanced( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
bool bPartIsInstanced = false;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
bPartIsInstanced = PartInfo.isInstanced;
|
|
|
|
return bPartIsInstanced;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiPartIsInstanced() const
|
|
{
|
|
return HapiPartIsInstanced( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetInstancedPartCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 InstancedPartCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
InstancedPartCount = PartInfo.instancedPartCount;
|
|
|
|
return InstancedPartCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetInstancedPartCount() const
|
|
{
|
|
return HapiPartGetInstancedPartCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetInstanceCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 InstanceCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
InstanceCount = PartInfo.instanceCount;
|
|
|
|
return InstanceCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetInstanceCount() const
|
|
{
|
|
return HapiPartGetInstanceCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetPointAttributeCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 PointAttributeCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
PointAttributeCount = PartInfo.attributeCounts[ HAPI_ATTROWNER_POINT ];
|
|
|
|
return PointAttributeCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetPointAttributeCount() const
|
|
{
|
|
return HapiPartGetPointAttributeCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetVertexAttributeCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 VertexAttributeCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
VertexAttributeCount = PartInfo.attributeCounts[ HAPI_ATTROWNER_VERTEX ];
|
|
|
|
return VertexAttributeCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetVertexAttributeCount() const
|
|
{
|
|
return HapiPartGetVertexAttributeCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetPrimitiveAttributeCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 PrimitiveAttributeCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
PrimitiveAttributeCount = PartInfo.attributeCounts[ HAPI_ATTROWNER_PRIM ];
|
|
|
|
return PrimitiveAttributeCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetPrimitiveAttributeCount() const
|
|
{
|
|
return HapiPartGetPrimitiveAttributeCount( AssetId );
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetDetailAttributeCount( HAPI_NodeId OtherAssetId ) const
|
|
{
|
|
int32 DetailAttributeCount = 0;
|
|
HAPI_PartInfo PartInfo;
|
|
|
|
if ( HapiPartGetInfo( OtherAssetId, PartInfo ) )
|
|
DetailAttributeCount = PartInfo.attributeCounts[ HAPI_ATTROWNER_DETAIL ];
|
|
|
|
return DetailAttributeCount;
|
|
}
|
|
|
|
int32
|
|
FHoudiniGeoPartObject::HapiPartGetDetailAttributeCount() const
|
|
{
|
|
return HapiPartGetDetailAttributeCount( AssetId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
FMemory::Memset< HAPI_AttributeInfo >( AttributeInfo, 0 );
|
|
|
|
if ( FHoudiniApi::GetAttributeInfo(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
GeoId, PartId, AttributeName, AttributeOwner,
|
|
&AttributeInfo ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
const char * AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
return HapiGetAttributeInfo( AssetId, AttributeName, AttributeOwner, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & AttributeInfo) const
|
|
{
|
|
return HapiGetAttributeInfo( OtherAssetId, AttributeName.c_str(), AttributeOwner, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
const std::string & AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & AttributeInfo) const
|
|
{
|
|
return HapiGetAttributeInfo( AssetId, AttributeName, AttributeOwner, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeInfo( OtherAssetId, AttributeNameRaw, AttributeOwner, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
const FString & AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
return HapiGetAttributeInfo( AssetId, AttributeName, AttributeOwner, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
for ( int32 AttrIdx = 0; AttrIdx < HAPI_ATTROWNER_MAX; ++AttrIdx )
|
|
{
|
|
if ( !HapiGetAttributeInfo(
|
|
OtherAssetId, AttributeName, (HAPI_AttributeOwner) AttrIdx, AttributeInfo ) )
|
|
{
|
|
AttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( AttributeInfo.exists )
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo( const char * AttributeName, HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
return HapiGetAttributeInfo( AssetId, AttributeName, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
return HapiGetAttributeInfo( OtherAssetId, AttributeName.c_str(), AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo( const std::string & AttributeName, HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
return HapiGetAttributeInfo( AssetId, AttributeName, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeInfo & AttributeInfo) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeInfo( OtherAssetId, AttributeNameRaw, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeInfo( const FString & AttributeName, HAPI_AttributeInfo & AttributeInfo ) const
|
|
{
|
|
return HapiGetAttributeInfo( AssetId, AttributeName, AttributeInfo );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
AttributeData.SetNumUninitialized( 0 );
|
|
|
|
if ( !HapiGetAttributeInfo( OtherAssetId, AttributeName, AttributeOwner, ResultAttributeInfo ) )
|
|
{
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( !ResultAttributeInfo.exists )
|
|
return false;
|
|
|
|
if ( TupleSize > 0 )
|
|
ResultAttributeInfo.tupleSize = TupleSize;
|
|
|
|
AttributeData.SetNumUninitialized( ResultAttributeInfo.count * ResultAttributeInfo.tupleSize );
|
|
|
|
if ( FHoudiniApi::GetAttributeFloatData(
|
|
FHoudiniEngine::Get().GetSession(), GeoId, PartId, AttributeName,
|
|
&ResultAttributeInfo, -1, &AttributeData[ 0 ], 0,
|
|
ResultAttributeInfo.count ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
const char * AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo, TArray< float > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat(
|
|
OtherAssetId, AttributeName.c_str(), AttributeOwner, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeDataAsFloat(
|
|
OtherAssetId, AttributeNameRaw, AttributeOwner, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
const FString & AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
for ( int32 AttrIdx = 0; AttrIdx < HAPI_ATTROWNER_MAX; ++AttrIdx )
|
|
{
|
|
if ( !HapiGetAttributeDataAsFloat(
|
|
OtherAssetId, AttributeName, (HAPI_AttributeOwner) AttrIdx,
|
|
ResultAttributeInfo, AttributeData, TupleSize ) )
|
|
{
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( ResultAttributeInfo.exists )
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
const char * AttributeName, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat(
|
|
OtherAssetId, AttributeName.c_str(), ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
const std::string & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray <float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeDataAsFloat(
|
|
OtherAssetId, AttributeNameRaw, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsFloat(
|
|
const FString & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< float > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsFloat( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
AttributeData.SetNumUninitialized( 0 );
|
|
|
|
if ( !HapiGetAttributeInfo( OtherAssetId, AttributeName, AttributeOwner, ResultAttributeInfo ) )
|
|
{
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( !ResultAttributeInfo.exists )
|
|
return false;
|
|
|
|
if ( TupleSize > 0 )
|
|
ResultAttributeInfo.tupleSize = TupleSize;
|
|
|
|
AttributeData.SetNumUninitialized( ResultAttributeInfo.count * ResultAttributeInfo.tupleSize );
|
|
|
|
if ( FHoudiniApi::GetAttributeIntData(
|
|
FHoudiniEngine::Get().GetSession(), GeoId, PartId, AttributeName,
|
|
&ResultAttributeInfo, -1, &AttributeData[ 0 ], 0,
|
|
ResultAttributeInfo.count ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
const char * AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt(
|
|
OtherAssetId, AttributeName.c_str(), AttributeOwner, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeDataAsInt(
|
|
OtherAssetId, AttributeNameRaw, AttributeOwner, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
const FString & AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
for ( int32 AttrIdx = 0; AttrIdx < HAPI_ATTROWNER_MAX; ++AttrIdx )
|
|
{
|
|
if ( !HapiGetAttributeDataAsInt(
|
|
OtherAssetId, AttributeName, (HAPI_AttributeOwner) AttrIdx,
|
|
ResultAttributeInfo, AttributeData, TupleSize ) )
|
|
{
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( ResultAttributeInfo.exists )
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
const char * AttributeName, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt(
|
|
OtherAssetId, AttributeName.c_str(), ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
const std::string & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeDataAsInt(
|
|
OtherAssetId, AttributeNameRaw, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsInt(
|
|
const FString & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< int32 > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsInt( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
AttributeData.SetNumUninitialized( 0 );
|
|
|
|
if ( !HapiGetAttributeInfo( OtherAssetId, AttributeName, AttributeOwner, ResultAttributeInfo ) )
|
|
{
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( !ResultAttributeInfo.exists )
|
|
return false;
|
|
|
|
if ( TupleSize > 0 )
|
|
ResultAttributeInfo.tupleSize = TupleSize;
|
|
|
|
TArray< HAPI_StringHandle > StringHandles;
|
|
StringHandles.Init( -1, ResultAttributeInfo.count * ResultAttributeInfo.tupleSize );
|
|
if ( FHoudiniApi::GetAttributeStringData(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
GeoId, PartId, AttributeName, &ResultAttributeInfo,
|
|
&StringHandles[ 0 ], 0, ResultAttributeInfo.count ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
// Use a map to minimize the number of HAPI calls for performance!
|
|
TMap<int32, FString> StringHandleToStringMap;
|
|
for ( int32 Idx = 0; Idx < StringHandles.Num(); ++Idx )
|
|
{
|
|
FString* FoundString = StringHandleToStringMap.Find( StringHandles[ Idx ] );
|
|
if ( FoundString )
|
|
{
|
|
AttributeData.Add( *FoundString );
|
|
}
|
|
else
|
|
{
|
|
FString HapiString = TEXT("");
|
|
FHoudiniEngineString HoudiniEngineString( StringHandles[ Idx ] );
|
|
HoudiniEngineString.ToFString( HapiString );
|
|
StringHandleToStringMap.Add( StringHandles[ Idx ], HapiString );
|
|
AttributeData.Add( *HapiString );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
const char * AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString(
|
|
OtherAssetId, AttributeName.c_str(), AttributeOwner, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
const std::string & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData,
|
|
int32 TupleSize ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeDataAsString(
|
|
OtherAssetId, AttributeNameRaw, AttributeOwner, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
const FString & AttributeName, HAPI_AttributeOwner AttributeOwner,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString(
|
|
AssetId, AttributeName, AttributeOwner, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
HAPI_NodeId OtherAssetId, const char * AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
for ( int32 AttrIdx = 0; AttrIdx < HAPI_ATTROWNER_MAX; ++AttrIdx )
|
|
{
|
|
if ( !HapiGetAttributeDataAsString(
|
|
OtherAssetId, AttributeName, (HAPI_AttributeOwner) AttrIdx,
|
|
ResultAttributeInfo, AttributeData, TupleSize ) )
|
|
{
|
|
ResultAttributeInfo.exists = false;
|
|
return false;
|
|
}
|
|
|
|
if ( ResultAttributeInfo.exists )
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
const char * AttributeName, HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
HAPI_NodeId OtherAssetId, const std::string & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo, TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString(
|
|
OtherAssetId, AttributeName.c_str(), ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
const std::string & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
HAPI_NodeId OtherAssetId, const FString & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
std::string AttributeNameRaw = "";
|
|
FHoudiniEngineUtils::ConvertUnrealString( AttributeName, AttributeNameRaw );
|
|
|
|
return HapiGetAttributeDataAsString(
|
|
OtherAssetId, AttributeNameRaw, ResultAttributeInfo,
|
|
AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeDataAsString(
|
|
const FString & AttributeName,
|
|
HAPI_AttributeInfo & ResultAttributeInfo,
|
|
TArray< FString > & AttributeData, int32 TupleSize ) const
|
|
{
|
|
return HapiGetAttributeDataAsString( AssetId, AttributeName, ResultAttributeInfo, AttributeData, TupleSize );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectGetUniqueInstancerMaterialId( HAPI_NodeId & MaterialId ) const
|
|
{
|
|
return HapiObjectGetUniqueInstancerMaterialId( AssetId, MaterialId );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiObjectGetUniqueInstancerMaterialId(
|
|
HAPI_NodeId OtherAssetId, HAPI_NodeId& MaterialId ) const
|
|
{
|
|
MaterialId = -1;
|
|
|
|
if ( HapiObjectIsInstancer( OtherAssetId ) )
|
|
{
|
|
HAPI_Bool bSingleFaceMaterial = false;
|
|
if ( FHoudiniApi::GetMaterialNodeIdsOnFaces(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
GeoId, PartId, &bSingleFaceMaterial,
|
|
&MaterialId, 0, 1 ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiPartGetUniqueMaterialIds( TSet< HAPI_NodeId > & MaterialIds ) const
|
|
{
|
|
return HapiPartGetUniqueMaterialIds( AssetId, MaterialIds );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiPartGetUniqueMaterialIds(
|
|
HAPI_NodeId OtherAssetId,
|
|
TSet< HAPI_NodeId > & MaterialIds ) const
|
|
{
|
|
MaterialIds.Empty();
|
|
|
|
int32 FaceCount = HapiPartGetFaceCount( OtherAssetId );
|
|
if ( FaceCount > 0 )
|
|
{
|
|
TArray< HAPI_NodeId > FaceMaterialIds;
|
|
FaceMaterialIds.SetNumUninitialized( FaceCount );
|
|
|
|
HAPI_Bool bSingleFaceMaterial = false;
|
|
if ( FHoudiniApi::GetMaterialNodeIdsOnFaces(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
GeoId, PartId, &bSingleFaceMaterial,
|
|
&FaceMaterialIds[0], 0, FaceCount ) == HAPI_RESULT_SUCCESS )
|
|
{
|
|
MaterialIds.Append( FaceMaterialIds );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAllAttributeNames( HAPI_NodeId OtherAssetId, TArray< FString > & AttributeNames ) const
|
|
{
|
|
AttributeNames.Empty();
|
|
|
|
for ( int32 AttrIdx = HAPI_ATTROWNER_VERTEX; AttrIdx < HAPI_ATTROWNER_MAX; ++AttrIdx )
|
|
{
|
|
TArray< FString > AttributeValues;
|
|
if ( HapiGetAttributeNames( OtherAssetId, (HAPI_AttributeOwner) AttrIdx, AttributeValues ) )
|
|
{
|
|
if ( AttributeValues.Num() > 0 )
|
|
AttributeNames.Append(AttributeValues);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAllAttributeNames( TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetAllAttributeNames( AssetId, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeNames(
|
|
HAPI_NodeId OtherAssetId, HAPI_AttributeOwner AttributeOwner,
|
|
TArray< FString > & AttributeNames ) const
|
|
{
|
|
AttributeNames.Empty();
|
|
int32 AttributeCount = 0;
|
|
|
|
switch ( AttributeOwner)
|
|
{
|
|
case HAPI_ATTROWNER_POINT:
|
|
{
|
|
AttributeCount = HapiPartGetPointAttributeCount( OtherAssetId );
|
|
break;
|
|
}
|
|
|
|
case HAPI_ATTROWNER_VERTEX:
|
|
{
|
|
AttributeCount = HapiPartGetVertexAttributeCount( OtherAssetId );
|
|
break;
|
|
}
|
|
|
|
case HAPI_ATTROWNER_PRIM:
|
|
{
|
|
AttributeCount = HapiPartGetPrimitiveAttributeCount( OtherAssetId );
|
|
break;
|
|
}
|
|
|
|
case HAPI_ATTROWNER_DETAIL:
|
|
{
|
|
AttributeCount = HapiPartGetDetailAttributeCount( OtherAssetId );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( AttributeCount > 0 )
|
|
{
|
|
TArray< HAPI_StringHandle > AttributeNameHandles;
|
|
AttributeNameHandles.SetNumUninitialized( AttributeCount );
|
|
|
|
if ( FHoudiniApi::GetAttributeNames(
|
|
FHoudiniEngine::Get().GetSession(), GeoId, PartId,
|
|
AttributeOwner, &AttributeNameHandles[ 0 ],
|
|
AttributeCount ) != HAPI_RESULT_SUCCESS )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for ( int32 Idx = 0, Num = AttributeNameHandles.Num(); Idx < Num; ++Idx )
|
|
{
|
|
FString HapiString = TEXT( "" );
|
|
FHoudiniEngineString HoudiniEngineString( AttributeNameHandles[ Idx ] );
|
|
if ( HoudiniEngineString.ToFString( HapiString ) )
|
|
AttributeNames.Add( HapiString );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetAttributeNames(
|
|
HAPI_AttributeOwner AttributeOwner,
|
|
TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetAttributeNames( AssetId, AttributeOwner, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetPointAttributeNames( HAPI_NodeId OtherAssetId, TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetAttributeNames( OtherAssetId, HAPI_ATTROWNER_POINT, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetPointAttributeNames( TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetPointAttributeNames( AssetId, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetVertexAttributeNames( HAPI_NodeId OtherAssetId, TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetAttributeNames( OtherAssetId, HAPI_ATTROWNER_VERTEX, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetVertexAttributeNames( TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetVertexAttributeNames( AssetId, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetPrimitiveAttributeNames(
|
|
HAPI_NodeId OtherAssetId,
|
|
TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetAttributeNames( OtherAssetId, HAPI_ATTROWNER_PRIM, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetPrimitiveAttributeNames( TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetPrimitiveAttributeNames( AssetId, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetDetailAttributeNames( HAPI_NodeId OtherAssetId, TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetAttributeNames( OtherAssetId, HAPI_ATTROWNER_DETAIL, AttributeNames );
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetDetailAttributeNames( TArray< FString > & AttributeNames ) const
|
|
{
|
|
return HapiGetDetailAttributeNames( AssetId, AttributeNames );
|
|
}
|
|
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetVertices( HAPI_NodeId OtherAssetId, TArray< int32 > & Vertices ) const
|
|
{
|
|
Vertices.Empty();
|
|
|
|
int32 VertexCount = HapiPartGetVertexCount( OtherAssetId );
|
|
if ( !VertexCount )
|
|
return false;
|
|
|
|
Vertices.SetNumUninitialized( VertexCount );
|
|
|
|
if ( FHoudiniApi::GetVertexList(
|
|
FHoudiniEngine::Get().GetSession(), GeoId,
|
|
PartId, &Vertices[ 0 ], 0, VertexCount ) != HAPI_RESULT_SUCCESS )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
FHoudiniGeoPartObject::HapiGetVertices( TArray< int32 > & Vertices ) const
|
|
{
|
|
return HapiGetVertices( AssetId, Vertices );
|
|
}
|