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