Houdini Engine 3.2
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
HAPI.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * COMMENTS:
7  * For parsing help, there is a variable naming convention we maintain:
8  * strings: char * and does not end in "buffer"
9  * binary: char * and is either exactly "buffer" or ends
10  * with "_buffer"
11  * single values: don't end with "_array" or "_buffer"
12  * arrays: <type> * and is either "array" or ends
13  * with "_array"
14  * array length: is either "length", "count", or ends with
15  * "_length" or "_count"
16  */
17 
18 #ifndef __HAPI_h__
19 #define __HAPI_h__
20 
21 #include "HAPI_API.h"
22 #include "HAPI_Common.h"
23 #include "HAPI_Helpers.h"
24 
25 // SESSION ------------------------------------------------------------------
26 
27 /// @brief Creates a new in-process session. There can only be
28 /// one such session per host process.
29 ///
30 /// @param[out] session
31 /// A ::HAPI_Session struct to receive the session id,
32 /// in this case always 0.
33 ///
35 
36 /// @brief Starts a Thrift RPC server process on the local host serving
37 /// clients on a TCP socket and waits for it to start serving.
38 /// It is safe to create an RPC session on local host using the
39 /// specified port after this call succeeds.
40 ///
41 /// @param[in] options
42 /// Options to configure the server being started.
43 ///
44 /// @param[in] port
45 /// The TCP socket to create on the server.
46 ///
47 /// @param[out] process_id
48 /// The process id of the server, if started successfully.
49 ///
51  const HAPI_ThriftServerOptions * options,
52  int port,
53  HAPI_ProcessId * process_id );
54 
55 /// @brief Creates a Thrift RPC session using a TCP socket as transport.
56 ///
57 /// @param[out] session
58 /// A ::HAPI_Session struct to receive the unique session id
59 /// of the new session.
60 ///
61 /// @param[in] host_name
62 /// The name of the server host.
63 ///
64 /// @param[in] port
65 /// The server port to connect to.
66 ///
68  const char * host_name,
69  int port );
70 
71 /// @brief Starts a Thrift RPC server process on the local host serving
72 /// clients on a Windows named pipe or a Unix domain socket and
73 /// waits for it to start serving. It is safe to create an RPC
74 /// session using the specified pipe or socket after this call
75 /// succeeds.
76 ///
77 /// @param[in] options
78 /// Options to configure the server being started.
79 ///
80 /// @param[in] pipe_name
81 /// The name of the pipe or socket.
82 ///
83 /// @param[out] process_id
84 /// The process id of the server, if started successfully.
85 ///
87  const HAPI_ThriftServerOptions * options,
88  const char * pipe_name,
89  HAPI_ProcessId * process_id );
90 
91 /// @brief Creates a Thrift RPC session using a Windows named pipe
92 /// or a Unix domain socket as transport.
93 ///
94 /// @param[out] session
95 /// A ::HAPI_Session struct to receive the unique session id
96 /// of the new session.
97 ///
98 /// @param[in] pipe_name
99 /// The name of the pipe or socket.
100 ///
102  const char * pipe_name );
103 
104 /// @brief Binds a new implementation DLL to one of the custom session
105 /// slots.
106 ///
107 /// @param[in] session_type
108 /// Which custom implementation slot to bind the
109 /// DLL to. Must be one of ::HAPI_SESSION_CUSTOM1,
110 /// ::HAPI_SESSION_CUSTOM2, or ::HAPI_SESSION_CUSTOM3.
111 ///
112 /// @param[in] dll_path
113 /// The path to the custom implementation DLL.
114 ///
116  const char * dll_path );
117 
118 /// @brief Creates a new session using a custom implementation.
119 /// Note that the implementation DLL must already have
120 /// been bound to the session via calling
121 /// ::HAPI_BindCustomImplementation().
122 ///
123 /// @param[in] session_type
124 /// session_type indicates which custom session
125 /// slot to create the session on.
126 ///
127 /// @param[in,out] session_info
128 /// Any data required by the custom implementation to
129 /// create its session.
130 ///
131 /// @param[out] session
132 /// A ::HAPI_Session struct to receive the session id,
133 /// The sessionType parameter of the struct should
134 /// also match the session_type parameter passed in.
135 ///
137  void * session_info,
138  HAPI_Session * session );
139 
140 /// @brief Checks whether the session identified by ::HAPI_Session::id is
141 /// a valid session opened in the implementation identified by
142 /// ::HAPI_Session::type.
143 ///
144 /// @param[in] session
145 /// The ::HAPI_Session to check.
146 ///
147 /// @return ::HAPI_RESULT_SUCCESS if the session is valid.
148 /// Otherwise, the session is invalid and passing it to
149 /// other HAPI calls may result in undefined behavior.
150 ///
151 HAPI_DECL HAPI_IsSessionValid( const HAPI_Session * session );
152 
153 /// @brief Closes a session. If the session has been established using
154 /// RPC, then the RPC connection is closed.
155 ///
156 /// @param[in] session
157 /// The HAPI_Session to close. After this call, this
158 /// session is invalid and passing it to HAPI calls other
159 /// than ::HAPI_IsSessionValid() may result in undefined
160 /// behavior.
161 ///
162 HAPI_DECL HAPI_CloseSession( const HAPI_Session * session );
163 
164 // INITIALIZATION / CLEANUP -------------------------------------------------
165 
166 /// @brief Check whether the runtime has been initialized yet using
167 /// ::HAPI_Initialize(). Function will return ::HAPI_RESULT_SUCCESS
168 /// if the runtime has been initialized and ::HAPI_RESULT_NOT_INITIALIZED
169 /// otherwise.
170 ///
171 /// @param[in] session
172 /// The session of Houdini you are interacting with.
173 /// See @ref HAPI_Sessions for more on sessions.
174 /// Pass NULL to just use the default in-process session.
175 ///
176 HAPI_DECL HAPI_IsInitialized( const HAPI_Session * session );
177 
178 /// @brief Create the asset manager, set up environment variables, and
179 /// initialize the main Houdini scene. No license checking is
180 /// during this step. Only when you try to load an asset library
181 /// (OTL) do we actually check for licenses.
182 ///
183 /// @param[in] session
184 /// The session of Houdini you are interacting with.
185 /// See @ref HAPI_Sessions for more on sessions.
186 /// Pass NULL to just use the default in-process session.
187 ///
188 /// @param[in] cook_options
189 /// Global cook options used by subsequent default cooks.
190 /// This can be overwritten by individual cooks but if
191 /// you choose to instantiate assets with cook_on_load
192 /// set to true then these cook options will be used.
193 ///
194 /// @param[in] use_cooking_thread
195 /// Use a separate thread for cooking of assets. This
196 /// allows for asynchronous cooking and larger stack size.
197 ///
198 /// @param[in] cooking_thread_stack_size
199 /// Set the stack size of the cooking thread. Use -1 to
200 /// set the stack size to the Houdini default. This
201 /// value is in bytes.
202 ///
203 /// @param[in] houdini_environment_files
204 /// A list of paths, separated by a ";" on Windows and a ":"
205 /// on Linux and Mac, to .env files that follow the same
206 /// syntax as the houdini.env file in Houdini's user prefs
207 /// folder. These will be applied after the default
208 /// houdini.env file and will overwrite the process'
209 /// environment variable values. You an use this to enforce
210 /// a stricter environment when running engine.
211 /// For more info, see:
212 /// http://www.sidefx.com/docs/houdini/basics/config_env
213 ///
214 /// @param[in] otl_search_path
215 /// The directory where OTLs are searched for. You can
216 /// pass NULL here which will only use the default
217 /// Houdini OTL search paths. You can also pass in
218 /// multiple paths separated by a ";" on Windows and a ":"
219 /// on Linux and Mac. If something other than NULL is
220 /// passed the default Houdini search paths will be
221 /// appended to the end of the path string.
222 ///
223 /// @param[in] dso_search_path
224 /// The directory where generic DSOs (custom plugins) are
225 /// searched for. You can pass NULL here which will
226 /// only use the default Houdini DSO search paths. You
227 /// can also pass in multiple paths separated by a ";"
228 /// on Windows and a ":" on Linux and Mac. If something
229 /// other than NULL is passed the default Houdini search
230 /// paths will be appended to the end of the path string.
231 ///
232 /// @param[in] image_dso_search_path
233 /// The directory where image DSOs (custom plugins) are
234 /// searched for. You can pass NULL here which will
235 /// only use the default Houdini DSO search paths. You
236 /// can also pass in multiple paths separated by a ";"
237 /// on Windows and a ":" on Linux and Mac. If something
238 /// other than NULL is passed the default Houdini search
239 /// paths will be appended to the end of the path string.
240 ///
241 /// @param[in] audio_dso_search_path
242 /// The directory where audio DSOs (custom plugins) are
243 /// searched for. You can pass NULL here which will
244 /// only use the default Houdini DSO search paths. You
245 /// can also pass in multiple paths separated by a ";"
246 /// on Windows and a ":" on Linux and Mac. If something
247 /// other than NULL is passed the default Houdini search
248 /// paths will be appended to the end of the path string.
249 ///
250 /// [HAPI_Initialize]
251 HAPI_DECL HAPI_Initialize( const HAPI_Session * session,
252  const HAPI_CookOptions * cook_options,
253  HAPI_Bool use_cooking_thread,
254  int cooking_thread_stack_size,
255  const char * houdini_environment_files,
256  const char * otl_search_path,
257  const char * dso_search_path,
258  const char * image_dso_search_path,
259  const char * audio_dso_search_path );
260 /// [HAPI_Initialize]
261 
262 /// @brief Clean up memory. This will unload all assets and you will
263 /// need to call ::HAPI_Initialize() again to be able to use any
264 /// HAPI methods again.
265 ///
266 /// @note This does NOT release any licenses.
267 ///
268 /// @param[in] session
269 /// The session of Houdini you are interacting with.
270 /// See @ref HAPI_Sessions for more on sessions.
271 /// Pass NULL to just use the default in-process session.
272 ///
273 HAPI_DECL HAPI_Cleanup( const HAPI_Session * session );
274 
275 // DIAGNOSTICS --------------------------------------------------------------
276 
277 /// @brief Gives back a certain environment integers like version number.
278 /// Note that you do not need a session for this. These constants
279 /// are hard-coded in all HAPI implementations, including HARC and
280 /// HAPIL. This should be the first API you call to determine if
281 /// any future API calls will mismatch implementation.
282 ///
283 /// @param[in] int_type
284 /// One of ::HAPI_EnvIntType.
285 ///
286 /// @param[out] value
287 /// Int value.
288 ///
289 HAPI_DECL HAPI_GetEnvInt( HAPI_EnvIntType int_type, int * value );
290 
291 /// @brief Gives back a certain session-specific environment integers
292 /// like current license type being used.
293 ///
294 /// @param[in] session
295 /// The session of Houdini you are interacting with.
296 /// See @ref HAPI_Sessions for more on sessions.
297 /// Pass NULL to just use the default in-process session.
298 ///
299 /// @param[in] int_type
300 /// One of ::HAPI_SessionEnvIntType.
301 ///
302 /// @param[out] value
303 /// Int value.
304 ///
306  HAPI_SessionEnvIntType int_type,
307  int * value );
308 
309 /// @brief Get environment variable from the server process as an integer.
310 ///
311 /// @param[in] session
312 /// The session of Houdini you are interacting with.
313 /// See @ref HAPI_Sessions for more on sessions.
314 /// Pass NULL to just use the default in-process session.
315 ///
316 /// @param[in] variable_name
317 /// Name of the environmnet variable.
318 ///
319 /// @param[out] value
320 /// The int pointer to return the value in.
321 ///
323  const char * variable_name,
324  int * value );
325 
326 /// @brief Get environment variable from the server process as a string.
327 ///
328 /// @param[in] session
329 /// The session of Houdini you are interacting with.
330 /// See @ref HAPI_Sessions for more on sessions.
331 /// Pass NULL to just use the default in-process session.
332 ///
333 /// @param[in] variable_name
334 /// Name of the environmnet variable.
335 ///
336 /// @param[out] value
337 /// The HAPI_StringHandle pointer to return the value in.
338 ///
340  const char * variable_name,
341  HAPI_StringHandle * value );
342 
343 /// @brief Provides the number of environment variables that are in
344 /// the server environment's process
345 ///
346 /// @param[in] session
347 /// The session of Houdini you are interacting with.
348 /// See @ref HAPI_Sessions for more on sessions.
349 /// Pass NULL to just use the default in-process session.
350 ///
351 /// @param[out] env_count
352 /// A pointer to an int to return the value in
354  int * env_count );
355 
356 /// @brief Provides a list of all of the environment variables
357 /// in the server's process
358 ///
359 /// @param[in] session
360 /// The session of Houdini you are interacting with.
361 /// See @ref HAPI_Sessions for more on sessions.
362 /// Pass NULL to just use the default in-process session.
363 ///
364 /// @param[out] values_array
365 /// An ::HAPI_StringHandle array at least the size of length
366 ///
367 /// @param[in] start
368 /// First index of range. Must be at least @c 0 and at most
369 /// @c env_count returned by ::HAPI_GetServerEnvVarCount()
370 ///
371 /// @param[in] length
372 /// Given @c env_count returned by ::HAPI_GetServerEnvVarCount(),
373 /// length should be at least @c 0 and at most <tt>env_count - start.</tt>
375  HAPI_StringHandle * values_array,
376  int start,
377  int length );
378 
379 /// @brief Set environment variable for the server process as an integer.
380 ///
381 /// Note that this may affect other sessions on the same server
382 /// process. The session parameter is mainly there to identify the
383 /// server process, not the specific session.
384 ///
385 /// For in-process sessions, this will affect the current process's
386 /// environment.
387 ///
388 /// @param[in] session
389 /// The session of Houdini you are interacting with.
390 /// See @ref HAPI_Sessions for more on sessions.
391 /// Pass NULL to just use the default in-process session.
392 ///
393 /// @param[in] variable_name
394 /// Name of the environmnet variable.
395 ///
396 /// @param[in] value
397 /// The integer value.
398 ///
400  const char * variable_name,
401  int value );
402 
403 /// @brief Set environment variable for the server process as a string.
404 ///
405 /// Note that this may affect other sessions on the same server
406 /// process. The session parameter is mainly there to identify the
407 /// server process, not the specific session.
408 ///
409 /// For in-process sessions, this will affect the current process's
410 /// environment.
411 ///
412 /// @param[in] session
413 /// The session of Houdini you are interacting with.
414 /// See @ref HAPI_Sessions for more on sessions.
415 /// Pass NULL to just use the default in-process session.
416 ///
417 /// @param[in] variable_name
418 /// Name of the environmnet variable.
419 ///
420 /// @param[in] value
421 /// The string value.
422 ///
424  const char * variable_name,
425  const char * value );
426 
427 /// @brief Gives back the status code for a specific status type.
428 ///
429 /// @param[in] session
430 /// The session of Houdini you are interacting with.
431 /// See @ref HAPI_Sessions for more on sessions.
432 /// Pass NULL to just use the default in-process session.
433 ///
434 /// @param[in] status_type
435 /// One of ::HAPI_StatusType.
436 ///
437 /// @param[out] status
438 /// Actual status code for the status type given. That is,
439 /// if you pass in ::HAPI_STATUS_CALL_RESULT as
440 /// status_type, you'll get back a ::HAPI_Result for this
441 /// argument. If you pass in ::HAPI_STATUS_COOK_STATE
442 /// as status_type, you'll get back a ::HAPI_State enum
443 /// for this argument.
444 ///
445 HAPI_DECL HAPI_GetStatus( const HAPI_Session * session,
446  HAPI_StatusType status_type,
447  int * status );
448 
449 /// @brief Return length of string buffer storing status string message.
450 ///
451 /// If called with ::HAPI_STATUS_COOK_RESULT this will actually
452 /// parse the node networks for the previously cooked asset(s)
453 /// and aggregate all node errors, warnings, and messages
454 /// (depending on the @c verbosity level set). Usually this is done
455 /// just for the last cooked single asset but if you load a whole
456 /// Houdini scene using ::HAPI_LoadHIPFile() then you'll have
457 /// multiple "previously cooked assets".
458 ///
459 /// You MUST call ::HAPI_GetStatusStringBufLength() before calling
460 /// ::HAPI_GetStatusString() because ::HAPI_GetStatusString() will
461 /// not return the real status string and instead return a
462 /// cached version of the string that was created inside
463 /// ::HAPI_GetStatusStringBufLength(). The reason for this is that
464 /// the length of the real status string may change between
465 /// the call to ::HAPI_GetStatusStringBufLength() and the call to
466 /// ::HAPI_GetStatusString().
467 ///
468 /// @param[in] session
469 /// The session of Houdini you are interacting with.
470 /// See @ref HAPI_Sessions for more on sessions.
471 /// Pass NULL to just use the default in-process session.
472 ///
473 /// @param[in] status_type
474 /// One of ::HAPI_StatusType.
475 ///
476 /// @param[in] verbosity
477 /// Preferred verbosity level.
478 ///
479 /// @param[out] buffer_length
480 /// Length of buffer char array ready to be filled.
481 ///
483  HAPI_StatusType status_type,
484  HAPI_StatusVerbosity verbosity,
485  int * buffer_length );
486 
487 /// @brief Return status string message.
488 ///
489 /// You MUST call ::HAPI_GetStatusStringBufLength() before calling
490 /// ::HAPI_GetStatusString() because ::HAPI_GetStatusString() will
491 /// not return the real status string and instead return a
492 /// cached version of the string that was created inside
493 /// ::HAPI_GetStatusStringBufLength(). The reason for this is that
494 /// the length of the real status string may change between
495 /// the call to ::HAPI_GetStatusStringBufLength() and the call to
496 /// ::HAPI_GetStatusString().
497 ///
498 /// @param[in] session
499 /// The session of Houdini you are interacting with.
500 /// See @ref HAPI_Sessions for more on sessions.
501 /// Pass NULL to just use the default in-process session.
502 ///
503 /// @param[in] status_type
504 /// One of ::HAPI_StatusType.
505 ///
506 /// @param[out] string_value
507 /// Buffer char array ready to be filled.
508 ///
509 /// @param[in] length
510 /// Length of the string buffer (must match size of
511 /// string_value - so including NULL terminator).
512 ///
514  HAPI_StatusType status_type,
515  char * string_value,
516  int length );
517 
518 /// @brief Compose the cook result string (errors and warnings) of a
519 /// specific node.
520 ///
521 /// This will actually parse the node network inside the given
522 /// node and return ALL errors/warnings/messages of all child nodes,
523 /// combined into a single string. If you'd like a more narrowed
524 /// search, call this function on one of the child nodes.
525 ///
526 /// You MUST call ::HAPI_ComposeNodeCookResult() before calling
527 /// ::HAPI_GetComposedNodeCookResult() because
528 /// ::HAPI_GetComposedNodeCookResult() will
529 /// not return the real result string and instead return a
530 /// cached version of the string that was created inside
531 /// ::HAPI_ComposeNodeCookResult(). The reason for this is that
532 /// the length of the real status string may change between
533 /// the call to ::HAPI_ComposeNodeCookResult() and the call to
534 /// ::HAPI_GetComposedNodeCookResult().
535 ///
536 /// @param[in] session
537 /// The session of Houdini you are interacting with.
538 /// See @ref HAPI_Sessions for more on sessions.
539 /// Pass NULL to just use the default in-process session.
540 ///
541 /// @param[in] node_id
542 /// The node id.
543 ///
544 /// @param[in] verbosity
545 /// Preferred verbosity level.
546 ///
547 /// @param[out] buffer_length
548 /// Length of buffer char array ready to be filled.
549 ///
551  HAPI_NodeId node_id,
552  HAPI_StatusVerbosity verbosity,
553  int * buffer_length );
554 
555 /// @brief Return cook result string message on a single node.
556 ///
557 /// You MUST call ::HAPI_ComposeNodeCookResult() before calling
558 /// ::HAPI_GetComposedNodeCookResult() because
559 /// ::HAPI_GetComposedNodeCookResult() will
560 /// not return the real result string and instead return a
561 /// cached version of the string that was created inside
562 /// ::HAPI_ComposeNodeCookResult(). The reason for this is that
563 /// the length of the real status string may change between
564 /// the call to ::HAPI_ComposeNodeCookResult() and the call to
565 /// ::HAPI_GetComposedNodeCookResult().
566 ///
567 /// @param[in] session
568 /// The session of Houdini you are interacting with.
569 /// See @ref HAPI_Sessions for more on sessions.
570 /// Pass NULL to just use the default in-process session.
571 ///
572 /// @param[out] string_value
573 /// Buffer char array ready to be filled.
574 ///
575 /// @param[in] length
576 /// Length of the string buffer (must match size of
577 /// string_value - so including NULL terminator).
578 ///
580  char * string_value,
581  int length );
582 
583 /// @brief Recursively check for specific errors by error code on a node.
584 ///
585 /// Note that checking for errors can be expensive because it checks
586 /// ALL child nodes within a node and then tries to do a string match
587 /// for the errors being looked for. This is why such error checking
588 /// is part of a standalone function and not done during the cooking
589 /// step.
590 ///
591 /// @param[in] session
592 /// The session of Houdini you are interacting with.
593 /// See @ref HAPI_Sessions for more on sessions.
594 /// Pass NULL to just use the default in-process session.
595 ///
596 /// @param[in] node_id
597 /// The node id.
598 ///
599 /// @param[in] errors_to_look_for
600 /// The HAPI_ErrorCode error codes (as a bitfield) to look for.
601 ///
602 /// @param[out] errors_found
603 /// Returned HAPI_ErrorCode bitfield indicating which of the
604 /// looked for errors have been found.
605 ///
607  HAPI_NodeId node_id,
608  HAPI_ErrorCodeBits errors_to_look_for,
609  HAPI_ErrorCodeBits * errors_found );
610 
611 /// @brief Get total number of nodes that need to cook in the current
612 /// session.
613 ///
614 /// @param[in] session
615 /// The session of Houdini you are interacting with.
616 /// See @ref HAPI_Sessions for more on sessions.
617 /// Pass NULL to just use the default in-process session.
618 ///
619 /// @param[out] count
620 /// Total cook count.
621 ///
623  int * count );
624 
625 /// @brief Get current number of nodes that have already cooked in the
626 /// current session. Note that this is a very crude approximation
627 /// of the cooking progress - it may never make it to 100% or it
628 /// might spend another hour at 100%. Use ::HAPI_GetStatusString
629 /// to get a better idea of progress if this number gets stuck.
630 ///
631 /// @param[in] session
632 /// The session of Houdini you are interacting with.
633 /// See @ref HAPI_Sessions for more on sessions.
634 /// Pass NULL to just use the default in-process session.
635 ///
636 /// @param[out] count
637 /// Current cook count.
638 ///
640  int * count );
641 
642 // UTILITY ------------------------------------------------------------------
643 
644 /// @brief Converts the transform described by a ::HAPI_TransformEuler
645 /// struct into a different transform and rotation order.
646 ///
647 /// @param[in] session
648 /// The session of Houdini you are interacting with.
649 /// See @ref HAPI_Sessions for more on sessions.
650 /// Pass NULL to just use the default in-process session.
651 ///
652 /// @param[in] transform_in
653 /// The transform to be converted.
654 ///
655 /// @param[in] rst_order
656 /// The desired transform order of the output.
657 ///
658 /// @param[in] rot_order
659 /// The desired rotation order of the output.
660 ///
661 /// @param[out] transform_out
662 /// The converted transform.
663 ///
665  const HAPI_TransformEuler * transform_in,
666  HAPI_RSTOrder rst_order,
667  HAPI_XYZOrder rot_order,
668  HAPI_TransformEuler * transform_out );
669 
670 /// @brief Converts a 4x4 matrix into its TRS form.
671 ///
672 /// @param[in] session
673 /// The session of Houdini you are interacting with.
674 /// See @ref HAPI_Sessions for more on sessions.
675 /// Pass NULL to just use the default in-process session.
676 ///
677 /// @param[in] matrix
678 /// A 4x4 matrix expressed in a 16 element float array.
679 ///
680 /// @param[in] rst_order
681 /// The desired transform order of the output.
682 ///
683 /// @param[out] transform_out
684 /// Used for the output.
685 ///
687  const float * matrix,
688  HAPI_RSTOrder rst_order,
689  HAPI_Transform * transform_out );
690 
691 /// @brief Converts a 4x4 matrix into its TRS form.
692 ///
693 /// @param[in] session
694 /// The session of Houdini you are interacting with.
695 /// See @ref HAPI_Sessions for more on sessions.
696 /// Pass NULL to just use the default in-process session.
697 ///
698 /// @param[in] matrix
699 /// A 4x4 matrix expressed in a 16 element float array.
700 ///
701 /// @param[in] rst_order
702 /// The desired transform order of the output.
703 ///
704 /// @param[in] rot_order
705 /// The desired rotation order of the output.
706 ///
707 /// @param[out] transform_out
708 /// Used for the output.
709 ///
711  const float * matrix,
712  HAPI_RSTOrder rst_order,
713  HAPI_XYZOrder rot_order,
714  HAPI_TransformEuler * transform_out );
715 
716 /// @brief Converts ::HAPI_Transform into a 4x4 transform matrix.
717 ///
718 /// @param[in] session
719 /// The session of Houdini you are interacting with.
720 /// See @ref HAPI_Sessions for more on sessions.
721 /// Pass NULL to just use the default in-process session.
722 ///
723 /// @param[in] transform
724 /// The ::HAPI_Transform you wish to convert.
725 ///
726 /// @param[out] matrix
727 /// A 16 element float array that will contain the result.
728 ///
730  const HAPI_Transform * transform,
731  float * matrix );
732 
733 /// @brief Converts ::HAPI_TransformEuler into a 4x4 transform matrix.
734 ///
735 /// @param[in] session
736 /// The session of Houdini you are interacting with.
737 /// See @ref HAPI_Sessions for more on sessions.
738 /// Pass NULL to just use the default in-process session.
739 ///
740 /// @param[in] transform
741 /// The ::HAPI_TransformEuler you wish to convert.
742 ///
743 /// @param[out] matrix
744 /// A 16 element float array that will contain the result.
745 ///
747  const HAPI_Session * session,
748  const HAPI_TransformEuler * transform,
749  float * matrix );
750 
751 /// @brief Acquires or releases the Python interpreter lock. This is
752 /// needed if HAPI is called from Python and HAPI is in threaded
753 /// mode (see ::HAPI_Initialize()).
754 ///
755 /// The problem arises when async functions like
756 /// ::HAPI_CreateNode() may start a cooking thread that
757 /// may try to run Python code. That is, we would now have
758 /// Python running on two different threads - something not
759 /// allowed by Python by default.
760 ///
761 /// We need to tell Python to explicitly "pause" the Python state
762 /// on the client thread while we run Python in our cooking thread.
763 ///
764 /// You must call this function first with locked == true before
765 /// any async HAPI call. Then, after the async call finished,
766 /// detected via calls to ::HAPI_GetStatus(), call this method
767 /// again to release the lock with locked == false.
768 ///
769 /// @param[in] session
770 /// The session of Houdini you are interacting with.
771 /// See @ref HAPI_Sessions for more on sessions.
772 /// Pass NULL to just use the default in-process session.
773 ///
774 /// @param[in] locked
775 /// True will acquire the interpreter lock to use it for
776 /// the HAPI cooking thread. False will release the lock
777 /// back to the client thread.
778 ///
780  HAPI_Bool locked );
781 
782 // STRINGS ------------------------------------------------------------------
783 
784 /// @brief Gives back the string length of the string with the
785 /// given handle.
786 ///
787 /// @param[in] session
788 /// The session of Houdini you are interacting with.
789 /// See @ref HAPI_Sessions for more on sessions.
790 /// Pass NULL to just use the default in-process session.
791 ///
792 /// @param[in] string_handle
793 /// Handle of the string to query.
794 ///
795 /// @param[out] buffer_length
796 /// Buffer length of the queried string (including NULL
797 /// terminator).
798 ///
800  HAPI_StringHandle string_handle,
801  int * buffer_length );
802 
803 /// @brief Gives back the string value of the string with the
804 /// given handle.
805 ///
806 /// @param[in] session
807 /// The session of Houdini you are interacting with.
808 /// See @ref HAPI_Sessions for more on sessions.
809 /// Pass NULL to just use the default in-process session.
810 ///
811 /// @param[in] string_handle
812 /// Handle of the string to query.
813 ///
814 /// @param[out] string_value
815 /// Actual string value (character array).
816 ///
817 /// @param[in] length
818 /// Length of the string buffer (must match size of
819 /// string_value - so including NULL terminator).
820 ///
821 HAPI_DECL HAPI_GetString( const HAPI_Session * session,
822  HAPI_StringHandle string_handle,
823  char * string_value,
824  int length );
825 
826 /// @brief Gives back the length of the buffer needed to hold
827 /// all the values null-separated for the given string
828 /// handles. Used with HAPI_GetStringBatch.
829 ///
830 /// @param[in] session
831 /// The session of Houdini you are interacting with.
832 /// See @ref HAPI_Sessions for more on sessions.
833 /// Pass NULL to just use the default in-process session.
834 ///
835 /// @param[in] string_handle_array
836 /// Array of string handles to be read.
837 ///
838 /// @param[in] string_handle_count
839 /// Length of string_handle_array
840 ///
841 /// @param[out] string_buffer_size
842 /// Buffer length required for subsequent call to
843 /// HAPI_GetStringBatch to hold all the given
844 /// string values null-terminated
845 ///
847  const int * string_handle_array,
848  int string_handle_count,
849  int* string_buffer_size);
850 
851 /// @brief Gives back the values of the given string handles.
852 /// The given char array is filled with null-separated
853 /// values, and the final value is null-terminated.
854 /// Used with HAPI_GetStringBatchSize. Using this function
855 /// instead of repeated calls to HAPI_GetString can be more
856 /// more efficient for a large number of strings.
857 ///
858 /// @param[in] session
859 /// The session of Houdini you are interacting with.
860 /// See @ref HAPI_Sessions for more on sessions.
861 /// Pass NULL to just use the default in-process session.
862 ///
863 /// @param[out] char_array
864 /// Array of characters to hold string values.
865 ///
866 /// @param[in] char_array_length
867 /// Length of char_array. Must be large enough to hold
868 /// all the string values including null separators.
869 ///
871  char * char_array,
872  int char_array_length);
873 
874 
875 // TIME ---------------------------------------------------------------------
876 
877 /// @brief Gets the global time of the scene. All API calls deal with
878 /// this time to cook.
879 ///
880 /// @param[in] session
881 /// The session of Houdini you are interacting with.
882 /// See @ref HAPI_Sessions for more on sessions.
883 /// Pass NULL to just use the default in-process session.
884 ///
885 /// @param[out] time
886 /// Time as a float in seconds.
887 ///
888 HAPI_DECL HAPI_GetTime( const HAPI_Session * session, float * time );
889 
890 /// @brief Sets the global time of the scene. All API calls will deal
891 /// with this time to cook.
892 ///
893 /// @param[in] session
894 /// The session of Houdini you are interacting with.
895 /// See @ref HAPI_Sessions for more on sessions.
896 /// Pass NULL to just use the default in-process session.
897 ///
898 /// @param[in] time
899 /// Time as a float in seconds.
900 ///
901 HAPI_DECL HAPI_SetTime( const HAPI_Session * session, float time );
902 
903 /// @brief Gets the current global timeline options.
904 ///
905 /// @param[in] session
906 /// The session of Houdini you are interacting with.
907 /// See @ref HAPI_Sessions for more on sessions.
908 /// Pass NULL to just use the default in-process session.
909 ///
910 /// @param[in] timeline_options
911 /// The global timeline options struct.
912 ///
914  HAPI_TimelineOptions * timeline_options );
915 
916 /// @brief Sets the global timeline options.
917 ///
918 /// @param[in] session
919 /// The session of Houdini you are interacting with.
920 /// See @ref HAPI_Sessions for more on sessions.
921 /// Pass NULL to just use the default in-process session.
922 ///
923 /// @param[in] timeline_options
924 /// The global timeline options struct.
925 ///
927  const HAPI_Session * session,
928  const HAPI_TimelineOptions * timeline_options );
929 
930 // ASSETS -------------------------------------------------------------------
931 
932 /// @brief Loads a Houdini asset library (OTL) from a .otl file.
933 /// It does NOT create anything inside the Houdini scene.
934 ///
935 /// @note This is when we actually check for valid licenses.
936 ///
937 /// The next step is to call ::HAPI_GetAvailableAssetCount()
938 /// to get the number of assets contained in the library using the
939 /// returned library_id. Then call ::HAPI_GetAvailableAssets()
940 /// to get the list of available assets by name. Use the asset
941 /// names with ::HAPI_CreateNode() to actually create
942 /// one of these nodes in the Houdini scene and get back
943 /// an asset_id.
944 ///
945 /// @note The HIP file saved using ::HAPI_SaveHIPFile() will only
946 /// have an absolute path reference to the loaded OTL meaning
947 /// that if the OTL is moved or renamed the HIP file won't
948 /// load properly. It also means that if you change the OTL
949 /// using the saved HIP scene the same OTL file will change
950 /// as the one used with Houdini Engine.
951 /// See @ref HAPI_Fundamentals_SavingHIPFile.
952 ///
953 /// @param[in] session
954 /// The session of Houdini you are interacting with.
955 /// See @ref HAPI_Sessions for more on sessions.
956 /// Pass NULL to just use the default in-process session.
957 ///
958 /// @param[in] file_path
959 /// Absolute path to the .otl file.
960 ///
961 /// @param[in] allow_overwrite
962 /// With this true, if the library file being loaded
963 /// contains asset definitions that have already been
964 /// loaded they will overwrite the existing definitions.
965 /// Otherwise, a library containing asset definitions that
966 /// already exist will fail to load, returning a
967 /// ::HAPI_Result of
968 /// ::HAPI_RESULT_ASSET_DEF_ALREADY_LOADED.
969 ///
970 /// @param[out] library_id
971 /// Newly loaded otl id to be used with
972 /// ::HAPI_GetAvailableAssetCount() and
973 /// ::HAPI_GetAvailableAssets().
974 ///
976  const char * file_path,
977  HAPI_Bool allow_overwrite,
978  HAPI_AssetLibraryId* library_id );
979 
980 /// @brief Loads a Houdini asset library (OTL) from memory.
981 /// It does NOT create anything inside the Houdini scene.
982 ///
983 /// @note This is when we actually check for valid licenses.
984 ///
985 /// Please note that the performance benefit of loading a library
986 /// from memory are negligible at best. Due to limitations of
987 /// Houdini's library manager, there is still some disk access
988 /// and file writes because every asset library needs to be
989 /// saved to a real file. Use this function only as a convenience
990 /// if you already have the library file in memory and don't wish
991 /// to have to create your own temporary library file and then
992 /// call ::HAPI_LoadAssetLibraryFromFile().
993 ///
994 /// The next step is to call ::HAPI_GetAvailableAssetCount()
995 /// to get the number of assets contained in the library using the
996 /// returned library_id. Then call ::HAPI_GetAvailableAssets()
997 /// to get the list of available assets by name. Use the asset
998 /// names with ::HAPI_CreateNode() to actually create
999 /// one of these nodes in the Houdini scene and get back
1000 /// an asset_id.
1001 ///
1002 /// @note The saved HIP file using ::HAPI_SaveHIPFile() will
1003 /// @a contain the OTL loaded as part of its @b Embedded OTLs.
1004 /// This means that you can safely move or rename the original
1005 /// OTL file and the HIP will continue to work but if you make
1006 /// changes to the OTL while using the saved HIP the changes
1007 /// won't be saved to the original OTL.
1008 /// See @ref HAPI_Fundamentals_SavingHIPFile.
1009 ///
1010 /// @param[in] session
1011 /// The session of Houdini you are interacting with.
1012 /// See @ref HAPI_Sessions for more on sessions.
1013 /// Pass NULL to just use the default in-process session.
1014 ///
1015 /// @param[in] library_buffer
1016 /// The memory buffer containing the asset definitions
1017 /// in the same format as a standard Houdini .otl file.
1018 ///
1019 /// @param[in] library_buffer_length
1020 /// The size of the OTL memory buffer.
1021 ///
1022 /// @param[in] allow_overwrite
1023 /// With this true, if the library file being loaded
1024 /// contains asset definitions that have already been
1025 /// loaded they will overwrite the existing definitions.
1026 /// Otherwise, a library containing asset definitions that
1027 /// already exist will fail to load, returning a
1028 /// ::HAPI_Result of
1029 /// ::HAPI_RESULT_ASSET_DEF_ALREADY_LOADED.
1030 ///
1031 /// @param[out] library_id
1032 /// Newly loaded otl id to be used with
1033 /// ::HAPI_GetAvailableAssetCount() and
1034 /// ::HAPI_GetAvailableAssets().
1035 ///
1037  const char * library_buffer,
1038  int library_buffer_length,
1039  HAPI_Bool allow_overwrite,
1040  HAPI_AssetLibraryId * library_id );
1041 
1042 /// @brief Get the number of assets contained in an asset library.
1043 /// You should call ::HAPI_LoadAssetLibraryFromFile() prior to
1044 /// get a library_id.
1045 ///
1046 /// @param[in] session
1047 /// The session of Houdini you are interacting with.
1048 /// See @ref HAPI_Sessions for more on sessions.
1049 /// Pass NULL to just use the default in-process session.
1050 ///
1051 /// @param[in] library_id
1052 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1053 ///
1054 /// @param[out] asset_count
1055 /// The number of assets contained in this asset library.
1056 ///
1058  HAPI_AssetLibraryId library_id,
1059  int * asset_count );
1060 
1061 /// @brief Get the names of the assets contained in an asset library.
1062 ///
1063 /// The asset names will contain additional information about
1064 /// the type of asset, namespace, and version, along with the
1065 /// actual asset name. For example, if you have an Object type
1066 /// asset, in the "hapi" namespace, of version 2.0, named
1067 /// "foo", the asset name returned here will be:
1068 /// hapi::Object/foo::2.0
1069 ///
1070 /// However, you should not need to worry about this detail. Just
1071 /// pass this string directly to ::HAPI_CreateNode() to
1072 /// create the node. You can then get the pretty name
1073 /// using ::HAPI_GetAssetInfo().
1074 ///
1075 /// You should call ::HAPI_LoadAssetLibraryFromFile() prior to
1076 /// get a library_id. Then, you should call
1077 /// ::HAPI_GetAvailableAssetCount() to get the number of assets to
1078 /// know how large of a string handles array you need to allocate.
1079 ///
1080 /// @param[in] session
1081 /// The session of Houdini you are interacting with.
1082 /// See @ref HAPI_Sessions for more on sessions.
1083 /// Pass NULL to just use the default in-process session.
1084 ///
1085 /// @param[in] library_id
1086 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1087 ///
1088 /// @param[out] asset_names_array
1089 /// Array of string handles (integers) that should be
1090 /// at least the size of asset_count.
1091 ///
1092 /// @param[out] asset_count
1093 /// Should be the same or less than the value returned by
1094 /// ::HAPI_GetAvailableAssetCount().
1095 ///
1097  HAPI_AssetLibraryId library_id,
1098  HAPI_StringHandle * asset_names_array,
1099  int asset_count );
1100 
1101 /// @brief Fill an asset_info struct from a node.
1102 ///
1103 /// @param[in] session
1104 /// The session of Houdini you are interacting with.
1105 /// See @ref HAPI_Sessions for more on sessions.
1106 /// Pass NULL to just use the default in-process session.
1107 ///
1108 /// @param[in] node_id
1109 /// The node id.
1110 ///
1111 /// @param[out] asset_info
1112 /// Returned ::HAPI_AssetInfo struct.
1113 ///
1114 HAPI_DECL HAPI_GetAssetInfo( const HAPI_Session * session,
1115  HAPI_NodeId node_id,
1116  HAPI_AssetInfo * asset_info );
1117 
1118 /// @brief Interrupt a cook or load operation.
1119 ///
1120 /// @param[in] session
1121 /// The session of Houdini you are interacting with.
1122 /// See @ref HAPI_Sessions for more on sessions.
1123 /// Pass NULL to just use the default in-process session.
1124 ///
1125 HAPI_DECL HAPI_Interrupt( const HAPI_Session * session );
1126 
1127 // HIP FILES ----------------------------------------------------------------
1128 
1129 /// @brief Loads a .hip file into the main Houdini scene.
1130 ///
1131 /// @note In threaded mode, this is an _async call_!
1132 ///
1133 /// @param[in] session
1134 /// The session of Houdini you are interacting with.
1135 /// See @ref HAPI_Sessions for more on sessions.
1136 /// Pass NULL to just use the default in-process session.
1137 ///
1138 /// @param[in] file_name
1139 /// Absolute path to the .hip file to load.
1140 ///
1141 /// @param[in] cook_on_load
1142 /// Set to true if you wish the nodes to cook as soon
1143 /// as they are created. Otherwise, you will have to
1144 /// call ::HAPI_CookNode() explicitly for each after you
1145 /// call this function.
1146 ///
1147 HAPI_DECL HAPI_LoadHIPFile( const HAPI_Session * session,
1148  const char * file_name,
1149  HAPI_Bool cook_on_load );
1150 
1151 /// @brief Saves a .hip file of the current Houdini scene.
1152 ///
1153 /// @param[in] session
1154 /// The session of Houdini you are interacting with.
1155 /// See @ref HAPI_Sessions for more on sessions.
1156 /// Pass NULL to just use the default in-process session.
1157 ///
1158 /// @param[in] file_path
1159 /// Absolute path to the .hip file to save to.
1160 ///
1161 /// @param[in] lock_nodes
1162 /// Specify whether to lock all SOP nodes before saving
1163 /// the scene file. This way, when you load the scene
1164 /// file you can see exactly the state of each SOP at
1165 /// the time it was saved instead of relying on the
1166 /// re-cook to accurately reproduce the state. It does,
1167 /// however, take a lot more space and time locking all
1168 /// nodes like this.
1169 ///
1170 HAPI_DECL HAPI_SaveHIPFile( const HAPI_Session * session,
1171  const char * file_path,
1172  HAPI_Bool lock_nodes );
1173 
1174 // NODES --------------------------------------------------------------------
1175 
1176 /// @brief Determine if your instance of the node actually still exists
1177 /// inside the Houdini scene. This is what can be used to
1178 /// determine when the Houdini scene needs to be re-populated
1179 /// using the host application's instances of the nodes.
1180 /// Note that this function will ALWAYS return
1181 /// ::HAPI_RESULT_SUCCESS.
1182 ///
1183 /// @param[in] session
1184 /// The session of Houdini you are interacting with.
1185 /// See @ref HAPI_Sessions for more on sessions.
1186 /// Pass NULL to just use the default in-process session.
1187 ///
1188 /// @param[in] node_id
1189 /// The node id.
1190 ///
1191 /// @param[in] unique_node_id
1192 /// The unique node id from
1193 /// ::HAPI_NodeInfo::uniqueHoudiniNodeId.
1194 ///
1195 /// @param[out] answer
1196 /// Answer to the question.
1197 ///
1198 HAPI_DECL HAPI_IsNodeValid( const HAPI_Session * session,
1199  HAPI_NodeId node_id,
1200  int unique_node_id,
1201  HAPI_Bool * answer );
1202 
1203 /// @brief Fill an ::HAPI_NodeInfo struct.
1204 ///
1205 /// @param[in] session
1206 /// The session of Houdini you are interacting with.
1207 /// See @ref HAPI_Sessions for more on sessions.
1208 /// Pass NULL to just use the default in-process session.
1209 ///
1210 /// @param[in] node_id
1211 /// The node id.
1212 ///
1213 /// @param[out] node_info
1214 /// Return value - contains things like asset id.
1215 ///
1216 HAPI_DECL HAPI_GetNodeInfo( const HAPI_Session * session,
1217  HAPI_NodeId node_id,
1218  HAPI_NodeInfo * node_info );
1219 
1220 /// @brief Get the node absolute path in the Houdini node network or a
1221 /// relative path any other node.
1222 ///
1223 /// @param[in] session
1224 /// The session of Houdini you are interacting with.
1225 /// See @ref HAPI_Sessions for more on sessions.
1226 /// Pass NULL to just use the default in-process session.
1227 ///
1228 /// @param[in] node_id
1229 /// The node id.
1230 ///
1231 /// @param[in] relative_to_node_id
1232 /// Set this to -1 to get the absolute path of the node_id.
1233 /// Otherwise, the path will be relative to this node id.
1234 ///
1235 /// @param[out] path
1236 /// The returned path string, valid until the next call to
1237 /// this function.
1238 ///
1239 HAPI_DECL HAPI_GetNodePath( const HAPI_Session * session,
1240  HAPI_NodeId node_id,
1241  HAPI_NodeId relative_to_node_id,
1242  HAPI_StringHandle * path );
1243 
1244 /// @brief Get the root node of a particular network type (ie. OBJ).
1245 ///
1246 /// @param[in] session
1247 /// The session of Houdini you are interacting with.
1248 /// See @ref HAPI_Sessions for more on sessions.
1249 /// Pass NULL to just use the default in-process session.
1250 ///
1251 /// @param[in] node_type
1252 /// The node network type.
1253 ///
1254 /// @param[out] node_id
1255 /// The node id of the root node network.
1256 ///
1258  HAPI_NodeType node_type,
1259  HAPI_NodeId * node_id );
1260 
1261 /// @brief Compose a list of child nodes based on given filters.
1262 ///
1263 /// This function will only compose the list of child nodes. It will
1264 /// not return this list. After your call to this function, call
1265 /// HAPI_GetComposedChildNodeList() to get the list of child node ids.
1266 ///
1267 /// Note: When looking for all Display SOP nodes using this function,
1268 /// and using recursive mode, the recursion will stop as soon as a
1269 /// display SOP is found within each OBJ geometry network. It is
1270 /// almost never useful to get a list of ALL display SOP nodes
1271 /// recursively as they would all containt the same geometry. Even so,
1272 /// this special case only comes up if the display SOP itself is a
1273 /// subnet.
1274 ///
1275 /// @param[in] session
1276 /// The session of Houdini you are interacting with.
1277 /// See @ref HAPI_Sessions for more on sessions.
1278 /// Pass NULL to just use the default in-process session.
1279 ///
1280 /// @param[in] parent_node_id
1281 /// The node id of the parent node.
1282 ///
1283 /// @param[in] node_type_filter
1284 /// The node type by which to filter the children.
1285 ///
1286 /// @param[in] node_flags_filter
1287 /// The node flags by which to filter the children.
1288 ///
1289 /// @param[in] recursive
1290 /// Whether or not to compose the list recursively.
1291 ///
1292 /// @param[out] count
1293 /// The number of child nodes composed. Use this as the
1294 /// argument to ::HAPI_GetComposedChildNodeList().
1295 ///
1297  HAPI_NodeId parent_node_id,
1298  HAPI_NodeTypeBits node_type_filter,
1299  HAPI_NodeFlagsBits node_flags_filter,
1300  HAPI_Bool recursive,
1301  int * count );
1302 
1303 /// @brief Get the composed list of child node ids from the previous call
1304 /// to HAPI_ComposeChildNodeList().
1305 ///
1306 /// @param[in] session
1307 /// The session of Houdini you are interacting with.
1308 /// See @ref HAPI_Sessions for more on sessions.
1309 /// Pass NULL to just use the default in-process session.
1310 ///
1311 /// @param[in] parent_node_id
1312 /// The node id of the parent node.
1313 ///
1314 /// @param[out] child_node_ids_array
1315 /// The array of ::HAPI_NodeId for the child nodes.
1316 ///
1317 /// @param[in] count
1318 /// The number of children in the composed list. MUST match
1319 /// the count returned by HAPI_ComposeChildNodeList().
1320 ///
1322  HAPI_NodeId parent_node_id,
1323  HAPI_NodeId * child_node_ids_array,
1324  int count );
1325 
1326 /// @brief Create a node inside a node network. Nodes created this way
1327 /// will have their ::HAPI_NodeInfo::createdPostAssetLoad set
1328 /// to true.
1329 ///
1330 /// @note In threaded mode, this is an _async call_!
1331 ///
1332 /// @note This is also when we actually check for valid licenses.
1333 ///
1334 /// This API will invoke the cooking thread if threading is
1335 /// enabled. This means it will return immediately with a call
1336 /// result of ::HAPI_RESULT_SUCCESS, even if fed garbage. Use
1337 /// the status and cooking count APIs under DIAGNOSTICS to get
1338 /// a sense of the progress. All other API calls will block
1339 /// until the creation (and, optionally, the first cook)
1340 /// of the node has finished.
1341 ///
1342 /// Also note that the cook result won't be of type
1343 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
1344 /// Whenever the threading cook is done it will fill the
1345 /// @a cook result which is queried using
1346 /// ::HAPI_STATUS_COOK_RESULT.
1347 ///
1348 /// @param[in] session
1349 /// The session of Houdini you are interacting with.
1350 /// See @ref HAPI_Sessions for more on sessions.
1351 /// Pass NULL to just use the default in-process session.
1352 ///
1353 /// @param[in] parent_node_id
1354 /// The parent node network's node id or -1 if the parent
1355 /// network is the manager (top-level) node. In that case,
1356 /// the manager must be identified by the table name in the
1357 /// operator_name.
1358 ///
1359 /// @param[in] operator_name
1360 /// The name of the node operator type.
1361 ///
1362 /// If you passed parent_node_id == -1, then the operator_name
1363 /// has to include the table name (ie. Object/ or Sop/).
1364 /// This is the common case for when creating asset nodes
1365 /// from a loaded asset library. In that case, just pass
1366 /// whatever ::HAPI_GetAvailableAssets() returns.
1367 ///
1368 /// If you have a parent_node_id then you should
1369 /// include only the namespace, name, and version.
1370 ///
1371 /// For example, lets say you have an Object type asset, in
1372 /// the "hapi" namespace, of version 2.0, named "foo". If
1373 /// you pass parent_node_id == -1, then set the operator_name
1374 /// as "Object/hapi::foo::2.0". Otherwise, if you have a valid
1375 /// parent_node_id, then just pass operator_name as
1376 /// "hapi::foo::2.0".
1377 ///
1378 /// @param[in] node_label
1379 /// (Optional) The label of the newly created node.
1380 ///
1381 /// @param[in] cook_on_creation
1382 /// Set whether the node should cook once created or not.
1383 ///
1384 /// @param[out] new_node_id
1385 /// The returned node id of the just-created node.
1386 ///
1387 HAPI_DECL HAPI_CreateNode( const HAPI_Session * session,
1388  HAPI_NodeId parent_node_id,
1389  const char * operator_name,
1390  const char * node_label,
1391  HAPI_Bool cook_on_creation,
1392  HAPI_NodeId * new_node_id );
1393 
1394 /// @brief Creates a simple geometry SOP node that can accept geometry input.
1395 /// This will create a dummy OBJ node with a Null SOP inside that
1396 /// you can set the geometry of using the geometry SET APIs.
1397 /// You can then connect this node to any other node as a geometry
1398 /// input.
1399 ///
1400 /// Note that when saving the Houdini scene using
1401 /// ::HAPI_SaveHIPFile() the nodes created with this
1402 /// method will be green and will start with the name "input".
1403 ///
1404 /// @param[in] session
1405 /// The session of Houdini you are interacting with.
1406 /// See @ref HAPI_Sessions for more on sessions.
1407 /// Pass NULL to just use the default in-process session.
1408 ///
1409 /// @param[out] node_id
1410 /// Newly created node's id. Use ::HAPI_GetNodeInfo()
1411 /// to get more information about the node.
1412 ///
1413 /// @param[in] name
1414 /// Give this input node a name for easy debugging.
1415 /// The node's parent OBJ node and the Null SOP node will both
1416 /// get this given name with "input_" prepended.
1417 /// You can also pass NULL in which case the name will
1418 /// be "input#" where # is some number.
1419 ///
1421  HAPI_NodeId * node_id,
1422  const char * name );
1423 
1424 /// @brief Creates the required node hierarchy needed for Heightfield inputs.
1425 ///
1426 /// Note that when saving the Houdini scene using
1427 /// ::HAPI_SaveHIPFile() the nodes created with this
1428 /// method will be green and will start with the name "input".
1429 ///
1430 /// @param[in] session
1431 /// The session of Houdini you are interacting with.
1432 /// See @ref HAPI_Sessions for more on sessions.
1433 /// Pass NULL to just use the default in-process session.
1434 ///
1435 /// @param[in] parent_node_id
1436 /// The parent node network's node id or -1 if the parent
1437 /// network is the manager (top-level) node. In that case,
1438 /// the manager must be identified by the table name in the
1439 /// operator_name.
1440 ///
1441 /// @param[in] name
1442 /// Give this input node a name for easy debugging.
1443 /// The node's parent OBJ node and the Null SOP node will both
1444 /// get this given name with "input_" prepended.
1445 /// You can also pass NULL in which case the name will
1446 /// be "input#" where # is some number.
1447 ///
1448 /// @param[in] xsize
1449 /// size of the heightfield in X
1450 ///
1451 /// @param[in] ysize
1452 /// size of the heightfield in y
1453 ///
1454 /// @param[in] voxelsize
1455 /// Size of the voxel
1456 ///
1457 /// @param[out] heightfield_node_id
1458 /// Newly created node id for the Heightfield node.
1459 /// Use ::HAPI_GetNodeInfo() to get more information about
1460 /// the node.
1461 ///
1462 /// @param[out] height_node_id
1463 /// Newly created node id for the height volume.
1464 /// Use ::HAPI_GetNodeInfo() to get more information about the node.
1465 ///
1466 /// @param[out] mask_node_id
1467 /// Newly created node id for the mask volume.
1468 /// Use ::HAPI_GetNodeInfo() to get more information about the
1469 /// node.
1470 ///
1471 /// @param[out] merge_node_id
1472 /// Newly created merge node id.
1473 /// The merge node can be used to connect additional input masks.
1474 /// Use ::HAPI_GetNodeInfo() to get more information about the node.
1475 ///
1477  HAPI_NodeId parent_node_id,
1478  const char * name,
1479  int xsize,
1480  int ysize,
1481  float voxelsize,
1482  HAPI_NodeId * heightfield_node_id,
1483  HAPI_NodeId * height_node_id,
1484  HAPI_NodeId * mask_node_id,
1485  HAPI_NodeId * merge_node_id );
1486 
1487 /// @brief Creates a volume input node that can be used with Heightfields
1488 ///
1489 /// Note that when saving the Houdini scene using
1490 /// ::HAPI_SaveHIPFile() the nodes created with this
1491 /// method will be green and will start with the name "input".
1492 ///
1493 /// @param[in] session
1494 /// The session of Houdini you are interacting with.
1495 /// See @ref HAPI_Sessions for more on sessions.
1496 /// Pass NULL to just use the default in-process session.
1497 ///
1498 /// @param[in] parent_node_id
1499 /// The parent node network's node id or -1 if the parent
1500 /// network is the manager (top-level) node. In that case,
1501 /// the manager must be identified by the table name in the
1502 /// operator_name.
1503 ///
1504 /// @param[out] new_node_id
1505 /// Newly created node id for the volume.
1506 /// Use ::HAPI_GetNodeInfo() to get more information about the
1507 /// node.
1508 ///
1509 /// @param[in] name
1510 /// The name of the volume to create.
1511 /// You can also pass NULL in which case the name will
1512 /// be "input#" where # is some number.
1513 ///
1514 /// @param[in] xsize
1515 /// size of the heightfield in X
1516 ///
1517 /// @param[in] ysize
1518 /// size of the heightfield in y
1519 ///
1520 /// @param[in] voxelsize
1521 /// Size of the voxel
1522 ///
1524  HAPI_NodeId parent_node_id,
1525  HAPI_NodeId * new_node_id,
1526  const char * name,
1527  int xsize,
1528  int ysize,
1529  float voxelsize );
1530 
1531 /// @brief Initiate a cook on this node. Note that this may trigger
1532 /// cooks on other nodes if they are connected.
1533 ///
1534 /// @note In threaded mode, this is an _async call_!
1535 ///
1536 /// This API will invoke the cooking thread if threading is
1537 /// enabled. This means it will return immediately. Use
1538 /// the status and cooking count APIs under DIAGNOSTICS to get
1539 /// a sense of the progress. All other API calls will block
1540 /// until the cook operation has finished.
1541 ///
1542 /// Also note that the cook result won't be of type
1543 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
1544 /// Whenever the threading cook is done it will fill the
1545 /// @a cook result which is queried using
1546 /// ::HAPI_STATUS_COOK_RESULT.
1547 ///
1548 /// @param[in] session
1549 /// The session of Houdini you are interacting with.
1550 /// See @ref HAPI_Sessions for more on sessions.
1551 /// Pass NULL to just use the default in-process session.
1552 ///
1553 /// @param[in] node_id
1554 /// The node id.
1555 ///
1556 /// @param[in] cook_options
1557 /// The cook options. Pass in NULL to use the global
1558 /// cook options that you specified when calling
1559 /// ::HAPI_Initialize().
1560 ///
1561 HAPI_DECL HAPI_CookNode( const HAPI_Session * session,
1562  HAPI_NodeId node_id,
1563  const HAPI_CookOptions * cook_options );
1564 
1565 /// @brief Delete a node from a node network. Only nodes with their
1566 /// ::HAPI_NodeInfo::createdPostAssetLoad set to true can be
1567 /// deleted this way.
1568 ///
1569 /// @param[in] session
1570 /// The session of Houdini you are interacting with.
1571 /// See @ref HAPI_Sessions for more on sessions.
1572 /// Pass NULL to just use the default in-process session.
1573 ///
1574 /// @param[in] node_id
1575 /// The node to delete.
1576 ///
1577 HAPI_DECL HAPI_DeleteNode( const HAPI_Session * session,
1578  HAPI_NodeId node_id );
1579 
1580 /// @brief Rename a node that you created. Only nodes with their
1581 /// ::HAPI_NodeInfo::createdPostAssetLoad set to true can be
1582 /// deleted this way.
1583 ///
1584 /// @param[in] session
1585 /// The session of Houdini you are interacting with.
1586 /// See @ref HAPI_Sessions for more on sessions.
1587 /// Pass NULL to just use the default in-process session.
1588 ///
1589 /// @param[in] node_id
1590 /// The node to delete.
1591 ///
1592 /// @param[in] new_name
1593 /// The new node name.
1594 ///
1595 HAPI_DECL HAPI_RenameNode( const HAPI_Session * session,
1596  HAPI_NodeId node_id,
1597  const char * new_name );
1598 
1599 /// @brief Connect two nodes together.
1600 ///
1601 /// @param[in] session
1602 /// The session of Houdini you are interacting with.
1603 /// See @ref HAPI_Sessions for more on sessions.
1604 /// Pass NULL to just use the default in-process session.
1605 ///
1606 /// @param[in] node_id
1607 /// The node whom's input to connect to.
1608 ///
1609 /// @param[in] input_index
1610 /// The input index. Should be between 0 and the
1611 /// to_node's ::HAPI_NodeInfo::inputCount.
1612 ///
1613 /// @param[in] node_id_to_connect
1614 /// The node to connect to node_id's input.
1615 ///
1616 /// @param[in] output_index
1617 /// The output index. Should be between 0 and the
1618 /// to_node's ::HAPI_NodeInfo::outputCount.
1619 ///
1621  HAPI_NodeId node_id,
1622  int input_index,
1623  HAPI_NodeId node_id_to_connect,
1624  int output_index );
1625 
1626 /// @brief Disconnect a node input.
1627 ///
1628 /// @param[in] session
1629 /// The session of Houdini you are interacting with.
1630 /// See @ref HAPI_Sessions for more on sessions.
1631 /// Pass NULL to just use the default in-process session.
1632 ///
1633 /// @param[in] node_id
1634 /// The node whom's input to disconnect.
1635 ///
1636 /// @param[in] input_index
1637 /// The input index. Should be between 0 and the
1638 /// to_node's ::HAPI_NodeInfo::inputCount.
1639 ///
1641  HAPI_NodeId node_id,
1642  int input_index );
1643 
1644 /// @brief Query which node is connected to another node's input.
1645 ///
1646 /// @param[in] session
1647 /// The session of Houdini you are interacting with.
1648 /// See @ref HAPI_Sessions for more on sessions.
1649 /// Pass NULL to just use the default in-process session.
1650 ///
1651 /// @param[in] node_to_query
1652 /// The node to query.
1653 ///
1654 /// @param[in] input_index
1655 /// The input index. Should be between 0 and the
1656 /// to_node's ::HAPI_NodeInfo::inputCount.
1657 ///
1658 /// @param[out] connected_node_id
1659 /// The node id of the connected node to this input. If
1660 /// nothing is connected then -1 will be returned.
1661 ///
1662 HAPI_DECL HAPI_QueryNodeInput( const HAPI_Session * session,
1663  HAPI_NodeId node_to_query,
1664  int input_index,
1665  HAPI_NodeId * connected_node_id );
1666 
1667 /// @brief Get the name of an node's input. This function will return
1668 /// a string handle for the name which will be valid (persist)
1669 /// until the next call to this function.
1670 ///
1671 /// @param[in] session
1672 /// The session of Houdini you are interacting with.
1673 /// See @ref HAPI_Sessions for more on sessions.
1674 /// Pass NULL to just use the default in-process session.
1675 ///
1676 /// @param[in] node_id
1677 /// The node id.
1678 ///
1679 /// @param[in] input_idx
1680 /// Input index of the asset.
1681 ///
1682 /// @param[out] name
1683 /// Input name string handle return value - valid until
1684 /// the next call to this function.
1685 ///
1687  HAPI_NodeId node_id,
1688  int input_idx,
1689  HAPI_StringHandle * name );
1690 
1691 /// @brief Disconnect all of the node's output connections at the output index.
1692 ///
1693 /// @param[in] session
1694 /// The session of Houdini you are interacting with.
1695 /// See @ref HAPI_Sessions for more on sessions.
1696 /// Pass NULL to just use the default in-process session.
1697 ///
1698 /// @param[in] node_id
1699 /// The node whom's outputs to disconnect.
1700 ///
1701 /// @param[in] output_index
1702 /// The output index. Should be between 0 and the
1703 /// to_node's ::HAPI_NodeInfo::outputCount.
1704 ///
1706  HAPI_NodeId node_id,
1707  int output_index );
1708 
1709 /// @brief Get the number of nodes currently connected to the given node at
1710 /// the output index.
1711 ///
1712 /// Use the @c count returned by this function to get the
1713 /// ::HAPI_NodeIds of connected nodes using
1714 /// ::HAPI_QueryNodeOutputConnectedNodes().
1715 ///
1716 /// @param[in] session
1717 /// The session of Houdini you are interacting with.
1718 /// See @ref HAPI_Sessions for more on sessions.
1719 /// Pass NULL to just use the default in-process session.
1720 ///
1721 /// @param[in] node_id
1722 /// The node id.
1723 ///
1724 /// @param[in] output_idx
1725 /// The output index. Should be between 0 and the
1726 /// to_node's ::HAPI_NodeInfo::outputCount.
1727 ///
1728 /// @param[in] into_subnets
1729 /// Whether to search by diving into subnets.
1730 ///
1731 /// @param[in] through_dots
1732 /// Whether to search through dots.
1733 ///
1734 /// @param[out] connected_count
1735 /// The number of nodes currently connected to this node at
1736 /// given output index. Use this count with a call to
1737 /// ::HAPI_QueryNodeOutputConnectedNodes() to get list of
1738 /// connected nodes.
1739 ///
1741  HAPI_NodeId node_id,
1742  int output_idx,
1743  HAPI_Bool into_subnets,
1744  HAPI_Bool through_dots,
1745  int * connected_count );
1746 
1747 /// @brief Get the ids of nodes currently connected to the given node
1748 /// at the output index.
1749 ///
1750 /// Use the @c connected_count returned by
1751 /// ::HAPI_QueryNodeOutputConnectedCount().
1752 ///
1753 /// @param[in] session
1754 /// The session of Houdini you are interacting with.
1755 /// See @ref HAPI_Sessions for more on sessions.
1756 /// Pass NULL to just use the default in-process session.
1757 ///
1758 /// @param[in] node_id
1759 /// The node id.
1760 ///
1761 /// @param[in] output_idx
1762 /// The output index. Should be between 0 and the
1763 /// to_node's ::HAPI_NodeInfo::outputCount.
1764 ///
1765 /// @param[in] into_subnets
1766 /// Whether to search by diving into subnets.
1767 ///
1768 /// @param[in] through_dots
1769 /// Whether to search through dots.
1770 ///
1771 /// @param[out] connected_node_ids
1772 /// Array of ::HAPI_NodeId at least the size of @c length.
1773 ///
1774 /// @param[in] start
1775 /// At least @c 0 and at most @c connected_count returned by
1776 /// ::HAPI_QueryNodeOutputConnectedCount().
1777 ///
1778 /// @param[in] length
1779 /// Given @c connected_count returned by
1780 /// ::HAPI_QueryNodeOutputConnectedCount(), @c length should
1781 /// be at least @c 0 and at most <tt>connected_count - start</tt>.
1782 ///
1784  HAPI_NodeId node_id,
1785  int output_idx,
1786  HAPI_Bool into_subnets,
1787  HAPI_Bool through_dots,
1788  HAPI_NodeId * connected_node_ids,
1789  int start, int length );
1790 
1791 /// @brief Get the name of an node's output. This function will return
1792 /// a string handle for the name which will be valid (persist)
1793 /// until the next call to this function.
1794 ///
1795 /// @param[in] session
1796 /// The session of Houdini you are interacting with.
1797 /// See @ref HAPI_Sessions for more on sessions.
1798 /// Pass NULL to just use the default in-process session.
1799 ///
1800 /// @param[in] node_id
1801 /// The node id.
1802 ///
1803 /// @param[in] output_idx
1804 /// The output index. Should be between 0 and the
1805 /// to_node's ::HAPI_NodeInfo::outputCount.
1806 ///
1807 /// @param[out] name
1808 /// Output name string handle return value - valid until
1809 /// the next call to this function.
1810 ///
1812  HAPI_NodeId node_id,
1813  int output_idx,
1814  HAPI_StringHandle * name );
1815 
1816 // PARAMETERS ---------------------------------------------------------------
1817 
1818 /// @brief Fill an array of ::HAPI_ParmInfo structs with parameter
1819 /// information from the asset instance node.
1820 ///
1821 /// @param[in] session
1822 /// The session of Houdini you are interacting with.
1823 /// See @ref HAPI_Sessions for more on sessions.
1824 /// Pass NULL to just use the default in-process session.
1825 ///
1826 /// @param[in] node_id
1827 /// The node id.
1828 ///
1829 /// @param[out] parm_infos_array
1830 /// Array of ::HAPI_ParmInfo at least the size of
1831 /// length.
1832 ///
1833 /// @param[in] start
1834 /// First index of range. Must be at least 0 and at
1835 /// most ::HAPI_NodeInfo::parmCount - 1.
1836 ///
1837 /// @param[in] length
1838 /// Must be at least 0 and at most
1839 /// ::HAPI_NodeInfo::parmCount - start.
1840 ///
1841 HAPI_DECL HAPI_GetParameters( const HAPI_Session * session,
1842  HAPI_NodeId node_id,
1843  HAPI_ParmInfo * parm_infos_array,
1844  int start, int length );
1845 
1846 /// @brief Get the parm info of a parameter by parm id.
1847 ///
1848 /// @param[in] session
1849 /// The session of Houdini you are interacting with.
1850 /// See @ref HAPI_Sessions for more on sessions.
1851 /// Pass NULL to just use the default in-process session.
1852 ///
1853 /// @param[in] node_id
1854 /// The node id.
1855 ///
1856 /// @param[in] parm_id
1857 /// The parm id.
1858 ///
1859 /// @param[out] parm_info
1860 /// The returned parm info.
1861 ///
1862 HAPI_DECL HAPI_GetParmInfo( const HAPI_Session * session,
1863  HAPI_NodeId node_id,
1864  HAPI_ParmId parm_id,
1865  HAPI_ParmInfo * parm_info );
1866 
1867 /// @brief All parameter APIs require a ::HAPI_ParmId but if you know the
1868 /// parameter you wish to operate on by name than you can use
1869 /// this function to get its ::HAPI_ParmId. If the parameter with
1870 /// the given name is not found the parameter id returned
1871 /// will be -1.
1872 ///
1873 /// @param[in] session
1874 /// The session of Houdini you are interacting with.
1875 /// See @ref HAPI_Sessions for more on sessions.
1876 /// Pass NULL to just use the default in-process session.
1877 ///
1878 /// @param[in] node_id
1879 /// The node id.
1880 ///
1881 /// @param[in] parm_name
1882 /// The parm name.
1883 ///
1884 /// @param[out] parm_id
1885 /// The return value. The parameter's ::HAPI_ParmId. If
1886 /// the parameter with the given name is not found the
1887 /// parameter id returned will be -1.
1888 ///
1890  HAPI_NodeId node_id,
1891  const char * parm_name,
1892  HAPI_ParmId * parm_id );
1893 
1894 /// @brief Get the parm info of a parameter by name.
1895 ///
1896 /// @param[in] session
1897 /// The session of Houdini you are interacting with.
1898 /// See @ref HAPI_Sessions for more on sessions.
1899 /// Pass NULL to just use the default in-process session.
1900 ///
1901 /// @param[in] node_id
1902 /// The node id.
1903 ///
1904 /// @param[in] parm_name
1905 /// The parm name.
1906 ///
1907 /// @param[out] parm_info
1908 /// The returned parm info.
1909 ///
1911  HAPI_NodeId node_id,
1912  const char * parm_name,
1913  HAPI_ParmInfo * parm_info );
1914 
1915 /// @brief Get the tag name on a parameter given an index.
1916 ///
1917 /// @param[in] session
1918 /// The session of Houdini you are interacting with.
1919 /// See @ref HAPI_Sessions for more on sessions.
1920 /// Pass NULL to just use the default in-process session.
1921 ///
1922 /// @param[in] node_id
1923 /// The node id.
1924 ///
1925 /// @param[in] parm_id
1926 /// The parm id.
1927 ///
1928 /// @param[in] tag_index
1929 /// The tag index, which should be between 0 and
1930 /// ::HAPI_ParmInfo::tagCount - 1.
1931 ///
1932 /// @param[out] tag_name
1933 /// The returned tag name. This string handle will be valid
1934 /// until another call to ::HAPI_GetParmTagName().
1935 ///
1936 HAPI_DECL HAPI_GetParmTagName( const HAPI_Session * session,
1937  HAPI_NodeId node_id,
1938  HAPI_ParmId parm_id,
1939  int tag_index,
1940  HAPI_StringHandle * tag_name );
1941 
1942 /// @brief Get the tag value on a parameter given the tag name.
1943 ///
1944 /// @param[in] session
1945 /// The session of Houdini you are interacting with.
1946 /// See @ref HAPI_Sessions for more on sessions.
1947 /// Pass NULL to just use the default in-process session.
1948 ///
1949 /// @param[in] node_id
1950 /// The node id.
1951 ///
1952 /// @param[in] parm_id
1953 /// The parm id.
1954 ///
1955 /// @param[in] tag_name
1956 /// The tag name, either known or returned by
1957 /// ::HAPI_GetParmTagName().
1958 ///
1959 /// @param[out] tag_value
1960 /// The returned tag value. This string handle will be valid
1961 /// until another call to ::HAPI_GetParmTagValue().
1962 ///
1964  HAPI_NodeId node_id,
1965  HAPI_ParmId parm_id,
1966  const char * tag_name,
1967  HAPI_StringHandle * tag_value );
1968 
1969 /// @brief See if a parameter has a specific tag.
1970 ///
1971 /// @param[in] session
1972 /// The session of Houdini you are interacting with.
1973 /// See @ref HAPI_Sessions for more on sessions.
1974 /// Pass NULL to just use the default in-process session.
1975 ///
1976 /// @param[in] node_id
1977 /// The node id.
1978 ///
1979 /// @param[in] parm_id
1980 /// The parm id.
1981 ///
1982 /// @param[in] tag_name
1983 /// The tag name to look for.
1984 ///
1985 /// @param[out] has_tag
1986 /// True if the tag exists on the parameter, false otherwise.
1987 ///
1988 HAPI_DECL HAPI_ParmHasTag( const HAPI_Session * session,
1989  HAPI_NodeId node_id,
1990  HAPI_ParmId parm_id,
1991  const char * tag_name,
1992  HAPI_Bool * has_tag );
1993 
1994 /// @brief See if a parameter has an expression
1995 ///
1996 /// @param[in] session
1997 /// The session of Houdini you are interacting with.
1998 /// See @ref HAPI_Sessions for more on sessions.
1999 /// Pass NULL to just use the default in-process session.
2000 ///
2001 /// @param[in] node_id
2002 /// The node id.
2003 ///
2004 /// @param[in] parm_name
2005 /// The parm name.
2006 ///
2007 /// @param[in] index
2008 /// The parm index.
2009 ///
2010 /// @param[out] has_expression
2011 /// True if an expression exists on the parameter, false otherwise.
2012 ///
2014  HAPI_NodeId node_id,
2015  const char * parm_name,
2016  int index,
2017  HAPI_Bool * has_expression );
2018 
2019 /// @brief Get the first parm with a specific, ideally unique, tag on it.
2020 /// This is particularly useful for getting the ogl parameters on a
2021 /// material node.
2022 ///
2023 /// @param[in] session
2024 /// The session of Houdini you are interacting with.
2025 /// See @ref HAPI_Sessions for more on sessions.
2026 /// Pass NULL to just use the default in-process session.
2027 ///
2028 /// @param[in] node_id
2029 /// The node id.
2030 ///
2031 /// @param[in] tag_name
2032 /// The tag name to look for.
2033 ///
2034 /// @param[out] parm_id
2035 /// The returned parm id. This will be -1 if no parm was found
2036 /// with this tag.
2037 ///
2038 HAPI_DECL HAPI_GetParmWithTag( const HAPI_Session * session,
2039  HAPI_NodeId node_id,
2040  const char * tag_name,
2041  HAPI_ParmId * parm_id );
2042 
2043 /// @brief Get single integer or float parm expression by name
2044 /// or Null string if no expression is present
2045 ///
2046 /// @param[in] session
2047 /// The session of Houdini you are interacting with.
2048 /// See @ref HAPI_Sessions for more on sessions.
2049 /// Pass NULL to just use the default in-process session.
2050 ///
2051 /// @param[in] node_id
2052 /// The node id.
2053 ///
2054 /// @param[in] parm_name
2055 /// The parm name.
2056 ///
2057 /// @param[in] index
2058 /// Index within the parameter's values tuple.
2059 ///
2060 /// @param[out] value
2061 /// The returned string value.
2062 ///
2064  HAPI_NodeId node_id,
2065  const char * parm_name,
2066  int index,
2067  HAPI_StringHandle * value );
2068 
2069 /// @brief Revert single parm by name to default
2070 ///
2071 /// @param[in] session
2072 /// The session of Houdini you are interacting with.
2073 /// See @ref HAPI_Sessions for more on sessions.
2074 /// Pass NULL to just use the default in-process session.
2075 ///
2076 /// @param[in] node_id
2077 /// The node id.
2078 ///
2079 /// @param[in] parm_name
2080 /// The parm name.
2081 ///
2082 /// @param[in] index
2083 /// Index within the parameter's values tuple.
2084 ///
2086  HAPI_NodeId node_id,
2087  const char * parm_name,
2088  int index);
2089 
2090 /// @brief Revert all instances of the parm by name to defaults
2091 ///
2092 /// @param[in] session
2093 /// The session of Houdini you are interacting with.
2094 /// See @ref HAPI_Sessions for more on sessions.
2095 /// Pass NULL to just use the default in-process session.
2096 ///
2097 /// @param[in] node_id
2098 /// The node id.
2099 ///
2100 /// @param[in] parm_name
2101 /// The parm name.
2102 ///
2104  HAPI_NodeId node_id,
2105  const char * parm_name);
2106 
2107 /// @brief Set (push) an expression string. We can only set a single value at
2108 /// a time because we want to avoid fixed size string buffers.
2109 ///
2110 /// @note Regardless of the value, when calling this function
2111 /// on a parameter, if that parameter has a callback function
2112 /// attached to it, that callback function will be called. For
2113 /// example, if the parameter is a button the button will be
2114 /// pressed.
2115 ///
2116 /// @note In threaded mode, this is an _async call_!
2117 ///
2118 /// This API will invoke the cooking thread if threading is
2119 /// enabled. This means it will return immediately. Use
2120 /// the status and cooking count APIs under DIAGNOSTICS to get
2121 /// a sense of the progress. All other API calls will block
2122 /// until the cook operation has finished.
2123 ///
2124 /// Also note that the cook result won't be of type
2125 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2126 /// Whenever the threading cook is done it will fill the
2127 /// @a cook result which is queried using
2128 /// ::HAPI_STATUS_COOK_RESULT.
2129 ///
2130 /// @param[in] session
2131 /// The session of Houdini you are interacting with.
2132 /// See @ref HAPI_Sessions for more on sessions.
2133 /// Pass NULL to just use the default in-process session.
2134 ///
2135 /// @param[in] node_id
2136 /// The node id.
2137 ///
2138 /// @param[in] value
2139 /// The expression string.
2140 ///
2141 /// @param[in] parm_id
2142 /// Parameter id of the parameter being updated.
2143 ///
2144 /// @param[in] index
2145 /// Index within the parameter's values tuple.
2146 ///
2148  HAPI_NodeId node_id,
2149  const char * value,
2150  HAPI_ParmId parm_id, int index );
2151 
2152 /// @brief Remove the expression string, leaving the value of the
2153 /// parm at the current value of the expression
2154 ///
2155 /// @note Regardless of the value, when calling this function
2156 /// on a parameter, if that parameter has a callback function
2157 /// attached to it, that callback function will be called. For
2158 /// example, if the parameter is a button the button will be
2159 /// pressed.
2160 ///
2161 /// @note In threaded mode, this is an _async call_!
2162 ///
2163 /// This API will invoke the cooking thread if threading is
2164 /// enabled. This means it will return immediately. Use
2165 /// the status and cooking count APIs under DIAGNOSTICS to get
2166 /// a sense of the progress. All other API calls will block
2167 /// until the cook operation has finished.
2168 ///
2169 /// Also note that the cook result won't be of type
2170 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2171 /// Whenever the threading cook is done it will fill the
2172 /// @a cook result which is queried using
2173 /// ::HAPI_STATUS_COOK_RESULT.
2174 ///
2175 /// @param[in] session
2176 /// The session of Houdini you are interacting with.
2177 /// See @ref HAPI_Sessions for more on sessions.
2178 /// Pass NULL to just use the default in-process session.
2179 ///
2180 /// @param[in] node_id
2181 /// The node id.
2182 ///
2183 /// @param[in] parm_id
2184 /// Parameter id of the parameter being updated.
2185 ///
2186 /// @param[in] index
2187 /// Index within the parameter's values tuple.
2188 ///
2189 
2191  HAPI_NodeId node_id,
2192  HAPI_ParmId parm_id, int index );
2193 
2194 /// @brief Get single parm int value by name.
2195 ///
2196 /// @param[in] session
2197 /// The session of Houdini you are interacting with.
2198 /// See @ref HAPI_Sessions for more on sessions.
2199 /// Pass NULL to just use the default in-process session.
2200 ///
2201 /// @param[in] node_id
2202 /// The node id.
2203 ///
2204 /// @param[in] parm_name
2205 /// The parm name.
2206 ///
2207 /// @param[in] index
2208 /// Index within the parameter's values tuple.
2209 ///
2210 /// @param[out] value
2211 /// The returned int value.
2212 ///
2213 
2214 
2216  HAPI_NodeId node_id,
2217  const char * parm_name,
2218  int index,
2219  int * value );
2220 
2221 /// @brief Fill an array of parameter int values. This is more efficient
2222 /// than calling ::HAPI_GetParmIntValue() individually for each
2223 /// parameter value.
2224 ///
2225 /// @param[in] session
2226 /// The session of Houdini you are interacting with.
2227 /// See @ref HAPI_Sessions for more on sessions.
2228 /// Pass NULL to just use the default in-process session.
2229 ///
2230 /// @param[in] node_id
2231 /// The node id.
2232 ///
2233 /// @param[out] values_array
2234 /// Array of ints at least the size of length.
2235 ///
2236 /// @param[in] start
2237 /// First index of range. Must be at least 0 and at
2238 /// most ::HAPI_NodeInfo::parmIntValueCount - 1.
2239 ///
2240 /// @param[in] length
2241 /// Must be at least 0 and at most
2242 /// ::HAPI_NodeInfo::parmIntValueCount - start.
2243 ///
2245  HAPI_NodeId node_id,
2246  int * values_array,
2247  int start, int length );
2248 
2249 /// @brief Get single parm float value by name.
2250 ///
2251 /// @param[in] session
2252 /// The session of Houdini you are interacting with.
2253 /// See @ref HAPI_Sessions for more on sessions.
2254 /// Pass NULL to just use the default in-process session.
2255 ///
2256 /// @param[in] node_id
2257 /// The node id.
2258 ///
2259 /// @param[in] parm_name
2260 /// The parm name.
2261 ///
2262 /// @param[in] index
2263 /// Index within the parameter's values tuple.
2264 ///
2265 /// @param[out] value
2266 /// The returned float value.
2267 ///
2269  HAPI_NodeId node_id,
2270  const char * parm_name,
2271  int index,
2272  float * value );
2273 
2274 /// @brief Fill an array of parameter float values. This is more efficient
2275 /// than calling ::HAPI_GetParmFloatValue() individually for each
2276 /// parameter value.
2277 ///
2278 /// @param[in] session
2279 /// The session of Houdini you are interacting with.
2280 /// See @ref HAPI_Sessions for more on sessions.
2281 /// Pass NULL to just use the default in-process session.
2282 ///
2283 /// @param[in] node_id
2284 /// The node id.
2285 ///
2286 /// @param[out] values_array
2287 /// Array of floats at least the size of length.
2288 ///
2289 /// @param[in] start
2290 /// First index of range. Must be at least 0 and at
2291 /// most ::HAPI_NodeInfo::parmFloatValueCount - 1.
2292 ///
2293 /// @param[in] length
2294 /// Must be at least 1 and at most
2295 /// ::HAPI_NodeInfo::parmFloatValueCount - start.
2296 ///
2298  HAPI_NodeId node_id,
2299  float * values_array,
2300  int start, int length );
2301 
2302 /// @brief Get single parm string value by name.
2303 ///
2304 /// @param[in] session
2305 /// The session of Houdini you are interacting with.
2306 /// See @ref HAPI_Sessions for more on sessions.
2307 /// Pass NULL to just use the default in-process session.
2308 ///
2309 /// @param[in] node_id
2310 /// The node id.
2311 ///
2312 /// @param[in] parm_name
2313 /// The name of the parameter.
2314 ///
2315 /// @param[in] index
2316 /// Index within the parameter's values tuple.
2317 ///
2318 /// @param[in] evaluate
2319 /// Whether or not to evaluate the string expression.
2320 /// For example, the string "$F" would evaluate to the
2321 /// current frame number. So, passing in evaluate = false
2322 /// would give you back the string "$F" and passing
2323 /// in evaluate = true would give you back "1" (assuming
2324 /// the current frame is 1).
2325 ///
2326 /// @param[out] value
2327 /// The returned string value.
2328 ///
2330  HAPI_NodeId node_id,
2331  const char * parm_name,
2332  int index,
2333  HAPI_Bool evaluate,
2334  HAPI_StringHandle * value );
2335 
2336 /// @brief Fill an array of parameter string handles. These handles must
2337 /// be used in conjunction with ::HAPI_GetString() to get the
2338 /// actual string values. This is more efficient than calling
2339 /// ::HAPI_GetParmStringValue() individually for each
2340 /// parameter value.
2341 ///
2342 /// @param[in] session
2343 /// The session of Houdini you are interacting with.
2344 /// See @ref HAPI_Sessions for more on sessions.
2345 /// Pass NULL to just use the default in-process session.
2346 ///
2347 /// @param[in] node_id
2348 /// The node id.
2349 ///
2350 /// @param[in] evaluate
2351 /// Whether or not to evaluate the string expression.
2352 /// For example, the string "$F" would evaluate to the
2353 /// current frame number. So, passing in evaluate = false
2354 /// would give you back the string "$F" and passing
2355 /// in evaluate = true would give you back "1" (assuming
2356 /// the current frame is 1).
2357 ///
2358 /// @param[out] values_array
2359 /// Array of integers at least the size of length.
2360 ///
2361 /// @param[in] start
2362 /// First index of range. Must be at least 0 and at
2363 /// most ::HAPI_NodeInfo::parmStringValueCount - 1.
2364 ///
2365 /// @param[in] length
2366 /// Must be at least 1 and at most
2367 /// ::HAPI_NodeInfo::parmStringValueCount - start.
2368 ///
2370  HAPI_NodeId node_id,
2371  HAPI_Bool evaluate,
2372  HAPI_StringHandle * values_array,
2373  int start, int length );
2374 
2375 /// @brief Get a single node id parm value of an Op Path parameter. This is
2376 /// how you see which node is connected as an input for the current
2377 /// node (via parameter).
2378 ///
2379 /// @param[in] session
2380 /// The session of Houdini you are interacting with.
2381 /// See @ref HAPI_Sessions for more on sessions.
2382 /// Pass NULL to just use the default in-process session.
2383 ///
2384 /// @param[in] node_id
2385 /// The node id.
2386 ///
2387 /// @param[in] parm_name
2388 /// The name of the parameter.
2389 ///
2390 /// @param[out] value
2391 /// The node id of the node being pointed to by the parm.
2392 /// If there is no node found, -1 will be returned.
2393 ///
2395  HAPI_NodeId node_id,
2396  const char * parm_name,
2397  HAPI_NodeId * value );
2398 
2399 /// @brief Extract a file specified by path on a parameter. This will copy
2400 /// the file to the destination directory from wherever it might be,
2401 /// inlcuding inside the asset definition or online.
2402 ///
2403 /// @param[in] session
2404 /// The session of Houdini you are interacting with.
2405 /// See @ref HAPI_Sessions for more on sessions.
2406 /// Pass NULL to just use the default in-process session.
2407 ///
2408 /// @param[in] node_id
2409 /// The node id.
2410 ///
2411 /// @param[in] parm_name
2412 /// The name of the parameter.
2413 ///
2414 /// @param[in] destination_directory
2415 /// The destination directory to copy the file to.
2416 ///
2417 /// @param[in] destination_file_name
2418 /// The destination file name.
2419 ///
2420 HAPI_DECL HAPI_GetParmFile( const HAPI_Session * session,
2421  HAPI_NodeId node_id,
2422  const char * parm_name,
2423  const char * destination_directory,
2424  const char * destination_file_name );
2425 
2426 /// @brief Fill an array of ::HAPI_ParmChoiceInfo structs with parameter
2427 /// choice list information from the asset instance node.
2428 ///
2429 /// @param[in] session
2430 /// The session of Houdini you are interacting with.
2431 /// See @ref HAPI_Sessions for more on sessions.
2432 /// Pass NULL to just use the default in-process session.
2433 ///
2434 /// @param[in] node_id
2435 /// The node id.
2436 ///
2437 /// @param[out] parm_choices_array
2438 /// Array of ::HAPI_ParmChoiceInfo exactly the size of
2439 /// length.
2440 ///
2441 /// @param[in] start
2442 /// First index of range. Must be at least 0 and at
2443 /// most ::HAPI_NodeInfo::parmChoiceCount - 1.
2444 ///
2445 /// @param[in] length
2446 /// Must be at least 1 and at most
2447 /// ::HAPI_NodeInfo::parmChoiceCount - start.
2448 ///
2450  HAPI_NodeId node_id,
2451  HAPI_ParmChoiceInfo *parm_choices_array,
2452  int start, int length );
2453 
2454 /// @brief Set single parm int value by name.
2455 ///
2456 /// @note Regardless of the value, when calling this function
2457 /// on a parameter, if that parameter has a callback function
2458 /// attached to it, that callback function will be called. For
2459 /// example, if the parameter is a button the button will be
2460 /// pressed.
2461 ///
2462 /// @note In threaded mode, this is an _async call_!
2463 ///
2464 /// This API will invoke the cooking thread if threading is
2465 /// enabled. This means it will return immediately. Use
2466 /// the status and cooking count APIs under DIAGNOSTICS to get
2467 /// a sense of the progress. All other API calls will block
2468 /// until the cook operation has finished.
2469 ///
2470 /// Also note that the cook result won't be of type
2471 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2472 /// Whenever the threading cook is done it will fill the
2473 /// @a cook result which is queried using
2474 /// ::HAPI_STATUS_COOK_RESULT.
2475 ///
2476 /// @param[in] session
2477 /// The session of Houdini you are interacting with.
2478 /// See @ref HAPI_Sessions for more on sessions.
2479 /// Pass NULL to just use the default in-process session.
2480 ///
2481 /// @param[in] node_id
2482 /// The node id.
2483 ///
2484 /// @param[in] parm_name
2485 /// The parm name.
2486 ///
2487 /// @param[in] index
2488 /// Index within the parameter's values tuple.
2489 ///
2490 /// @param[in] value
2491 /// The int value.
2492 ///
2494  HAPI_NodeId node_id,
2495  const char * parm_name,
2496  int index,
2497  int value );
2498 
2499 /// @brief Set (push) an array of parameter int values.
2500 ///
2501 /// @note Regardless of the values, when calling this function
2502 /// on a set of parameters, if any parameter has a callback
2503 /// function attached to it, that callback function will be called.
2504 /// For example, if the parameter is a button the button will be
2505 /// pressed.
2506 ///
2507 /// @note In threaded mode, this is an _async call_!
2508 ///
2509 /// This API will invoke the cooking thread if threading is
2510 /// enabled. This means it will return immediately. Use
2511 /// the status and cooking count APIs under DIAGNOSTICS to get
2512 /// a sense of the progress. All other API calls will block
2513 /// until the cook operation has finished.
2514 ///
2515 /// Also note that the cook result won't be of type
2516 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2517 /// Whenever the threading cook is done it will fill the
2518 /// @a cook result which is queried using
2519 /// ::HAPI_STATUS_COOK_RESULT.
2520 ///
2521 /// @param[in] session
2522 /// The session of Houdini you are interacting with.
2523 /// See @ref HAPI_Sessions for more on sessions.
2524 /// Pass NULL to just use the default in-process session.
2525 ///
2526 /// @param[in] node_id
2527 /// The node id.
2528 ///
2529 /// @param[in] values_array
2530 /// Array of integers at least the size of length.
2531 ///
2532 /// @param[in] start
2533 /// First index of range. Must be at least 0 and at
2534 /// most ::HAPI_NodeInfo::parmIntValueCount - 1.
2535 ///
2536 /// @param[in] length
2537 /// Must be at least 1 and at most
2538 /// ::HAPI_NodeInfo::parmIntValueCount - start.
2539 ///
2541  HAPI_NodeId node_id,
2542  const int * values_array,
2543  int start, int length );
2544 
2545 /// @brief Set single parm float value by name.
2546 ///
2547 /// @note Regardless of the value, when calling this function
2548 /// on a parameter, if that parameter has a callback function
2549 /// attached to it, that callback function will be called. For
2550 /// example, if the parameter is a button the button will be
2551 /// pressed.
2552 ///
2553 /// @note In threaded mode, this is an _async call_!
2554 ///
2555 /// This API will invoke the cooking thread if threading is
2556 /// enabled. This means it will return immediately. Use
2557 /// the status and cooking count APIs under DIAGNOSTICS to get
2558 /// a sense of the progress. All other API calls will block
2559 /// until the cook operation has finished.
2560 ///
2561 /// Also note that the cook result won't be of type
2562 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2563 /// Whenever the threading cook is done it will fill the
2564 /// @a cook result which is queried using
2565 /// ::HAPI_STATUS_COOK_RESULT.
2566 ///
2567 /// @param[in] session
2568 /// The session of Houdini you are interacting with.
2569 /// See @ref HAPI_Sessions for more on sessions.
2570 /// Pass NULL to just use the default in-process session.
2571 ///
2572 /// @param[in] node_id
2573 /// The node id.
2574 ///
2575 /// @param[in] parm_name
2576 /// The parm name.
2577 ///
2578 /// @param[in] index
2579 /// Index within the parameter's values tuple.
2580 ///
2581 /// @param[in] value
2582 /// The float value.
2583 ///
2585  HAPI_NodeId node_id,
2586  const char * parm_name,
2587  int index,
2588  float value );
2589 
2590 /// @brief Set (push) an array of parameter float values.
2591 ///
2592 /// @note Regardless of the values, when calling this function
2593 /// on a set of parameters, if any parameter has a callback
2594 /// function attached to it, that callback function will be called.
2595 /// For example, if the parameter is a button the button will be
2596 /// pressed.
2597 ///
2598 /// @note In threaded mode, this is an _async call_!
2599 ///
2600 /// This API will invoke the cooking thread if threading is
2601 /// enabled. This means it will return immediately. Use
2602 /// the status and cooking count APIs under DIAGNOSTICS to get
2603 /// a sense of the progress. All other API calls will block
2604 /// until the cook operation has finished.
2605 ///
2606 /// Also note that the cook result won't be of type
2607 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2608 /// Whenever the threading cook is done it will fill the
2609 /// @a cook result which is queried using
2610 /// ::HAPI_STATUS_COOK_RESULT.
2611 ///
2612 /// @param[in] session
2613 /// The session of Houdini you are interacting with.
2614 /// See @ref HAPI_Sessions for more on sessions.
2615 /// Pass NULL to just use the default in-process session.
2616 ///
2617 /// @param[in] node_id
2618 /// The node id.
2619 ///
2620 /// @param[in] values_array
2621 /// Array of floats at least the size of length.
2622 ///
2623 /// @param[in] start
2624 /// First index of range. Must be at least 0 and at
2625 /// most ::HAPI_NodeInfo::parmFloatValueCount - 1.
2626 ///
2627 /// @param[in] length
2628 /// Must be at least 1 and at most
2629 /// ::HAPI_NodeInfo::parmFloatValueCount - start.
2630 ///
2632  HAPI_NodeId node_id,
2633  const float * values_array,
2634  int start, int length );
2635 
2636 /// @brief Set (push) a string value. We can only set a single value at
2637 /// a time because we want to avoid fixed size string buffers.
2638 ///
2639 /// @note Regardless of the value, when calling this function
2640 /// on a parameter, if that parameter has a callback function
2641 /// attached to it, that callback function will be called. For
2642 /// example, if the parameter is a button the button will be
2643 /// pressed.
2644 ///
2645 /// @note In threaded mode, this is an _async call_!
2646 ///
2647 /// This API will invoke the cooking thread if threading is
2648 /// enabled. This means it will return immediately. Use
2649 /// the status and cooking count APIs under DIAGNOSTICS to get
2650 /// a sense of the progress. All other API calls will block
2651 /// until the cook operation has finished.
2652 ///
2653 /// Also note that the cook result won't be of type
2654 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2655 /// Whenever the threading cook is done it will fill the
2656 /// @a cook result which is queried using
2657 /// ::HAPI_STATUS_COOK_RESULT.
2658 ///
2659 /// @param[in] session
2660 /// The session of Houdini you are interacting with.
2661 /// See @ref HAPI_Sessions for more on sessions.
2662 /// Pass NULL to just use the default in-process session.
2663 ///
2664 /// @param[in] node_id
2665 /// The node id.
2666 ///
2667 /// @param[in] value
2668 /// The string value.
2669 ///
2670 /// @param[in] parm_id
2671 /// Parameter id of the parameter being updated.
2672 ///
2673 /// @param[in] index
2674 /// Index within the parameter's values tuple.
2675 ///
2677  HAPI_NodeId node_id,
2678  const char * value,
2679  HAPI_ParmId parm_id, int index );
2680 
2681 /// @brief Set a node id parm value of an Op Path parameter. For example,
2682 /// This is how you connect the geometry output of an asset to the
2683 /// geometry input of another asset - whether the input is a parameter
2684 /// or a node input (the top of the node). Node inputs get converted
2685 /// top parameters in HAPI.
2686 ///
2687 /// @param[in] session
2688 /// The session of Houdini you are interacting with.
2689 /// See @ref HAPI_Sessions for more on sessions.
2690 /// Pass NULL to just use the default in-process session.
2691 ///
2692 /// @param[in] node_id
2693 /// The node id.
2694 ///
2695 /// @param[in] parm_name
2696 /// The name of the parameter.
2697 ///
2698 /// @param[in] value
2699 /// The node id of the node being connected. Pass -1 to
2700 /// disconnect.
2701 ///
2703  HAPI_NodeId node_id,
2704  const char * parm_name,
2705  HAPI_NodeId value );
2706 
2707 /// @brief Insert an instance of a multiparm before instance_position.
2708 ///
2709 /// @param[in] session
2710 /// The session of Houdini you are interacting with.
2711 /// See @ref HAPI_Sessions for more on sessions.
2712 /// Pass NULL to just use the default in-process session.
2713 ///
2714 /// @param[in] node_id
2715 /// The node id.
2716 ///
2717 /// @param[in] parm_id
2718 /// A parm id given by a ::HAPI_ParmInfo struct that
2719 /// has type ::HAPI_PARMTYPE_MULTIPARMLIST.
2720 ///
2721 /// @param[in] instance_position
2722 /// The new instance will be inserted at this position
2723 /// index. Do note the multiparms can start at position
2724 /// 1 or 0. Use ::HAPI_ParmInfo::instanceStartOffset to
2725 /// distinguish.
2726 ///
2728  HAPI_NodeId node_id,
2729  HAPI_ParmId parm_id,
2730  int instance_position );
2731 
2732 /// @brief Remove the instance of a multiparm given by instance_position.
2733 ///
2734 /// @param[in] session
2735 /// The session of Houdini you are interacting with.
2736 /// See @ref HAPI_Sessions for more on sessions.
2737 /// Pass NULL to just use the default in-process session.
2738 ///
2739 /// @param[in] node_id
2740 /// The node id.
2741 ///
2742 /// @param[in] parm_id
2743 /// A parm id given by a ::HAPI_ParmInfo struct that
2744 /// has type ::HAPI_PARMTYPE_MULTIPARMLIST.
2745 ///
2746 /// @param[in] instance_position
2747 /// The instance at instance_position will removed.
2748 ///
2750  HAPI_NodeId node_id,
2751  HAPI_ParmId parm_id,
2752  int instance_position );
2753 
2754 // HANDLES ------------------------------------------------------------------
2755 
2756 /// @brief Fill an array of ::HAPI_HandleInfo structs with information
2757 /// about every exposed user manipulation handle on the node.
2758 ///
2759 /// @param[in] session
2760 /// The session of Houdini you are interacting with.
2761 /// See @ref HAPI_Sessions for more on sessions.
2762 /// Pass NULL to just use the default in-process session.
2763 ///
2764 /// @param[in] node_id
2765 /// The node id.
2766 ///
2767 /// @param[out] handle_infos_array
2768 /// Array of ::HAPI_HandleInfo at least the size of length.
2769 ///
2770 /// @param[in] start
2771 /// First index of range. Must be at least 0 and at
2772 /// most ::HAPI_AssetInfo::handleCount - 1.
2773 ///
2774 /// @param[in] length
2775 /// Must be at least 1 and at most
2776 /// ::HAPI_AssetInfo::handleCount - start.
2777 ///
2778 HAPI_DECL HAPI_GetHandleInfo( const HAPI_Session * session,
2779  HAPI_NodeId node_id,
2780  HAPI_HandleInfo * handle_infos_array,
2781  int start, int length );
2782 
2783 /// @brief Fill an array of ::HAPI_HandleInfo structs with information
2784 /// about every exposed user manipulation handle on the node.
2785 ///
2786 /// @param[in] session
2787 /// The session of Houdini you are interacting with.
2788 /// See @ref HAPI_Sessions for more on sessions.
2789 /// Pass NULL to just use the default in-process session.
2790 ///
2791 /// @param[in] node_id
2792 /// The node id.
2793 ///
2794 /// @param[in] handle_index
2795 /// The index of the handle, from 0 to handleCount - 1
2796 /// from the call to ::HAPI_GetAssetInfo().
2797 ///
2798 /// @param[out] handle_binding_infos_array
2799 /// Array of ::HAPI_HandleBindingInfo at least the size
2800 /// of length.
2801 ///
2802 /// @param[in] start
2803 /// First index of range. Must be at least 0 and at
2804 /// most ::HAPI_HandleInfo::bindingsCount - 1.
2805 ///
2806 /// @param[in] length
2807 /// Must be at least 0 and at most
2808 /// ::HAPI_HandleInfo::bindingsCount - start.
2809 ///
2811  const HAPI_Session * session,
2812  HAPI_NodeId node_id,
2813  int handle_index,
2814  HAPI_HandleBindingInfo * handle_binding_infos_array,
2815  int start, int length );
2816 
2817 // PRESETS ------------------------------------------------------------------
2818 
2819 /// @brief Generate a preset blob of the current state of all the
2820 /// parameter values, cache it, and return its size in bytes.
2821 ///
2822 /// @param[in] session
2823 /// The session of Houdini you are interacting with.
2824 /// See @ref HAPI_Sessions for more on sessions.
2825 /// Pass NULL to just use the default in-process session.
2826 ///
2827 /// @param[in] node_id
2828 /// The exposed node id.
2829 ///
2830 /// @param[in] preset_type
2831 /// The preset type.
2832 ///
2833 /// @param[in] preset_name
2834 /// Optional. This is only used if the @p preset_type is
2835 /// ::HAPI_PRESETTYPE_IDX. If NULL is given, the preset
2836 /// name will be the same as the name of the node with
2837 /// the given @p node_id.
2838 ///
2839 /// @param[out] buffer_length
2840 /// Size of the buffer.
2841 ///
2843  HAPI_NodeId node_id,
2844  HAPI_PresetType preset_type,
2845  const char * preset_name,
2846  int * buffer_length );
2847 
2848 /// @brief Generates a preset for the given asset.
2849 ///
2850 /// @param[in] session
2851 /// The session of Houdini you are interacting with.
2852 /// See @ref HAPI_Sessions for more on sessions.
2853 /// Pass NULL to just use the default in-process session.
2854 ///
2855 /// @param[in] node_id
2856 /// The exposed node id.
2857 ///
2858 /// @param[out] buffer
2859 /// Buffer to hold the preset data.
2860 ///
2861 /// @param[in] buffer_length
2862 /// Size of the buffer. Should be the same as the length
2863 /// returned by ::HAPI_GetPresetBufLength().
2864 ///
2865 HAPI_DECL HAPI_GetPreset( const HAPI_Session * session,
2866  HAPI_NodeId node_id,
2867  char * buffer,
2868  int buffer_length );
2869 
2870 /// @brief Sets a particular asset to a given preset.
2871 ///
2872 /// @param[in] session
2873 /// The session of Houdini you are interacting with.
2874 /// See @ref HAPI_Sessions for more on sessions.
2875 /// Pass NULL to just use the default in-process session.
2876 ///
2877 /// @param[in] node_id
2878 /// The exposed node id.
2879 ///
2880 /// @param[in] preset_type
2881 /// The preset type.
2882 ///
2883 /// @param[in] preset_name
2884 /// Optional. This is only used if the @p preset_type is
2885 /// ::HAPI_PRESETTYPE_IDX. If NULL is give, the first
2886 /// preset in the IDX file will be chosen.
2887 ///
2888 /// @param[in] buffer
2889 /// Buffer to hold the preset data.
2890 ///
2891 /// @param[in] buffer_length
2892 /// Size of the buffer.
2893 ///
2894 HAPI_DECL HAPI_SetPreset( const HAPI_Session * session,
2895  HAPI_NodeId node_id,
2896  HAPI_PresetType preset_type,
2897  const char * preset_name,
2898  const char * buffer,
2899  int buffer_length );
2900 
2901 // OBJECTS ------------------------------------------------------------------
2902 
2903 /// @brief Get the object info on an OBJ node.
2904 ///
2905 /// @param[in] session
2906 /// The session of Houdini you are interacting with.
2907 /// See @ref HAPI_Sessions for more on sessions.
2908 /// Pass NULL to just use the default in-process session.
2909 ///
2910 /// @param[in] node_id
2911 /// The node id.
2912 ///
2913 /// @param[out] object_info
2914 /// The output ::HAPI_ObjectInfo.
2915 ///
2916 HAPI_DECL HAPI_GetObjectInfo( const HAPI_Session * session,
2917  HAPI_NodeId node_id,
2918  HAPI_ObjectInfo * object_info );
2919 
2920 /// @brief Get the tranform of an OBJ node.
2921 ///
2922 /// @param[in] session
2923 /// The session of Houdini you are interacting with.
2924 /// See @ref HAPI_Sessions for more on sessions.
2925 /// Pass NULL to just use the default in-process session.
2926 ///
2927 /// @param[in] node_id
2928 /// The object node id.
2929 ///
2930 /// @param[in] relative_to_node_id
2931 /// The object node id for the object to which the returned
2932 /// transform will be relative to. Pass -1 or the node_id
2933 /// to just get the object's local transform.
2934 ///
2935 /// @param[in] rst_order
2936 /// The order of application of translation, rotation and
2937 /// scale.
2938 ///
2939 /// @param[out] transform
2940 /// The output ::HAPI_Transform transform.
2941 ///
2943  HAPI_NodeId node_id,
2944  HAPI_NodeId relative_to_node_id,
2945  HAPI_RSTOrder rst_order,
2946  HAPI_Transform * transform );
2947 
2948 /// @brief Compose a list of child object nodes given a parent node id.
2949 ///
2950 /// Use the @c object_count returned by this function to get the
2951 /// ::HAPI_ObjectInfo structs for each child object using
2952 /// ::HAPI_GetComposedObjectList().
2953 ///
2954 /// Note, if not using the @c categories arg, this is equivalent to:
2955 /// @code
2956 /// HAPI_ComposeChildNodeList(
2957 /// session, parent_node_id,
2958 /// HAPI_NODETYPE_OBJ,
2959 /// HAPI_NODEFLAGS_OBJ_GEOMETRY,
2960 /// true, &object_count );
2961 /// @endcode
2962 ///
2963 /// @param[in] session
2964 /// The session of Houdini you are interacting with.
2965 /// See @ref HAPI_Sessions for more on sessions.
2966 /// Pass NULL to just use the default in-process session.
2967 ///
2968 /// @param[in] parent_node_id
2969 /// The parent node id.
2970 ///
2971 /// @param[in] categories
2972 /// (Optional) Lets you filter object nodes by their render
2973 /// categories. This is a standard OBJ parameter, usually
2974 /// under the Render > Shading tab. If an OBJ node does not
2975 /// have this parameter, one can always add it as a spare.
2976 ///
2977 /// The value of this string argument should be NULL if not
2978 /// used or a space-separated list of category names.
2979 /// Multiple category names will be treated as an AND op.
2980 ///
2981 /// @param[out] object_count
2982 /// The number of object nodes currently under the parent.
2983 /// Use this count with a call to
2984 /// ::HAPI_GetComposedObjectList() to get the object infos.
2985 ///
2987  HAPI_NodeId parent_node_id,
2988  const char * categories,
2989  int * object_count );
2990 
2991 /// @brief Fill an array of ::HAPI_ObjectInfo structs.
2992 ///
2993 /// This is best used with ::HAPI_ComposeObjectList() with.
2994 ///
2995 /// @param[in] session
2996 /// The session of Houdini you are interacting with.
2997 /// See @ref HAPI_Sessions for more on sessions.
2998 /// Pass NULL to just use the default in-process session.
2999 ///
3000 /// @param[in] parent_node_id
3001 /// The parent node id.
3002 ///
3003 /// @param[out] object_infos_array
3004 /// Array of ::HAPI_ObjectInfo at least the size of
3005 /// @c length.
3006 ///
3007 /// @param[in] start
3008 /// At least @c 0 and at most @c object_count returned by
3009 /// ::HAPI_ComposeObjectList().
3010 ///
3011 /// @param[in] length
3012 /// Given @c object_count returned by
3013 /// ::HAPI_ComposeObjectList(), @c length should be at least
3014 /// @c 0 and at most <tt>object_count - start</tt>.
3015 ///
3017  HAPI_NodeId parent_node_id,
3018  HAPI_ObjectInfo * object_infos_array,
3019  int start, int length );
3020 
3021 /// @brief Fill an array of ::HAPI_Transform structs.
3022 ///
3023 /// This is best used with ::HAPI_ComposeObjectList() with.
3024 ///
3025 /// Note that these transforms will be relative to the
3026 /// @c parent_node_id originally given to ::HAPI_ComposeObjectList()
3027 /// and expected to be the same with this call. If @c parent_node_id
3028 /// is not an OBJ node, the transforms will be given as they are on
3029 /// the object node itself.
3030 ///
3031 /// @param[in] session
3032 /// The session of Houdini you are interacting with.
3033 /// See @ref HAPI_Sessions for more on sessions.
3034 /// Pass NULL to just use the default in-process session.
3035 ///
3036 /// @param[in] parent_node_id
3037 /// The parent node id. The object transforms will be
3038 /// relative to this node unless this node is not an OBJ.
3039 ///
3040 /// @param[in] rst_order
3041 /// The order of application of translation, rotation and
3042 /// scale.
3043 ///
3044 /// @param[out] transform_array
3045 /// Array of ::HAPI_Transform at least the size of
3046 /// length.
3047 ///
3048 /// @param[in] start
3049 /// At least @c 0 and at most @c object_count returned by
3050 /// ::HAPI_ComposeObjectList().
3051 ///
3052 /// @param[in] length
3053 /// Given @c object_count returned by
3054 /// ::HAPI_ComposeObjectList(), @c length should be at least
3055 /// @c 0 and at most <tt>object_count - start</tt>.
3056 ///
3058  HAPI_NodeId parent_node_id,
3059  HAPI_RSTOrder rst_order,
3060  HAPI_Transform * transform_array,
3061  int start, int length );
3062 
3063 /// @brief Get the node ids for the objects being instanced by an
3064 /// Instance OBJ node.
3065 ///
3066 /// @param[in] session
3067 /// The session of Houdini you are interacting with.
3068 /// See @ref HAPI_Sessions for more on sessions.
3069 /// Pass NULL to just use the default in-process session.
3070 ///
3071 /// @param[in] object_node_id
3072 /// The object node id.
3073 ///
3074 /// @param[out] instanced_node_id_array
3075 /// Array of ::HAPI_NodeId at least the size of length.
3076 ///
3077 /// @param[in] start
3078 /// First index of range. Must be at least 0 and at
3079 /// most ::HAPI_PartInfo::pointCount - 1. This is the 0th
3080 /// part of the display geo of the instancer object node.
3081 ///
3082 /// @param[in] length
3083 /// Must be at least 0 and at most
3084 /// ::HAPI_PartInfo::pointCount - @p start. This is the 0th
3085 /// part of the display geo of the instancer object node.
3086 ///
3088  HAPI_NodeId object_node_id,
3089  HAPI_NodeId * instanced_node_id_array,
3090  int start, int length );
3091 
3092 /// @brief Fill an array of ::HAPI_Transform structs with the transforms
3093 /// of each instance of this instancer object.
3094 ///
3095 /// @param[in] session
3096 /// The session of Houdini you are interacting with.
3097 /// See @ref HAPI_Sessions for more on sessions.
3098 /// Pass NULL to just use the default in-process session.
3099 ///
3100 /// @param[in] object_node_id
3101 /// The object node id.
3102 ///
3103 /// @param[in] rst_order
3104 /// The order of application of translation, rotation and
3105 /// scale.
3106 ///
3107 /// @param[out] transforms_array
3108 /// Array of ::HAPI_Transform at least the size of length.
3109 ///
3110 /// @param[in] start
3111 /// First index of range. Must be at least 0 and at
3112 /// most ::HAPI_PartInfo::pointCount - 1. This is the 0th
3113 /// part of the display geo of the instancer object node.
3114 ///
3115 /// @param[in] length
3116 /// Must be at least 0 and at most
3117 /// ::HAPI_PartInfo::pointCount - @p start. This is the 0th
3118 /// part of the display geo of the instancer object node.
3119 ///
3121  HAPI_NodeId object_node_id,
3122  HAPI_RSTOrder rst_order,
3123  HAPI_Transform * transforms_array,
3124  int start, int length );
3125 
3126 /// @brief Set the transform of an individual object. Note that the object
3127 /// nodes have to either be editable or have their transform
3128 /// parameters exposed at the asset level. This won't work otherwise.
3129 ///
3130 /// @param[in] session
3131 /// The session of Houdini you are interacting with.
3132 /// See @ref HAPI_Sessions for more on sessions.
3133 /// Pass NULL to just use the default in-process session.
3134 ///
3135 /// @param[in] node_id
3136 /// The object node id.
3137 ///
3138 /// @param[in] trans
3139 /// A ::HAPI_TransformEuler that stores the transform.
3140 ///
3142  HAPI_NodeId node_id,
3143  const HAPI_TransformEuler * trans );
3144 
3145 // GEOMETRY GETTERS ---------------------------------------------------------
3146 
3147 /// @brief Get the display geo (SOP) node inside an Object node. If there
3148 /// there are multiple display SOP nodes, only the first one is
3149 /// returned. If the node is a display SOP itself, even if a network,
3150 /// it will return its own geo info. If the node is a SOP but not
3151 /// a network and not the display SOP, this function will fail.
3152 ///
3153 /// The above implies that you can safely call this function on both
3154 /// OBJ and SOP asset nodes and get the same (equivalent) geometry
3155 /// display node back. SOP asset nodes will simply return themselves.
3156 ///
3157 /// @param[in] session
3158 /// The session of Houdini you are interacting with.
3159 /// See @ref HAPI_Sessions for more on sessions.
3160 /// Pass NULL to just use the default in-process session.
3161 ///
3162 /// @param[in] object_node_id
3163 /// The object node id.
3164 ///
3165 /// @param[out] geo_info
3166 /// ::HAPI_GeoInfo return value.
3167 ///
3169  HAPI_NodeId object_node_id,
3170  HAPI_GeoInfo * geo_info );
3171 
3172 /// @brief Get the geometry info struct (::HAPI_GeoInfo) on a SOP node.
3173 ///
3174 /// @param[in] session
3175 /// The session of Houdini you are interacting with.
3176 /// See @ref HAPI_Sessions for more on sessions.
3177 /// Pass NULL to just use the default in-process session.
3178 ///
3179 /// @param[in] node_id
3180 /// The node id.
3181 ///
3182 /// @param[out] geo_info
3183 /// ::HAPI_GeoInfo return value.
3184 ///
3185 HAPI_DECL HAPI_GetGeoInfo( const HAPI_Session * session,
3186  HAPI_NodeId node_id,
3187  HAPI_GeoInfo * geo_info );
3188 
3189 /// @brief Get a particular part info struct.
3190 ///
3191 /// @param[in] session
3192 /// The session of Houdini you are interacting with.
3193 /// See @ref HAPI_Sessions for more on sessions.
3194 /// Pass NULL to just use the default in-process session.
3195 ///
3196 /// @param[in] node_id
3197 /// The SOP node id.
3198 ///
3199 /// @param[in] part_id
3200 /// The part id.
3201 ///
3202 /// @param[out] part_info
3203 /// ::HAPI_PartInfo return value.
3204 ///
3205 HAPI_DECL HAPI_GetPartInfo( const HAPI_Session * session,
3206  HAPI_NodeId node_id,
3207  HAPI_PartId part_id,
3208  HAPI_PartInfo * part_info );
3209 
3210 /// @brief Get the array of faces where the nth integer in the array is
3211 /// the number of vertices the nth face has.
3212 ///
3213 /// @param[in] session
3214 /// The session of Houdini you are interacting with.
3215 /// See @ref HAPI_Sessions for more on sessions.
3216 /// Pass NULL to just use the default in-process session.
3217 ///
3218 /// @param[in] node_id
3219 /// The node id.
3220 ///
3221 /// @param[in] part_id
3222 /// The part id.
3223 ///
3224 /// @param[out] face_counts_array
3225 /// An integer array at least the size of length.
3226 ///
3227 /// @param[in] start
3228 /// First index of range. Must be at least 0 and at
3229 /// most ::HAPI_PartInfo::faceCount - 1.
3230 ///
3231 /// @param[in] length
3232 /// Must be at least 0 and at most
3233 /// ::HAPI_PartInfo::faceCount - @p start.
3234 ///
3235 HAPI_DECL HAPI_GetFaceCounts( const HAPI_Session * session,
3236  HAPI_NodeId node_id,
3237  HAPI_PartId part_id,
3238  int * face_counts_array,
3239  int start, int length );
3240 
3241 /// @brief Get array containing the vertex-point associations where the
3242 /// ith element in the array is the point index the ith vertex
3243 /// associates with.
3244 ///
3245 /// @param[in] session
3246 /// The session of Houdini you are interacting with.
3247 /// See @ref HAPI_Sessions for more on sessions.
3248 /// Pass NULL to just use the default in-process session.
3249 ///
3250 /// @param[in] node_id
3251 /// The node id.
3252 ///
3253 /// @param[in] part_id
3254 /// The part id.
3255 ///
3256 /// @param[out] vertex_list_array
3257 /// An integer array at least the size of length.
3258 ///
3259 /// @param[in] start
3260 /// First index of range. Must be at least 0 and at
3261 /// most ::HAPI_PartInfo::vertexCount - 1.
3262 ///
3263 /// @param[in] length
3264 /// Must be at least 0 and at most
3265 /// ::HAPI_PartInfo::vertexCount - @p start.
3266 ///
3267 HAPI_DECL HAPI_GetVertexList( const HAPI_Session * session,
3268  HAPI_NodeId node_id,
3269  HAPI_PartId part_id,
3270  int * vertex_list_array,
3271  int start, int length );
3272 
3273 /// @brief Get the attribute info struct for the attribute specified by name.
3274 ///
3275 /// @param[in] session
3276 /// The session of Houdini you are interacting with.
3277 /// See @ref HAPI_Sessions for more on sessions.
3278 /// Pass NULL to just use the default in-process session.
3279 ///
3280 /// @param[in] node_id
3281 /// The node id.
3282 ///
3283 /// @param[in] part_id
3284 /// The part id.
3285 ///
3286 /// @param[in] name
3287 /// Attribute name.
3288 ///
3289 /// @param[in] owner
3290 /// Attribute owner.
3291 ///
3292 /// @param[out] attr_info
3293 /// ::HAPI_AttributeInfo to be filled. Check
3294 /// ::HAPI_AttributeInfo::exists to see if this attribute
3295 /// exists.
3296 ///
3298  HAPI_NodeId node_id,
3299  HAPI_PartId part_id,
3300  const char * name,
3301  HAPI_AttributeOwner owner,
3302  HAPI_AttributeInfo * attr_info );
3303 
3304 /// @brief Get list of attribute names by attribute owner. Note that the
3305 /// name string handles are only valid until the next time this
3306 /// function is called.
3307 ///
3308 /// @param[in] session
3309 /// The session of Houdini you are interacting with.
3310 /// See @ref HAPI_Sessions for more on sessions.
3311 /// Pass NULL to just use the default in-process session.
3312 ///
3313 /// @param[in] node_id
3314 /// The node id.
3315 ///
3316 /// @param[in] part_id
3317 /// The part id.
3318 ///
3319 /// @param[in] owner
3320 /// The ::HAPI_AttributeOwner enum value specifying the
3321 /// owner of the attribute.
3322 ///
3323 /// @param[out] attribute_names_array
3324 /// Array of ints (string handles) to house the
3325 /// attribute names. Should be exactly the size of the
3326 /// appropriate attribute owner type count
3327 /// in ::HAPI_PartInfo.
3328 ///
3329 /// @param[in] count
3330 /// Sanity check count. Must be equal to the appropriate
3331 /// attribute owner type count in ::HAPI_PartInfo.
3332 ///
3334  HAPI_NodeId node_id,
3335  HAPI_PartId part_id,
3336  HAPI_AttributeOwner owner,
3337  HAPI_StringHandle * attribute_names_array,
3338  int count );
3339 
3340 /// @brief Get attribute integer data.
3341 ///
3342 /// @param[in] session
3343 /// The session of Houdini you are interacting with.
3344 /// See @ref HAPI_Sessions for more on sessions.
3345 /// Pass NULL to just use the default in-process session.
3346 ///
3347 /// @param[in] node_id
3348 /// The node id.
3349 ///
3350 /// @param[in] part_id
3351 /// The part id.
3352 ///
3353 /// @param[in] name
3354 /// Attribute name.
3355 ///
3356 /// @param[in] attr_info
3357 /// ::HAPI_AttributeInfo used as input for what tuple size.
3358 /// you want. Also contains some sanity checks like
3359 /// data type. Generally should be the same struct
3360 /// returned by ::HAPI_GetAttributeInfo().
3361 ///
3362 /// @param[in] stride
3363 /// Specifies how many items to skip over for each element.
3364 /// With a stride of -1, the stride will be set to
3365 /// @c attr_info->tuple_size. Otherwise, the stride will be
3366 /// set to the maximum of @c attr_info->tuple_size and
3367 /// @c stride.
3368 ///
3369 /// @param[out] data_array
3370 /// An integer array at least the size of
3371 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
3372 ///
3373 /// @param[in] start
3374 /// First index of range. Must be at least 0 and at
3375 /// most ::HAPI_AttributeInfo::count - 1.
3376 ///
3377 /// @param[in] length
3378 /// Must be at least 0 and at most
3379 /// ::HAPI_AttributeInfo::count - @p start.
3380 /// Note, if 0 is passed for length, the function will just
3381 /// do nothing and return ::HAPI_RESULT_SUCCESS.
3382 ///
3384  HAPI_NodeId node_id,
3385  HAPI_PartId part_id,
3386  const char * name,
3387  HAPI_AttributeInfo * attr_info,
3388  int stride,
3389  int * data_array,
3390  int start, int length );
3391 
3392 /// @brief Get attribute 64-bit integer data.
3393 ///
3394 /// @param[in] session
3395 /// The session of Houdini you are interacting with.
3396 /// See @ref HAPI_Sessions for more on sessions.
3397 /// Pass NULL to just use the default in-process session.
3398 ///
3399 /// @param[in] node_id
3400 /// The node id.
3401 ///
3402 /// @param[in] part_id
3403 /// The part id.
3404 ///
3405 /// @param[in] name
3406 /// Attribute name.
3407 ///
3408 /// @param[in] attr_info
3409 /// ::HAPI_AttributeInfo used as input for what tuple size.
3410 /// you want. Also contains some sanity checks like
3411 /// data type. Generally should be the same struct
3412 /// returned by ::HAPI_GetAttributeInfo().
3413 ///
3414 /// @param[in] stride
3415 /// Specifies how many items to skip over for each element.
3416 /// With a stride of -1, the stride will be set to
3417 /// @c attr_info->tuple_size. Otherwise, the stride will be
3418 /// set to the maximum of @c attr_info->tuple_size and
3419 /// @c stride.
3420 ///
3421 /// @param[out] data_array
3422 /// An 64-bit integer array at least the size of
3423 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
3424 ///
3425 /// @param[in] start
3426 /// First index of range. Must be at least 0 and at
3427 /// most ::HAPI_AttributeInfo::count - 1.
3428 ///
3429 /// @param[in] length
3430 /// Must be at least 0 and at most
3431 /// ::HAPI_AttributeInfo::count - @p start.
3432 /// Note, if 0 is passed for length, the function will just
3433 /// do nothing and return ::HAPI_RESULT_SUCCESS.
3434 ///
3436  HAPI_NodeId node_id,
3437  HAPI_PartId part_id,
3438  const char * name,
3439  HAPI_AttributeInfo * attr_info,
3440  int stride,
3441  HAPI_Int64 * data_array,
3442  int start, int length );
3443 
3444 /// @brief Get attribute float data.
3445 ///
3446 /// @param[in] session
3447 /// The session of Houdini you are interacting with.
3448 /// See @ref HAPI_Sessions for more on sessions.
3449 /// Pass NULL to just use the default in-process session.
3450 ///
3451 /// @param[in] node_id
3452 /// The node id.
3453 ///
3454 /// @param[in] part_id
3455 /// The part id.
3456 ///
3457 /// @param[in] name
3458 /// Attribute name.
3459 ///
3460 /// @param[in] attr_info
3461 /// ::HAPI_AttributeInfo used as input for what tuple size.
3462 /// you want. Also contains some sanity checks like
3463 /// data type. Generally should be the same struct
3464 /// returned by ::HAPI_GetAttributeInfo().
3465 ///
3466 /// @param[in] stride
3467 /// Specifies how many items to skip over for each element.
3468 /// With a stride of -1, the stride will be set to
3469 /// @c attr_info->tuple_size. Otherwise, the stride will be
3470 /// set to the maximum of @c attr_info->tuple_size and
3471 /// @c stride.
3472 ///
3473 /// @param[out] data_array
3474 /// An float array at least the size of
3475 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
3476 ///
3477 /// @param[in] start
3478 /// First index of range. Must be at least 0 and at
3479 /// most ::HAPI_AttributeInfo::count - 1.
3480 ///
3481 /// @param[in] length
3482 /// Must be at least 0 and at most
3483 /// ::HAPI_AttributeInfo::count - @p start.
3484 /// Note, if 0 is passed for length, the function will just
3485 /// do nothing and return ::HAPI_RESULT_SUCCESS.
3486 ///
3488  HAPI_NodeId node_id,
3489  HAPI_PartId part_id,
3490  const char * name,
3491  HAPI_AttributeInfo * attr_info,
3492  int stride,
3493  float * data_array,
3494  int start, int length );
3495 
3496 /// @brief Get 64-bit attribute float data.
3497 ///
3498 /// @param[in] session
3499 /// The session of Houdini you are interacting with.
3500 /// See @ref HAPI_Sessions for more on sessions.
3501 /// Pass NULL to just use the default in-process session.
3502 ///
3503 /// @param[in] node_id
3504 /// The node id.
3505 ///
3506 /// @param[in] part_id
3507 /// The part id.
3508 ///
3509 /// @param[in] name
3510 /// Attribute name.
3511 ///
3512 /// @param[in] attr_info
3513 /// ::HAPI_AttributeInfo used as input for what tuple size.
3514 /// you want. Also contains some sanity checks like
3515 /// data type. Generally should be the same struct
3516 /// returned by ::HAPI_GetAttributeInfo().
3517 ///
3518 /// @param[in] stride
3519 /// Specifies how many items to skip over for each element.
3520 /// With a stride of -1, the stride will be set to
3521 /// @c attr_info->tuple_size. Otherwise, the stride will be
3522 /// set to the maximum of @c attr_info->tuple_size and
3523 /// @c stride.
3524 ///
3525 /// @param[out] data_array
3526 /// An 64-bit float array at least the size of
3527 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
3528 ///
3529 /// @param[in] start
3530 /// First index of range. Must be at least 0 and at
3531 /// most ::HAPI_AttributeInfo::count - 1.
3532 ///
3533 /// @param[in] length
3534 /// Must be at least 0 and at most
3535 /// ::HAPI_AttributeInfo::count - @p start.
3536 /// Note, if 0 is passed for length, the function will just
3537 /// do nothing and return ::HAPI_RESULT_SUCCESS.
3538 ///
3540  HAPI_NodeId node_id,
3541  HAPI_PartId part_id,
3542  const char * name,
3543  HAPI_AttributeInfo * attr_info,
3544  int stride,
3545  double * data_array,
3546  int start, int length );
3547 
3548 /// @brief Get attribute string data. Note that the string handles
3549 /// returned are only valid until the next time this function
3550 /// is called.
3551 ///
3552 /// @param[in] session
3553 /// The session of Houdini you are interacting with.
3554 /// See @ref HAPI_Sessions for more on sessions.
3555 /// Pass NULL to just use the default in-process session.
3556 ///
3557 /// @param[in] node_id
3558 /// The node id.
3559 ///
3560 /// @param[in] part_id
3561 /// The part id.
3562 ///
3563 /// @param[in] name
3564 /// Attribute name.
3565 ///
3566 /// @param[in] attr_info
3567 /// ::HAPI_AttributeInfo used as input for what tuple size.
3568 /// you want. Also contains some sanity checks like
3569 /// data type. Generally should be the same struct
3570 /// returned by ::HAPI_GetAttributeInfo().
3571 ///
3572 /// @param[out] data_array
3573 /// An ::HAPI_StringHandle array at least the size of
3574 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
3575 ///
3576 /// @param[in] start
3577 /// First index of range. Must be at least 0 and at
3578 /// most ::HAPI_AttributeInfo::count - 1.
3579 ///
3580 /// @param[in] length
3581 /// Must be at least 0 and at most
3582 /// ::HAPI_AttributeInfo::count - @p start.
3583 /// Note, if 0 is passed for length, the function will just
3584 /// do nothing and return ::HAPI_RESULT_SUCCESS.
3585 ///
3587  HAPI_NodeId node_id,
3588  HAPI_PartId part_id,
3589  const char * name,
3590  HAPI_AttributeInfo * attr_info,
3591  HAPI_StringHandle * data_array,
3592  int start, int length );
3593 
3594 /// @brief Get group names for an entire geo. Please note that this
3595 /// function is NOT per-part, but it is per-geo. The companion
3596 /// function ::HAPI_GetGroupMembership() IS per-part. Also keep
3597 /// in mind that the name string handles are only
3598 /// valid until the next time this function is called.
3599 ///
3600 /// @param[in] session
3601 /// The session of Houdini you are interacting with.
3602 /// See @ref HAPI_Sessions for more on sessions.
3603 /// Pass NULL to just use the default in-process session.
3604 ///
3605 /// @param[in] node_id
3606 /// The node id.
3607 ///
3608 /// @param[in] group_type
3609 /// The group type.
3610 ///
3611 /// @param[out] group_names_array
3612 /// The array of names to be filled. Should be the size
3613 /// given by ::HAPI_GeoInfo_GetGroupCountByType() with
3614 /// @p group_type and the ::HAPI_GeoInfo of @p geo_id.
3615 /// @note These string handles are only valid until the
3616 /// next call to ::HAPI_GetGroupNames().
3617 ///
3618 /// @param[in] group_count
3619 /// Sanity check. Should be less than or equal to the size
3620 /// of @p group_names.
3621 ///
3622 HAPI_DECL HAPI_GetGroupNames( const HAPI_Session * session,
3623  HAPI_NodeId node_id,
3624  HAPI_GroupType group_type,
3625  HAPI_StringHandle * group_names_array,
3626  int group_count );
3627 
3628 /// @brief Get group membership.
3629 ///
3630 /// @param[in] session
3631 /// The session of Houdini you are interacting with.
3632 /// See @ref HAPI_Sessions for more on sessions.
3633 /// Pass NULL to just use the default in-process session.
3634 ///
3635 /// @param[in] node_id
3636 /// The node id.
3637 ///
3638 /// @param[in] part_id
3639 /// The part id.
3640 ///
3641 /// @param[in] group_type
3642 /// The group type.
3643 ///
3644 /// @param[in] group_name
3645 /// The group name.
3646 ///
3647 /// @param[out] membership_array_all_equal
3648 /// (optional) Quick way to determine if all items are in
3649 /// the given group or all items our not in the group.
3650 /// You can just pass NULL here if not interested.
3651 ///
3652 /// @param[out] membership_array
3653 /// Array of ints that represent the membership of this
3654 /// group. Should be the size given by
3655 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
3656 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
3657 ///
3658 /// @param[in] start
3659 /// Start offset into the membership array. Must be
3660 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
3661 ///
3662 /// @param[in] length
3663 /// Should be less than or equal to the size
3664 /// of @p membership.
3665 ///
3667  HAPI_NodeId node_id,
3668  HAPI_PartId part_id,
3669  HAPI_GroupType group_type,
3670  const char * group_name,
3671  HAPI_Bool * membership_array_all_equal,
3672  int * membership_array,
3673  int start, int length );
3674 
3675 /// @brief Get group counts for a specific packed instanced part.
3676 ///
3677 /// @param[in] session
3678 /// The session of Houdini you are interacting with.
3679 /// See @ref HAPI_Sessions for more on sessions.
3680 /// Pass NULL to just use the default in-process session.
3681 ///
3682 /// @param[in] node_id
3683 /// The node id.
3684 ///
3685 /// @param[in] part_id
3686 /// The part id. (should be a packed primitive)
3687 ///
3688 /// @param[out] pointGroupCount
3689 /// Number of point groups on the packed instance part.
3690 /// Will be set to -1 if the part is not a valid packed part.
3691 ///
3692 /// @param[out] primitiveGroupCount
3693 /// Number of primitive groups on the instanced part.
3694 /// Will be set to -1 if the part is not a valid instancer
3695 ///
3697  HAPI_NodeId node_id,
3698  HAPI_PartId part_id,
3699  int * pointGroupCount,
3700  int * primitiveGroupCount );
3701 
3702 /// @brief Get the group names for a packed instance part
3703 /// This functions allows you to get the group name for a specific
3704 /// packed primitive part.
3705 /// Keep in mind that the name string handles are only
3706 /// valid until the next time this function is called.
3707 ///
3708 /// @param[in] session
3709 /// The session of Houdini you are interacting with.
3710 /// See @ref HAPI_Sessions for more on sessions.
3711 /// Pass NULL to just use the default in-process session.
3712 ///
3713 /// @param[in] node_id
3714 /// The node id.
3715 ///
3716 /// @param[in] part_id
3717 /// The part id. (should be a packed primitive)
3718 ///
3719 /// @param[in] group_type
3720 /// The group type.
3721 ///
3722 /// @param[out] group_names_array
3723 /// The array of names to be filled. Should be the size
3724 /// given by ::HAPI_GetGroupCountOnInstancedPart() with
3725 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
3726 /// @note These string handles are only valid until the
3727 /// next call to ::HAPI_GetGroupNamesOnPackedInstancePart().
3728 ///
3729 /// @param[in] group_count
3730 /// Sanity check. Should be less than or equal to the size
3731 /// of @p group_names.
3732 ///
3734  HAPI_NodeId node_id,
3735  HAPI_PartId part_id,
3736  HAPI_GroupType group_type,
3737  HAPI_StringHandle * group_names_array,
3738  int group_count );
3739 
3740 /// @brief Get group membership for a packed instance part
3741 /// This functions allows you to get the group membership for a specific
3742 /// packed primitive part.
3743 ///
3744 /// @param[in] session
3745 /// The session of Houdini you are interacting with.
3746 /// See @ref HAPI_Sessions for more on sessions.
3747 /// Pass NULL to just use the default in-process session.
3748 ///
3749 /// @param[in] node_id
3750 /// The node id.
3751 ///
3752 /// @param[in] part_id
3753 /// The part id. (should be a packed primitive)
3754 ///
3755 /// @param[in] group_type
3756 /// The group type.
3757 ///
3758 /// @param[in] group_name
3759 /// The group name.
3760 ///
3761 /// @param[out] membership_array_all_equal
3762 /// (optional) Quick way to determine if all items are in
3763 /// the given group or all items our not in the group.
3764 /// You can just pass NULL here if not interested.
3765 ///
3766 /// @param[out] membership_array
3767 /// Array of ints that represent the membership of this
3768 /// group. Should be the size given by
3769 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
3770 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
3771 ///
3772 /// @param[in] start
3773 /// Start offset into the membership array. Must be
3774 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
3775 ///
3776 /// @param[in] length
3777 /// Should be less than or equal to the size
3778 /// of @p membership.
3779 ///
3781  HAPI_NodeId node_id,
3782  HAPI_PartId part_id,
3783  HAPI_GroupType group_type,
3784  const char * group_name,
3785  HAPI_Bool * membership_array_all_equal,
3786  int * membership_array,
3787  int start, int length );
3788 
3789 /// @brief Get the part ids that this instancer part is instancing.
3790 ///
3791 /// @param[in] session
3792 /// The session of Houdini you are interacting with.
3793 /// See @ref HAPI_Sessions for more on sessions.
3794 /// Pass NULL to just use the default in-process session.
3795 ///
3796 /// @param[in] node_id
3797 /// The node id.
3798 ///
3799 /// @param[in] part_id
3800 /// The instancer part id.
3801 ///
3802 /// @param[out] instanced_parts_array
3803 /// Array of ::HAPI_PartId's to instance.
3804 ///
3805 /// @param[in] start
3806 /// Should be less than @p part_id's
3807 /// ::HAPI_PartInfo::instancedPartCount but more than or
3808 /// equal to 0.
3809 ///
3810 /// @param[in] length
3811 /// Should be less than @p part_id's
3812 /// ::HAPI_PartInfo::instancedPartCount - @p start.
3813 ///
3815  HAPI_NodeId node_id,
3816  HAPI_PartId part_id,
3817  HAPI_PartId * instanced_parts_array,
3818  int start, int length );
3819 
3820 /// @brief Get the instancer part's list of transforms on which to
3821 /// instance the instanced parts you got from
3822 /// ::HAPI_GetInstancedPartIds().
3823 ///
3824 /// @param[in] session
3825 /// The session of Houdini you are interacting with.
3826 /// See @ref HAPI_Sessions for more on sessions.
3827 /// Pass NULL to just use the default in-process session.
3828 ///
3829 /// @param[in] node_id
3830 /// The node id.
3831 ///
3832 /// @param[in] part_id
3833 /// The instancer part id.
3834 ///
3835 /// @param[in] rst_order
3836 /// The order of application of translation, rotation and
3837 /// scale.
3838 ///
3839 /// @param[out] transforms_array
3840 /// Array of ::HAPI_PartId's to instance.
3841 ///
3842 /// @param[in] start
3843 /// Should be less than @p part_id's
3844 /// ::HAPI_PartInfo::instanceCount but more than or
3845 /// equal to 0.
3846 ///
3847 /// @param[in] length
3848 /// Should be less than @p part_id's
3849 /// ::HAPI_PartInfo::instanceCount - @p start.
3850 ///
3852  HAPI_NodeId node_id,
3853  HAPI_PartId part_id,
3854  HAPI_RSTOrder rst_order,
3855  HAPI_Transform * transforms_array,
3856  int start, int length );
3857 
3858 // GEOMETRY SETTERS ---------------------------------------------------------
3859 
3860 /// @brief Set the main part info struct (::HAPI_PartInfo).
3861 ///
3862 /// @param[in] session
3863 /// The session of Houdini you are interacting with.
3864 /// See @ref HAPI_Sessions for more on sessions.
3865 /// Pass NULL to just use the default in-process session.
3866 ///
3867 /// @param[in] node_id
3868 /// The SOP node id.
3869 ///
3870 /// @param[in] part_id
3871 /// Currently not used. Just pass 0.
3872 ///
3873 /// @param[in] part_info
3874 /// ::HAPI_PartInfo value that describes the input
3875 /// geometry.
3876 ///
3877 HAPI_DECL HAPI_SetPartInfo( const HAPI_Session * session,
3878  HAPI_NodeId node_id,
3879  HAPI_PartId part_id,
3880  const HAPI_PartInfo * part_info );
3881 
3882 /// @brief Set the array of faces where the nth integer in the array is
3883 /// the number of vertices the nth face has.
3884 ///
3885 /// @param[in] session
3886 /// The session of Houdini you are interacting with.
3887 /// See @ref HAPI_Sessions for more on sessions.
3888 /// Pass NULL to just use the default in-process session.
3889 ///
3890 /// @param[in] node_id
3891 /// The SOP node id.
3892 ///
3893 /// @param[in] part_id
3894 /// Currently not used. Just pass 0.
3895 ///
3896 /// @param[in] face_counts_array
3897 /// An integer array at least the size of @p length.
3898 ///
3899 /// @param[in] start
3900 /// First index of range. Must be at least 0 and at
3901 /// most ::HAPI_PartInfo::faceCount - 1.
3902 ///
3903 /// @param[in] length
3904 /// Must be at least 0 and at most
3905 /// ::HAPI_PartInfo::faceCount - @p start.
3906 ///
3907 HAPI_DECL HAPI_SetFaceCounts( const HAPI_Session * session,
3908  HAPI_NodeId node_id,
3909  HAPI_PartId part_id,
3910  const int * face_counts_array,
3911  int start, int length );
3912 
3913 /// @brief Set array containing the vertex-point associations where the
3914 /// ith element in the array is the point index the ith vertex
3915 /// associates with.
3916 ///
3917 /// @param[in] session
3918 /// The session of Houdini you are interacting with.
3919 /// See @ref HAPI_Sessions for more on sessions.
3920 /// Pass NULL to just use the default in-process session.
3921 ///
3922 /// @param[in] node_id
3923 /// The SOP node id.
3924 ///
3925 /// @param[in] part_id
3926 /// Currently not used. Just pass 0.
3927 ///
3928 /// @param[in] vertex_list_array
3929 /// An integer array at least the size of length.
3930 ///
3931 /// @param[in] start
3932 /// First index of range. Must be at least 0 and at
3933 /// most ::HAPI_PartInfo::vertexCount - 1.
3934 ///
3935 /// @param[in] length
3936 /// Must be at least 0 and at most
3937 /// ::HAPI_PartInfo::vertexCount - @p start.
3938 ///
3939 HAPI_DECL HAPI_SetVertexList( const HAPI_Session * session,
3940  HAPI_NodeId node_id,
3941  HAPI_PartId part_id,
3942  const int * vertex_list_array,
3943  int start, int length );
3944 
3945 /// @brief Add an attribute.
3946 ///
3947 /// @param[in] session
3948 /// The session of Houdini you are interacting with.
3949 /// See @ref HAPI_Sessions for more on sessions.
3950 /// Pass NULL to just use the default in-process session.
3951 ///
3952 /// @param[in] node_id
3953 /// The SOP node id.
3954 ///
3955 /// @param[in] part_id
3956 /// Currently not used. Just pass 0.
3957 ///
3958 /// @param[in] name
3959 /// Attribute name.
3960 ///
3961 /// @param[in] attr_info
3962 /// ::HAPI_AttributeInfo stores attribute properties.
3963 ///
3964 HAPI_DECL HAPI_AddAttribute( const HAPI_Session * session,
3965  HAPI_NodeId node_id,
3966  HAPI_PartId part_id,
3967  const char * name,
3968  const HAPI_AttributeInfo * attr_info );
3969 /// @brief Delete an attribute from an input geo
3970 ///
3971 /// @param[in] session
3972 /// The session of Houdini you are interacting with.
3973 /// See @ref HAPI_Sessions for more on sessions.
3974  /// Pass NULL to just use the default in-process session.
3975 ///
3976 /// @param[in] node_id
3977 /// The SOP node id.
3978 ///
3979 /// @param[in] part_id
3980 /// Currently not used. Just pass 0.
3981 ///
3982 /// @param[in] name
3983 /// Attribute name.
3984 ///
3985 /// @param[in] attr_info
3986 /// ::HAPI_AttributeInfo stores attribute properties.
3987 ///
3989  HAPI_NodeId node_id,
3990  HAPI_PartId part_id,
3991  const char * name,
3992  const HAPI_AttributeInfo * attr_info );
3993 
3994 /// @brief Set attribute integer data.
3995 ///
3996 /// @param[in] session
3997 /// The session of Houdini you are interacting with.
3998 /// See @ref HAPI_Sessions for more on sessions.
3999 /// Pass NULL to just use the default in-process session.
4000 ///
4001 /// @param[in] node_id
4002 /// The SOP node id.
4003 ///
4004 /// @param[in] part_id
4005 /// Currently not used. Just pass 0.
4006 ///
4007 /// @param[in] name
4008 /// Attribute name.
4009 ///
4010 /// @param[in] attr_info
4011 /// ::HAPI_AttributeInfo used as input for what tuple size.
4012 /// you want. Also contains some sanity checks like
4013 /// data type. Generally should be the same struct
4014 /// returned by ::HAPI_GetAttributeInfo().
4015 ///
4016 /// @param[out] data_array
4017 /// An integer array at least the size of
4018 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4019 ///
4020 /// @param[in] start
4021 /// First index of range. Must be at least 0 and at
4022 /// most ::HAPI_AttributeInfo::count - 1.
4023 ///
4024 /// @param[in] length
4025 /// Must be at least 0 and at most
4026 /// ::HAPI_AttributeInfo::count - @p start.
4027 ///
4029  HAPI_NodeId node_id,
4030  HAPI_PartId part_id,
4031  const char * name,
4032  const HAPI_AttributeInfo * attr_info,
4033  const int * data_array,
4034  int start, int length );
4035 
4036 /// @brief Set 64-bit attribute integer data.
4037 ///
4038 /// @param[in] session
4039 /// The session of Houdini you are interacting with.
4040 /// See @ref HAPI_Sessions for more on sessions.
4041 /// Pass NULL to just use the default in-process session.
4042 ///
4043 /// @param[in] node_id
4044 /// The SOP node id.
4045 ///
4046 /// @param[in] part_id
4047 /// Currently not used. Just pass 0.
4048 ///
4049 /// @param[in] name
4050 /// Attribute name.
4051 ///
4052 /// @param[in] attr_info
4053 /// ::HAPI_AttributeInfo used as input for what tuple size.
4054 /// you want. Also contains some sanity checks like
4055 /// data type. Generally should be the same struct
4056 /// returned by ::HAPI_GetAttributeInfo().
4057 ///
4058 /// @param[out] data_array
4059 /// An 64-bit integer array at least the size of
4060 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4061 ///
4062 /// @param[in] start
4063 /// First index of range. Must be at least 0 and at
4064 /// most ::HAPI_AttributeInfo::count - 1.
4065 ///
4066 /// @param[in] length
4067 /// Must be at least 0 and at most
4068 /// ::HAPI_AttributeInfo::count - @p start.
4069 ///
4071  HAPI_NodeId node_id,
4072  HAPI_PartId part_id,
4073  const char * name,
4074  const HAPI_AttributeInfo * attr_info,
4075  const HAPI_Int64 * data_array,
4076  int start, int length );
4077 
4078 /// @brief Set attribute float data.
4079 ///
4080 /// @param[in] session
4081 /// The session of Houdini you are interacting with.
4082 /// See @ref HAPI_Sessions for more on sessions.
4083 /// Pass NULL to just use the default in-process session.
4084 ///
4085 /// @param[in] node_id
4086 /// The SOP node id.
4087 ///
4088 /// @param[in] part_id
4089 /// Currently not used. Just pass 0.
4090 ///
4091 /// @param[in] name
4092 /// Attribute name.
4093 ///
4094 /// @param[in] attr_info
4095 /// ::HAPI_AttributeInfo used as input for what tuple size.
4096 /// you want. Also contains some sanity checks like
4097 /// data type. Generally should be the same struct
4098 /// returned by ::HAPI_GetAttributeInfo().
4099 ///
4100 /// @param[out] data_array
4101 /// An float array at least the size of
4102 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4103 ///
4104 /// @param[in] start
4105 /// First index of range. Must be at least 0 and at
4106 /// most ::HAPI_AttributeInfo::count - 1.
4107 ///
4108 /// @param[in] length
4109 /// Must be at least 0 and at most
4110 /// ::HAPI_AttributeInfo::count - @p start.
4111 ///
4113  HAPI_NodeId node_id,
4114  HAPI_PartId part_id,
4115  const char * name,
4116  const HAPI_AttributeInfo * attr_info,
4117  const float * data_array,
4118  int start, int length );
4119 
4120 /// @brief Set 64-bit attribute float data.
4121 ///
4122 /// @param[in] session
4123 /// The session of Houdini you are interacting with.
4124 /// See @ref HAPI_Sessions for more on sessions.
4125 /// Pass NULL to just use the default in-process session.
4126 ///
4127 /// @param[in] node_id
4128 /// The SOP node id.
4129 ///
4130 /// @param[in] part_id
4131 /// Currently not used. Just pass 0.
4132 ///
4133 /// @param[in] name
4134 /// Attribute name.
4135 ///
4136 /// @param[in] attr_info
4137 /// ::HAPI_AttributeInfo used as input for what tuple size.
4138 /// you want. Also contains some sanity checks like
4139 /// data type. Generally should be the same struct
4140 /// returned by ::HAPI_GetAttributeInfo().
4141 ///
4142 /// @param[out] data_array
4143 /// An 64-bit float array at least the size of
4144 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4145 ///
4146 /// @param[in] start
4147 /// First index of range. Must be at least 0 and at
4148 /// most ::HAPI_AttributeInfo::count - 1.
4149 ///
4150 /// @param[in] length
4151 /// Must be at least 0 and at most
4152 /// ::HAPI_AttributeInfo::count - @p start.
4153 ///
4155  HAPI_NodeId node_id,
4156  HAPI_PartId part_id,
4157  const char * name,
4158  const HAPI_AttributeInfo * attr_info,
4159  const double * data_array,
4160  int start, int length );
4161 
4162 /// @brief Set attribute string data.
4163 ///
4164 /// @param[in] session
4165 /// The session of Houdini you are interacting with.
4166 /// See @ref HAPI_Sessions for more on sessions.
4167 /// Pass NULL to just use the default in-process session.
4168 ///
4169 /// @param[in] node_id
4170 /// The SOP node id.
4171 ///
4172 /// @param[in] part_id
4173 /// Currently not used. Just pass 0.
4174 ///
4175 /// @param[in] name
4176 /// Attribute name.
4177 ///
4178 /// @param[in] attr_info
4179 /// ::HAPI_AttributeInfo used as input for what tuple size.
4180 /// you want. Also contains some sanity checks like
4181 /// data type. Generally should be the same struct
4182 /// returned by ::HAPI_GetAttributeInfo().
4183 ///
4184 /// @param[out] data_array
4185 /// An ::HAPI_StringHandle array at least the size of
4186 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4187 ///
4188 /// @param[in] start
4189 /// First index of range. Must be at least 0 and at
4190 /// most ::HAPI_AttributeInfo::count - 1.
4191 ///
4192 /// @param[in] length
4193 /// Must be at least 0 and at most
4194 /// ::HAPI_AttributeInfo::count - @p start.
4195 ///
4197  HAPI_NodeId node_id,
4198  HAPI_PartId part_id,
4199  const char * name,
4200  const HAPI_AttributeInfo *attr_info,
4201  const char ** data_array,
4202  int start, int length );
4203 
4204 /// @brief Add a group to the input geo with the given type and name.
4205 ///
4206 /// @param[in] session
4207 /// The session of Houdini you are interacting with.
4208 /// See @ref HAPI_Sessions for more on sessions.
4209 /// Pass NULL to just use the default in-process session.
4210 ///
4211 /// @param[in] node_id
4212 /// The SOP node id.
4213 ///
4214 /// @param[in] part_id
4215 /// Currently not used. Just pass 0.
4216 ///
4217 /// @param[in] group_type
4218 /// The group type.
4219 ///
4220 /// @param[in] group_name
4221 /// Name of new group to be added.
4222 ///
4223 HAPI_DECL HAPI_AddGroup( const HAPI_Session * session,
4224  HAPI_NodeId node_id,
4225  HAPI_PartId part_id,
4226  HAPI_GroupType group_type,
4227  const char * group_name );
4228 
4229 /// @brief Set group membership.
4230 ///
4231 /// @param[in] session
4232 /// The session of Houdini you are interacting with.
4233 /// See @ref HAPI_Sessions for more on sessions.
4234 /// Pass NULL to just use the default in-process session.
4235 ///
4236 /// @param[in] node_id
4237 /// The SOP node id.
4238 ///
4239 /// @param[in] part_id
4240 /// Currently not used. Just pass 0.
4241 ///
4242 /// @param[in] group_type
4243 /// The group type.
4244 ///
4245 /// @param[in] group_name
4246 /// The group name.
4247 ///
4248 /// @param[in] membership_array
4249 /// Array of ints that represent the membership of this
4250 /// group. Should be the size given by
4251 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
4252 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
4253 ///
4254 /// @param[in] start
4255 /// Start offset into the membership array. Must be
4256 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
4257 ///
4258 /// @param[in] length
4259 /// Should be less than or equal to the size
4260 /// of @p membership.
4261 ///
4263  HAPI_NodeId node_id,
4264  HAPI_PartId part_id,
4265  HAPI_GroupType group_type,
4266  const char * group_name,
4267  const int * membership_array,
4268  int start, int length );
4269 
4270 /// @brief Commit the current input geometry to the cook engine. Nodes
4271 /// that use this geometry node will re-cook using the input
4272 /// geometry given through the geometry setter API calls.
4273 ///
4274 /// @param[in] session
4275 /// The session of Houdini you are interacting with.
4276 /// See @ref HAPI_Sessions for more on sessions.
4277 /// Pass NULL to just use the default in-process session.
4278 ///
4279 /// @param[in] node_id
4280 /// The SOP node id.
4281 ///
4282 HAPI_DECL HAPI_CommitGeo( const HAPI_Session * session,
4283  HAPI_NodeId node_id );
4284 
4285 /// @brief Remove all changes that have been committed to this
4286 /// geometry. If this is an intermediate result node (Edit SOP), all
4287 /// deltas will be removed. If it's any other type of node, the node
4288 /// will be unlocked if it is locked.
4289 ///
4290 /// @param[in] session
4291 /// The session of Houdini you are interacting with.
4292 /// See @ref HAPI_Sessions for more on sessions.
4293 /// Pass NULL to just use the default in-process session.
4294 ///
4295 /// @param[in] node_id
4296 /// The SOP node id.
4297 ///
4298 HAPI_DECL HAPI_RevertGeo( const HAPI_Session * session,
4299  HAPI_NodeId node_id );
4300 
4301 // MATERIALS ----------------------------------------------------------------
4302 
4303 /// @brief Get material ids by face/primitive. The material ids returned
4304 /// will be valid as long as the asset is alive. You should query
4305 /// this list after every cook to see if the material assignments
4306 /// have changed. You should also query each material individually
4307 /// using ::HAPI_GetMaterialInfo() to see if it is dirty and needs
4308 /// to be re-imported.
4309 ///
4310 /// @param[in] session
4311 /// The session of Houdini you are interacting with.
4312 /// See @ref HAPI_Sessions for more on sessions.
4313 /// Pass NULL to just use the default in-process session.
4314 ///
4315 /// @param[in] geometry_node_id
4316 /// The geometry node id.
4317 ///
4318 /// @param[in] part_id
4319 /// The part id.
4320 ///
4321 /// @param[out] are_all_the_same
4322 /// (optional) If true, all faces on this part have the
4323 /// same material assignment. You can pass NULL here.
4324 ///
4325 /// @param[out] material_ids_array
4326 /// An array of ::HAPI_NodeId at least the size of
4327 /// @p length and at most the size of
4328 /// ::HAPI_PartInfo::faceCount.
4329 ///
4330 /// @param[in] start
4331 /// The starting index into the list of faces from which
4332 /// you wish to get the material ids from. Note that
4333 /// this should be less than ::HAPI_PartInfo::faceCount.
4334 ///
4335 /// @param[in] length
4336 /// The number of material ids you wish to get. Note that
4337 /// this should be at most:
4338 /// ::HAPI_PartInfo::faceCount - @p start.
4339 ///
4341  HAPI_NodeId geometry_node_id,
4342  HAPI_PartId part_id,
4343  HAPI_Bool * are_all_the_same,
4344  HAPI_NodeId * material_ids_array,
4345  int start, int length );
4346 
4347 /// @brief Get the material info.
4348 ///
4349 /// @param[in] session
4350 /// The session of Houdini you are interacting with.
4351 /// See @ref HAPI_Sessions for more on sessions.
4352 /// Pass NULL to just use the default in-process session.
4353 ///
4354 /// @param[in] material_node_id
4355 /// The material node id.
4356 ///
4357 /// @param[out] material_info
4358 /// The returned material info.
4359 ///
4361  HAPI_NodeId material_node_id,
4362  HAPI_MaterialInfo * material_info );
4363 
4364 /// @brief Render a single texture from a COP to an image for
4365 /// later extraction.
4366 ///
4367 /// Note that you must call this first for any of the other material
4368 /// APIs to work.
4369 ///
4370 /// @param[in] session
4371 /// The session of Houdini you are interacting with.
4372 /// See @ref HAPI_Sessions for more on sessions.
4373 /// Pass NULL to just use the default in-process session.
4374 ///
4375 /// @param[in] cop_node_id
4376 /// The COP node id.
4377 ///
4379  HAPI_NodeId cop_node_id );
4380 
4381 /// @brief Render only a single texture to an image for later extraction.
4382 /// An example use of this method might be to render the diffuse,
4383 /// normal, and bump texture maps of a material to individual
4384 /// texture files for use within the client application.
4385 ///
4386 /// Note that you must call this first for any of the other material
4387 /// APIs to work.
4388 ///
4389 /// @param[in] session
4390 /// The session of Houdini you are interacting with.
4391 /// See @ref HAPI_Sessions for more on sessions.
4392 /// Pass NULL to just use the default in-process session.
4393 ///
4394 /// @param[in] material_node_id
4395 /// The material node id.
4396 ///
4397 /// @param[in] parm_id
4398 /// This is the index in the parameter list of the
4399 /// material_id's node of the parameter containing the
4400 /// texture map file path.
4401 ///
4403  HAPI_NodeId material_node_id,
4404  HAPI_ParmId parm_id );
4405 
4406 /// @brief Get information about the image that was just rendered, like
4407 /// resolution and default file format. This information will be
4408 /// used when extracting planes to an image.
4409 ///
4410 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4411 /// this method call to make sense.
4412 ///
4413 /// @param[in] session
4414 /// The session of Houdini you are interacting with.
4415 /// See @ref HAPI_Sessions for more on sessions.
4416 /// Pass NULL to just use the default in-process session.
4417 ///
4418 /// @param[in] material_node_id
4419 /// The material node id.
4420 ///
4421 /// @param[out] image_info
4422 /// The struct containing the image information.
4423 ///
4424 HAPI_DECL HAPI_GetImageInfo( const HAPI_Session * session,
4425  HAPI_NodeId material_node_id,
4426  HAPI_ImageInfo * image_info );
4427 
4428 /// @brief Set image information like resolution and file format.
4429 /// This information will be used when extracting planes to
4430 /// an image.
4431 ///
4432 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4433 /// this method call to make sense.
4434 ///
4435 /// You should also first call ::HAPI_GetImageInfo() to get the
4436 /// current Image Info and change only the properties
4437 /// you don't like.
4438 ///
4439 /// @param[in] session
4440 /// The session of Houdini you are interacting with.
4441 /// See @ref HAPI_Sessions for more on sessions.
4442 /// Pass NULL to just use the default in-process session.
4443 ///
4444 /// @param[in] material_node_id
4445 /// The material node id.
4446 ///
4447 /// @param[in] image_info
4448 /// The struct containing the new image information.
4449 ///
4450 HAPI_DECL HAPI_SetImageInfo( const HAPI_Session * session,
4451  HAPI_NodeId material_node_id,
4452  const HAPI_ImageInfo * image_info );
4453 
4454 /// @brief Get the number of image planes for the just rendered image.
4455 ///
4456 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4457 /// this method call to make sense.
4458 ///
4459 /// @param[in] session
4460 /// The session of Houdini you are interacting with.
4461 /// See @ref HAPI_Sessions for more on sessions.
4462 /// Pass NULL to just use the default in-process session.
4463 ///
4464 /// @param[in] material_node_id
4465 /// The material node id.
4466 ///
4467 /// @param[out] image_plane_count
4468 /// The number of image planes.
4469 ///
4471  HAPI_NodeId material_node_id,
4472  int * image_plane_count );
4473 
4474 /// @brief Get the names of the image planes of the just rendered image.
4475 ///
4476 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4477 /// this method call to make sense.
4478 ///
4479 /// You should also call ::HAPI_GetImagePlaneCount() first to get
4480 /// the total number of image planes so you know how large the
4481 /// image_planes string handle array should be.
4482 ///
4483 /// @param[in] session
4484 /// The session of Houdini you are interacting with.
4485 /// See @ref HAPI_Sessions for more on sessions.
4486 /// Pass NULL to just use the default in-process session.
4487 ///
4488 /// @param[in] material_node_id
4489 /// The material node id.
4490 ///
4491 /// @param[out] image_planes_array
4492 /// The image plane names.
4493 ///
4494 /// @param[in] image_plane_count
4495 /// The number of image planes to get names for. This
4496 /// must be less than or equal to the count returned
4497 /// by ::HAPI_GetImagePlaneCount().
4498 ///
4499 HAPI_DECL HAPI_GetImagePlanes( const HAPI_Session * session,
4500  HAPI_NodeId material_node_id,
4501  HAPI_StringHandle * image_planes_array,
4502  int image_plane_count );
4503 
4504 /// @brief Extract a rendered image to a file.
4505 ///
4506 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4507 /// this method call to make sense.
4508 ///
4509 /// @param[in] session
4510 /// The session of Houdini you are interacting with.
4511 /// See @ref HAPI_Sessions for more on sessions.
4512 /// Pass NULL to just use the default in-process session.
4513 ///
4514 /// @param[in] material_node_id
4515 /// The material node id.
4516 ///
4517 /// @param[in] image_file_format_name
4518 /// The image file format name you wish the image to be
4519 /// extracted as. You can leave this parameter NULL to
4520 /// get the image in the original format if it comes from
4521 /// another texture file or in the default HAPI format,
4522 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
4523 /// is generated.
4524 ///
4525 /// You can get some of the very common standard image
4526 /// file format names from HAPI_Common.h under the
4527 /// "Defines" section.
4528 ///
4529 /// You can also get a list of all supported file formats
4530 /// (and the exact names this parameter expects)
4531 /// by using ::HAPI_GetSupportedImageFileFormats(). This
4532 /// list will include custom file formats you created via
4533 /// custom DSOs (see HDK docs about IMG_Format). You will
4534 /// get back a list of ::HAPI_ImageFileFormat. This
4535 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
4536 /// of a given image file format.
4537 ///
4538 /// @param[in] image_planes
4539 /// The image planes you wish to extract into the file.
4540 /// Multiple image planes should be separated by spaces.
4541 ///
4542 /// @param[in] destination_folder_path
4543 /// The folder where the image file should be created.
4544 ///
4545 /// @param[in] destination_file_name
4546 /// Optional parameter to overwrite the name of the
4547 /// extracted texture file. This should NOT include
4548 /// the extension as the file type will be decided
4549 /// by the ::HAPI_ImageInfo you can set using
4550 /// ::HAPI_SetImageInfo(). You still have to use
4551 /// destination_file_path to get the final file path.
4552 ///
4553 /// Pass in NULL to have the file name be automatically
4554 /// generated from the name of the material SHOP node,
4555 /// the name of the texture map parameter if the
4556 /// image was rendered from a texture, and the image
4557 /// plane names specified.
4558 ///
4559 /// @param[out] destination_file_path
4560 /// The full path string handle, including the
4561 /// destination_folder_path and the texture file name,
4562 /// to the extracted file. Note that this string handle
4563 /// will only be valid until the next call to
4564 /// this function.
4565 ///
4567  HAPI_NodeId material_node_id,
4568  const char * image_file_format_name,
4569  const char * image_planes,
4570  const char * destination_folder_path,
4571  const char * destination_file_name,
4572  int * destination_file_path );
4573 
4574 /// @brief Extract a rendered image to memory.
4575 ///
4576 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4577 /// this method call to make sense.
4578 ///
4579 /// Also note that this function will do all the work of
4580 /// extracting and compositing the image into a memory buffer
4581 /// but will not return to you that buffer, only its size. Use
4582 /// the returned size to allocated a sufficiently large buffer
4583 /// and call ::HAPI_GetImageMemoryBuffer() to fill your buffer
4584 /// with the just extracted image.
4585 ///
4586 /// @param[in] session
4587 /// The session of Houdini you are interacting with.
4588 /// See @ref HAPI_Sessions for more on sessions.
4589 /// Pass NULL to just use the default in-process session.
4590 ///
4591 /// @param[in] material_node_id
4592 /// The material node id.
4593 ///
4594 /// @param[in] image_file_format_name
4595 /// The image file format name you wish the image to be
4596 /// extracted as. You can leave this parameter NULL to
4597 /// get the image in the original format if it comes from
4598 /// another texture file or in the default HAPI format,
4599 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
4600 /// is generated.
4601 ///
4602 /// You can get some of the very common standard image
4603 /// file format names from HAPI_Common.h under the
4604 /// "Defines" section.
4605 ///
4606 /// You can also get a list of all supported file formats
4607 /// (and the exact names this parameter expects)
4608 /// by using ::HAPI_GetSupportedImageFileFormats(). This
4609 /// list will include custom file formats you created via
4610 /// custom DSOs (see HDK docs about IMG_Format). You will
4611 /// get back a list of ::HAPI_ImageFileFormat. This
4612 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
4613 /// of a given image file format.
4614 ///
4615 /// @param[in] image_planes
4616 /// The image planes you wish to extract into the file.
4617 /// Multiple image planes should be separated by spaces.
4618 ///
4619 /// @param[out] buffer_size
4620 /// The extraction will be done to an internal buffer
4621 /// who's size you get via this parameter. Use the
4622 /// returned buffer_size when calling
4623 /// ::HAPI_GetImageMemoryBuffer() to get the image
4624 /// buffer you just extracted.
4625 ///
4627  HAPI_NodeId material_node_id,
4628  const char * image_file_format_name,
4629  const char * image_planes,
4630  int * buffer_size );
4631 
4632 /// @brief Fill your allocated buffer with the just extracted
4633 /// image buffer.
4634 ///
4635 /// Note that you must call ::HAPI_RenderTextureToImage() first for
4636 /// this method call to make sense.
4637 ///
4638 /// Also note that you must call ::HAPI_ExtractImageToMemory()
4639 /// first in order to perform the extraction and get the
4640 /// extracted image buffer size that you need to know how much
4641 /// memory to allocated to fit your extracted image.
4642 ///
4643 /// @param[in] session
4644 /// The session of Houdini you are interacting with.
4645 /// See @ref HAPI_Sessions for more on sessions.
4646 /// Pass NULL to just use the default in-process session.
4647 ///
4648 /// @param[in] material_node_id
4649 /// The material node id.
4650 ///
4651 /// @param[out] buffer
4652 /// The buffer passed in here will be filled with the
4653 /// image buffer created during the call to
4654 /// ::HAPI_ExtractImageToMemory().
4655 ///
4656 /// @param[in] length
4657 /// Sanity check. This size should be the same as the
4658 /// size allocated for the buffer passed in and should
4659 /// be at least as large as the buffer_size returned by
4660 /// the call to ::HAPI_ExtractImageToMemory().
4661 ///
4663  HAPI_NodeId material_node_id,
4664  char * buffer, int length );
4665 
4666 /// @brief Get the number of supported texture file formats.
4667 ///
4668 /// @param[in] session
4669 /// The session of Houdini you are interacting with.
4670 /// See @ref HAPI_Sessions for more on sessions.
4671 /// Pass NULL to just use the default in-process session.
4672 ///
4673 /// @param[out] file_format_count
4674 /// The number of supported texture file formats.
4675 ///
4677  int * file_format_count );
4678 
4679 /// @brief Get a list of support image file formats - their names,
4680 /// descriptions and a list of recognized extensions.
4681 ///
4682 /// Note that you MUST call
4683 /// ::HAPI_GetSupportedImageFileFormatCount()
4684 /// before calling this function for the first time.
4685 ///
4686 /// @param[in] session
4687 /// The session of Houdini you are interacting with.
4688 /// See @ref HAPI_Sessions for more on sessions.
4689 /// Pass NULL to just use the default in-process session.
4690 ///
4691 /// @param[out] formats_array
4692 /// The list of ::HAPI_ImageFileFormat structs to
4693 /// be filled.
4694 ///
4695 /// @param[in] file_format_count
4696 /// The number of supported texture file formats. This
4697 /// should be at least as large as the count returned
4698 /// by ::HAPI_GetSupportedImageFileFormatCount().
4699 ///
4701  const HAPI_Session * session,
4702  HAPI_ImageFileFormat * formats_array,
4703  int file_format_count );
4704 
4705 // SIMULATION/ANIMATION -----------------------------------------------------
4706 
4707 /// @brief Set an animation curve on a parameter of an exposed node.
4708 ///
4709 /// @param[in] session
4710 /// The session of Houdini you are interacting with.
4711 /// See @ref HAPI_Sessions for more on sessions.
4712 /// Pass NULL to just use the default in-process session.
4713 ///
4714 /// @param[in] node_id
4715 /// The exposed node id.
4716 ///
4717 /// @param[in] parm_id
4718 /// The id of an exposed parameter within the node.
4719 /// @param[in] parm_index
4720 /// The index of the parameter, if it is for example
4721 /// a 3 tuple
4722 ///
4723 /// @param[in] curve_keyframes_array
4724 /// An array of ::HAPI_Keyframe structs that describes
4725 /// the keys on this curve.
4726 ///
4727 /// @param[in] keyframe_count
4728 /// The number of keys on the curve.
4729 ///
4730 HAPI_DECL HAPI_SetAnimCurve( const HAPI_Session * session,
4731  HAPI_NodeId node_id, HAPI_ParmId parm_id,
4732  int parm_index,
4733  const HAPI_Keyframe * curve_keyframes_array,
4734  int keyframe_count );
4735 
4736 /// @brief A specialized convenience function to set the T,R,S values
4737 /// on an exposed node.
4738 ///
4739 /// @param[in] session
4740 /// The session of Houdini you are interacting with.
4741 /// See @ref HAPI_Sessions for more on sessions.
4742 /// Pass NULL to just use the default in-process session.
4743 ///
4744 /// @param[in] node_id
4745 /// The exposed node id.
4746 ///
4747 /// @param[in] trans_comp
4748 /// A value of ::HAPI_TransformComponent that
4749 /// identifies the particular component of the
4750 /// transform to attach the curve to, for example
4751 /// ::HAPI_TRANSFORM_TX.
4752 ///
4753 /// @param[in] curve_keyframes_array
4754 /// An array of ::HAPI_Keyframe structs that describes
4755 /// the keys on this curve.
4756 ///
4757 /// @param[in] keyframe_count
4758 /// The number of keys on the curve.
4759 ///
4761  const HAPI_Session * session,
4762  HAPI_NodeId node_id,
4763  HAPI_TransformComponent trans_comp,
4764  const HAPI_Keyframe * curve_keyframes_array,
4765  int keyframe_count );
4766 
4767 /// @brief Resets the simulation cache of the asset. This is very useful
4768 /// for assets that use dynamics, to be called after some
4769 /// setup has changed for the asset - for example, asset inputs
4770 ///
4771 /// @param[in] session
4772 /// The session of Houdini you are interacting with.
4773 /// See @ref HAPI_Sessions for more on sessions.
4774 /// Pass NULL to just use the default in-process session.
4775 ///
4776 /// @param[in] node_id
4777 /// The asset node id.
4778 ///
4780  HAPI_NodeId node_id );
4781 
4782 // VOLUMES ------------------------------------------------------------------
4783 
4784 /// @brief Retrieve any meta-data about the volume primitive, including
4785 /// its transform, location, scale, taper, resolution.
4786 ///
4787 /// @param[in] session
4788 /// The session of Houdini you are interacting with.
4789 /// See @ref HAPI_Sessions for more on sessions.
4790 /// Pass NULL to just use the default in-process session.
4791 ///
4792 /// @param[in] node_id
4793 /// The node id.
4794 ///
4795 /// @param[in] part_id
4796 /// The part id.
4797 ///
4798 /// @param[out] volume_info
4799 /// The meta-data associated with the volume on the
4800 /// part specified by the previous parameters.
4801 ///
4802 HAPI_DECL HAPI_GetVolumeInfo( const HAPI_Session * session,
4803  HAPI_NodeId node_id,
4804  HAPI_PartId part_id,
4805  HAPI_VolumeInfo * volume_info );
4806 
4807 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
4808 /// Start iterating through the value of the volume at part_id.
4809 ///
4810 /// @param[in] session
4811 /// The session of Houdini you are interacting with.
4812 /// See @ref HAPI_Sessions for more on sessions.
4813 /// Pass NULL to just use the default in-process session.
4814 ///
4815 /// @param[in] node_id
4816 /// The node id.
4817 ///
4818 /// @param[in] part_id
4819 /// The part id.
4820 ///
4821 /// @param[out] tile
4822 /// The tile info referring to the first tile in the
4823 /// volume at part_id.
4824 ///
4826  HAPI_NodeId node_id,
4827  HAPI_PartId part_id,
4828  HAPI_VolumeTileInfo * tile );
4829 
4830 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
4831 /// Continue iterating through the value of the volume at part_id.
4832 ///
4833 /// @param[in] session
4834 /// The session of Houdini you are interacting with.
4835 /// See @ref HAPI_Sessions for more on sessions.
4836 /// Pass NULL to just use the default in-process session.
4837 ///
4838 /// @param[in] node_id
4839 /// The node id.
4840 ///
4841 /// @param[in] part_id
4842 /// The part id.
4843 ///
4844 /// @param[out] tile
4845 /// The tile info referring to the next tile in the
4846 /// set of tiles associated with the volume at this part.
4847 ///
4849  HAPI_NodeId node_id,
4850  HAPI_PartId part_id,
4851  HAPI_VolumeTileInfo * tile );
4852 
4853 /// @brief Retrieve floating point values of the voxel at a specific
4854 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
4855 /// to this call.
4856 ///
4857 /// @param[in] session
4858 /// The session of Houdini you are interacting with.
4859 /// See @ref HAPI_Sessions for more on sessions.
4860 /// Pass NULL to just use the default in-process session.
4861 ///
4862 /// @param[in] node_id
4863 /// The node id.
4864 ///
4865 /// @param[in] part_id
4866 /// The part id.
4867 ///
4868 /// @param[in] x_index
4869 /// The x index/coordinate of the voxel.
4870 ///
4871 /// @param[in] y_index
4872 /// The y index/coordinate of the voxel.
4873 ///
4874 /// @param[in] z_index
4875 /// The z index/coordinate of the voxel.
4876 ///
4877 /// @param[out] values_array
4878 /// The values of the voxel.
4879 ///
4880 /// @param[in] value_count
4881 /// Should be equal to the volume's
4882 /// ::HAPI_VolumeInfo::tupleSize.
4883 ///
4885  HAPI_NodeId node_id,
4886  HAPI_PartId part_id,
4887  int x_index,
4888  int y_index,
4889  int z_index,
4890  float * values_array,
4891  int value_count );
4892 
4893 /// @brief Retrieve floating point values of the voxels pointed to
4894 /// by a tile. Note that a tile may extend beyond the limits
4895 /// of the volume so not all values in the given buffer will
4896 /// be written to. Voxels outside the volume will be initialized
4897 /// to the given fill value.
4898 ///
4899 /// @param[in] session
4900 /// The session of Houdini you are interacting with.
4901 /// See @ref HAPI_Sessions for more on sessions.
4902 /// Pass NULL to just use the default in-process session.
4903 ///
4904 /// @param[in] node_id
4905 /// The node id.
4906 ///
4907 /// @param[in] part_id
4908 /// The part id.
4909 ///
4910 /// @param[in] fill_value
4911 /// Value that will be used to fill the @p values_array.
4912 /// This is useful so that you can see what values
4913 /// have actually been written to.
4914 ///
4915 /// @param[in] tile
4916 /// The tile to retrieve.
4917 ///
4918 /// @param[out] values_array
4919 /// The values of the tile.
4920 ///
4921 /// @param[in] length
4922 /// The length should be ( 8 ^ 3 ) * tupleSize.
4923 ///
4925  HAPI_NodeId node_id,
4926  HAPI_PartId part_id,
4927  float fill_value,
4928  const HAPI_VolumeTileInfo * tile,
4929  float * values_array,
4930  int length );
4931 
4932 /// @brief Retrieve integer point values of the voxel at a specific
4933 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
4934 /// to this call.
4935 ///
4936 /// @param[in] session
4937 /// The session of Houdini you are interacting with.
4938 /// See @ref HAPI_Sessions for more on sessions.
4939 /// Pass NULL to just use the default in-process session.
4940 ///
4941 /// @param[in] node_id
4942 /// The node id.
4943 ///
4944 /// @param[in] part_id
4945 /// The part id.
4946 ///
4947 /// @param[in] x_index
4948 /// The x index/coordinate of the voxel.
4949 ///
4950 /// @param[in] y_index
4951 /// The y index/coordinate of the voxel.
4952 ///
4953 /// @param[in] z_index
4954 /// The z index/coordinate of the voxel.
4955 ///
4956 /// @param[out] values_array
4957 /// The values of the voxel.
4958 ///
4959 /// @param[in] value_count
4960 /// Should be equal to the volume's
4961 /// ::HAPI_VolumeInfo::tupleSize.
4962 ///
4964  HAPI_NodeId node_id,
4965  HAPI_PartId part_id,
4966  int x_index,
4967  int y_index,
4968  int z_index,
4969  int * values_array,
4970  int value_count );
4971 
4972 /// @brief Retrieve integer point values of the voxels pointed to
4973 /// by a tile. Note that a tile may extend beyond the limits
4974 /// of the volume so not all values in the given buffer will
4975 /// be written to. Voxels outside the volume will be initialized
4976 /// to the given fill value.
4977 ///
4978 /// @param[in] session
4979 /// The session of Houdini you are interacting with.
4980 /// See @ref HAPI_Sessions for more on sessions.
4981 /// Pass NULL to just use the default in-process session.
4982 ///
4983 /// @param[in] node_id
4984 /// The node id.
4985 ///
4986 /// @param[in] part_id
4987 /// The part id.
4988 ///
4989 /// @param[in] fill_value
4990 /// Value that will be used to fill the @p values_array.
4991 /// This is useful so that you can see what values
4992 /// have actually been written to.
4993 ///
4994 /// @param[in] tile
4995 /// The tile to retrieve.
4996 ///
4997 /// @param[out] values_array
4998 /// The values of the tile.
4999 ///
5000 /// @param[in] length
5001 /// The length should be ( 8 ^ 3 ) * tupleSize.
5002 ///
5004  HAPI_NodeId node_id,
5005  HAPI_PartId part_id,
5006  int fill_value,
5007  const HAPI_VolumeTileInfo * tile,
5008  int * values_array,
5009  int length );
5010 
5011 /// @brief Get the height field data for a terrain volume as a flattened
5012 /// 2D array of float heights. Should call ::HAPI_GetVolumeInfo()
5013 /// first to make sure the volume info is initialized.
5014 ///
5015 /// @param[in] session
5016 /// The session of Houdini you are interacting with.
5017 /// See @ref HAPI_Sessions for more on sessions.
5018 /// Pass NULL to just use the default in-process session.
5019 ///
5020 /// @param[in] node_id
5021 /// The node id.
5022 ///
5023 /// @param[in] part_id
5024 /// The part id.
5025 ///
5026 /// @param[out] values_array
5027 /// Heightfield flattened array. Should be at least the size of
5028 /// @p start + @p length.
5029 ///
5030 /// @param[in] start
5031 /// The start at least 0 and at most
5032 /// ( ::HAPI_VolumeInfo.xLength * ::HAPI_VolumeInfo::yLength )
5033 /// - @p length.
5034 ///
5035 /// @param[in] length
5036 /// The length should be at least 1 or at most
5037 /// ( ::HAPI_VolumeInfo.xLength * ::HAPI_VolumeInfo::yLength )
5038 /// - @p start.
5039 ///
5041  HAPI_NodeId node_id,
5042  HAPI_PartId part_id,
5043  float * values_array,
5044  int start, int length );
5045 
5046 /// @brief Set the volume info of a geo on a geo input.
5047 ///
5048 /// @param[in] session
5049 /// The session of Houdini you are interacting with.
5050 /// See @ref HAPI_Sessions for more on sessions.
5051 /// Pass NULL to just use the default in-process session.
5052 ///
5053 /// @param[in] node_id
5054 /// The node id.
5055 ///
5056 /// @param[in] part_id
5057 /// The part id.
5058 ///
5059 /// @param[in] volume_info
5060 /// All volume information that can be specified per
5061 /// volume. This includes the position, orientation, scale,
5062 /// data format, tuple size, and taper. The tile size is
5063 /// always 8x8x8.
5064 ///
5065 HAPI_DECL HAPI_SetVolumeInfo( const HAPI_Session * session,
5066  HAPI_NodeId node_id,
5067  HAPI_PartId part_id,
5068  const HAPI_VolumeInfo * volume_info );
5069 
5070 /// @brief Set the values of a float tile: this is an 8x8x8 subsection of
5071 /// the volume.
5072 ///
5073 /// @param[in] session
5074 /// The session of Houdini you are interacting with.
5075 /// See @ref HAPI_Sessions for more on sessions.
5076 /// Pass NULL to just use the default in-process session.
5077 ///
5078 /// @param[in] node_id
5079 /// The node id.
5080 ///
5081 /// @param[in] part_id
5082 /// The part id.
5083 ///
5084 /// @param[in] tile
5085 /// The tile that the volume will be input into.
5086 ///
5087 /// @param[in] values_array
5088 /// The values of the individual voxel tiles in the
5089 /// volume. The length of this array should
5090 /// be ( 8 ^ 3 ) * tupleSize.
5091 ///
5092 /// @param[in] length
5093 /// The length should be ( 8 ^ 3 ) * tupleSize.
5094 ///
5096  HAPI_NodeId node_id,
5097  HAPI_PartId part_id,
5098  const HAPI_VolumeTileInfo * tile,
5099  const float * values_array,
5100  int length );
5101 
5102 /// @brief Set the values of an int tile: this is an 8x8x8 subsection of
5103 /// the volume.
5104 ///
5105 /// @param[in] session
5106 /// The session of Houdini you are interacting with.
5107 /// See @ref HAPI_Sessions for more on sessions.
5108 /// Pass NULL to just use the default in-process session.
5109 ///
5110 /// @param[in] node_id
5111 /// The node id.
5112 ///
5113 /// @param[in] part_id
5114 /// The part id.
5115 ///
5116 /// @param[in] tile
5117 /// The tile that the volume will be input into.
5118 ///
5119 /// @param[in] values_array
5120 /// The values of the individual voxel tiles in the
5121 /// volume. The length of this array should
5122 /// be ( 8 ^ 3 ) * tupleSize.
5123 ///
5124 /// @param[in] length
5125 /// The length should be ( 8 ^ 3 ) * tupleSize.
5126 ///
5128  HAPI_NodeId node_id,
5129  HAPI_PartId part_id,
5130  const HAPI_VolumeTileInfo * tile,
5131  const int * values_array,
5132  int length );
5133 
5134 /// @brief Set the values of a float voxel in the volume.
5135 ///
5136 /// @param[in] session
5137 /// The session of Houdini you are interacting with.
5138 /// See @ref HAPI_Sessions for more on sessions.
5139 /// Pass NULL to just use the default in-process session.
5140 ///
5141 /// @param[in] node_id
5142 /// The node id.
5143 ///
5144 /// @param[in] part_id
5145 /// The part id.
5146 ///
5147 /// @param[in] x_index
5148 /// The x index/coordinate of the voxel.
5149 ///
5150 /// @param[in] y_index
5151 /// The y index/coordinate of the voxel.
5152 ///
5153 /// @param[in] z_index
5154 /// The z index/coordinate of the voxel.
5155 ///
5156 /// @param[in] values_array
5157 /// The values of the voxel.
5158 ///
5159 /// @param[in] value_count
5160 /// Should be equal to the volume's
5161 /// ::HAPI_VolumeInfo::tupleSize.
5162 ///
5164  HAPI_NodeId node_id,
5165  HAPI_PartId part_id,
5166  int x_index,
5167  int y_index,
5168  int z_index,
5169  const float * values_array,
5170  int value_count );
5171 
5172 /// @brief Set the values of a integer voxel in the volume.
5173 ///
5174 /// @param[in] session
5175 /// The session of Houdini you are interacting with.
5176 /// See @ref HAPI_Sessions for more on sessions.
5177 /// Pass NULL to just use the default in-process session.
5178 ///
5179 /// @param[in] node_id
5180 /// The node id.
5181 ///
5182 /// @param[in] part_id
5183 /// The part id.
5184 ///
5185 /// @param[in] x_index
5186 /// The x index/coordinate of the voxel.
5187 ///
5188 /// @param[in] y_index
5189 /// The y index/coordinate of the voxel.
5190 ///
5191 /// @param[in] z_index
5192 /// The z index/coordinate of the voxel.
5193 ///
5194 /// @param[in] values_array
5195 /// The values of the voxel.
5196 ///
5197 /// @param[in] value_count
5198 /// Should be equal to the volume's
5199 /// ::HAPI_VolumeInfo::tupleSize.
5200 ///
5202  HAPI_NodeId node_id,
5203  HAPI_PartId part_id,
5204  int x_index,
5205  int y_index,
5206  int z_index,
5207  const int * values_array,
5208  int value_count );
5209 
5210 /// @brief Get the bounding values of a volume.
5211 ///
5212 /// @param[in] session
5213 /// The session of Houdini you are interacting with.
5214 /// See @ref HAPI_Sessions for more on sessions.
5215 /// Pass NULL to just use the default in-process session.
5216 ///
5217 /// @param[in] node_id
5218 /// The node id.
5219 ///
5220 /// @param[in] part_id
5221 /// The part id.
5222 ///
5223 /// @param[out] x_min
5224 /// The minimum x value of the volume's bounding box.
5225 /// Can be null if you do not want this value.
5226 ///
5227 /// @param[out] y_min
5228 /// The minimum y value of the volume's bounding box.
5229 /// Can be null if you do not want this value.
5230 ///
5231 /// @param[out] z_min
5232 /// The minimum z value of the volume's bounding box.
5233 /// Can be null if you do not want this value.
5234 ///
5235 /// @param[out] x_max
5236 /// The maximum x value of the volume's bounding box.
5237 /// Can be null if you do not want this value.
5238 ///
5239 /// @param[out] y_max
5240 /// The maximum y value of the volume's bounding box.
5241 /// Can be null if you do not want this value.
5242 ///
5243 /// @param[out] z_max
5244 /// The maximum z value of the volume's bounding box.
5245 /// Can be null if you do not want this value.
5246 ///
5247 /// @param[out] x_center
5248 /// The x value of the volume's bounding box center.
5249 /// Can be null if you do not want this value.
5250 ///
5251 /// @param[out] y_center
5252 /// The y value of the volume's bounding box center.
5253 /// Can be null if you do not want this value.
5254 ///
5255 /// @param[out] z_center
5256 /// The z value of the volume's bounding box center.
5257 /// Can be null if you do not want this value.
5258 ///
5260  HAPI_NodeId node_id,
5261  HAPI_PartId part_id,
5262  float * x_min, float * y_min, float * z_min,
5263  float * x_max, float * y_max, float * z_max,
5264  float * x_center, float * y_center, float * z_center );
5265 
5266 /// @brief Set the height field data for a terrain volume with the values from
5267 /// a flattened 2D array of float.
5268 /// ::HAPI_SetVolumeInfo() should be called first to make sure that the
5269 /// volume and its info are initialized.
5270 ///
5271 /// @param[in] session
5272 /// The session of Houdini you are interacting with.
5273 /// See @ref HAPI_Sessions for more on sessions.
5274 /// Pass NULL to just use the default in-process session.
5275 ///
5276 /// @param[in] node_id
5277 /// The node id.
5278 ///
5279 /// @param[in] part_id
5280 /// The part id.
5281 ///
5282 /// @param[in] values_array
5283 /// Heightfield flattened array. Should be at least the size of
5284 /// @p start + @p length.
5285 ///
5286 /// @param[in] start
5287 /// The start at least 0 and at most
5288 /// ( ::HAPI_VolumeInfo.xLength * ::HAPI_VolumeInfo::yLength )
5289 /// - @p length.
5290 ///
5291 /// @param[in] length
5292 /// The length should be at least 1 or at most
5293 /// ( ::HAPI_VolumeInfo.xLength * ::HAPI_VolumeInfo::yLength )
5294 /// - @p start.
5295 ///
5296 /// @param[in] name
5297 /// The name of the volume used for the heightfield.
5298 /// If set to "height" the values will be used for height information,
5299 /// if not, the data will used as a mask.
5300 ///
5302  HAPI_NodeId node_id,
5303  HAPI_PartId part_id,
5304  const char * name,
5305  const float * values_array,
5306  int start, int length );
5307 
5308 // CURVES -------------------------------------------------------------------
5309 
5310 /// @brief Retrieve any meta-data about the curves, including the
5311 /// curve's type, order, and periodicity.
5312 ///
5313 /// @param[in] session
5314 /// The session of Houdini you are interacting with.
5315 /// See @ref HAPI_Sessions for more on sessions.
5316 /// Pass NULL to just use the default in-process session.
5317 ///
5318 /// @param[in] node_id
5319 /// The node id.
5320 ///
5321 /// @param[in] part_id
5322 /// The part id.
5323 ///
5324 /// @param[out] info
5325 /// The curve info represents the meta-data about
5326 /// the curves, including the type, order,
5327 /// and periodicity.
5328 ///
5329 HAPI_DECL HAPI_GetCurveInfo( const HAPI_Session * session,
5330  HAPI_NodeId node_id,
5331  HAPI_PartId part_id,
5332  HAPI_CurveInfo * info );
5333 
5334 /// @brief Retrieve the number of vertices for each curve in the part.
5335 ///
5336 /// @param[in] session
5337 /// The session of Houdini you are interacting with.
5338 /// See @ref HAPI_Sessions for more on sessions.
5339 /// Pass NULL to just use the default in-process session.
5340 ///
5341 /// @param[in] node_id
5342 /// The node id.
5343 ///
5344 /// @param[in] part_id
5345 /// The part id.
5346 ///
5347 /// @param[out] counts_array
5348 /// The number of cvs each curve contains
5349 ///
5350 /// @param[in] start
5351 /// The index of the first curve.
5352 ///
5353 /// @param[in] length
5354 /// The number of curves' counts to retrieve.
5355 ///
5356 HAPI_DECL HAPI_GetCurveCounts( const HAPI_Session * session,
5357  HAPI_NodeId node_id,
5358  HAPI_PartId part_id,
5359  int * counts_array,
5360  int start, int length );
5361 
5362 /// @brief Retrieve the orders for each curve in the part if the
5363 /// curve has varying order.
5364 ///
5365 /// @param[in] session
5366 /// The session of Houdini you are interacting with.
5367 /// See @ref HAPI_Sessions for more on sessions.
5368 /// Pass NULL to just use the default in-process session.
5369 ///
5370 /// @param[in] node_id
5371 /// The node id.
5372 ///
5373 /// @param[in] part_id
5374 /// The part id.
5375 ///
5376 /// @param[out] orders_array
5377 /// The order of each curve will be returned in this
5378 /// array.
5379 ///
5380 /// @param[in] start
5381 /// The index of the first curve.
5382 ///
5383 /// @param[in] length
5384 /// The number of curves' orders to retrieve.
5385 ///
5386 HAPI_DECL HAPI_GetCurveOrders( const HAPI_Session * session,
5387  HAPI_NodeId node_id,
5388  HAPI_PartId part_id,
5389  int * orders_array,
5390  int start, int length );
5391 
5392 /// @brief Retrieve the knots of the curves in this part.
5393 ///
5394 /// @param[in] session
5395 /// The session of Houdini you are interacting with.
5396 /// See @ref HAPI_Sessions for more on sessions.
5397 /// Pass NULL to just use the default in-process session.
5398 ///
5399 /// @param[in] node_id
5400 /// The node id.
5401 ///
5402 /// @param[in] part_id
5403 /// The part id.
5404 ///
5405 /// @param[out] knots_array
5406 /// The knots of each curve will be returned in this
5407 /// array.
5408 ///
5409 /// @param[in] start
5410 /// The index of the first curve.
5411 ///
5412 /// @param[in] length
5413 /// The number of curves' knots to retrieve. The
5414 /// length of all the knots on a single curve is
5415 /// the order of that curve plus the number of
5416 /// vertices (see ::HAPI_GetCurveOrders(),
5417 /// and ::HAPI_GetCurveCounts()).
5418 ///
5419 HAPI_DECL HAPI_GetCurveKnots( const HAPI_Session * session,
5420  HAPI_NodeId node_id,
5421  HAPI_PartId part_id,
5422  float * knots_array,
5423  int start, int length );
5424 
5425 /// @brief Set meta-data for the curve mesh, including the
5426 /// curve type, order, and periodicity.
5427 ///
5428 /// @param[in] session
5429 /// The session of Houdini you are interacting with.
5430 /// See @ref HAPI_Sessions for more on sessions.
5431 /// Pass NULL to just use the default in-process session.
5432 ///
5433 /// @param[in] node_id
5434 /// The node id.
5435 ///
5436 /// @param[in] part_id
5437 /// Currently unused. Input asset geos are assumed
5438 /// to have only one part.
5439 ///
5440 /// @param[in] info
5441 /// The curve info represents the meta-data about
5442 /// the curves, including the type, order,
5443 /// and periodicity.
5444 ///
5445 HAPI_DECL HAPI_SetCurveInfo( const HAPI_Session * session,
5446  HAPI_NodeId node_id,
5447  HAPI_PartId part_id,
5448  const HAPI_CurveInfo * info );
5449 
5450 /// @brief Set the number of vertices for each curve in the part.
5451 ///
5452 /// @param[in] session
5453 /// The session of Houdini you are interacting with.
5454 /// See @ref HAPI_Sessions for more on sessions.
5455 /// Pass NULL to just use the default in-process session.
5456 ///
5457 /// @param[in] node_id
5458 /// The node id.
5459 ///
5460 /// @param[in] part_id
5461 /// Currently unused. Input asset geos are assumed
5462 /// to have only one part.
5463 ///
5464 /// @param[in] counts_array
5465 /// The number of cvs each curve contains.
5466 ///
5467 /// @param[in] start
5468 /// The index of the first curve.
5469 ///
5470 /// @param[in] length
5471 /// The number of curves' counts to set.
5472 ///
5473 HAPI_DECL HAPI_SetCurveCounts( const HAPI_Session * session,
5474  HAPI_NodeId node_id,
5475  HAPI_PartId part_id,
5476  const int * counts_array,
5477  int start, int length );
5478 
5479 /// @brief Set the orders for each curve in the part if the
5480 /// curve has varying order.
5481 ///
5482 /// @param[in] session
5483 /// The session of Houdini you are interacting with.
5484 /// See @ref HAPI_Sessions for more on sessions.
5485 /// Pass NULL to just use the default in-process session.
5486 ///
5487 /// @param[in] node_id
5488 /// The node id.
5489 ///
5490 /// @param[in] part_id
5491 /// Currently unused. Input asset geos are assumed
5492 /// to have only one part.
5493 ///
5494 /// @param[in] orders_array
5495 /// The orders of each curve.
5496 ///
5497 /// @param[in] start
5498 /// The index of the first curve.
5499 ///
5500 /// @param[in] length
5501 /// The number of curves' orders to retrieve.
5502 ///
5503 HAPI_DECL HAPI_SetCurveOrders( const HAPI_Session * session,
5504  HAPI_NodeId node_id,
5505  HAPI_PartId part_id,
5506  const int * orders_array,
5507  int start, int length );
5508 
5509 /// @brief Set the knots of the curves in this part.
5510 ///
5511 /// @param[in] session
5512 /// The session of Houdini you are interacting with.
5513 /// See @ref HAPI_Sessions for more on sessions.
5514 /// Pass NULL to just use the default in-process session.
5515 ///
5516 /// @param[in] node_id
5517 /// The node id.
5518 ///
5519 /// @param[in] part_id
5520 /// Currently unused. Input asset geos are assumed
5521 /// to have only one part.
5522 ///
5523 /// @param[in] knots_array
5524 /// The knots of each curve.
5525 ///
5526 /// @param[in] start
5527 /// The index of the first curve.
5528 ///
5529 /// @param[in] length
5530 /// The number of curves' knots to set. The
5531 /// length of all the knots on a single curve is
5532 /// the order of that curve plus the number of
5533 /// vertices (see ::HAPI_SetCurveOrders(),
5534 /// and ::HAPI_SetCurveCounts()).
5535 ///
5536 HAPI_DECL HAPI_SetCurveKnots( const HAPI_Session * session,
5537  HAPI_NodeId node_id,
5538  HAPI_PartId part_id,
5539  const float * knots_array,
5540  int start, int length );
5541 
5542 // BASIC PRIMITIVES ---------------------------------------------------------
5543 
5544 /// @brief Get the box info on a geo part (if the part is a box).
5545 ///
5546 /// @param[in] session
5547 /// The session of Houdini you are interacting with.
5548 /// See @ref HAPI_Sessions for more on sessions.
5549 /// Pass NULL to just use the default in-process session.
5550 ///
5551 /// @param[in] geo_node_id
5552 /// The geo node id.
5553 ///
5554 /// @param[in] part_id
5555 /// The part id of the
5556 ///
5557 /// @param[out] box_info
5558 /// The returned box info.
5559 ///
5560 HAPI_DECL HAPI_GetBoxInfo( const HAPI_Session * session,
5561  HAPI_NodeId geo_node_id,
5562  HAPI_PartId part_id,
5563  HAPI_BoxInfo * box_info );
5564 
5565 /// @brief Get the sphere info on a geo part (if the part is a sphere).
5566 ///
5567 /// @param[in] session
5568 /// The session of Houdini you are interacting with.
5569 /// See @ref HAPI_Sessions for more on sessions.
5570 /// Pass NULL to just use the default in-process session.
5571 ///
5572 /// @param[in] geo_node_id
5573 /// The geo node id.
5574 ///
5575 /// @param[in] part_id
5576 /// The part id of the
5577 ///
5578 /// @param[out] sphere_info
5579 /// The returned sphere info.
5580 ///
5581 HAPI_DECL HAPI_GetSphereInfo( const HAPI_Session * session,
5582  HAPI_NodeId geo_node_id,
5583  HAPI_PartId part_id,
5584  HAPI_SphereInfo * sphere_info );
5585 
5586 // CACHING ------------------------------------------------------------------
5587 
5588 /// @brief Get the number of currently active caches.
5589 ///
5590 /// @param[in] session
5591 /// The session of Houdini you are interacting with.
5592 /// See @ref HAPI_Sessions for more on sessions.
5593 /// Pass NULL to just use the default in-process session.
5594 ///
5595 /// @param[out] active_cache_count
5596 /// The number of currently active caches.
5597 ///
5599  int * active_cache_count );
5600 
5601 /// @brief Get the names of the currently active caches.
5602 ///
5603 /// Requires a valid active cache count which you get from:
5604 /// ::HAPI_GetActiveCacheCount().
5605 ///
5606 /// @param[in] session
5607 /// The session of Houdini you are interacting with.
5608 /// See @ref HAPI_Sessions for more on sessions.
5609 /// Pass NULL to just use the default in-process session.
5610 ///
5611 /// @param[out] cache_names_array
5612 /// String array with the returned cache names. Must be
5613 /// at least the size of @a active_cache_count.
5614 ///
5615 /// @param[in] active_cache_count
5616 /// The count returned by ::HAPI_GetActiveCacheCount().
5617 ///
5619  HAPI_StringHandle * cache_names_array,
5620  int active_cache_count );
5621 
5622 /// @brief Lets you inspect specific properties of the different memory
5623 /// caches in the current Houdini context.
5624 ///
5625 /// @param[in] session
5626 /// The session of Houdini you are interacting with.
5627 /// See @ref HAPI_Sessions for more on sessions.
5628 /// Pass NULL to just use the default in-process session.
5629 ///
5630 /// @param[in] cache_name
5631 /// Cache name from ::HAPI_GetActiveCacheNames().
5632 ///
5633 /// @param[in] cache_property
5634 /// The specific property of the cache to get the value for.
5635 ///
5636 /// @param[out] property_value
5637 /// Returned property value.
5638 ///
5640  const char * cache_name,
5641  HAPI_CacheProperty cache_property,
5642  int * property_value );
5643 
5644 /// @brief Lets you modify specific properties of the different memory
5645 /// caches in the current Houdini context. This includes clearing
5646 /// caches, reducing their memory use, or changing how memory limits
5647 /// are respected by a cache.
5648 ///
5649 /// @param[in] session
5650 /// The session of Houdini you are interacting with.
5651 /// See @ref HAPI_Sessions for more on sessions.
5652 /// Pass NULL to just use the default in-process session.
5653 ///
5654 /// @param[in] cache_name
5655 /// Cache name from ::HAPI_GetActiveCacheNames().
5656 ///
5657 /// @param[in] cache_property
5658 /// The specific property of the cache to modify.
5659 ///
5660 /// @param[in] property_value
5661 /// The new property value.
5662 ///
5664  const char * cache_name,
5665  HAPI_CacheProperty cache_property,
5666  int property_value );
5667 
5668 /// @brief Saves a geometry to file. The type of file to save is
5669 /// to be determined by the extension ie. .bgeo, .obj
5670 ///
5671 /// @param[in] session
5672 /// The session of Houdini you are interacting with.
5673 /// See @ref HAPI_Sessions for more on sessions.
5674 /// Pass NULL to just use the default in-process session.
5675 ///
5676 /// @param[in] node_id
5677 /// The node id.
5678 ///
5679 /// @param[in] file_name
5680 /// The name of the file to be saved. The extension
5681 /// of the file determines its type.
5682 ///
5683 HAPI_DECL HAPI_SaveGeoToFile( const HAPI_Session * session,
5684  HAPI_NodeId node_id,
5685  const char * file_name );
5686 
5687 /// @brief Loads a geometry file and put its contents onto a SOP
5688 /// node.
5689 ///
5690 /// @param[in] session
5691 /// The session of Houdini you are interacting with.
5692 /// See @ref HAPI_Sessions for more on sessions.
5693 /// Pass NULL to just use the default in-process session.
5694 ///
5695 /// @param[in] node_id
5696 /// The node id.
5697 ///
5698 /// @param[in] file_name
5699 /// The name of the file to be loaded
5700 ///
5702  HAPI_NodeId node_id,
5703  const char * file_name );
5704 
5705 /// @brief Cache the current state of the geo to memory, given the
5706 /// format, and return the size. Use this size with your call
5707 /// to ::HAPI_SaveGeoToMemory() to copy the cached geo to your
5708 /// buffer. It is guaranteed that the size will not change between
5709 /// your call to ::HAPI_GetGeoSize() and ::HAPI_SaveGeoToMemory().
5710 ///
5711 /// @param[in] session
5712 /// The session of Houdini you are interacting with.
5713 /// See @ref HAPI_Sessions for more on sessions.
5714 /// Pass NULL to just use the default in-process session.
5715 ///
5716 /// @param[in] node_id
5717 /// The node id.
5718 ///
5719 /// @param[in] format
5720 /// The file format, ie. "obj", "bgeo" etc.
5721 ///
5722 /// @param[out] size
5723 /// The size of the buffer required to hold the output.
5724 ///
5725 HAPI_DECL HAPI_GetGeoSize( const HAPI_Session * session,
5726  HAPI_NodeId node_id,
5727  const char * format,
5728  int * size );
5729 
5730 /// @brief Saves the cached geometry to your buffer in memory,
5731 /// whose format and required size is identified by the call to
5732 /// ::HAPI_GetGeoSize(). The call to ::HAPI_GetGeoSize() is
5733 /// required as ::HAPI_GetGeoSize() does the actual saving work.
5734 ///
5735 /// Also note that this call to ::HAPI_SaveGeoToMemory will delete
5736 /// the internal geo buffer that was cached in the previous call
5737 /// to ::HAPI_GetGeoSize(). This means that you will need to call
5738 /// ::HAPI_GetGeoSize() again before you can call this function.
5739 ///
5740 /// @param[in] session
5741 /// The session of Houdini you are interacting with.
5742 /// See @ref HAPI_Sessions for more on sessions.
5743 /// Pass NULL to just use the default in-process session.
5744 ///
5745 /// @param[in] node_id
5746 /// The node id.
5747 ///
5748 /// @param[out] buffer
5749 /// The buffer we will write into.
5750 ///
5751 /// @param[in] length
5752 /// The size of the buffer passed in.
5753 ///
5755  HAPI_NodeId node_id,
5756  char * buffer,
5757  int length );
5758 
5759 /// @brief Loads a geometry from memory and put its
5760 /// contents onto a SOP node.
5761 ///
5762 /// @param[in] session
5763 /// The session of Houdini you are interacting with.
5764 /// See @ref HAPI_Sessions for more on sessions.
5765 /// Pass NULL to just use the default in-process session.
5766 ///
5767 /// @param[in] node_id
5768 /// The node id.
5769 ///
5770 /// @param[in] format
5771 /// The file format, ie. "obj", "bgeo" etc.
5772 ///
5773 /// @param[in] buffer
5774 /// The buffer we will read the geometry from.
5775 ///
5776 /// @param[in] length
5777 /// The size of the buffer passed in.
5778 ///
5780  HAPI_NodeId node_id,
5781  const char * format,
5782  const char * buffer,
5783  int length );
5784 
5785 // @brief Return an array of PDG graph context names and ids, the first
5786 /// count names will be returned. These ids can be used
5787 /// with ::HAPI_GetPDGEvents and ::HAPI_GetPDGState. The values
5788 /// of the names can be retrieved with ::HAPI_GetString.
5789 ///
5790 /// @param[in] session
5791 /// The session of Houdini you are interacting with.
5792 /// See @ref HAPI_Sessions for more on sessions.
5793 /// Pass NULL to just use the default in-process session.
5794 ///
5795 /// @param[out] num_contexts
5796 /// Total number of PDG graph contexts found.
5797 ///
5798 /// @param[out] context_names_array
5799 /// Array of int (string handles) to house the
5800 /// context names. These handles are valid until the next
5801 /// call to this function.
5802 ///
5803 /// @param[out] context_id_array
5804 /// Array of graph context ids.
5805 ///
5806 /// @param[in] count
5807 /// Length of context_names_array and context_id_array
5808 ///
5810  int * num_contexts,
5811  HAPI_StringHandle * context_names_array,
5812  HAPI_PDG_GraphContextId * context_id_array,
5813  int count );
5814 
5815 // @brief Starts a PDG cooking operation. This can be asynchronous.
5816 /// Progress can be checked with ::HAPI_GetPDGState and ::HAPI_GetPDGState.
5817 /// Events generated during this cook can be collected with ::HAPI_GetPDGEvents.
5818 /// Any uncollected events will be discarded at the start of the cook.
5819 ///
5820 /// @param[in] session
5821 /// The session of Houdini you are interacting with.
5822 /// See @ref HAPI_Sessions for more on sessions.
5823 /// Pass NULL to just use the default in-process session.
5824 ///
5825 /// @param[in] graph_context_id
5826 /// The id of the graph context
5827 ///
5828 /// @param[in] cook_node_id
5829 /// The node id of the TOP node for the cook operation.
5830 ///
5831 /// @param[in] cook_type
5832 /// The ::HAPI_PDG_CookType cooking mode to perform.
5833 ///
5834 /// @param[in] blocking
5835 /// 0 means return immediately and cooking will be done
5836 /// asynchronously. 1 means return when cooking completes.
5837 ///
5838 HAPI_DECL HAPI_CookPDG( const HAPI_Session * session,
5839  HAPI_PDG_GraphContextId graph_context_id,
5840  HAPI_NodeId cook_node_id,
5841  HAPI_PDG_CookType cook_type,
5842  int blocking );
5843 
5844 // @brief Returns PDG events that have been collected. Calling this function
5845 /// will remove those events from the queue. Events collection is restarted
5846 /// by calls to ::HAPI_CookPDG.
5847 ///
5848 ///
5849 /// @param[in] session
5850 /// The session of Houdini you are interacting with.
5851 /// See @ref HAPI_Sessions for more on sessions.
5852 /// Pass NULL to just use the default in-process session.
5853 ///
5854 /// @param[in] graph_context_id
5855 /// The id of the graph context
5856 ///
5857 /// @param[out] event_array
5858 /// buffer of ::HAPI_PDG_EventInfo of size at least length.
5859 ///
5860 /// @param[in] length
5861 /// The size of the buffer passed in.
5862 ///
5863 /// @param[out] event_count
5864 /// Number of events removed from queue and copied to buffer.
5865 ///
5866 /// @param[out] remaining_events
5867 /// Number of queued events remaining after this operation.
5868 ///
5869 HAPI_DECL HAPI_GetPDGEvents( const HAPI_Session * session,
5870  HAPI_PDG_GraphContextId graph_context_id,
5871  HAPI_PDG_EventInfo * event_array,
5872  int length,
5873  int * event_count,
5874  int * remaining_events );
5875 
5876 // @brief Gets the state of a PDG graph
5877 ///
5878 ///
5879 /// @param[in] session
5880 /// The session of Houdini you are interacting with.
5881 /// See @ref HAPI_Sessions for more on sessions.
5882 /// Pass NULL to just use the default in-process session.
5883 ///
5884 /// @param[in] graph_context_id
5885 /// The graph context id
5886 ///
5887 /// @param[out] pdg_state
5888 /// One of ::HAPI_PDG_State.
5889 ///
5890 HAPI_DECL HAPI_GetPDGState( const HAPI_Session * session,
5891  HAPI_PDG_GraphContextId graph_context_id,
5892  int * pdg_state );
5893 
5894 
5895 // @brief Creates a new pending workitem for the given node. The workitem
5896 /// will not be submitted to the graph until it is committed with
5897 /// ::HAPI_CommitWorkitems. The node is expected to be a generator type.
5898 ///
5899 /// @param[in] session
5900 /// The session of Houdini you are interacting with.
5901 /// See @ref HAPI_Sessions for more on sessions.
5902 /// Pass NULL to just use the default in-process session.
5903 ///
5904 /// @param[in] node_id
5905 /// The node id.
5906 ///
5907 /// @param[out] workitem_id
5908 /// The id of the pending workitem.
5909 ///
5910 /// @param[in] name
5911 /// The null-terminated name of the workitem. The name will
5912 /// be automatically suffixed to make it unique.
5913 ///
5914 /// @param[in] index
5915 /// The index of the workitem. The semantics of the index
5916 /// are user defined.
5917 ///
5918 HAPI_DECL HAPI_CreateWorkitem( const HAPI_Session * session,
5919  HAPI_NodeId node_id,
5920  HAPI_PDG_WorkitemId * workitem_id,
5921  const char * name,
5922  int index );
5923 
5924 // @brief Retrieves the info of a given workitem by id.
5925 ///
5926 /// @param[in] session
5927 /// The session of Houdini you are interacting with.
5928 /// See @ref HAPI_Sessions for more on sessions.
5929 /// Pass NULL to just use the default in-process session.
5930 ///
5931 /// @param[in] graph_context_id
5932 /// The graph context that the workitem is in.
5933 ///
5934 /// @param[in] workitem_id
5935 /// The id of the workitem.
5936 ///
5937 /// @param[out] workitem_info
5938 /// The returned ::HAPI_PDG_WorkitemInfo for the workitem. Note
5939 /// that the enclosed string handle is only valid until the next
5940 /// call to this function.
5941 ///
5943  HAPI_PDG_GraphContextId graph_context_id,
5944  HAPI_PDG_WorkitemId workitem_id,
5945  HAPI_PDG_WorkitemInfo * workitem_info );
5946 
5947 // @brief Adds integer data to a pending PDG workitem data member for the given node.
5948 ///
5949 ///
5950 /// @param[in] session
5951 /// The session of Houdini you are interacting with.
5952 /// See @ref HAPI_Sessions for more on sessions.
5953 /// Pass NULL to just use the default in-process session.
5954 ///
5955 /// @param[in] node_id
5956 /// The node id.
5957 ///
5958 /// @param[out] workitem_id
5959 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem
5960 ///
5961 /// @param[in] data_name
5962 /// null-terminated name of the data member
5963 ///
5964 /// @param[in] values_array
5965 /// array of integer values
5966 ///
5967 /// @param[in] length
5968 /// number of values to copy from values_array to the parameter
5969 ///
5971  HAPI_NodeId node_id,
5972  HAPI_PDG_WorkitemId workitem_id,
5973  const char * data_name,
5974  const int * values_array,
5975  int length );
5976 
5977 // @brief Adds float data to a pending PDG workitem data member for the given node.
5978 ///
5979 ///
5980 /// @param[in] session
5981 /// The session of Houdini you are interacting with.
5982 /// See @ref HAPI_Sessions for more on sessions.
5983 /// Pass NULL to just use the default in-process session.
5984 ///
5985 /// @param[in] node_id
5986 /// The node id.
5987 ///
5988 /// @param[out] workitem_id
5989 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem
5990 ///
5991 /// @param[in] data_name
5992 /// null-terminated name of the workitem data member
5993 ///
5994 /// @param[in] values_array
5995 /// array of float values
5996 ///
5997 /// @param[in] length
5998 /// number of values to copy from values_array to the parameter
5999 ///
6001  HAPI_NodeId node_id,
6002  HAPI_PDG_WorkitemId workitem_id,
6003  const char * data_name,
6004  const float * values_array,
6005  int length );
6006 
6007 // @brief Adds integer data to a pending PDG workitem data member for the given node.
6008 ///
6009 ///
6010 /// @param[in] session
6011 /// The session of Houdini you are interacting with.
6012 /// See @ref HAPI_Sessions for more on sessions.
6013 /// Pass NULL to just use the default in-process session.
6014 ///
6015 /// @param[in] node_id
6016 /// The node id.
6017 ///
6018 /// @param[out] workitem_id
6019 /// The id of the created workitem returned by HAPI_CreateWorkitem
6020 ///
6021 /// @param[in] data_name
6022 /// null-terminated name of the data member
6023 ///
6024 /// @param[in] data_index
6025 /// index of the string data member
6026 ///
6027 /// @param[in] value
6028 /// null-terminated string to copy to the workitem data member
6029 ///
6031  HAPI_NodeId node_id,
6032  HAPI_PDG_WorkitemId workitem_id,
6033  const char * data_name,
6034  int data_index,
6035  const char * value );
6036 
6037 // @brief Commits any pending workitems.
6038 ///
6039 /// @param[in] session
6040 /// The session of Houdini you are interacting with.
6041 /// See @ref HAPI_Sessions for more on sessions.
6042 /// Pass NULL to just use the default in-process session.
6043 ///
6044 /// @param[in] node_id
6045 /// The node id for which the pending workitems have been
6046 /// created but not yet injected.
6047 ///
6049  HAPI_NodeId node_id );
6050 
6051 // @brief Gets the number of workitems that are available on the given node.
6052 /// Should be used with ::HAPI_GetWorkitems.
6053 ///
6054 /// @param[in] session
6055 /// The session of Houdini you are interacting with.
6056 /// See @ref HAPI_Sessions for more on sessions.
6057 /// Pass NULL to just use the default in-process session.
6058 ///
6059 /// @param[in] node_id
6060 /// The node id.
6061 ///
6062 /// @param[out] num
6063 /// The number of workitems.
6064 ///
6066  HAPI_NodeId node_id,
6067  int * num );
6068 
6069 // @brief Gets the list of work item ids for the given node
6070 ///
6071 /// @param[in] session
6072 /// The session of Houdini you are interacting with.
6073 /// See @ref HAPI_Sessions for more on sessions.
6074 /// Pass NULL to just use the default in-process session.
6075 ///
6076 /// @param[in] node_id
6077 /// The node id.
6078 ///
6079 /// @param[out] workitem_ids
6080 /// buffer for resulting array of ::HAPI_PDG_WorkitemId
6081 ///
6082 /// @param[in] length
6083 /// The length of the workitem_ids buffer
6084 ///
6085 HAPI_DECL HAPI_GetWorkitems( const HAPI_Session * session,
6086  HAPI_NodeId node_id,
6087  int * workitem_ids, int length );
6088 
6089 // @brief Gets the length of the workitem data member.
6090 /// It is the length of the array of data.
6091 ///
6092 /// @param[in] session
6093 /// The session of Houdini you are interacting with.
6094 /// See @ref HAPI_Sessions for more on sessions.
6095 /// Pass NULL to just use the default in-process session.
6096 ///
6097 /// @param[in] node_id
6098 /// The node id.
6099 ///
6100 /// @param[in] workitem_id
6101 /// The id of the workitem
6102 ///
6103 /// @param[in] data_name
6104 /// null-terminated name of the data member
6105 ///
6106 /// @param[out] length
6107 /// The length of the data member array
6108 ///
6110  HAPI_NodeId node_id,
6111  HAPI_PDG_WorkitemId workitem_id,
6112  const char * data_name,
6113  int * length );
6114 
6115 // @brief Gets int data from a work item member.
6116 ///
6117 /// @param[in] session
6118 /// The session of Houdini you are interacting with.
6119 /// See @ref HAPI_Sessions for more on sessions.
6120 /// Pass NULL to just use the default in-process session.
6121 ///
6122 /// @param[in] node_id
6123 /// The node id.
6124 ///
6125 /// @param[in] workitem_id
6126 /// The id of the workitem
6127 ///
6128 /// @param[in] data_name
6129 /// null-terminated name of the data member
6130 ///
6131 /// @param[out] data_array
6132 /// buffer of at least size length to copy the data into. The required
6133 /// length should be determined by HAPI_GetWorkitemDataLength.
6134 ///
6135 /// @param[in] length
6136 /// The length of the supplied buffer
6137 ///
6139  HAPI_NodeId node_id,
6140  HAPI_PDG_WorkitemId workitem_id,
6141  const char* data_name,
6142  int * data_array,
6143  int length );
6144 
6145 // @brief Gets float data from a work item member.
6146 ///
6147 /// @param[in] session
6148 /// The session of Houdini you are interacting with.
6149 /// See @ref HAPI_Sessions for more on sessions.
6150 /// Pass NULL to just use the default in-process session.
6151 ///
6152 /// @param[in] node_id
6153 /// The node id.
6154 ///
6155 /// @param[in] workitem_id
6156 /// The id of the workitem
6157 ///
6158 /// @param[in] data_name
6159 /// null-terminated name of the data member
6160 ///
6161 /// @param[out] data_array
6162 /// buffer of at least size length to copy the data into. The required
6163 /// length should be determined by HAPI_GetWorkitemDataLength.
6164 ///
6165 /// @param[in] length
6166 /// The length of the supplied buffer
6167 ///
6169  HAPI_NodeId node_id,
6170  HAPI_PDG_WorkitemId workitem_id,
6171  const char * data_name,
6172  float * data_array,
6173  int length );
6174 
6175 // @brief Gets string ids from a work item member.
6176 ///
6177 /// @param[in] session
6178 /// The session of Houdini you are interacting with.
6179 /// See @ref HAPI_Sessions for more on sessions.
6180 /// Pass NULL to just use the default in-process session.
6181 ///
6182 /// @param[in] node_id
6183 /// The node id.
6184 ///
6185 /// @param[in] workitem_id
6186 /// The id of the workitem
6187 ///
6188 /// @param[in] data_name
6189 /// null-terminated name of the data member
6190 ///
6191 /// @param[out] data_array
6192 /// buffer of at least size length to copy the data into. The required
6193 /// length should be determined by HAPI_GetWorkitemDataLength. The data
6194 /// is an array of HAPI_StringHandle which can be used with
6195 /// HAPI_GetString. The string handles are valid until the next call to
6196 /// this function.
6197 ///
6198 /// @param[in] length
6199 /// The length of the supplied buffer
6200 ///
6202  HAPI_NodeId node_id,
6203  HAPI_PDG_Wor