Andron666
197 lines
7.7 KiB
Python
197 lines
7.7 KiB
Python
# Copyright (c) <2021> Side Effects Software Inc.
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
#
|
|
# 1. Redistributions of source code must retain the above copyright notice,
|
|
# this list of conditions and the following disclaimer.
|
|
#
|
|
# 2. The name of Side Effects Software may not be used to endorse or
|
|
# promote products derived from this software without specific prior
|
|
# written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
|
|
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
""" An example script that uses the API and
|
|
HoudiniEngineV2.asyncprocessor.ProcessHDA. ProcessHDA is configured with the
|
|
asset to instantiate, as well as 2 inputs: a geometry input (a cube) and a
|
|
curve input (a helix).
|
|
|
|
ProcessHDA is then activiated upon which the asset will be instantiated,
|
|
inputs set, and cooked. The ProcessHDA class's on_post_processing() function is
|
|
overridden to fetch the input structure and logged. The other state/phase
|
|
functions (on_pre_instantiate(), on_post_instantiate() etc) are overridden to
|
|
simply log the function name, in order to observe progress in the log.
|
|
|
|
"""
|
|
import math
|
|
|
|
import unreal
|
|
|
|
from HoudiniEngineV2.asyncprocessor import ProcessHDA
|
|
|
|
|
|
_g_processor = None
|
|
|
|
|
|
class ProcessHDAExample(ProcessHDA):
|
|
@staticmethod
|
|
def _print_api_input(in_input):
|
|
print('\t\tInput type: {0}'.format(in_input.__class__))
|
|
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
|
|
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
|
|
if isinstance(in_input, unreal.HoudiniPublicAPIGeoInput):
|
|
print('\t\tbPackBeforeMerge: {0}'.format(in_input.pack_before_merge))
|
|
print('\t\tbExportLODs: {0}'.format(in_input.export_lo_ds))
|
|
print('\t\tbExportSockets: {0}'.format(in_input.export_sockets))
|
|
print('\t\tbExportColliders: {0}'.format(in_input.export_colliders))
|
|
elif isinstance(in_input, unreal.HoudiniPublicAPICurveInput):
|
|
print('\t\tbCookOnCurveChanged: {0}'.format(in_input.cook_on_curve_changed))
|
|
print('\t\tbAddRotAndScaleAttributesOnCurves: {0}'.format(in_input.add_rot_and_scale_attributes_on_curves))
|
|
|
|
input_objects = in_input.get_input_objects()
|
|
if not input_objects:
|
|
print('\t\tEmpty input!')
|
|
else:
|
|
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
|
|
for idx, input_object in enumerate(input_objects):
|
|
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
|
|
if hasattr(in_input, 'get_object_transform_offset'):
|
|
print('\t\t\tObject Transform Offset: {0}'.format(in_input.get_object_transform_offset(input_object)))
|
|
if isinstance(input_object, unreal.HoudiniPublicAPICurveInputObject):
|
|
print('\t\t\tbClosed: {0}'.format(input_object.is_closed()))
|
|
print('\t\t\tCurveMethod: {0}'.format(input_object.get_curve_method()))
|
|
print('\t\t\tCurveType: {0}'.format(input_object.get_curve_type()))
|
|
print('\t\t\tReversed: {0}'.format(input_object.is_reversed()))
|
|
print('\t\t\tCurvePoints: {0}'.format(input_object.get_curve_points()))
|
|
|
|
def on_failure(self):
|
|
print('on_failure')
|
|
global _g_processor
|
|
_g_processor = None
|
|
|
|
def on_complete(self):
|
|
print('on_complete')
|
|
global _g_processor
|
|
_g_processor = None
|
|
|
|
def on_pre_instantiation(self):
|
|
print('on_pre_instantiation')
|
|
|
|
def on_post_instantiation(self):
|
|
print('on_post_instantiation')
|
|
|
|
def on_post_auto_cook(self, cook_success):
|
|
print('on_post_auto_cook, success = {0}'.format(cook_success))
|
|
|
|
def on_pre_process(self):
|
|
print('on_pre_process')
|
|
|
|
def on_post_processing(self):
|
|
print('on_post_processing')
|
|
|
|
# Fetch inputs, iterate over it and log
|
|
node_inputs = self.asset_wrapper.get_inputs_at_indices()
|
|
parm_inputs = self.asset_wrapper.get_input_parameters()
|
|
|
|
if not node_inputs:
|
|
print('No node inputs found!')
|
|
else:
|
|
print('Number of node inputs: {0}'.format(len(node_inputs)))
|
|
for input_index, input_wrapper in node_inputs.items():
|
|
print('\tInput index: {0}'.format(input_index))
|
|
self._print_api_input(input_wrapper)
|
|
|
|
if not parm_inputs:
|
|
print('No parameter inputs found!')
|
|
else:
|
|
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
|
|
for parm_name, input_wrapper in parm_inputs.items():
|
|
print('\tInput parameter name: {0}'.format(parm_name))
|
|
self._print_api_input(input_wrapper)
|
|
|
|
def on_post_auto_bake(self, bake_success):
|
|
print('on_post_auto_bake, succes = {0}'.format(bake_success))
|
|
|
|
|
|
def get_test_hda_path():
|
|
return '/HoudiniEngine/Examples/hda/copy_to_curve_1_0.copy_to_curve_1_0'
|
|
|
|
|
|
def get_test_hda():
|
|
return unreal.load_object(None, get_test_hda_path())
|
|
|
|
|
|
def get_geo_asset_path():
|
|
return '/Engine/BasicShapes/Cube.Cube'
|
|
|
|
|
|
def get_geo_asset():
|
|
return unreal.load_object(None, get_geo_asset_path())
|
|
|
|
|
|
def build_inputs():
|
|
print('configure_inputs')
|
|
|
|
# get the API singleton
|
|
houdini_api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
|
|
|
|
node_inputs = {}
|
|
|
|
# Create a geo input
|
|
geo_input = houdini_api.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
|
|
# Set the input objects/assets for this input
|
|
geo_object = get_geo_asset()
|
|
geo_input.set_input_objects((geo_object, ))
|
|
# store the input data to the HDA as node input 0
|
|
node_inputs[0] = geo_input
|
|
|
|
# Create a curve input
|
|
curve_input = houdini_api.create_empty_input(unreal.HoudiniPublicAPICurveInput)
|
|
# Create a curve wrapper/helper
|
|
curve_object = unreal.HoudiniPublicAPICurveInputObject(curve_input)
|
|
# Make it a Nurbs curve
|
|
curve_object.set_curve_type(unreal.HoudiniPublicAPICurveType.NURBS)
|
|
# Set the points of the curve, for this example we create a helix
|
|
# consisting of 100 points
|
|
curve_points = []
|
|
for i in range(100):
|
|
t = i / 20.0 * math.pi * 2.0
|
|
x = 100.0 * math.cos(t)
|
|
y = 100.0 * math.sin(t)
|
|
z = i
|
|
curve_points.append(unreal.Transform([x, y, z], [0, 0, 0], [1, 1, 1]))
|
|
curve_object.set_curve_points(curve_points)
|
|
# Set the curve wrapper as an input object
|
|
curve_input.set_input_objects((curve_object, ))
|
|
# Store the input data to the HDA as node input 1
|
|
node_inputs[1] = curve_input
|
|
|
|
return node_inputs
|
|
|
|
|
|
def run():
|
|
# Create the processor with preconfigured inputs
|
|
global _g_processor
|
|
_g_processor = ProcessHDAExample(
|
|
get_test_hda(), node_inputs=build_inputs())
|
|
# Activate the processor, this will starts instantiation, and then cook
|
|
if not _g_processor.activate():
|
|
unreal.log_warning('Activation failed.')
|
|
else:
|
|
unreal.log('Activated!')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
run()
|