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.
6269 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6270 ///
6271 /// @param[out] job_id
6272 /// The id assigned to the job.
6273 ///
6275  HAPI_NodeId node_id,
6276  HAPI_PartId part_id,
6277  const char * name,
6278  HAPI_AttributeInfo * attr_info,
6279  int stride,
6280  HAPI_Int8 * data_array,
6281  int start, int length,
6282  int * job_id );
6283 
6284 /// @brief Get attribute 16-bit integer data asynchronously.
6285 ///
6286 /// @ingroup GeometryGetters Attributes
6287 ///
6288 /// @param[in] session
6289 /// The session of Houdini you are interacting with.
6290 /// See @ref HAPI_Sessions for more on sessions.
6291 /// Pass NULL to just use the default in-process session.
6292 /// <!-- default NULL -->
6293 ///
6294 /// @param[in] node_id
6295 /// The node id.
6296 ///
6297 /// @param[in] part_id
6298 /// The part id.
6299 ///
6300 /// @param[in] name
6301 /// Attribute name.
6302 ///
6303 /// @param[in] attr_info
6304 /// ::HAPI_AttributeInfo used as input for what tuple size.
6305 /// you want. Also contains some sanity checks like
6306 /// data type. Generally should be the same struct
6307 /// returned by ::HAPI_GetAttributeInfo().
6308 ///
6309 /// @param[in] stride
6310 /// Specifies how many items to skip over for each element.
6311 /// With a stride of -1, the stride will be set to
6312 /// @c attr_info->tuple_size. Otherwise, the stride will be
6313 /// set to the maximum of @c attr_info->tuple_size and
6314 /// @c stride.
6315 ///
6316 /// @param[out] data_array
6317 /// An integer array at least the size of
6318 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6319 ///
6320 /// @param[in] start
6321 /// First index of range. Must be at least 0 and at
6322 /// most ::HAPI_AttributeInfo::count - 1.
6323 /// <!-- default 0 -->
6324 ///
6325 /// @param[in] length
6326 /// Must be at least 0 and at most
6327 /// ::HAPI_AttributeInfo::count - @p start.
6328 /// Note, if 0 is passed for length, the function will just
6329 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6330 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6331 ///
6332 /// @param[out] job_id
6333 /// The id assigned to the job.
6334 ///
6336  HAPI_NodeId node_id,
6337  HAPI_PartId part_id,
6338  const char * name,
6339  HAPI_AttributeInfo * attr_info,
6340  int stride,
6341  HAPI_Int16 * data_array,
6342  int start, int length,
6343  int * job_id );
6344 
6345 /// @brief Get attribute 64-bit integer data asynchronously.
6346 ///
6347 /// @ingroup GeometryGetters Attributes
6348 ///
6349 /// @param[in] session
6350 /// The session of Houdini you are interacting with.
6351 /// See @ref HAPI_Sessions for more on sessions.
6352 /// Pass NULL to just use the default in-process session.
6353 /// <!-- default NULL -->
6354 ///
6355 /// @param[in] node_id
6356 /// The node id.
6357 ///
6358 /// @param[in] part_id
6359 /// The part id.
6360 ///
6361 /// @param[in] name
6362 /// Attribute name.
6363 ///
6364 /// @param[in] attr_info
6365 /// ::HAPI_AttributeInfo used as input for what tuple size.
6366 /// you want. Also contains some sanity checks like
6367 /// data type. Generally should be the same struct
6368 /// returned by ::HAPI_GetAttributeInfo().
6369 ///
6370 /// @param[in] stride
6371 /// Specifies how many items to skip over for each element.
6372 /// With a stride of -1, the stride will be set to
6373 /// @c attr_info->tuple_size. Otherwise, the stride will be
6374 /// set to the maximum of @c attr_info->tuple_size and
6375 /// @c stride.
6376 ///
6377 /// @param[out] data_array
6378 /// An integer array at least the size of
6379 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6380 ///
6381 /// @param[in] start
6382 /// First index of range. Must be at least 0 and at
6383 /// most ::HAPI_AttributeInfo::count - 1.
6384 /// <!-- default 0 -->
6385 ///
6386 /// @param[in] length
6387 /// Must be at least 0 and at most
6388 /// ::HAPI_AttributeInfo::count - @p start.
6389 /// Note, if 0 is passed for length, the function will just
6390 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6391 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6392 ///
6393 /// @param[out] job_id
6394 /// The id assigned to the job.
6395 ///
6397  HAPI_NodeId node_id,
6398  HAPI_PartId part_id,
6399  const char * name,
6400  HAPI_AttributeInfo * attr_info,
6401  int stride,
6402  HAPI_Int64 * data_array,
6403  int start, int length,
6404  int * job_id );
6405 
6406 
6407 /// @brief Get attribute float data asynchronously.
6408 ///
6409 /// @ingroup GeometryGetters Attributes
6410 ///
6411 /// @param[in] session
6412 /// The session of Houdini you are interacting with.
6413 /// See @ref HAPI_Sessions for more on sessions.
6414 /// Pass NULL to just use the default in-process session.
6415 /// <!-- default NULL -->
6416 ///
6417 /// @param[in] node_id
6418 /// The node id.
6419 ///
6420 /// @param[in] part_id
6421 /// The part id.
6422 ///
6423 /// @param[in] name
6424 /// Attribute name.
6425 ///
6426 /// @param[in] attr_info
6427 /// ::HAPI_AttributeInfo used as input for what tuple size.
6428 /// you want. Also contains some sanity checks like
6429 /// data type. Generally should be the same struct
6430 /// returned by ::HAPI_GetAttributeInfo().
6431 ///
6432 /// @param[in] stride
6433 /// Specifies how many items to skip over for each element.
6434 /// With a stride of -1, the stride will be set to
6435 /// @c attr_info->tuple_size. Otherwise, the stride will be
6436 /// set to the maximum of @c attr_info->tuple_size and
6437 /// @c stride.
6438 ///
6439 /// @param[out] data_array
6440 /// An integer array at least the size of
6441 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6442 ///
6443 /// @param[in] start
6444 /// First index of range. Must be at least 0 and at
6445 /// most ::HAPI_AttributeInfo::count - 1.
6446 /// <!-- default 0 -->
6447 ///
6448 /// @param[in] length
6449 /// Must be at least 0 and at most
6450 /// ::HAPI_AttributeInfo::count - @p start.
6451 /// Note, if 0 is passed for length, the function will just
6452 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6453 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6454 ///
6455 /// @param[out] job_id
6456 /// The id assigned to the job.
6457 ///
6459  HAPI_NodeId node_id,
6460  HAPI_PartId part_id,
6461  const char * name,
6462  HAPI_AttributeInfo * attr_info,
6463  int stride,
6464  float * data_array,
6465  int start, int length,
6466  int * job_id );
6467 
6468 /// @brief Get attribute 64-bit float data asynchronously.
6469 ///
6470 /// @ingroup GeometryGetters Attributes
6471 ///
6472 /// @param[in] session
6473 /// The session of Houdini you are interacting with.
6474 /// See @ref HAPI_Sessions for more on sessions.
6475 /// Pass NULL to just use the default in-process session.
6476 /// <!-- default NULL -->
6477 ///
6478 /// @param[in] node_id
6479 /// The node id.
6480 ///
6481 /// @param[in] part_id
6482 /// The part id.
6483 ///
6484 /// @param[in] name
6485 /// Attribute name.
6486 ///
6487 /// @param[in] attr_info
6488 /// ::HAPI_AttributeInfo used as input for what tuple size.
6489 /// you want. Also contains some sanity checks like
6490 /// data type. Generally should be the same struct
6491 /// returned by ::HAPI_GetAttributeInfo().
6492 ///
6493 /// @param[in] stride
6494 /// Specifies how many items to skip over for each element.
6495 /// With a stride of -1, the stride will be set to
6496 /// @c attr_info->tuple_size. Otherwise, the stride will be
6497 /// set to the maximum of @c attr_info->tuple_size and
6498 /// @c stride.
6499 ///
6500 /// @param[out] data_array
6501 /// An integer array at least the size of
6502 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6503 ///
6504 /// @param[in] start
6505 /// First index of range. Must be at least 0 and at
6506 /// most ::HAPI_AttributeInfo::count - 1.
6507 /// <!-- default 0 -->
6508 ///
6509 /// @param[in] length
6510 /// Must be at least 0 and at most
6511 /// ::HAPI_AttributeInfo::count - @p start.
6512 /// Note, if 0 is passed for length, the function will just
6513 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6514 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6515 ///
6516 /// @param[out] job_id
6517 /// The id assigned to the job.
6518 ///
6520  HAPI_NodeId node_id,
6521  HAPI_PartId part_id,
6522  const char * name,
6523  HAPI_AttributeInfo * attr_info,
6524  int stride,
6525  double * data_array,
6526  int start, int length,
6527  int * job_id );
6528 
6529 /// @brief Get attribute string data asynchronously.
6530 ///
6531 /// @ingroup GeometryGetters Attributes
6532 ///
6533 /// @param[in] session
6534 /// The session of Houdini you are interacting with.
6535 /// See @ref HAPI_Sessions for more on sessions.
6536 /// Pass NULL to just use the default in-process session.
6537 /// <!-- default NULL -->
6538 ///
6539 /// @param[in] node_id
6540 /// The node id.
6541 ///
6542 /// @param[in] part_id
6543 /// The part id.
6544 ///
6545 /// @param[in] name
6546 /// Attribute name.
6547 ///
6548 /// @param[in] attr_info
6549 /// ::HAPI_AttributeInfo used as input for what tuple size.
6550 /// you want. Also contains some sanity checks like
6551 /// data type. Generally should be the same struct
6552 /// returned by ::HAPI_GetAttributeInfo().
6553 ///
6554 /// @param[out] data_array
6555 /// An integer array at least the size of
6556 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6557 ///
6558 /// @param[in] start
6559 /// First index of range. Must be at least 0 and at
6560 /// most ::HAPI_AttributeInfo::count - 1.
6561 /// <!-- default 0 -->
6562 ///
6563 /// @param[in] length
6564 /// Must be at least 0 and at most
6565 /// ::HAPI_AttributeInfo::count - @p start.
6566 /// Note, if 0 is passed for length, the function will just
6567 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6568 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6569 ///
6570 /// @param[out] job_id
6571 /// The id assigned to the job.
6572 ///
6573 /// @warning The string handles should be used to retrieve the strings
6574 /// immediately and are invalidated when another call to get
6575 /// this attribute's data is made.
6576 ///
6578  HAPI_NodeId node_id,
6579  HAPI_PartId part_id,
6580  const char * name,
6581  HAPI_AttributeInfo * attr_info,
6582  HAPI_StringHandle * data_array,
6583  int start, int length,
6584  int * job_id );
6585 
6586 /// @brief Get attribute dictionary data asynchronously.
6587 ///
6588 /// @ingroup GeometryGetters Attributes
6589 ///
6590 /// @param[in] session
6591 /// The session of Houdini you are interacting with.
6592 /// See @ref HAPI_Sessions for more on sessions.
6593 /// Pass NULL to just use the default in-process session.
6594 /// <!-- default NULL -->
6595 ///
6596 /// @param[in] node_id
6597 /// The node id.
6598 ///
6599 /// @param[in] part_id
6600 /// The part id.
6601 ///
6602 /// @param[in] name
6603 /// Attribute name.
6604 ///
6605 /// @param[in] attr_info
6606 /// ::HAPI_AttributeInfo used as input for what tuple size.
6607 /// you want. Also contains some sanity checks like
6608 /// data type. Generally should be the same struct
6609 /// returned by ::HAPI_GetAttributeInfo().
6610 ///
6611 /// @param[out] data_array
6612 /// An integer array at least the size of
6613 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6614 ///
6615 /// @param[in] start
6616 /// First index of range. Must be at least 0 and at
6617 /// most ::HAPI_AttributeInfo::count - 1.
6618 /// <!-- default 0 -->
6619 ///
6620 /// @param[in] length
6621 /// Must be at least 0 and at most
6622 /// ::HAPI_AttributeInfo::count - @p start.
6623 /// Note, if 0 is passed for length, the function will just
6624 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6625 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6626 ///
6627 /// @param[out] job_id
6628 /// The id assigned to the job.
6629 ///
6630 /// @warning The string handles should be used to retrieve the strings
6631 /// immediately and are invalidated when another call to get
6632 /// this attribute's data is made.
6633 ///
6635  HAPI_NodeId node_id,
6636  HAPI_PartId part_id,
6637  const char * name,
6638  HAPI_AttributeInfo * attr_info,
6639  HAPI_StringHandle * data_array,
6640  int start, int length,
6641  int * job_id );
6642 
6643 /// @brief Get array attribute integer data asynchronously.
6644 /// Each entry in an array attribute can have varying array lengths.
6645 /// Therefore the array values are returned as a flat array, with
6646 /// another sizes array containing the lengths of each array entry.
6647 ///
6648 /// @ingroup GeometryGetters Attributes
6649 ///
6650 /// @param[in] session
6651 /// The session of Houdini you are interacting with.
6652 /// See @ref HAPI_Sessions for more on sessions.
6653 /// Pass NULL to just use the default in-process session.
6654 /// <!-- default NULL -->
6655 ///
6656 /// @param[in] node_id
6657 /// The node id.
6658 ///
6659 /// @param[in] part_id
6660 /// The part id.
6661 ///
6662 /// @param[in] attr_name
6663 /// Attribute name.
6664 ///
6665 /// @param[in] attr_info
6666 /// ::HAPI_AttributeInfo used as input for what tuple size.
6667 /// you want. Also contains some sanity checks like
6668 /// data type. Generally should be the same struct
6669 /// returned by ::HAPI_GetAttributeInfo().
6670 ///
6671 /// @param[out] data_fixed_array
6672 /// An integer array at least the size of
6673 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6674 ///
6675 /// @param[in] data_fixed_length
6676 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6677 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6678 ///
6679 /// @param[out] sizes_fixed_array
6680 /// An integer array at least the size of
6681 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6682 /// <!-- source ::HAPI_AttributeInfo::count -->
6683 ///
6684 /// @param[in] start
6685 /// First index of range. Must be at least 0 and at
6686 /// most ::HAPI_AttributeInfo::count - 1.
6687 /// <!-- default 0 -->
6688 ///
6689 /// @param[in] sizes_fixed_length
6690 /// Must be at least 0 and at most
6691 /// ::HAPI_AttributeInfo::count - @p start.
6692 /// Note, if 0 is passed for length, the function will just
6693 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6694 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6695 ///
6696 /// @param[out] job_id
6697 /// The id assigned to the job.
6698 ///
6700  HAPI_NodeId node_id,
6701  HAPI_PartId part_id,
6702  const char * attr_name,
6703  HAPI_AttributeInfo * attr_info,
6704  int * data_fixed_array,
6705  int data_fixed_length,
6706  int * sizes_fixed_array,
6707  int start, int sizes_fixed_length,
6708  int * job_id );
6709 
6710 /// @brief Get array attribute unsigned 8-bit integer data asynchronously.
6711 /// Each entry in an array attribute can have varying array lengths.
6712 /// Therefore the array values are returned as a flat array, with
6713 /// another sizes array containing the lengths of each array entry.
6714 ///
6715 /// @ingroup GeometryGetters Attributes
6716 ///
6717 /// @param[in] session
6718 /// The session of Houdini you are interacting with.
6719 /// See @ref HAPI_Sessions for more on sessions.
6720 /// Pass NULL to just use the default in-process session.
6721 /// <!-- default NULL -->
6722 ///
6723 /// @param[in] node_id
6724 /// The node id.
6725 ///
6726 /// @param[in] part_id
6727 /// The part id.
6728 ///
6729 /// @param[in] attr_name
6730 /// Attribute name.
6731 ///
6732 /// @param[in] attr_info
6733 /// ::HAPI_AttributeInfo used as input for what tuple size.
6734 /// you want. Also contains some sanity checks like
6735 /// data type. Generally should be the same struct
6736 /// returned by ::HAPI_GetAttributeInfo().
6737 ///
6738 /// @param[out] data_fixed_array
6739 /// An integer array at least the size of
6740 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6741 ///
6742 /// @param[in] data_fixed_length
6743 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6744 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6745 ///
6746 /// @param[out] sizes_fixed_array
6747 /// An integer array at least the size of
6748 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6749 /// <!-- source ::HAPI_AttributeInfo::count -->
6750 ///
6751 /// @param[in] start
6752 /// First index of range. Must be at least 0 and at
6753 /// most ::HAPI_AttributeInfo::count - 1.
6754 /// <!-- default 0 -->
6755 ///
6756 /// @param[in] sizes_fixed_length
6757 /// Must be at least 0 and at most
6758 /// ::HAPI_AttributeInfo::count - @p start.
6759 /// Note, if 0 is passed for length, the function will just
6760 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6761 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6762 ///
6763 /// @param[out] job_id
6764 /// The id assigned to the job.
6765 ///
6767  HAPI_NodeId node_id,
6768  HAPI_PartId part_id,
6769  const char * attr_name,
6770  HAPI_AttributeInfo * attr_info,
6771  HAPI_UInt8 * data_fixed_array,
6772  int data_fixed_length,
6773  int * sizes_fixed_array,
6774  int start, int sizes_fixed_length,
6775  int * job_id );
6776 
6777 /// @brief Get array attribute 8-bit integer data asynchronously.
6778 /// Each entry in an array attribute can have varying array lengths.
6779 /// Therefore the array values are returned as a flat array, with
6780 /// another sizes array containing the lengths of each array entry.
6781 ///
6782 /// @ingroup GeometryGetters Attributes
6783 ///
6784 /// @param[in] session
6785 /// The session of Houdini you are interacting with.
6786 /// See @ref HAPI_Sessions for more on sessions.
6787 /// Pass NULL to just use the default in-process session.
6788 /// <!-- default NULL -->
6789 ///
6790 /// @param[in] node_id
6791 /// The node id.
6792 ///
6793 /// @param[in] part_id
6794 /// The part id.
6795 ///
6796 /// @param[in] attr_name
6797 /// Attribute name.
6798 ///
6799 /// @param[in] attr_info
6800 /// ::HAPI_AttributeInfo used as input for what tuple size.
6801 /// you want. Also contains some sanity checks like
6802 /// data type. Generally should be the same struct
6803 /// returned by ::HAPI_GetAttributeInfo().
6804 ///
6805 /// @param[out] data_fixed_array
6806 /// An integer array at least the size of
6807 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6808 ///
6809 /// @param[in] data_fixed_length
6810 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6811 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6812 ///
6813 /// @param[out] sizes_fixed_array
6814 /// An integer array at least the size of
6815 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6816 /// <!-- source ::HAPI_AttributeInfo::count -->
6817 ///
6818 /// @param[in] start
6819 /// First index of range. Must be at least 0 and at
6820 /// most ::HAPI_AttributeInfo::count - 1.
6821 /// <!-- default 0 -->
6822 ///
6823 /// @param[in] sizes_fixed_length
6824 /// Must be at least 0 and at most
6825 /// ::HAPI_AttributeInfo::count - @p start.
6826 /// Note, if 0 is passed for length, the function will just
6827 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6828 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6829 ///
6830 /// @param[out] job_id
6831 /// The id assigned to the job.
6832 ///
6834  HAPI_NodeId node_id,
6835  HAPI_PartId part_id,
6836  const char * attr_name,
6837  HAPI_AttributeInfo * attr_info,
6838  HAPI_Int8 * data_fixed_array,
6839  int data_fixed_length,
6840  int * sizes_fixed_array,
6841  int start, int sizes_fixed_length,
6842  int * job_id );
6843 
6844 /// @brief Get array attribute 16-bit integer data asynchronously.
6845 /// Each entry in an array attribute can have varying array lengths.
6846 /// Therefore the array values are returned as a flat array, with
6847 /// another sizes array containing the lengths of each array entry.
6848 ///
6849 /// @ingroup GeometryGetters Attributes
6850 ///
6851 /// @param[in] session
6852 /// The session of Houdini you are interacting with.
6853 /// See @ref HAPI_Sessions for more on sessions.
6854 /// Pass NULL to just use the default in-process session.
6855 /// <!-- default NULL -->
6856 ///
6857 /// @param[in] node_id
6858 /// The node id.
6859 ///
6860 /// @param[in] part_id
6861 /// The part id.
6862 ///
6863 /// @param[in] attr_name
6864 /// Attribute name.
6865 ///
6866 /// @param[in] attr_info
6867 /// ::HAPI_AttributeInfo used as input for what tuple size.
6868 /// you want. Also contains some sanity checks like
6869 /// data type. Generally should be the same struct
6870 /// returned by ::HAPI_GetAttributeInfo().
6871 ///
6872 /// @param[out] data_fixed_array
6873 /// An integer array at least the size of
6874 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6875 ///
6876 /// @param[in] data_fixed_length
6877 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6878 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6879 ///
6880 /// @param[out] sizes_fixed_array
6881 /// An integer array at least the size of
6882 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6883 /// <!-- source ::HAPI_AttributeInfo::count -->
6884 ///
6885 /// @param[in] start
6886 /// First index of range. Must be at least 0 and at
6887 /// most ::HAPI_AttributeInfo::count - 1.
6888 /// <!-- default 0 -->
6889 ///
6890 /// @param[in] sizes_fixed_length
6891 /// Must be at least 0 and at most
6892 /// ::HAPI_AttributeInfo::count - @p start.
6893 /// Note, if 0 is passed for length, the function will just
6894 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6895 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6896 ///
6897 /// @param[out] job_id
6898 /// The id assigned to the job.
6899 ///
6901  HAPI_NodeId node_id,
6902  HAPI_PartId part_id,
6903  const char * attr_name,
6904  HAPI_AttributeInfo * attr_info,
6905  HAPI_Int16 * data_fixed_array,
6906  int data_fixed_length,
6907  int * sizes_fixed_array,
6908  int start, int sizes_fixed_length,
6909  int * job_id );
6910 
6911 /// @brief Get array attribute 64-bit integer data asynchronously.
6912 /// Each entry in an array attribute can have varying array lengths.
6913 /// Therefore the array values are returned as a flat array, with
6914 /// another sizes array containing the lengths of each array entry.
6915 ///
6916 /// @ingroup GeometryGetters Attributes
6917 ///
6918 /// @param[in] session
6919 /// The session of Houdini you are interacting with.
6920 /// See @ref HAPI_Sessions for more on sessions.
6921 /// Pass NULL to just use the default in-process session.
6922 /// <!-- default NULL -->
6923 ///
6924 /// @param[in] node_id
6925 /// The node id.
6926 ///
6927 /// @param[in] part_id
6928 /// The part id.
6929 ///
6930 /// @param[in] attr_name
6931 /// Attribute name.
6932 ///
6933 /// @param[in] attr_info
6934 /// ::HAPI_AttributeInfo used as input for what tuple size.
6935 /// you want. Also contains some sanity checks like
6936 /// data type. Generally should be the same struct
6937 /// returned by ::HAPI_GetAttributeInfo().
6938 ///
6939 /// @param[out] data_fixed_array
6940 /// An integer array at least the size of
6941 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6942 ///
6943 /// @param[in] data_fixed_length
6944 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6945 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6946 ///
6947 /// @param[out] sizes_fixed_array
6948 /// An integer array at least the size of
6949 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6950 /// <!-- source ::HAPI_AttributeInfo::count -->
6951 ///
6952 /// @param[in] start
6953 /// First index of range. Must be at least 0 and at
6954 /// most ::HAPI_AttributeInfo::count - 1.
6955 /// <!-- default 0 -->
6956 ///
6957 /// @param[in] sizes_fixed_length
6958 /// Must be at least 0 and at most
6959 /// ::HAPI_AttributeInfo::count - @p start.
6960 /// Note, if 0 is passed for length, the function will just
6961 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6962 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6963 ///
6964 /// @param[out] job_id
6965 /// The id assigned to the job.
6966 ///
6968  HAPI_NodeId node_id,
6969  HAPI_PartId part_id,
6970  const char * attr_name,
6971  HAPI_AttributeInfo * attr_info,
6972  HAPI_Int64 * data_fixed_array,
6973  int data_fixed_length,
6974  int * sizes_fixed_array,
6975  int start, int sizes_fixed_length,
6976  int * job_id );
6977 
6978 /// @brief Get array attribute float data asynchronously.
6979 /// Each entry in an array attribute can have varying array lengths.
6980 /// Therefore the array values are returned as a flat array, with
6981 /// another sizes array containing the lengths of each array entry.
6982 ///
6983 /// @ingroup GeometryGetters Attributes
6984 ///
6985 /// @param[in] session
6986 /// The session of Houdini you are interacting with.
6987 /// See @ref HAPI_Sessions for more on sessions.
6988 /// Pass NULL to just use the default in-process session.
6989 /// <!-- default NULL -->
6990 ///
6991 /// @param[in] node_id
6992 /// The node id.
6993 ///
6994 /// @param[in] part_id
6995 /// The part id.
6996 ///
6997 /// @param[in] attr_name
6998 /// Attribute name.
6999 ///
7000 /// @param[in] attr_info
7001 /// ::HAPI_AttributeInfo used as input for what tuple size.
7002 /// you want. Also contains some sanity checks like
7003 /// data type. Generally should be the same struct
7004 /// returned by ::HAPI_GetAttributeInfo().
7005 ///
7006 /// @param[out] data_fixed_array
7007 /// An integer array at least the size of
7008 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7009 ///
7010 /// @param[in] data_fixed_length
7011 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7012 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7013 ///
7014 /// @param[out] sizes_fixed_array
7015 /// An integer array at least the size of
7016 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7017 /// <!-- source ::HAPI_AttributeInfo::count -->
7018 ///
7019 /// @param[in] start
7020 /// First index of range. Must be at least 0 and at
7021 /// most ::HAPI_AttributeInfo::count - 1.
7022 /// <!-- default 0 -->
7023 ///
7024 /// @param[in] sizes_fixed_length
7025 /// Must be at least 0 and at most
7026 /// ::HAPI_AttributeInfo::count - @p start.
7027 /// Note, if 0 is passed for length, the function will just
7028 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7029 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7030 ///
7031 /// @param[out] job_id
7032 /// The id assigned to the job.
7033 ///
7035  HAPI_NodeId node_id,
7036  HAPI_PartId part_id,
7037  const char * attr_name,
7038  HAPI_AttributeInfo * attr_info,
7039  float * data_fixed_array,
7040  int data_fixed_length,
7041  int * sizes_fixed_array,
7042  int start, int sizes_fixed_length,
7043  int * job_id );
7044 
7045 /// @brief Get array attribute 64-bit float data asynchronously.
7046 /// Each entry in an array attribute can have varying array lengths.
7047 /// Therefore the array values are returned as a flat array, with
7048 /// another sizes array containing the lengths of each array entry.
7049 ///
7050 /// @ingroup GeometryGetters Attributes
7051 ///
7052 /// @param[in] session
7053 /// The session of Houdini you are interacting with.
7054 /// See @ref HAPI_Sessions for more on sessions.
7055 /// Pass NULL to just use the default in-process session.
7056 /// <!-- default NULL -->
7057 ///
7058 /// @param[in] node_id
7059 /// The node id.
7060 ///
7061 /// @param[in] part_id
7062 /// The part id.
7063 ///
7064 /// @param[in] attr_name
7065 /// Attribute name.
7066 ///
7067 /// @param[in] attr_info
7068 /// ::HAPI_AttributeInfo used as input for what tuple size.
7069 /// you want. Also contains some sanity checks like
7070 /// data type. Generally should be the same struct
7071 /// returned by ::HAPI_GetAttributeInfo().
7072 ///
7073 /// @param[out] data_fixed_array
7074 /// An integer array at least the size of
7075 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7076 ///
7077 /// @param[in] data_fixed_length
7078 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7079 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7080 ///
7081 /// @param[out] sizes_fixed_array
7082 /// An integer array at least the size of
7083 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7084 /// <!-- source ::HAPI_AttributeInfo::count -->
7085 ///
7086 /// @param[in] start
7087 /// First index of range. Must be at least 0 and at
7088 /// most ::HAPI_AttributeInfo::count - 1.
7089 /// <!-- default 0 -->
7090 ///
7091 /// @param[in] sizes_fixed_length
7092 /// Must be at least 0 and at most
7093 /// ::HAPI_AttributeInfo::count - @p start.
7094 /// Note, if 0 is passed for length, the function will just
7095 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7096 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7097 ///
7098 /// @param[out] job_id
7099 /// The id assigned to the job.
7100 ///
7102  HAPI_NodeId node_id,
7103  HAPI_PartId part_id,
7104  const char * attr_name,
7105  HAPI_AttributeInfo * attr_info,
7106  double * data_fixed_array,
7107  int data_fixed_length,
7108  int * sizes_fixed_array,
7109  int start, int sizes_fixed_length,
7110  int * job_id );
7111 
7112 /// @brief Get array attribute string data asynchronously.
7113 /// Each entry in an array attribute can have varying array lengths.
7114 /// Therefore the array values are returned as a flat array, with
7115 /// another sizes array containing the lengths of each array entry.
7116 ///
7117 /// @ingroup GeometryGetters Attributes
7118 ///
7119 /// @param[in] session
7120 /// The session of Houdini you are interacting with.
7121 /// See @ref HAPI_Sessions for more on sessions.
7122 /// Pass NULL to just use the default in-process session.
7123 /// <!-- default NULL -->
7124 ///
7125 /// @param[in] node_id
7126 /// The node id.
7127 ///
7128 /// @param[in] part_id
7129 /// The part id.
7130 ///
7131 /// @param[in] attr_name
7132 /// Attribute name.
7133 ///
7134 /// @param[in] attr_info
7135 /// ::HAPI_AttributeInfo used as input for what tuple size.
7136 /// you want. Also contains some sanity checks like
7137 /// data type. Generally should be the same struct
7138 /// returned by ::HAPI_GetAttributeInfo().
7139 ///
7140 /// @param[out] data_fixed_array
7141 /// An integer array at least the size of
7142 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7143 ///
7144 /// @param[in] data_fixed_length
7145 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7146 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7147 ///
7148 /// @param[out] sizes_fixed_array
7149 /// An integer array at least the size of
7150 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7151 /// <!-- source ::HAPI_AttributeInfo::count -->
7152 ///
7153 /// @param[in] start
7154 /// First index of range. Must be at least 0 and at
7155 /// most ::HAPI_AttributeInfo::count - 1.
7156 /// <!-- default 0 -->
7157 ///
7158 /// @param[in] sizes_fixed_length
7159 /// Must be at least 0 and at most
7160 /// ::HAPI_AttributeInfo::count - @p start.
7161 /// Note, if 0 is passed for length, the function will just
7162 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7163 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7164 ///
7165 /// @param[out] job_id
7166 /// The id assigned to the job.
7167 ///
7168 /// @warning The string handles should be used to retrieve the strings
7169 /// immediately and are invalidated when another call to get
7170 /// this attribute's data is made.
7171 ///
7173  HAPI_NodeId node_id,
7174  HAPI_PartId part_id,
7175  const char * attr_name,
7176  HAPI_AttributeInfo * attr_info,
7177  HAPI_StringHandle * data_fixed_array,
7178  int data_fixed_length,
7179  int * sizes_fixed_array,
7180  int start, int sizes_fixed_length,
7181  int * job_id );
7182 
7183 /// @brief Get array attribute dictionary data asynchronously.
7184 /// Each entry in an array attribute can have varying array lengths.
7185 /// Therefore the array values are returned as a flat array, with
7186 /// another sizes array containing the lengths of each array entry.
7187 ///
7188 /// @ingroup GeometryGetters Attributes
7189 ///
7190 /// @param[in] session
7191 /// The session of Houdini you are interacting with.
7192 /// See @ref HAPI_Sessions for more on sessions.
7193 /// Pass NULL to just use the default in-process session.
7194 /// <!-- default NULL -->
7195 ///
7196 /// @param[in] node_id
7197 /// The node id.
7198 ///
7199 /// @param[in] part_id
7200 /// The part id.
7201 ///
7202 /// @param[in] attr_name
7203 /// Attribute name.
7204 ///
7205 /// @param[in] attr_info
7206 /// ::HAPI_AttributeInfo used as input for what tuple size.
7207 /// you want. Also contains some sanity checks like
7208 /// data type. Generally should be the same struct
7209 /// returned by ::HAPI_GetAttributeInfo().
7210 ///
7211 /// @param[out] data_fixed_array
7212 /// An integer array at least the size of
7213 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7214 ///
7215 /// @param[in] data_fixed_length
7216 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7217 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7218 ///
7219 /// @param[out] sizes_fixed_array
7220 /// An integer array at least the size of
7221 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7222 /// <!-- source ::HAPI_AttributeInfo::count -->
7223 ///
7224 /// @param[in] start
7225 /// First index of range. Must be at least 0 and at
7226 /// most ::HAPI_AttributeInfo::count - 1.
7227 /// <!-- default 0 -->
7228 ///
7229 /// @param[in] sizes_fixed_length
7230 /// Must be at least 0 and at most
7231 /// ::HAPI_AttributeInfo::count - @p start.
7232 /// Note, if 0 is passed for length, the function will just
7233 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7234 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7235 ///
7236 /// @param[out] job_id
7237 /// The id assigned to the job.
7238 ///
7239 /// @warning The string handles should be used to retrieve the strings
7240 /// immediately and are invalidated when another call to get
7241 /// this attribute's data is made.
7242 ///
7244  HAPI_NodeId node_id,
7245  HAPI_PartId part_id,
7246  const char * attr_name,
7247  HAPI_AttributeInfo * attr_info,
7248  HAPI_StringHandle * data_fixed_array,
7249  int data_fixed_length,
7250  int * sizes_fixed_array,
7251  int start, int sizes_fixed_length,
7252  int * job_id );
7253 
7254 /// @brief Get status of a job.
7255 ///
7256 /// @ingroup Status
7257 ///
7258 /// @param[in] session
7259 /// The session of Houdini you are interacting with.
7260 /// See @ref HAPI_Sessions for more on sessions.
7261 /// Pass NULL to just use the default in-process session.
7262 /// <!-- default NULL -->
7263 ///
7264 /// @param[in] job_id
7265 /// The id assigned to the job. It must equal to the index
7266 /// assigned through a previous call to an asynchronous HAPI
7267 /// method.
7268 ///
7269 /// @param[out] job_status
7270 /// The current status of the job. One of ::HAPI_JobStatus.
7271 ///
7272 HAPI_DECL HAPI_GetJobStatus( const HAPI_Session * session,
7273  int job_id,
7274  HAPI_JobStatus * job_status );
7275 
7276 /// @brief Get group names for an entire geo. Please note that this
7277 /// function is NOT per-part, but it is per-geo. The companion
7278 /// function ::HAPI_GetGroupMembership() IS per-part. Also keep
7279 /// in mind that the name string handles are only
7280 /// valid until the next time this function is called.
7281 ///
7282 /// @ingroup GeometryGetters
7283 ///
7284 /// @param[in] session
7285 /// The session of Houdini you are interacting with.
7286 /// See @ref HAPI_Sessions for more on sessions.
7287 /// Pass NULL to just use the default in-process session.
7288 /// <!-- default NULL -->
7289 ///
7290 /// @param[in] node_id
7291 /// The node id.
7292 ///
7293 /// @param[in] group_type
7294 /// The group type.
7295 ///
7296 /// @param[out] group_names_array
7297 /// The array of names to be filled. Should be the size
7298 /// given by ::HAPI_GeoInfo_GetGroupCountByType() with
7299 /// @p group_type and the ::HAPI_GeoInfo of @p geo_id.
7300 /// @note These string handles are only valid until the
7301 /// next call to ::HAPI_GetGroupNames().
7302 ///
7303 /// @param[in] group_count
7304 /// Sanity check. Should be less than or equal to the size
7305 /// of @p group_names.
7306 ///
7307 HAPI_DECL HAPI_GetGroupNames( const HAPI_Session * session,
7308  HAPI_NodeId node_id,
7309  HAPI_GroupType group_type,
7310  HAPI_StringHandle * group_names_array,
7311  int group_count );
7312 
7313 /// @brief Get group membership.
7314 ///
7315 /// @ingroup GeometryGetters
7316 ///
7317 /// @param[in] session
7318 /// The session of Houdini you are interacting with.
7319 /// See @ref HAPI_Sessions for more on sessions.
7320 /// Pass NULL to just use the default in-process session.
7321 /// <!-- default NULL -->
7322 ///
7323 /// @param[in] node_id
7324 /// The node id.
7325 ///
7326 /// @param[in] part_id
7327 /// The part id.
7328 ///
7329 /// @param[in] group_type
7330 /// The group type.
7331 ///
7332 /// @param[in] group_name
7333 /// The group name.
7334 ///
7335 /// @param[out] membership_array_all_equal
7336 /// (optional) Quick way to determine if all items are in
7337 /// the given group or all items our not in the group.
7338 /// If you do not need this information or you are getting edge
7339 /// group information, you can just pass NULL for this argument.
7340 ///
7341 /// @param[out] membership_array
7342 /// Array of ints that represent the membership of this
7343 /// group. When getting membership information for a point or
7344 /// primitive group, the size of the array should be the size
7345 /// given by ::HAPI_PartInfo_GetElementCountByGroupType() with
7346 /// @p group_type and the ::HAPI_PartInfo of @p part_id. When
7347 /// retrieving the edges belonging to an edge group, the
7348 /// membership array will be filled with point numbers that
7349 /// comprise the edges of the edge group. Each edge is specified
7350 /// by two points, which means that the size of the array should
7351 /// be the size given by ::HAPI_GetEdgeCountOfEdgeGroup() * 2.
7352 ///
7353 /// @param[in] start
7354 /// Start offset into the membership array. Must be
7355 /// less than ::HAPI_PartInfo_GetElementCountByGroupType() when
7356 /// it is a point or primitive group. When getting the
7357 /// membership information for an edge group, this argument must
7358 /// be less than the size returned by
7359 /// ::HAPI_GetEdgeCountOfEdgeGroup() * 2 - 1.
7360 /// <!-- default 0 -->
7361 ///
7362 /// @param[in] length
7363 /// Should be less than or equal to the size
7364 /// of @p membership_array.
7365 ///
7367  HAPI_NodeId node_id,
7368  HAPI_PartId part_id,
7369  HAPI_GroupType group_type,
7370  const char * group_name,
7371  HAPI_Bool * membership_array_all_equal,
7372  int * membership_array,
7373  int start, int length );
7374 
7375 /// @brief Get group counts for a specific packed instanced part.
7376 ///
7377 /// @ingroup GeometryGetters
7378 ///
7379 /// @param[in] session
7380 /// The session of Houdini you are interacting with.
7381 /// See @ref HAPI_Sessions for more on sessions.
7382 /// Pass NULL to just use the default in-process session.
7383 /// <!-- default NULL -->
7384 ///
7385 /// @param[in] node_id
7386 /// The node id.
7387 ///
7388 /// @param[in] part_id
7389 /// The part id. (should be a packed primitive)
7390 ///
7391 /// @param[out] pointGroupCount
7392 /// Number of point groups on the packed instance part.
7393 /// Will be set to -1 if the part is not a valid packed part.
7394 ///
7395 /// @param[out] primitiveGroupCount
7396 /// Number of primitive groups on the instanced part.
7397 /// Will be set to -1 if the part is not a valid instancer
7398 ///
7400  HAPI_NodeId node_id,
7401  HAPI_PartId part_id,
7402  int * pointGroupCount,
7403  int * primitiveGroupCount );
7404 
7405 /// @brief Get the group names for a packed instance part
7406 /// This functions allows you to get the group name for a specific
7407 /// packed primitive part.
7408 /// Keep in mind that the name string handles are only
7409 /// valid until the next time this function is called.
7410 ///
7411 /// @ingroup GeometryGetters
7412 ///
7413 /// @param[in] session
7414 /// The session of Houdini you are interacting with.
7415 /// See @ref HAPI_Sessions for more on sessions.
7416 /// Pass NULL to just use the default in-process session.
7417 /// <!-- default NULL -->
7418 ///
7419 /// @param[in] node_id
7420 /// The node id.
7421 ///
7422 /// @param[in] part_id
7423 /// The part id. (should be a packed primitive)
7424 ///
7425 /// @param[in] group_type
7426 /// The group type.
7427 ///
7428 /// @param[out] group_names_array
7429 /// The array of names to be filled. Should be the size
7430 /// given by ::HAPI_GetGroupCountOnPackedInstancePart() with
7431 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
7432 /// @note These string handles are only valid until the
7433 /// next call to ::HAPI_GetGroupNamesOnPackedInstancePart().
7434 ///
7435 /// @param[in] group_count
7436 /// Sanity check. Should be less than or equal to the size
7437 /// of @p group_names.
7438 ///
7440  HAPI_NodeId node_id,
7441  HAPI_PartId part_id,
7442  HAPI_GroupType group_type,
7443  HAPI_StringHandle * group_names_array,
7444  int group_count );
7445 
7446 /// @brief Get group membership for a packed instance part
7447 /// This functions allows you to get the group membership for a specific
7448 /// packed primitive part.
7449 ///
7450 /// @ingroup GeometryGetters
7451 ///
7452 /// @param[in] session
7453 /// The session of Houdini you are interacting with.
7454 /// See @ref HAPI_Sessions for more on sessions.
7455 /// Pass NULL to just use the default in-process session.
7456 /// <!-- default NULL -->
7457 ///
7458 /// @param[in] node_id
7459 /// The node id.
7460 ///
7461 /// @param[in] part_id
7462 /// The part id. (should be a packed primitive)
7463 ///
7464 /// @param[in] group_type
7465 /// The group type.
7466 ///
7467 /// @param[in] group_name
7468 /// The group name.
7469 ///
7470 /// @param[out] membership_array_all_equal
7471 /// (optional) Quick way to determine if all items are in
7472 /// the given group or all items our not in the group.
7473 /// You can just pass NULL here if not interested.
7474 ///
7475 /// @param[out] membership_array
7476 /// Array of ints that represent the membership of this
7477 /// group. Should be the size given by
7478 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
7479 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
7480 ///
7481 /// @param[in] start
7482 /// Start offset into the membership array. Must be
7483 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
7484 /// <!-- default 0 -->
7485 ///
7486 /// @param[in] length
7487 /// Should be less than or equal to the size
7488 /// of @p membership_array.
7489 /// <!-- source ::HAPI_PartInfo_GetElementCountByGroupType -->
7490 ///
7492  HAPI_NodeId node_id,
7493  HAPI_PartId part_id,
7494  HAPI_GroupType group_type,
7495  const char * group_name,
7496  HAPI_Bool * membership_array_all_equal,
7497  int * membership_array,
7498  int start, int length );
7499 
7500 /// @brief Get the part ids that this instancer part is instancing.
7501 ///
7502 /// @ingroup GeometryGetters
7503 ///
7504 /// @param[in] session
7505 /// The session of Houdini you are interacting with.
7506 /// See @ref HAPI_Sessions for more on sessions.
7507 /// Pass NULL to just use the default in-process session.
7508 /// <!-- default NULL -->
7509 ///
7510 /// @param[in] node_id
7511 /// The node id.
7512 ///
7513 /// @param[in] part_id
7514 /// The instancer part id.
7515 ///
7516 /// @param[out] instanced_parts_array
7517 /// Array of ::HAPI_PartId's to instance.
7518 ///
7519 /// @param[in] start
7520 /// Should be less than @p part_id's
7521 /// ::HAPI_PartInfo::instancedPartCount but more than or
7522 /// equal to 0.
7523 /// <!-- default 0 -->
7524 ///
7525 /// @param[in] length
7526 /// Should be less than @p part_id's
7527 /// ::HAPI_PartInfo::instancedPartCount - @p start.
7528 /// <!-- source ::HAPI_PartInfo::instancedPartCount - start -->
7529 ///
7531  HAPI_NodeId node_id,
7532  HAPI_PartId part_id,
7533  HAPI_PartId * instanced_parts_array,
7534  int start, int length );
7535 
7536 /// @brief Get the instancer part's list of transforms on which to
7537 /// instance the instanced parts you got from
7538 /// ::HAPI_GetInstancedPartIds().
7539 ///
7540 /// @ingroup GeometryGetters
7541 ///
7542 /// @param[in] session
7543 /// The session of Houdini you are interacting with.
7544 /// See @ref HAPI_Sessions for more on sessions.
7545 /// Pass NULL to just use the default in-process session.
7546 /// <!-- default NULL -->
7547 ///
7548 /// @param[in] node_id
7549 /// The node id.
7550 ///
7551 /// @param[in] part_id
7552 /// The instancer part id.
7553 ///
7554 /// @param[in] rst_order
7555 /// The order of application of translation, rotation and
7556 /// scale.
7557 ///
7558 /// @param[out] transforms_array
7559 /// Array of ::HAPI_PartId's to instance.
7560 ///
7561 /// @param[in] start
7562 /// Should be less than @p part_id's
7563 /// ::HAPI_PartInfo::instanceCount but more than or
7564 /// equal to 0.
7565 /// <!-- default 0 -->
7566 ///
7567 /// @param[in] length
7568 /// Should be less than @p part_id's
7569 /// ::HAPI_PartInfo::instanceCount - @p start.
7570 /// <!-- source ::HAPI_PartInfo::instanceCount - start -->
7571 ///
7573  HAPI_NodeId node_id,
7574  HAPI_PartId part_id,
7575  HAPI_RSTOrder rst_order,
7576  HAPI_Transform * transforms_array,
7577  int start, int length );
7578 
7579 /// @defgroup GeometrySetters Geometry Setters
7580 /// Functions for setting geometry (SOP) data
7581 
7582 /// @brief Set the main part info struct (::HAPI_PartInfo).
7583 ///
7584 /// @ingroup GeometrySetters
7585 ///
7586 /// @param[in] session
7587 /// The session of Houdini you are interacting with.
7588 /// See @ref HAPI_Sessions for more on sessions.
7589 /// Pass NULL to just use the default in-process session.
7590 /// <!-- default NULL -->
7591 ///
7592 /// @param[in] node_id
7593 /// The SOP node id.
7594 ///
7595 /// @param[in] part_id
7596 /// Currently not used. Just pass 0.
7597 /// <!-- default 0 -->
7598 ///
7599 /// @param[in] part_info
7600 /// ::HAPI_PartInfo value that describes the input
7601 /// geometry.
7602 ///
7603 HAPI_DECL HAPI_SetPartInfo( const HAPI_Session * session,
7604  HAPI_NodeId node_id,
7605  HAPI_PartId part_id,
7606  const HAPI_PartInfo * part_info );
7607 
7608 /// @brief Set the array of faces where the nth integer in the array is
7609 /// the number of vertices the nth face has.
7610 ///
7611 /// @ingroup GeometrySetters
7612 ///
7613 /// @param[in] session
7614 /// The session of Houdini you are interacting with.
7615 /// See @ref HAPI_Sessions for more on sessions.
7616 /// Pass NULL to just use the default in-process session.
7617 /// <!-- default NULL -->
7618 ///
7619 /// @param[in] node_id
7620 /// The SOP node id.
7621 ///
7622 /// @param[in] part_id
7623 /// Currently not used. Just pass 0.
7624 /// <!-- default 0 -->
7625 ///
7626 /// @param[in] face_counts_array
7627 /// An integer array at least the size of @p length.
7628 ///
7629 /// @param[in] start
7630 /// First index of range. Must be at least 0 and at
7631 /// most ::HAPI_PartInfo::faceCount - 1.
7632 /// <!-- default 0 -->
7633 ///
7634 /// @param[in] length
7635 /// Must be at least 0 and at most
7636 /// ::HAPI_PartInfo::faceCount - @p start.
7637 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
7638 ///
7639 HAPI_DECL HAPI_SetFaceCounts( const HAPI_Session * session,
7640  HAPI_NodeId node_id,
7641  HAPI_PartId part_id,
7642  const int * face_counts_array,
7643  int start, int length );
7644 
7645 /// @brief Set array containing the vertex-point associations where the
7646 /// ith element in the array is the point index the ith vertex
7647 /// associates with.
7648 ///
7649 /// @ingroup GeometrySetters
7650 ///
7651 /// @param[in] session
7652 /// The session of Houdini you are interacting with.
7653 /// See @ref HAPI_Sessions for more on sessions.
7654 /// Pass NULL to just use the default in-process session.
7655 /// <!-- default NULL -->
7656 ///
7657 /// @param[in] node_id
7658 /// The SOP node id.
7659 ///
7660 /// @param[in] part_id
7661 /// Currently not used. Just pass 0.
7662 ///
7663 /// @param[in] vertex_list_array
7664 /// An integer array at least the size of length.
7665 ///
7666 /// @param[in] start
7667 /// First index of range. Must be at least 0 and at
7668 /// most ::HAPI_PartInfo::vertexCount - 1.
7669 /// <!-- default 0 -->
7670 ///
7671 /// @param[in] length
7672 /// Must be at least 0 and at most
7673 /// ::HAPI_PartInfo::vertexCount - @p start.
7674 /// <!-- source ::HAPI_PartInfo::vertexCount - start -->
7675 ///
7676 HAPI_DECL HAPI_SetVertexList( const HAPI_Session * session,
7677  HAPI_NodeId node_id,
7678  HAPI_PartId part_id,
7679  const int * vertex_list_array,
7680  int start, int length );
7681 
7682 /// @brief Add an attribute.
7683 ///
7684 /// @ingroup GeometrySetters Attributes
7685 ///
7686 /// @param[in] session
7687 /// The session of Houdini you are interacting with.
7688 /// See @ref HAPI_Sessions for more on sessions.
7689 /// Pass NULL to just use the default in-process session.
7690 /// <!-- default NULL -->
7691 ///
7692 /// @param[in] node_id
7693 /// The SOP node id.
7694 ///
7695 /// @param[in] part_id
7696 /// Currently not used. Just pass 0.
7697 ///
7698 /// @param[in] name
7699 /// Attribute name.
7700 ///
7701 /// @param[in] attr_info
7702 /// ::HAPI_AttributeInfo stores attribute properties.
7703 ///
7704 HAPI_DECL HAPI_AddAttribute( const HAPI_Session * session,
7705  HAPI_NodeId node_id,
7706  HAPI_PartId part_id,
7707  const char * name,
7708  const HAPI_AttributeInfo * attr_info );
7709 
7710 /// @brief Delete an attribute from an input geo
7711 ///
7712 /// @ingroup GeometrySetters Attributes
7713 ///
7714 /// @param[in] session
7715 /// The session of Houdini you are interacting with.
7716 /// See @ref HAPI_Sessions for more on sessions.
7717 /// Pass NULL to just use the default in-process session.
7718 /// <!-- default NULL -->
7719 ///
7720 /// @param[in] node_id
7721 /// The SOP node id.
7722 ///
7723 /// @param[in] part_id
7724 /// Currently not used. Just pass 0.
7725 ///
7726 /// @param[in] name
7727 /// Attribute name.
7728 ///
7729 /// @param[in] attr_info
7730 /// ::HAPI_AttributeInfo stores attribute properties.
7731 ///
7733  HAPI_NodeId node_id,
7734  HAPI_PartId part_id,
7735  const char * name,
7736  const HAPI_AttributeInfo * attr_info );
7737 
7738 /// @brief Set attribute integer data.
7739 ///
7740 /// @ingroup GeometrySetters Attributes
7741 ///
7742 /// @param[in] session
7743 /// The session of Houdini you are interacting with.
7744 /// See @ref HAPI_Sessions for more on sessions.
7745 /// Pass NULL to just use the default in-process session.
7746 /// <!-- default NULL -->
7747 ///
7748 /// @param[in] node_id
7749 /// The SOP node id.
7750 ///
7751 /// @param[in] part_id
7752 /// Currently not used. Just pass 0.
7753 ///
7754 /// @param[in] name
7755 /// Attribute name.
7756 ///
7757 /// @param[in] attr_info
7758 /// ::HAPI_AttributeInfo used as input for what tuple size.
7759 /// you want. Also contains some sanity checks like
7760 /// data type. Generally should be the same struct
7761 /// returned by ::HAPI_GetAttributeInfo().
7762 ///
7763 /// @param[in] data_array
7764 /// An integer array at least the size of
7765 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7766 ///
7767 /// @param[in] start
7768 /// First index of range. Must be at least 0 and at
7769 /// most ::HAPI_AttributeInfo::count - 1.
7770 /// <!-- default 0 -->
7771 ///
7772 /// @param[in] length
7773 /// Must be at least 0 and at most
7774 /// ::HAPI_AttributeInfo::count - @p start.
7775 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7776 ///
7778  HAPI_NodeId node_id,
7779  HAPI_PartId part_id,
7780  const char * name,
7781  const HAPI_AttributeInfo * attr_info,
7782  const int * data_array,
7783  int start, int length );
7784 
7785 /// @brief Set unsigned 8-bit attribute integer data.
7786 ///
7787 /// @ingroup GeometrySetters Attributes
7788 ///
7789 /// @param[in] session
7790 /// The session of Houdini you are interacting with.
7791 /// See @ref HAPI_Sessions for more on sessions.
7792 /// Pass NULL to just use the default in-process session.
7793 /// <!-- default NULL -->
7794 ///
7795 /// @param[in] node_id
7796 /// The SOP node id.
7797 ///
7798 /// @param[in] part_id
7799 /// Currently not used. Just pass 0.
7800 ///
7801 /// @param[in] name
7802 /// Attribute name.
7803 ///
7804 /// @param[in] attr_info
7805 /// ::HAPI_AttributeInfo used as input for what tuple size.
7806 /// you want. Also contains some sanity checks like
7807 /// data type. Generally should be the same struct
7808 /// returned by ::HAPI_GetAttributeInfo().
7809 ///
7810 /// @param[in] data_array
7811 /// An unsigned 8-bit integer array at least the size of
7812 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7813 ///
7814 /// @param[in] start
7815 /// First index of range. Must be at least 0 and at
7816 /// most ::HAPI_AttributeInfo::count - 1.
7817 /// <!-- default 0 -->
7818 ///
7819 /// @param[in] length
7820 /// Must be at least 0 and at most
7821 /// ::HAPI_AttributeInfo::count - @p start.
7822 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7823 ///
7825  HAPI_NodeId node_id,
7826  HAPI_PartId part_id,
7827  const char * name,
7828  const HAPI_AttributeInfo * attr_info,
7829  const HAPI_UInt8 * data_array,
7830  int start, int length );
7831 
7832 /// @brief Set 8-bit attribute integer data.
7833 ///
7834 /// @ingroup GeometrySetters Attributes
7835 ///
7836 /// @param[in] session
7837 /// The session of Houdini you are interacting with.
7838 /// See @ref HAPI_Sessions for more on sessions.
7839 /// Pass NULL to just use the default in-process session.
7840 /// <!-- default NULL -->
7841 ///
7842 /// @param[in] node_id
7843 /// The SOP node id.
7844 ///
7845 /// @param[in] part_id
7846 /// Currently not used. Just pass 0.
7847 ///
7848 /// @param[in] name
7849 /// Attribute name.
7850 ///
7851 /// @param[in] attr_info
7852 /// ::HAPI_AttributeInfo used as input for what tuple size.
7853 /// you want. Also contains some sanity checks like
7854 /// data type. Generally should be the same struct
7855 /// returned by ::HAPI_GetAttributeInfo().
7856 ///
7857 /// @param[in] data_array
7858 /// An 8-bit integer array at least the size of
7859 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7860 ///
7861 /// @param[in] start
7862 /// First index of range. Must be at least 0 and at
7863 /// most ::HAPI_AttributeInfo::count - 1.
7864 /// <!-- default 0 -->
7865 ///
7866 /// @param[in] length
7867 /// Must be at least 0 and at most
7868 /// ::HAPI_AttributeInfo::count - @p start.
7869 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7870 ///
7872  HAPI_NodeId node_id,
7873  HAPI_PartId part_id,
7874  const char * name,
7875  const HAPI_AttributeInfo * attr_info,
7876  const HAPI_Int8 * data_array,
7877  int start, int length );
7878 
7879 /// @brief Set 16-bit attribute integer data.
7880 ///
7881 /// @ingroup GeometrySetters Attributes
7882 ///
7883 /// @param[in] session
7884 /// The session of Houdini you are interacting with.
7885 /// See @ref HAPI_Sessions for more on sessions.
7886 /// Pass NULL to just use the default in-process session.
7887 /// <!-- default NULL -->
7888 ///
7889 /// @param[in] node_id
7890 /// The SOP node id.
7891 ///
7892 /// @param[in] part_id
7893 /// Currently not used. Just pass 0.
7894 ///
7895 /// @param[in] name
7896 /// Attribute name.
7897 ///
7898 /// @param[in] attr_info
7899 /// ::HAPI_AttributeInfo used as input for what tuple size.
7900 /// you want. Also contains some sanity checks like
7901 /// data type. Generally should be the same struct
7902 /// returned by ::HAPI_GetAttributeInfo().
7903 ///
7904 /// @param[in] data_array
7905 /// An 16-bit integer array at least the size of
7906 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7907 ///
7908 /// @param[in] start
7909 /// First index of range. Must be at least 0 and at
7910 /// most ::HAPI_AttributeInfo::count - 1.
7911 /// <!-- default 0 -->
7912 ///
7913 /// @param[in] length
7914 /// Must be at least 0 and at most
7915 /// ::HAPI_AttributeInfo::count - @p start.
7916 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7917 ///
7919  HAPI_NodeId node_id,
7920  HAPI_PartId part_id,
7921  const char * name,
7922  const HAPI_AttributeInfo * attr_info,
7923  const HAPI_Int16 * data_array,
7924  int start, int length );
7925 
7926 /// @brief Set 64-bit attribute integer data.
7927 ///
7928 /// @ingroup GeometrySetters Attributes
7929 ///
7930 /// @param[in] session
7931 /// The session of Houdini you are interacting with.
7932 /// See @ref HAPI_Sessions for more on sessions.
7933 /// Pass NULL to just use the default in-process session.
7934 /// <!-- default NULL -->
7935 ///
7936 /// @param[in] node_id
7937 /// The SOP node id.
7938 ///
7939 /// @param[in] part_id
7940 /// Currently not used. Just pass 0.
7941 ///
7942 /// @param[in] name
7943 /// Attribute name.
7944 ///
7945 /// @param[in] attr_info
7946 /// ::HAPI_AttributeInfo used as input for what tuple size.
7947 /// you want. Also contains some sanity checks like
7948 /// data type. Generally should be the same struct
7949 /// returned by ::HAPI_GetAttributeInfo().
7950 ///
7951 /// @param[in] data_array
7952 /// An 64-bit integer array at least the size of
7953 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7954 ///
7955 /// @param[in] start
7956 /// First index of range. Must be at least 0 and at
7957 /// most ::HAPI_AttributeInfo::count - 1.
7958 /// <!-- default 0 -->
7959 ///
7960 /// @param[in] length
7961 /// Must be at least 0 and at most
7962 /// ::HAPI_AttributeInfo::count - @p start.
7963 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7964 ///
7966  HAPI_NodeId node_id,
7967  HAPI_PartId part_id,
7968  const char * name,
7969  const HAPI_AttributeInfo * attr_info,
7970  const HAPI_Int64 * data_array,
7971  int start, int length );
7972 
7973 /// @brief Set attribute float data.
7974 ///
7975 /// @ingroup GeometrySetters Attributes
7976 ///
7977 /// @param[in] session
7978 /// The session of Houdini you are interacting with.
7979 /// See @ref HAPI_Sessions for more on sessions.
7980 /// Pass NULL to just use the default in-process session.
7981 /// <!-- default NULL -->
7982 ///
7983 /// @param[in] node_id
7984 /// The SOP node id.
7985 ///
7986 /// @param[in] part_id
7987 /// Currently not used. Just pass 0.
7988 ///
7989 /// @param[in] name
7990 /// Attribute name.
7991 ///
7992 /// @param[in] attr_info
7993 /// ::HAPI_AttributeInfo used as input for what tuple size.
7994 /// you want. Also contains some sanity checks like
7995 /// data type. Generally should be the same struct
7996 /// returned by ::HAPI_GetAttributeInfo().
7997 ///
7998 /// @param[in] data_array
7999 /// An float array at least the size of
8000 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8001 ///
8002 /// @param[in] start
8003 /// First index of range. Must be at least 0 and at
8004 /// most ::HAPI_AttributeInfo::count - 1.
8005 /// <!-- default 0 -->
8006 ///
8007 /// @param[in] length
8008 /// Must be at least 0 and at most
8009 /// ::HAPI_AttributeInfo::count - @p start.
8010 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8011 ///
8013  HAPI_NodeId node_id,
8014  HAPI_PartId part_id,
8015  const char * name,
8016  const HAPI_AttributeInfo * attr_info,
8017  const float * data_array,
8018  int start, int length );
8019 
8020 /// @brief Set 64-bit attribute float data.
8021 ///
8022 /// @ingroup GeometrySetters Attributes
8023 ///
8024 /// @param[in] session
8025 /// The session of Houdini you are interacting with.
8026 /// See @ref HAPI_Sessions for more on sessions.
8027 /// Pass NULL to just use the default in-process session.
8028 /// <!-- default NULL -->
8029 ///
8030 /// @param[in] node_id
8031 /// The SOP node id.
8032 ///
8033 /// @param[in] part_id
8034 /// Currently not used. Just pass 0.
8035 ///
8036 /// @param[in] name
8037 /// Attribute name.
8038 ///
8039 /// @param[in] attr_info
8040 /// ::HAPI_AttributeInfo used as input for what tuple size.
8041 /// you want. Also contains some sanity checks like
8042 /// data type. Generally should be the same struct
8043 /// returned by ::HAPI_GetAttributeInfo().
8044 ///
8045 /// @param[in] data_array
8046 /// An 64-bit float array at least the size of
8047 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8048 ///
8049 /// @param[in] start
8050 /// First index of range. Must be at least 0 and at
8051 /// most ::HAPI_AttributeInfo::count - 1.
8052 /// <!-- default 0 -->
8053 ///
8054 /// @param[in] length
8055 /// Must be at least 0 and at most
8056 /// ::HAPI_AttributeInfo::count - @p start.
8057 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8058 ///
8060  HAPI_NodeId node_id,
8061  HAPI_PartId part_id,
8062  const char * name,
8063  const HAPI_AttributeInfo * attr_info,
8064  const double * data_array,
8065  int start, int length );
8066 
8067 /// @brief Set attribute string data.
8068 ///
8069 /// @ingroup GeometrySetters Attributes
8070 ///
8071 /// @param[in] session
8072 /// The session of Houdini you are interacting with.
8073 /// See @ref HAPI_Sessions for more on sessions.
8074 /// Pass NULL to just use the default in-process session.
8075 /// <!-- default NULL -->
8076 ///
8077 /// @param[in] node_id
8078 /// The SOP node id.
8079 ///
8080 /// @param[in] part_id
8081 /// Currently not used. Just pass 0.
8082 ///
8083 /// @param[in] name
8084 /// Attribute name.
8085 ///
8086 /// @param[in] attr_info
8087 /// ::HAPI_AttributeInfo used as input for what tuple size
8088 /// you want. Also contains some sanity checks like
8089 /// data type. Generally should be the same struct
8090 /// returned by ::HAPI_GetAttributeInfo().
8091 ///
8092 /// @param[in] data_array
8093 /// An ::HAPI_StringHandle array at least the size of
8094 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8095 ///
8096 /// @param[in] start
8097 /// First index of range. Must be at least 0 and at
8098 /// most ::HAPI_AttributeInfo::count - 1.
8099 /// <!-- default 0 -->
8100 ///
8101 /// @param[in] length
8102 /// Must be at least 0 and at most
8103 /// ::HAPI_AttributeInfo::count - @p start.
8104 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8105 ///
8107  HAPI_NodeId node_id,
8108  HAPI_PartId part_id,
8109  const char * name,
8110  const HAPI_AttributeInfo * attr_info,
8111  const char ** data_array,
8112  int start, int length );
8113 
8114 /// @brief Set attribute string data by index.
8115 ///
8116 /// @ingroup GeometrySetters Attributes
8117 ///
8118 /// @param[in] session
8119 /// The session of Houdini you are interacting with.
8120 /// See @ref HAPI_Sessions for more on sessions.
8121 /// Pass NULL to just use the default in-process session.
8122 /// <!-- default NULL -->
8123 ///
8124 /// @param[in] node_id
8125 /// The SOP node id.
8126 ///
8127 /// @param[in] part_id
8128 /// Currently not used. Just pass 0.
8129 ///
8130 /// @param[in] name
8131 /// Attribute name.
8132 ///
8133 /// @param[in] attr_info
8134 /// ::HAPI_AttributeInfo used as input for what tuple size.
8135 /// you want. Also contains some sanity checks like
8136 /// data type. Generally should be the same struct
8137 /// returned by ::HAPI_GetAttributeInfo().
8138 ///
8139 /// @param[in] string_array
8140 /// An array of strings at least the size of
8141 /// <tt>string_count/tt>.
8142 ///
8143 /// @param[in] string_count
8144 /// Number of strings that are indexed.
8145 ///
8146 /// @param[in] indices_array
8147 /// integer array at least the size of
8148 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>. Each
8149 /// entry indexes string_array.
8150 ///
8151 /// @param[in] indices_start
8152 /// First index of range. Must be at least 0 and at
8153 /// most ::HAPI_AttributeInfo::count - 1.
8154 /// <!-- default 0 -->
8155 ///
8156 /// @param[in] indices_length
8157 /// Must be at least 0 and at most
8158 /// ::HAPI_AttributeInfo::count - @p start.
8159 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8160 ///
8162  HAPI_NodeId node_id,
8163  HAPI_PartId part_id,
8164  const char* name,
8165  const HAPI_AttributeInfo* attr_info,
8166  const char** string_array,
8167  int string_count,
8168  const int* indices_array,
8169  int indices_start,
8170  int indices_length);
8171 
8172 /// @brief Set multiple attribute string data to the same unique value.
8173 ///
8174 /// @ingroup GeometrySetters Attributes
8175 ///
8176 /// @param[in] session
8177 /// The session of Houdini you are interacting with.
8178 /// See @ref HAPI_Sessions for more on sessions.
8179 /// Pass NULL to just use the default in-process session.
8180 /// <!-- default NULL -->
8181 ///
8182 /// @param[in] node_id
8183 /// The SOP node id.
8184 ///
8185 /// @param[in] part_id
8186 /// Currently not used. Just pass 0.
8187 ///
8188 /// @param[in] name
8189 /// Attribute name.
8190 ///
8191 /// @param[in] attr_info
8192 /// ::HAPI_AttributeInfo used as input for what tuple size.
8193 /// you want. Also contains some sanity checks like
8194 /// data type. Generally should be the same struct
8195 /// returned by ::HAPI_GetAttributeInfo().
8196 ///
8197 /// @param[in] data_array
8198 /// A string
8199 ///
8200 /// @param[in] data_length
8201 /// Must be the length of string data.
8202 ///
8203 /// @param[in] start_index
8204 /// Must be at least 0 and at most
8205 /// ::HAPI_AttributeInfo::count - @p start.
8206 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8207 ///
8208 /// @param[in] num_indices
8209 /// Must be at least 0 and at most
8210 /// ::HAPI_AttributeInfo::count - @p start.
8211 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8212 ///
8214  const HAPI_Session* session,
8215  HAPI_NodeId node_id,
8216  HAPI_PartId part_id,
8217  const char* name,
8218  const HAPI_AttributeInfo* attr_info,
8219  const char* data_array,
8220  int data_length,
8221  int start_index,
8222  int num_indices);
8223 
8224 /// @brief Set multiple attribute int data to the same unique value.
8225 ///
8226 /// @ingroup GeometrySetters Attributes
8227 ///
8228 /// @param[in] session
8229 /// The session of Houdini you are interacting with.
8230 /// See @ref HAPI_Sessions for more on sessions.
8231 /// Pass NULL to just use the default in-process session.
8232 /// <!-- default NULL -->
8233 ///
8234 /// @param[in] node_id
8235 /// The SOP node id.
8236 ///
8237 /// @param[in] part_id
8238 /// Currently not used. Just pass 0.
8239 ///
8240 /// @param[in] name
8241 /// Attribute name.
8242 ///
8243 /// @param[in] attr_info
8244 /// ::HAPI_AttributeInfo used as input for what tuple size.
8245 /// you want. Also contains some sanity checks like
8246 /// data type. Generally should be the same struct
8247 /// returned by ::HAPI_GetAttributeInfo().
8248 ///
8249 /// @param[in] data_array
8250 /// A integer array at least the size of
8251 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8252 ///
8253 /// @param[in] data_length
8254 /// An integer of at least the size of
8255 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8256 ///
8257 /// @param[in] start_index
8258 /// First index of range. Must be at least 0 and at
8259 /// most ::HAPI_AttributeInfo::count - 1.
8260 /// <!-- default 0 -->
8261 ///
8262 /// @param[in] num_indices
8263 /// Must be at least 0 and at most
8264 /// ::HAPI_AttributeInfo::count - @p start_index.
8265 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8266 ///
8268  const HAPI_Session* session,
8269  HAPI_NodeId node_id,
8270  HAPI_PartId part_id,
8271  const char* name,
8272  const HAPI_AttributeInfo* attr_info,
8273  const int* data_array,
8274  int data_length,
8275  int start_index,
8276  int num_indices);
8277 
8278 /// @brief Set multiple attribute unsigned 8-bit int data to the same unique value.
8279 ///
8280 /// @ingroup GeometrySetters Attributes
8281 ///
8282 /// @param[in] session
8283 /// The session of Houdini you are interacting with.
8284 /// See @ref HAPI_Sessions for more on sessions.
8285 /// Pass NULL to just use the default in-process session.
8286 /// <!-- default NULL -->
8287 ///
8288 /// @param[in] node_id
8289 /// The SOP node id.
8290 ///
8291 /// @param[in] part_id
8292 /// Currently not used. Just pass 0.
8293 ///
8294 /// @param[in] name
8295 /// Attribute name.
8296 ///
8297 /// @param[in] attr_info
8298 /// ::HAPI_AttributeInfo used as input for what tuple size.
8299 /// you want. Also contains some sanity checks like
8300 /// data type. Generally should be the same struct
8301 /// returned by ::HAPI_GetAttributeInfo().
8302 ///
8303 /// @param[in] data_array
8304 /// A integer array at least the size of
8305 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8306 ///
8307 /// @param[in] data_length
8308 /// An integer of at least the size of
8309 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8310 ///
8311 /// @param[in] start_index
8312 /// First index of range. Must be at least 0 and at
8313 /// most ::HAPI_AttributeInfo::count - 1.
8314 /// <!-- default 0 -->
8315 ///
8316 /// @param[in] num_indices
8317 /// Must be at least 0 and at most
8318 /// ::HAPI_AttributeInfo::count - @p start_index.
8319 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8320 ///
8322  const HAPI_Session* session,
8323  HAPI_NodeId node_id,
8324  HAPI_PartId part_id,
8325  const char* name,
8326  const HAPI_AttributeInfo* attr_info,
8327  const HAPI_UInt8* data_array,
8328  int data_length,
8329  int start_index,
8330  int num_indices);
8331 
8332 /// @brief Set multiple attribute 8-bit int data to the same unique value.
8333 ///
8334 ///
8335 /// @ingroup GeometrySetters Attributes
8336 ///
8337 /// @param[in] session
8338 /// The session of Houdini you are interacting with.
8339 /// See @ref HAPI_Sessions for more on sessions.
8340 /// Pass NULL to just use the default in-process session.
8341 /// <!-- default NULL -->
8342 ///
8343 /// @param[in] node_id
8344 /// The SOP node id.
8345 ///
8346 /// @param[in] part_id
8347 /// Currently not used. Just pass 0.
8348 ///
8349 /// @param[in] name
8350 /// Attribute name.
8351 ///
8352 /// @param[in] attr_info
8353 /// ::HAPI_AttributeInfo used as input for what tuple size.
8354 /// you want. Also contains some sanity checks like
8355 /// data type. Generally should be the same struct
8356 /// returned by ::HAPI_GetAttributeInfo().
8357 ///
8358 /// @param[in] data_array
8359 /// A integer array at least the size of
8360 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8361 ///
8362 /// @param[in] data_length
8363 /// An integer of at least the size of
8364 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8365 ///
8366 /// @param[in] start_index
8367 /// First index of range. Must be at least 0 and at
8368 /// most ::HAPI_AttributeInfo::count - 1.
8369 /// <!-- default 0 -->
8370 ///
8371 /// @param[in] num_indices
8372 /// Must be at least 0 and at most
8373 /// ::HAPI_AttributeInfo::count - @p start_index.
8374 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8375 ///
8377  const HAPI_Session* session,
8378  HAPI_NodeId node_id,
8379  HAPI_PartId part_id,
8380  const char* name,
8381  const HAPI_AttributeInfo* attr_info,
8382  const HAPI_Int8* data_array,
8383  int data_length,
8384  int start_index,
8385  int num_indices);
8386 
8387 /// @brief Set multiple attribute 16-bit int data to the same unique value.
8388 ///
8389 /// @ingroup GeometrySetters Attributes
8390 ///
8391 /// @param[in] session
8392 /// The session of Houdini you are interacting with.
8393 /// See @ref HAPI_Sessions for more on sessions.
8394 /// Pass NULL to just use the default in-process session.
8395 /// <!-- default NULL -->
8396 ///
8397 /// @param[in] node_id
8398 /// The SOP node id.
8399 ///
8400 /// @param[in] part_id
8401 /// Currently not used. Just pass 0.
8402 ///
8403 /// @param[in] name
8404 /// Attribute name.
8405 ///
8406 /// @param[in] attr_info
8407 /// ::HAPI_AttributeInfo used as input for what tuple size.
8408 /// you want. Also contains some sanity checks like
8409 /// data type. Generally should be the same struct
8410 /// returned by ::HAPI_GetAttributeInfo().
8411 ///
8412 /// @param[in] data_array
8413 /// A integer array at least the size of
8414 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8415 ///
8416 /// @param[in] data_length
8417 /// An integer of at least the size of
8418 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8419 ///
8420 /// @param[in] start_index
8421 /// First index of range. Must be at least 0 and at
8422 /// most ::HAPI_AttributeInfo::count - 1.
8423 /// <!-- default 0 -->
8424 ///
8425 /// @param[in] num_indices
8426 /// Must be at least 0 and at most
8427 /// ::HAPI_AttributeInfo::count - @p start_index.
8428 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8429 ///
8431  const HAPI_Session* session,
8432  HAPI_NodeId node_id,
8433  HAPI_PartId part_id,
8434  const char* name,
8435  const HAPI_AttributeInfo* attr_info,
8436  const HAPI_Int16* data_array,
8437  int data_length,
8438  int start_index,
8439  int num_indices);
8440 
8441 /// @brief Set multiple attribute 64-bit int data to the same unique value.
8442 ///
8443 /// @ingroup GeometrySetters Attributes
8444 ///
8445 /// @param[in] session
8446 /// The session of Houdini you are interacting with.
8447 /// See @ref HAPI_Sessions for more on sessions.
8448 /// Pass NULL to just use the default in-process session.
8449 /// <!-- default NULL -->
8450 ///
8451 /// @param[in] node_id
8452 /// The SOP node id.
8453 ///
8454 /// @param[in] part_id
8455 /// Currently not used. Just pass 0.
8456 ///
8457 /// @param[in] name
8458 /// Attribute name.
8459 ///
8460 /// @param[in] attr_info
8461 /// ::HAPI_AttributeInfo used as input for what tuple size.
8462 /// you want. Also contains some sanity checks like
8463 /// data type. Generally should be the same struct
8464 /// returned by ::HAPI_GetAttributeInfo().
8465 ///
8466 /// @param[in] data_array
8467 /// A integer array at least the size of
8468 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8469 ///
8470 /// @param[in] data_length
8471 /// An integer of at least the size of
8472 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8473 ///
8474 /// @param[in] start_index
8475 /// First index of range. Must be at least 0 and at
8476 /// most ::HAPI_AttributeInfo::count - 1.
8477 /// <!-- default 0 -->
8478 ///
8479 /// @param[in] num_indices
8480 /// Must be at least 0 and at most
8481 /// ::HAPI_AttributeInfo::count - @p start_index.
8482 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8483 ///
8485  const HAPI_Session* session,
8486  HAPI_NodeId node_id,
8487  HAPI_PartId part_id,
8488  const char* name,
8489  const HAPI_AttributeInfo* attr_info,
8490  const HAPI_Int64* data_array,
8491  int data_length,
8492  int start_index,
8493  int num_indices);
8494 
8495 /// @brief Set multiple attribute float data to the same unique value.
8496 ///
8497 /// @ingroup GeometrySetters Attributes
8498 ///
8499 /// @param[in] session
8500 /// The session of Houdini you are interacting with.
8501 /// See @ref HAPI_Sessions for more on sessions.
8502 /// Pass NULL to just use the default in-process session.
8503 /// <!-- default NULL -->
8504 ///
8505 /// @param[in] node_id
8506 /// The SOP node id.
8507 ///
8508 /// @param[in] part_id
8509 /// Currently not used. Just pass 0.
8510 ///
8511 /// @param[in] name
8512 /// Attribute name.
8513 ///
8514 /// @param[in] attr_info
8515 /// ::HAPI_AttributeInfo used as input for what tuple size.
8516 /// you want. Also contains some sanity checks like
8517 /// data type. Generally should be the same struct
8518 /// returned by ::HAPI_GetAttributeInfo().
8519 ///
8520 /// @param[in] data_array
8521 /// A floating point array at least the size of
8522 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8523 ///
8524 /// @param[in] data_length
8525 /// An integer of at least the size of
8526 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8527 ///
8528 /// @param[in] start_index
8529 /// First index of range. Must be at least 0 and at
8530 /// most ::HAPI_AttributeInfo::count - 1.
8531 /// <!-- default 0 -->
8532 ///
8533 /// @param[in] num_indices
8534 /// Must be at least 0 and at most
8535 /// ::HAPI_AttributeInfo::count - @p start_index.
8536 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8537 ///
8539  const HAPI_Session* session,
8540  HAPI_NodeId node_id,
8541  HAPI_PartId part_id,
8542  const char* name,
8543  const HAPI_AttributeInfo* attr_info,
8544  const float* data_array,
8545  int data_length,
8546  int start_index,
8547  int num_indices);
8548 
8549 /// @brief Set multiple attribute 64-bit float data to the same unique value.
8550 ///
8551 /// @ingroup GeometrySetters Attributes
8552 ///
8553 /// @param[in] session
8554 /// The session of Houdini you are interacting with.
8555 /// See @ref HAPI_Sessions for more on sessions.
8556 /// Pass NULL to just use the default in-process session.
8557 /// <!-- default NULL -->
8558 ///
8559 /// @param[in] node_id
8560 /// The SOP node id.
8561 ///
8562 /// @param[in] part_id
8563 /// Currently not used. Just pass 0.
8564 ///
8565 /// @param[in] name
8566 /// Attribute name.
8567 ///
8568 /// @param[in] attr_info
8569 /// ::HAPI_AttributeInfo used as input for what tuple size.
8570 /// you want. Also contains some sanity checks like
8571 /// data type. Generally should be the same struct
8572 /// returned by ::HAPI_GetAttributeInfo().
8573 ///
8574 /// @param[in] data_array
8575 /// A floating point array at least the size of
8576 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8577 ///
8578 /// @param[in] data_length
8579 /// An integer of at least the size of
8580 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8581 ///
8582 /// @param[in] start_index
8583 /// First index of range. Must be at least 0 and at
8584 /// most ::HAPI_AttributeInfo::count - 1.
8585 /// <!-- default 0 -->
8586 ///
8587 /// @param[in] num_indices
8588 /// Must be at least 0 and at most
8589 /// ::HAPI_AttributeInfo::count - @p start_index.
8590 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8591 ///
8593  const HAPI_Session* session,
8594  HAPI_NodeId node_id,
8595  HAPI_PartId part_id,
8596  const char* name,
8597  const HAPI_AttributeInfo* attr_info,
8598  const double* data_array,
8599  int data_length,
8600  int start_index,
8601  int num_indices);
8602 
8603 /// @brief Set attribute dictionary data. The dictionary data should
8604 /// be provided as JSON-encoded strings.
8605 ///
8606 /// @ingroup GeometrySetters Attributes
8607 ///
8608 /// @param[in] session
8609 /// The session of Houdini you are interacting with.
8610 /// See @ref HAPI_Sessions for more on sessions.
8611 /// Pass NULL to just use the default in-process session.
8612 /// <!-- default NULL -->
8613 ///
8614 /// @param[in] node_id
8615 /// The SOP node id.
8616 ///
8617 /// @param[in] part_id
8618 /// Currently not used. Just pass 0.
8619 ///
8620 /// @param[in] name
8621 /// Attribute name.
8622 ///
8623 /// @param[in] attr_info
8624 /// ::HAPI_AttributeInfo used as input for what tuple size
8625 /// you want. Also contains some sanity checks like
8626 /// data type. Generally should be the same struct
8627 /// returned by ::HAPI_GetAttributeInfo().
8628 ///
8629 /// @param[in] data_array
8630 /// An ::HAPI_StringHandle array at least the size of
8631 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8632 ///
8633 /// @param[in] start
8634 /// First index of range. Must be at least 0 and at
8635 /// most ::HAPI_AttributeInfo::count - 1.
8636 /// <!-- default 0 -->
8637 ///
8638 /// @param[in] length
8639 /// Must be at least 0 and at most
8640 /// ::HAPI_AttributeInfo::count - @p start.
8641 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8642 ///
8644  HAPI_NodeId node_id,
8645  HAPI_PartId part_id,
8646  const char* name,
8647  const HAPI_AttributeInfo* attr_info,
8648  const char** data_array,
8649  int start, int length );
8650 
8651 /// @brief Set integer array attribute data.
8652 ///
8653 /// @ingroup GeometrySetters Attributes
8654 ///
8655 /// @param[in] session
8656 /// The session of Houdini you are interacting with.
8657 /// See @ref HAPI_Sessions for more on sessions.
8658 /// Pass NULL to just use the default in-process session.
8659 /// <!-- default NULL -->
8660 ///
8661 /// @param[in] node_id
8662 /// The SOP node id.
8663 ///
8664 /// @param[in] part_id
8665 /// Currently not used. Just pass 0.
8666 ///
8667 /// @param[in] name
8668 /// Attribute name.
8669 ///
8670 /// @param[in] attr_info
8671 /// ::HAPI_AttributeInfo that contains the description for the
8672 /// attribute that is being set.
8673 ///
8674 /// @param[in] data_fixed_array
8675 /// An array containing the int values of the attribute.
8676 ///
8677 /// @param[in] data_fixed_length
8678 /// The total size of the data array. The size can be no greater
8679 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8680 /// of the attribute.
8681 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8682 ///
8683 /// @param[in] sizes_fixed_array
8684 /// An array of integers that contains the sizes of each
8685 /// attribute array. This is required because the attribute
8686 /// array for each geometry component can be of variable size.
8687 ///
8688 /// @param[in] start
8689 /// First index of range. Must be at least 0 and at most
8690 /// ::HAPI_AttributeInfo::count - 1.
8691 /// <!-- default 0 -->
8692 ///
8693 /// @param[in] sizes_fixed_length
8694 /// Must be at least 0 and at most
8695 /// ::HAPI_AttributeInfo::count - @p start.
8696 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8698  HAPI_NodeId node_id,
8699  HAPI_PartId part_id,
8700  const char * name,
8701  const HAPI_AttributeInfo * attr_info,
8702  const int * data_fixed_array,
8703  int data_fixed_length,
8704  const int * sizes_fixed_array,
8705  int start,
8706  int sizes_fixed_length );
8707 
8708 /// @brief Set unsigned 8-bit integer array attribute data.
8709 ///
8710 /// @ingroup GeometrySetters Attributes
8711 ///
8712 /// @param[in] session
8713 /// The session of Houdini you are interacting with.
8714 /// See @ref HAPI_Sessions for more on sessions.
8715 /// Pass NULL to just use the default in-process session.
8716 /// <!-- default NULL -->
8717 ///
8718 /// @param[in] node_id
8719 /// The SOP node id.
8720 ///
8721 /// @param[in] part_id
8722 /// Currently not used. Just pass 0.
8723 ///
8724 /// @param[in] name
8725 /// Attribute name.
8726 ///
8727 /// @param[in] attr_info
8728 /// ::HAPI_AttributeInfo that contains the description for the
8729 /// attribute that is being set.
8730 ///
8731 /// @param[in] data_fixed_array
8732 /// An array containing the HAPI_UInt8 values of the attribute.
8733 ///
8734 /// @param[in] data_fixed_length
8735 /// The total size of the data array. The size can be no greater
8736 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8737 /// of the attribute.
8738 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8739 ///
8740 /// @param[in] sizes_fixed_array
8741 /// An array of integers that contains the sizes of each
8742 /// attribute array. This is required because the attribute
8743 /// array for each geometry component can be of variable size.
8744 ///
8745 /// @param[in] start
8746 /// First index of range. Must be at least 0 and at most
8747 /// ::HAPI_AttributeInfo::count - 1.
8748 /// <!-- default 0 -->
8749 ///
8750 /// @param[in] sizes_fixed_length
8751 /// Must be at least 0 and at most
8752 /// ::HAPI_AttributeInfo::count - @p start.
8753 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8755  HAPI_NodeId node_id,
8756  HAPI_PartId part_id,
8757  const char * name,
8758  const HAPI_AttributeInfo * attr_info,
8759  const HAPI_UInt8 * data_fixed_array,
8760  int data_fixed_length,
8761  const int * sizes_fixed_array,
8762  int start,
8763  int sizes_fixed_length );
8764 
8765 /// @brief Set 8-bit integer array attribute data.
8766 ///
8767 /// @ingroup GeometrySetters Attributes
8768 ///
8769 /// @param[in] session
8770 /// The session of Houdini you are interacting with.
8771 /// See @ref HAPI_Sessions for more on sessions.
8772 /// Pass NULL to just use the default in-process session.
8773 /// <!-- default NULL -->
8774 ///
8775 /// @param[in] node_id
8776 /// The SOP node id.
8777 ///
8778 /// @param[in] part_id
8779 /// Currently not used. Just pass 0.
8780 ///
8781 /// @param[in] name
8782 /// Attribute name.
8783 ///
8784 /// @param[in] attr_info
8785 /// ::HAPI_AttributeInfo that contains the description for the
8786 /// attribute that is being set.
8787 ///
8788 /// @param[in] data_fixed_array
8789 /// An array containing the HAPI_Int8 values of the attribute.
8790 ///
8791 /// @param[in] data_fixed_length
8792 /// The total size of the data array. The size can be no greater
8793 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8794 /// of the attribute.
8795 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8796 ///
8797 /// @param[in] sizes_fixed_array
8798 /// An array of integers that contains the sizes of each
8799 /// attribute array. This is required because the attribute
8800 /// array for each geometry component can be of variable size.
8801 ///
8802 /// @param[in] start
8803 /// First index of range. Must be at least 0 and at most
8804 /// ::HAPI_AttributeInfo::count - 1.
8805 /// <!-- default 0 -->
8806 ///
8807 /// @param[in] sizes_fixed_length
8808 /// Must be at least 0 and at most
8809 /// ::HAPI_AttributeInfo::count - @p start.
8810 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8812  HAPI_NodeId node_id,
8813  HAPI_PartId part_id,
8814  const char * name,
8815  const HAPI_AttributeInfo * attr_info,
8816  const HAPI_Int8 * data_fixed_array,
8817  int data_fixed_length,
8818  const int * sizes_fixed_array,
8819  int start,
8820  int sizes_fixed_length);
8821 
8822 /// @brief Set 16-bit integer array attribute data.
8823 ///
8824 /// @ingroup GeometrySetters Attributes
8825 ///
8826 /// @param[in] session
8827 /// The session of Houdini you are interacting with.
8828 /// See @ref HAPI_Sessions for more on sessions.
8829 /// Pass NULL to just use the default in-process session.
8830 /// <!-- default NULL -->
8831 ///
8832 /// @param[in] node_id
8833 /// The SOP node id.
8834 ///
8835 /// @param[in] part_id
8836 /// Currently not used. Just pass 0.
8837 ///
8838 /// @param[in] name
8839 /// Attribute name.
8840 ///
8841 /// @param[in] attr_info
8842 /// ::HAPI_AttributeInfo that contains the description for the
8843 /// attribute that is being set.
8844 ///
8845 /// @param[in] data_fixed_array
8846 /// An array containing the HAPI_Int16 values of the attribute.
8847 ///
8848 /// @param[in] data_fixed_length
8849 /// The total size of the data array. The size can be no greater
8850 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8851 /// of the attribute.
8852 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8853 ///
8854 /// @param[in] sizes_fixed_array
8855 /// An array of integers that contains the sizes of each
8856 /// attribute array. This is required because the attribute
8857 /// array for each geometry component can be of variable size.
8858 ///
8859 /// @param[in] start
8860 /// First index of range. Must be at least 0 and at most
8861 /// ::HAPI_AttributeInfo::count - 1.
8862 /// <!-- default 0 -->
8863 ///
8864 /// @param[in] sizes_fixed_length
8865 /// Must be at least 0 and at most
8866 /// ::HAPI_AttributeInfo::count - @p start.
8867 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8869  HAPI_NodeId node_id,
8870  HAPI_PartId part_id,
8871  const char * name,
8872  const HAPI_AttributeInfo * attr_info,
8873  const HAPI_Int16 * data_fixed_array,
8874  int data_fixed_length,
8875  const int * sizes_fixed_array,
8876  int start,
8877  int sizes_fixed_length );
8878 
8879 /// @brief Set 64-bit integer array attribute data.
8880 ///
8881 /// @ingroup GeometrySetters Attributes
8882 ///
8883 /// @param[in] session
8884 /// The session of Houdini you are interacting with.
8885 /// See @ref HAPI_Sessions for more on sessions.
8886 /// Pass NULL to just use the default in-process session.
8887 /// <!-- default NULL -->
8888 ///
8889 /// @param[in] node_id
8890 /// The SOP node id.
8891 ///
8892 /// @param[in] part_id
8893 /// Currently not used. Just pass 0.
8894 ///
8895 /// @param[in] name
8896 /// Attribute name.
8897 ///
8898 /// @param[in] attr_info
8899 /// ::HAPI_AttributeInfo that contains the description for the
8900 /// attribute that is being set.
8901 ///
8902 /// @param[in] data_fixed_array
8903 /// An array containing the HAPI_Int64 values of the attribute.
8904 ///
8905 /// @param[in] data_fixed_length
8906 /// The total size of the data array. The size can be no greater
8907 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8908 /// of the attribute.
8909 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8910 ///
8911 /// @param[in] sizes_fixed_array
8912 /// An array of integers that contains the sizes of each
8913 /// attribute array. This is required because the attribute
8914 /// array for each geometry component can be of variable size.
8915 ///
8916 /// @param[in] start
8917 /// First index of range. Must be at least 0 and at most
8918 /// ::HAPI_AttributeInfo::count - 1.
8919 /// <!-- default 0 -->
8920 ///
8921 /// @param[in] sizes_fixed_length
8922 /// Must be at least 0 and at most
8923 /// ::HAPI_AttributeInfo::count - @p start.
8924 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8926  HAPI_NodeId node_id,
8927  HAPI_PartId part_id,
8928  const char * name,
8929  const HAPI_AttributeInfo * attr_info,
8930  const HAPI_Int64 * data_fixed_array,
8931  int data_fixed_length,
8932  const int * sizes_fixed_array,
8933  int start,
8934  int sizes_fixed_length );
8935 
8936 /// @brief Set float array attribute data.
8937 ///
8938 /// @ingroup GeometrySetters Attributes
8939 ///
8940 /// @param[in] session
8941 /// The session of Houdini you are interacting with.
8942 /// See @ref HAPI_Sessions for more on sessions.
8943 /// Pass NULL to just use the default in-process session.
8944 /// <!-- default NULL -->
8945 ///
8946 /// @param[in] node_id
8947 /// The SOP node id.
8948 ///
8949 /// @param[in] part_id
8950 /// Currently not used. Just pass 0.
8951 ///
8952 /// @param[in] name
8953 /// Attribute name.
8954 ///
8955 /// @param[in] attr_info
8956 /// ::HAPI_AttributeInfo that contains the description for the
8957 /// attribute that is being set.
8958 ///
8959 /// @param[in] data_fixed_array
8960 /// An array containing the float values of the attribute.
8961 ///
8962 /// @param[in] data_fixed_length
8963 /// The total size of the data array. The size can be no greater
8964 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8965 /// of the attribute.
8966 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8967 ///
8968 /// @param[in] sizes_fixed_array
8969 /// An array of integers that contains the sizes of each
8970 /// attribute array. This is required because the attribute
8971 /// array for each geometry component can be of variable size.
8972 ///
8973 /// @param[in] start
8974 /// First index of range. Must be at least 0 and at most
8975 /// ::HAPI_AttributeInfo::count - 1.
8976 /// <!-- default 0 -->
8977 ///
8978 /// @param[in] sizes_fixed_length
8979 /// Must be at least 0 and at most
8980 /// ::HAPI_AttributeInfo::count - @p start.
8981 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8983  HAPI_NodeId node_id,
8984  HAPI_PartId part_id,
8985  const char * name,
8986  const HAPI_AttributeInfo * attr_info,
8987  const float * data_fixed_array,
8988  int data_fixed_length,
8989  const int * sizes_fixed_array,
8990  int start,
8991  int sizes_fixed_length );
8992 
8993 /// @brief Set 64-bit float array attribute data.
8994 ///
8995 /// @ingroup GeometrySetters Attributes
8996 ///
8997 /// @param[in] session
8998 /// The session of Houdini you are interacting with.
8999 /// See @ref HAPI_Sessions for more on sessions.
9000 /// Pass NULL to just use the default in-process session.
9001 /// <!-- default NULL -->
9002 ///
9003 /// @param[in] node_id
9004 /// The SOP node id.
9005 ///
9006 /// @param[in] part_id
9007 /// Currently not used. Just pass 0.
9008 ///
9009 /// @param[in] name
9010 /// Attribute name.
9011 ///
9012 /// @param[in] attr_info
9013 /// ::HAPI_AttributeInfo that contains the description for the
9014 /// attribute that is being set.
9015 ///
9016 /// @param[in] data_fixed_array
9017 /// An array containing the double values of the attribute.
9018 ///
9019 /// @param[in] data_fixed_length
9020 /// The total size of the data array. The size can be no greater
9021 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
9022 /// of the attribute.
9023 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
9024 ///
9025 /// @param[in] sizes_fixed_array
9026 /// An array of integers that contains the sizes of each
9027 /// attribute array. This is required because the attribute
9028 /// array for each geometry component can be of variable size.
9029 ///
9030 /// @param[in] start
9031 /// First index of range. Must be at least 0 and at most
9032 /// ::HAPI_AttributeInfo::count - 1.
9033 /// <!-- default 0 -->
9034 ///
9035 /// @param[in] sizes_fixed_length
9036 /// Must be at least 0 and at most
9037 /// ::HAPI_AttributeInfo::count - @p start.
9038 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9040  HAPI_NodeId node_id,
9041  HAPI_PartId part_id,
9042  const char * name,
9043  const HAPI_AttributeInfo * attr_info,
9044  const double * data_fixed_array,
9045  int data_fixed_length,
9046  const int * sizes_fixed_array,
9047  int start,
9048  int sizes_fixed_length );
9049 
9050 /// @brief Set string array attribute data.
9051 ///
9052 /// @ingroup GeometrySetters Attributes
9053 ///
9054 /// @param[in] session
9055 /// The session of Houdini you are interacting with.
9056 /// See @ref HAPI_Sessions for more on sessions.
9057 /// Pass NULL to just use the default in-process session.
9058 /// <!-- default NULL -->
9059 ///
9060 /// @param[in] node_id
9061 /// The SOP node id.
9062 ///
9063 /// @param[in] part_id
9064 /// Currently not used. Just pass 0.
9065 ///
9066 /// @param[in] name
9067 /// Attribute name.
9068 ///
9069 /// @param[in] attr_info
9070 /// ::HAPI_AttributeInfo that contains the description for the
9071 /// attribute that is being set.
9072 ///
9073 /// @param[in] data_fixed_array
9074 /// An array containing the string values of the attribute.
9075 ///
9076 /// @param[in] data_fixed_length
9077 /// The total size of the data array. The size can be no greater
9078 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
9079 /// of the attribute.
9080 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
9081 ///
9082 /// @param[in] sizes_fixed_array
9083 /// An array of integers that contains the sizes of each
9084 /// attribute array. This is required because the attribute
9085 /// array for each geometry component can be of variable size.
9086 ///
9087 /// @param[in] start
9088 /// First index of range. Must be at least 0 and at most
9089 /// ::HAPI_AttributeInfo::count - 1.
9090 /// <!-- default 0 -->
9091 ///
9092 /// @param[in] sizes_fixed_length
9093 /// Must be at least 0 and at most
9094 /// ::HAPI_AttributeInfo::count - @p start.
9095 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9097  HAPI_NodeId node_id,
9098  HAPI_PartId part_id,
9099  const char * name,
9100  const HAPI_AttributeInfo * attr_info,
9101  const char ** data_fixed_array,
9102  int data_fixed_length,
9103  const int * sizes_fixed_array,
9104  int start,
9105  int sizes_fixed_length );
9106 
9107 /// @brief Set attribute dictionary array data. The dictionary data should
9108 /// be provided as JSON-encoded strings.
9109 ///
9110 /// @ingroup GeometrySetters Attributes
9111 ///
9112 /// @param[in] session
9113 /// The session of Houdini you are interacting with.
9114 /// See @ref HAPI_Sessions for more on sessions.
9115 /// Pass NULL to just use the default in-process session.
9116 /// <!-- default NULL -->
9117 ///
9118 /// @param[in] node_id
9119 /// The SOP node id.
9120 ///
9121 /// @param[in] part_id
9122 /// Currently not used. Just pass 0.
9123 ///
9124 /// @param[in] name
9125 /// Attribute name.
9126 ///
9127 /// @param[in] attr_info
9128 /// ::HAPI_AttributeInfo that contains the description for the
9129 /// attribute that is being set.
9130 ///
9131 /// @param[in] data_fixed_array
9132 /// An array containing the dictionary values of the attribute.
9133 ///
9134 /// @param[in] data_fixed_length
9135 /// The total size of the data array. The size can be no greater
9136 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
9137 /// of the attribute.
9138 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
9139 ///
9140 /// @param[in] sizes_fixed_array
9141 /// An array of integers that contains the sizes of each
9142 /// attribute array. This is required because the attribute
9143 /// array for each geometry component can be of variable size.
9144 ///
9145 /// @param[in] start
9146 /// First index of range. Must be at least 0 and at most
9147 /// ::HAPI_AttributeInfo::count - 1.
9148 /// <!-- default 0 -->
9149 ///
9150 /// @param[in] sizes_fixed_length
9151 /// Must be at least 0 and at most
9152 /// ::HAPI_AttributeInfo::count - @p start.
9153 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9155  HAPI_NodeId node_id,
9156  HAPI_PartId part_id,
9157  const char* name,
9158  const HAPI_AttributeInfo* attr_info,
9159  const char** data_fixed_array,
9160  int data_fixed_length,
9161  const int* sizes_fixed_array,
9162  int start,
9163  int sizes_fixed_length);
9164 
9165 /// @brief Set attribute integer data asynchronously.
9166 ///
9167 /// @ingroup GeometrySetters Attributes
9168 ///
9169 /// @param[in] session
9170 /// The session of Houdini you are interacting with.
9171 /// See @ref HAPI_Sessions for more on sessions.
9172 /// Pass NULL to just use the default in-process session.
9173 /// <!-- default NULL -->
9174 ///
9175 /// @param[in] node_id
9176 /// The SOP node id.
9177 ///
9178 /// @param[in] part_id
9179 /// Currently not used. Just pass 0.
9180 ///
9181 /// @param[in] name
9182 /// Attribute name.
9183 ///
9184 /// @param[in] attr_info
9185 /// ::HAPI_AttributeInfo used as input for what tuple size.
9186 /// you want. Also contains some sanity checks like
9187 /// data type. Generally should be the same struct
9188 /// returned by ::HAPI_GetAttributeInfo().
9189 ///
9190 /// @param[in] data_array
9191 /// An integer array at least the size of
9192 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9193 ///
9194 /// @param[in] start
9195 /// First index of range. Must be at least 0 and at
9196 /// most ::HAPI_AttributeInfo::count - 1.
9197 /// <!-- default 0 -->
9198 ///
9199 /// @param[in] length
9200 /// Must be at least 0 and at most
9201 /// ::HAPI_AttributeInfo::count - @p start.
9202 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9203 ///
9204 /// @param[out] job_id
9205 /// The id assigned to the job.
9206 ///
9208  HAPI_NodeId node_id,
9209  HAPI_PartId part_id,
9210  const char * name,
9211  const HAPI_AttributeInfo * attr_info,
9212  const int * data_array,
9213  int start, int length,
9214  int * job_id );
9215 
9216 /// @brief Set unsigned 8-bit attribute integer data asynchronously.
9217 ///
9218 /// @ingroup GeometrySetters Attributes
9219 ///
9220 /// @param[in] session
9221 /// The session of Houdini you are interacting with.
9222 /// See @ref HAPI_Sessions for more on sessions.
9223 /// Pass NULL to just use the default in-process session.
9224 /// <!-- default NULL -->
9225 ///
9226 /// @param[in] node_id
9227 /// The SOP node id.
9228 ///
9229 /// @param[in] part_id
9230 /// Currently not used. Just pass 0.
9231 ///
9232 /// @param[in] name
9233 /// Attribute name.
9234 ///
9235 /// @param[in] attr_info
9236 /// ::HAPI_AttributeInfo used as input for what tuple size.
9237 /// you want. Also contains some sanity checks like
9238 /// data type. Generally should be the same struct
9239 /// returned by ::HAPI_GetAttributeInfo().
9240 ///
9241 /// @param[in] data_array
9242 /// An unsigned 8-bit integer array at least the size of
9243 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9244 ///
9245 /// @param[in] start
9246 /// First index of range. Must be at least 0 and at
9247 /// most ::HAPI_AttributeInfo::count - 1.
9248 /// <!-- default 0 -->
9249 ///
9250 /// @param[in] length
9251 /// Must be at least 0 and at most
9252 /// ::HAPI_AttributeInfo::count - @p start.
9253 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9254 ///
9255 /// @param[out] job_id
9256 /// The id assigned to the job.
9257 ///
9259  HAPI_NodeId node_id,
9260  HAPI_PartId part_id,
9261  const char * name,
9262  const HAPI_AttributeInfo * attr_info,
9263  const HAPI_UInt8 * data_array,
9264  int start, int length,
9265  int * job_id );
9266 
9267 /// @brief Set 8-bit attribute integer data asynchronously.
9268 ///
9269 /// @ingroup GeometrySetters Attributes
9270 ///
9271 /// @param[in] session
9272 /// The session of Houdini you are interacting with.
9273 /// See @ref HAPI_Sessions for more on sessions.
9274 /// Pass NULL to just use the default in-process session.
9275 /// <!-- default NULL -->
9276 ///
9277 /// @param[in] node_id
9278 /// The SOP node id.
9279 ///
9280 /// @param[in] part_id
9281 /// Currently not used. Just pass 0.
9282 ///
9283 /// @param[in] name
9284 /// Attribute name.
9285 ///
9286 /// @param[in] attr_info
9287 /// ::HAPI_AttributeInfo used as input for what tuple size.
9288 /// you want. Also contains some sanity checks like
9289 /// data type. Generally should be the same struct
9290 /// returned by ::HAPI_GetAttributeInfo().
9291 ///
9292 /// @param[in] data_array
9293 /// An 8-bit integer array at least the size of
9294 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9295 ///
9296 /// @param[in] start
9297 /// First index of range. Must be at least 0 and at
9298 /// most ::HAPI_AttributeInfo::count - 1.
9299 /// <!-- default 0 -->
9300 ///
9301 /// @param[in] length
9302 /// Must be at least 0 and at most
9303 /// ::HAPI_AttributeInfo::count - @p start.
9304 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9305 ///
9306 /// @param[out] job_id
9307 /// The id assigned to the job.
9308 ///
9310  HAPI_NodeId node_id,
9311  HAPI_PartId part_id,
9312  const char * name,
9313  const HAPI_AttributeInfo * attr_info,
9314  const HAPI_Int8 * data_array,
9315  int start, int length,
9316  int * job_id );
9317 
9318 /// @brief Set 16-bit attribute integer data asynchronously.
9319 ///
9320 /// @ingroup GeometrySetters Attributes
9321 ///
9322 /// @param[in] session
9323 /// The session of Houdini you are interacting with.
9324 /// See @ref HAPI_Sessions for more on sessions.
9325 /// Pass NULL to just use the default in-process session.
9326 /// <!-- default NULL -->
9327 ///
9328 /// @param[in] node_id
9329 /// The SOP node id.
9330 ///
9331 /// @param[in] part_id
9332 /// Currently not used. Just pass 0.
9333 ///
9334 /// @param[in] name
9335 /// Attribute name.
9336 ///
9337 /// @param[in] attr_info
9338 /// ::HAPI_AttributeInfo used as input for what tuple size.
9339 /// you want. Also contains some sanity checks like
9340 /// data type. Generally should be the same struct
9341 /// returned by ::HAPI_GetAttributeInfo().
9342 ///
9343 /// @param[in] data_array
9344 /// An 16-bit integer array at least the size of
9345 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9346 ///
9347 /// @param[in] start
9348 /// First index of range. Must be at least 0 and at
9349 /// most ::HAPI_AttributeInfo::count - 1.
9350 /// <!-- default 0 -->
9351 ///
9352 /// @param[in] length
9353 /// Must be at least 0 and at most
9354 /// ::HAPI_AttributeInfo::count - @p start.
9355 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9356 ///
9357 /// @param[out] job_id
9358 /// The id assigned to the job.
9359 ///
9361  HAPI_NodeId node_id,
9362  HAPI_PartId part_id,
9363  const char * name,
9364  const HAPI_AttributeInfo * attr_info,
9365  const HAPI_Int16 * data_array,
9366  int start, int length,
9367  int * job_id );
9368 
9369 /// @brief Set 64-bit attribute integer data asynchronously.
9370 ///
9371 /// @ingroup GeometrySetters Attributes
9372 ///
9373 /// @param[in] session
9374 /// The session of Houdini you are interacting with.
9375 /// See @ref HAPI_Sessions for more on sessions.
9376 /// Pass NULL to just use the default in-process session.
9377 /// <!-- default NULL -->
9378 ///
9379 /// @param[in] node_id
9380 /// The SOP node id.
9381 ///
9382 /// @param[in] part_id
9383 /// Currently not used. Just pass 0.
9384 ///
9385 /// @param[in] name
9386 /// Attribute name.
9387 ///
9388 /// @param[in] attr_info
9389 /// ::HAPI_AttributeInfo used as input for what tuple size.
9390 /// you want. Also contains some sanity checks like
9391 /// data type. Generally should be the same struct
9392 /// returned by ::HAPI_GetAttributeInfo().
9393 ///
9394 /// @param[in] data_array
9395 /// An 64-bit integer array at least the size of
9396 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9397 ///
9398 /// @param[in] start
9399 /// First index of range. Must be at least 0 and at
9400 /// most ::HAPI_AttributeInfo::count - 1.
9401 /// <!-- default 0 -->
9402 ///
9403 /// @param[in] length
9404 /// Must be at least 0 and at most
9405 /// ::HAPI_AttributeInfo::count - @p start.
9406 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9407 ///
9408 /// @param[out] job_id
9409 /// The id assigned to the job.
9410 ///
9412  HAPI_NodeId node_id,
9413  HAPI_PartId part_id,
9414  const char * name,
9415  const HAPI_AttributeInfo * attr_info,
9416  const HAPI_Int64 * data_array,
9417  int start, int length,
9418  int * job_id );
9419 
9420 /// @brief Set attribute float data asynchronously.
9421 ///
9422 /// @ingroup GeometrySetters Attributes
9423 ///
9424 /// @param[in] session
9425 /// The session of Houdini you are interacting with.
9426 /// See @ref HAPI_Sessions for more on sessions.
9427 /// Pass NULL to just use the default in-process session.
9428 /// <!-- default NULL -->
9429 ///
9430 /// @param[in] node_id
9431 /// The SOP node id.
9432 ///
9433 /// @param[in] part_id
9434 /// Currently not used. Just pass 0.
9435 ///
9436 /// @param[in] name
9437 /// Attribute name.
9438 ///
9439 /// @param[in] attr_info
9440 /// ::HAPI_AttributeInfo used as input for what tuple size.
9441 /// you want. Also contains some sanity checks like
9442 /// data type. Generally should be the same struct
9443 /// returned by ::HAPI_GetAttributeInfo().
9444 ///
9445 /// @param[in] data_array
9446 /// An float array at least the size of
9447 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9448 ///
9449 /// @param[in] start
9450 /// First index of range. Must be at least 0 and at
9451 /// most ::HAPI_AttributeInfo::count - 1.
9452 /// <!-- default 0 -->
9453 ///
9454 /// @param[in] length
9455 /// Must be at least 0 and at most
9456 /// ::HAPI_AttributeInfo::count - @p start.
9457 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9458 ///
9459 /// @param[out] job_id
9460 /// The id assigned to the job.
9461 ///
9463  HAPI_NodeId node_id,
9464  HAPI_PartId part_id,
9465  const char * name,
9466  const HAPI_AttributeInfo * attr_info,
9467  const float * data_array,
9468  int start, int length,
9469  int * job_id );
9470 
9471 /// @brief Set 64-bit attribute float data asynchronously.
9472 ///
9473 /// @ingroup GeometrySetters Attributes
9474 ///
9475 /// @param[in] session
9476 /// The session of Houdini you are interacting with.
9477 /// See @ref HAPI_Sessions for more on sessions.
9478 /// Pass NULL to just use the default in-process session.
9479 /// <!-- default NULL -->
9480 ///
9481 /// @param[in] node_id
9482 /// The SOP node id.
9483 ///
9484 /// @param[in] part_id
9485 /// Currently not used. Just pass 0.
9486 ///
9487 /// @param[in] name
9488 /// Attribute name.
9489 ///
9490 /// @param[in] attr_info
9491 /// ::HAPI_AttributeInfo used as input for what tuple size.
9492 /// you want. Also contains some sanity checks like
9493 /// data type. Generally should be the same struct
9494 /// returned by ::HAPI_GetAttributeInfo().
9495 ///
9496 /// @param[in] data_array
9497 /// An 64-bit float array at least the size of
9498 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9499 ///
9500 /// @param[in] start
9501 /// First index of range. Must be at least 0 and at
9502 /// most ::HAPI_AttributeInfo::count - 1.
9503 /// <!-- default 0 -->
9504 ///
9505 /// @param[in] length
9506 /// Must be at least 0 and at most
9507 /// ::HAPI_AttributeInfo::count - @p start.
9508 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9509 ///
9510 /// @param[out] job_id
9511 /// The id assigned to the job.
9512 ///
9514  const HAPI_Session * session,
9515  HAPI_NodeId node_id,
9516  HAPI_PartId part_id,
9517  const char * name,
9518  const HAPI_AttributeInfo * attr_info,
9519  const double * data_array,
9520  int start, int length,
9521  int * job_id );
9522 
9523 /// @brief Set attribute string data asynchronously.
9524 ///
9525 /// @ingroup GeometrySetters Attributes
9526 ///
9527 /// @param[in] session
9528 /// The session of Houdini you are interacting with.
9529 /// See @ref HAPI_Sessions for more on sessions.
9530 /// Pass NULL to just use the default in-process session.
9531 /// <!-- default NULL -->
9532 ///
9533 /// @param[in] node_id
9534 /// The SOP node id.
9535 ///
9536 /// @param[in] part_id
9537 /// Currently not used. Just pass 0.
9538 ///
9539 /// @param[in] name
9540 /// Attribute name.
9541 ///
9542 /// @param[in] attr_info
9543 /// ::HAPI_AttributeInfo used as input for what tuple size
9544 /// you want. Also contains some sanity checks like
9545 /// data type. Generally should be the same struct
9546 /// returned by ::HAPI_GetAttributeInfo().
9547 ///
9548 /// @param[in] data_array
9549 /// An ::HAPI_StringHandle array at least the size of
9550 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9551 ///
9552 /// @param[in] start
9553 /// First index of range. Must be at least 0 and at
9554 /// most ::HAPI_AttributeInfo::count - 1.
9555 /// <!-- default 0 -->
9556 ///
9557 /// @param[in] length
9558 /// Must be at least 0 and at most
9559 /// ::HAPI_AttributeInfo::count - @p start.
9560 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9561 ///
9562 /// @param[out] job_id
9563 /// The id assigned to the job.
9564 ///
9566  const HAPI_Session * session,
9567  HAPI_NodeId node_id,
9568  HAPI_PartId part_id,
9569  const char * name,
9570  const HAPI_AttributeInfo * attr_info,
9571  const char ** data_array,
9572  int start, int length,
9573  int * job_id );
9574 
9575 /// @brief Set attribute string data by index asynchronously.
9576 ///
9577 /// @ingroup GeometrySetters Attributes
9578 ///
9579 /// @param[in] session
9580 /// The session of Houdini you are interacting with.
9581 /// See @ref HAPI_Sessions for more on sessions.
9582 /// Pass NULL to just use the default in-process session.
9583 /// <!-- default NULL -->
9584 ///
9585 /// @param[in] node_id
9586 /// The SOP node id.
9587 ///
9588 /// @param[in] part_id
9589 /// Currently not used. Just pass 0.
9590 ///
9591 /// @param[in] name
9592 /// Attribute name.
9593 ///
9594 /// @param[in] attr_info
9595 /// ::HAPI_AttributeInfo used as input for what tuple size.
9596 /// you want. Also contains some sanity checks like
9597 /// data type. Generally should be the same struct
9598 /// returned by ::HAPI_GetAttributeInfo().
9599 ///
9600 /// @param[in] string_array
9601 /// An array of strings at least the size of
9602 /// <tt>string_count/tt>.
9603 ///
9604 /// @param[in] string_count
9605 /// Number of strings that are indexed.
9606 ///
9607 /// @param[in] indices_array
9608 /// integer array at least the size of
9609 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>. Each
9610 /// entry indexes string_array.
9611 ///
9612 /// @param[in] indices_start
9613 /// First index of range. Must be at least 0 and at
9614 /// most ::HAPI_AttributeInfo::count - 1.
9615 /// <!-- default 0 -->
9616 ///
9617 /// @param[in] indices_length
9618 /// Must be at least 0 and at most
9619 /// ::HAPI_AttributeInfo::count - @p start.
9620 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9621 ///
9622 /// @param[out] job_id
9623 /// The id assigned to the job.
9624 ///
9626  const HAPI_Session * session,
9627  HAPI_NodeId node_id,
9628  HAPI_PartId part_id,
9629  const char * name,
9630  const HAPI_AttributeInfo * attr_info,
9631  const char ** string_array,
9632  int string_count,
9633  const int * indices_array,
9634  int indices_start,
9635  int indices_length,
9636  int * job_id );
9637 
9638 /// @brief Set multiple attribute string data to the same unique value
9639 /// asynchronously.
9640 ///
9641 /// @ingroup GeometrySetters Attributes
9642 ///
9643 /// @param[in] session
9644 /// The session of Houdini you are interacting with.
9645 /// See @ref HAPI_Sessions for more on sessions.
9646 /// Pass NULL to just use the default in-process session.
9647 /// <!-- default NULL -->
9648 ///
9649 /// @param[in] node_id
9650 /// The SOP node id.
9651 ///
9652 /// @param[in] part_id
9653 /// Currently not used. Just pass 0.
9654 ///
9655 /// @param[in] name
9656 /// Attribute name.
9657 ///
9658 /// @param[in] attr_info
9659 /// ::HAPI_AttributeInfo used as input for what tuple size.
9660 /// you want. Also contains some sanity checks like
9661 /// data type. Generally should be the same struct
9662 /// returned by ::HAPI_GetAttributeInfo().
9663 ///
9664 /// @param[in] data_array
9665 /// A string
9666 ///
9667 /// @param[in] data_length
9668 /// Must be the length of string data.
9669 ///
9670 /// @param[in] start_index
9671 /// Must be at least 0 and at most
9672 /// ::HAPI_AttributeInfo::count - @p start.
9673 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9674 ///
9675 /// @param[in] num_indices
9676 /// Must be at least 0 and at most
9677 /// ::HAPI_AttributeInfo::count - @p start.
9678 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9679 ///
9680 /// @param[out] job_id
9681 /// The id assigned to the job.
9682 ///
9684  const HAPI_Session * session,
9685  HAPI_NodeId node_id,
9686  HAPI_PartId part_id,
9687  const char * name,
9688  const HAPI_AttributeInfo * attr_info,
9689  const char * data_array,
9690  int data_length,
9691  int start_index,
9692  int num_indices,
9693  int * job_id );
9694 
9695 /// @brief Set multiple attribute int data to the same unique value
9696 /// asynchronously.
9697 ///
9698 /// @ingroup GeometrySetters Attributes
9699 ///
9700 /// @param[in] session
9701 /// The session of Houdini you are interacting with.
9702 /// See @ref HAPI_Sessions for more on sessions.
9703 /// Pass NULL to just use the default in-process session.
9704 /// <!-- default NULL -->
9705 ///
9706 /// @param[in] node_id
9707 /// The SOP node id.
9708 ///
9709 /// @param[in] part_id
9710 /// Currently not used. Just pass 0.
9711 ///
9712 /// @param[in] name
9713 /// Attribute name.
9714 ///
9715 /// @param[in] attr_info
9716 /// ::HAPI_AttributeInfo used as input for what tuple size.
9717 /// you want. Also contains some sanity checks like
9718 /// data type. Generally should be the same struct
9719 /// returned by ::HAPI_GetAttributeInfo().
9720 ///
9721 /// @param[in] data_array
9722 /// A integer array at least the size of
9723 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9724 ///
9725 /// @param[in] data_length
9726 /// An integer of at least the size of
9727 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9728 ///
9729 /// @param[in] start_index
9730 /// First index of range. Must be at least 0 and at
9731 /// most ::HAPI_AttributeInfo::count - 1.
9732 /// <!-- default 0 -->
9733 ///
9734 /// @param[in] num_indices
9735 /// Must be at least 0 and at most
9736 /// ::HAPI_AttributeInfo::count - @p start_index.
9737 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9738 ///
9739 /// @param[out] job_id
9740 /// The id assigned to the job.
9741 ///
9743  const HAPI_Session * session,
9744  HAPI_NodeId node_id,
9745  HAPI_PartId part_id,
9746  const char * name,
9747  const HAPI_AttributeInfo * attr_info,
9748  const int * data_array,
9749  int data_length,
9750  int start_index,
9751  int num_indices,
9752  int * job_id );
9753 
9754 /// @brief Set multiple attribute unsigned 8-bit int data to the same unique
9755 /// value asynchronously.
9756 ///
9757 /// @ingroup GeometrySetters Attributes
9758 ///
9759 /// @param[in] session
9760 /// The session of Houdini you are interacting with.
9761 /// See @ref HAPI_Sessions for more on sessions.
9762 /// Pass NULL to just use the default in-process session.
9763 /// <!-- default NULL -->
9764 ///
9765 /// @param[in] node_id
9766 /// The SOP node id.
9767 ///
9768 /// @param[in] part_id
9769 /// Currently not used. Just pass 0.
9770 ///
9771 /// @param[in] name
9772 /// Attribute name.
9773 ///
9774 /// @param[in] attr_info
9775 /// ::HAPI_AttributeInfo used as input for what tuple size.
9776 /// you want. Also contains some sanity checks like
9777 /// data type. Generally should be the same struct
9778 /// returned by ::HAPI_GetAttributeInfo().
9779 ///
9780 /// @param[in] data_array
9781 /// A integer array at least the size of
9782 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9783 ///
9784 /// @param[in] data_length
9785 /// An integer of at least the size of
9786 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9787 ///
9788 /// @param[in] start_index
9789 /// First index of range. Must be at least 0 and at
9790 /// most ::HAPI_AttributeInfo::count - 1.
9791 /// <!-- default 0 -->
9792 ///
9793 /// @param[in] num_indices
9794 /// Must be at least 0 and at most
9795 /// ::HAPI_AttributeInfo::count - @p start_index.
9796 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9797 ///
9798 /// @param[out] job_id
9799 /// The id assigned to the job.
9800 ///
9802  const HAPI_Session * session,
9803  HAPI_NodeId node_id,
9804  HAPI_PartId part_id,
9805  const char * name,
9806  const HAPI_AttributeInfo * attr_info,
9807  const HAPI_UInt8 * data_array,
9808  int data_length,
9809  int start_index,
9810  int num_indices,
9811  int * job_id );
9812 
9813 /// @brief Set multiple attribute 8-bit int data to the same unique value
9814 /// asynchronously.
9815 ///
9816 /// @ingroup GeometrySetters Attributes
9817 ///
9818 /// @param[in] session
9819 /// The session of Houdini you are interacting with.
9820 /// See @ref HAPI_Sessions for more on sessions.
9821 /// Pass NULL to just use the default in-process session.
9822 /// <!-- default NULL -->
9823 ///
9824 /// @param[in] node_id
9825 /// The SOP node id.
9826 ///
9827 /// @param[in] part_id
9828 /// Currently not used. Just pass 0.
9829 ///
9830 /// @param[in] name
9831 /// Attribute name.
9832 ///
9833 /// @param[in] attr_info
9834 /// ::HAPI_AttributeInfo used as input for what tuple size.
9835 /// you want. Also contains some sanity checks like
9836 /// data type. Generally should be the same struct
9837 /// returned by ::HAPI_GetAttributeInfo().
9838 ///
9839 /// @param[in] data_array
9840 /// A integer array at least the size of
9841 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9842 ///
9843 /// @param[in] data_length
9844 /// An integer of at least the size of
9845 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9846 ///
9847 /// @param[in] start_index
9848 /// First index of range. Must be at least 0 and at
9849 /// most ::HAPI_AttributeInfo::count - 1.
9850 /// <!-- default 0 -->
9851 ///
9852 /// @param[in] num_indices
9853 /// Must be at least 0 and at most
9854 /// ::HAPI_AttributeInfo::count - @p start_index.
9855 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9856 ///
9857 /// @param[out] job_id
9858 /// The id assigned to the job.
9859 ///
9861  const HAPI_Session * session,
9862  HAPI_NodeId node_id,
9863  HAPI_PartId part_id,
9864  const char * name,
9865  const HAPI_AttributeInfo * attr_info,
9866  const HAPI_Int8* data_array,
9867  int data_length,
9868  int start_index,
9869  int num_indices,
9870  int * job_id );
9871 
9872 /// @brief Set multiple attribute 16-bit int data to the same unique value
9873 /// asynchronously.
9874 ///
9875 /// @ingroup GeometrySetters Attributes
9876 ///
9877 /// @param[in] session
9878 /// The session of Houdini you are interacting with.
9879 /// See @ref HAPI_Sessions for more on sessions.
9880 /// Pass NULL to just use the default in-process session.
9881 /// <!-- default NULL -->
9882 ///
9883 /// @param[in] node_id
9884 /// The SOP node id.
9885 ///
9886 /// @param[in] part_id
9887 /// Currently not used. Just pass 0.
9888 ///
9889 /// @param[in] name
9890 /// Attribute name.
9891 ///
9892 /// @param[in] attr_info
9893 /// ::HAPI_AttributeInfo used as input for what tuple size.
9894 /// you want. Also contains some sanity checks like
9895 /// data type. Generally should be the same struct
9896 /// returned by ::HAPI_GetAttributeInfo().
9897 ///
9898 /// @param[in] data_array
9899 /// A integer array at least the size of
9900 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9901 ///
9902 /// @param[in] data_length
9903 /// An integer of at least the size of
9904 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9905 ///
9906 /// @param[in] start_index
9907 /// First index of range. Must be at least 0 and at
9908 /// most ::HAPI_AttributeInfo::count - 1.
9909 /// <!-- default 0 -->
9910 ///
9911 /// @param[in] num_indices
9912 /// Must be at least 0 and at most
9913 /// ::HAPI_AttributeInfo::count - @p start_index.
9914 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9915 ///
9916 /// @param[out] job_id
9917 /// The id assigned to the job.
9918 ///
9920  const HAPI_Session* session,
9921  HAPI_NodeId node_id,
9922  HAPI_PartId part_id,
9923  const char* name,
9924  const HAPI_AttributeInfo* attr_info,
9925  const HAPI_Int16* data_array,
9926  int data_length,
9927  int start_index,
9928  int num_indices,
9929  int * job_id );
9930 
9931 /// @brief Set multiple attribute 64-bit int data to the same unique value
9932 /// asynchronously.
9933 ///
9934 /// @ingroup GeometrySetters Attributes
9935 ///
9936 /// @param[in] session
9937 /// The session of Houdini you are interacting with.
9938 /// See @ref HAPI_Sessions for more on sessions.
9939 /// Pass NULL to just use the default in-process session.
9940 /// <!-- default NULL -->
9941 ///
9942 /// @param[in] node_id
9943 /// The SOP node id.
9944 ///
9945 /// @param[in] part_id
9946 /// Currently not used. Just pass 0.
9947 ///
9948 /// @param[in] name
9949 /// Attribute name.
9950 ///
9951 /// @param[in] attr_info
9952 /// ::HAPI_AttributeInfo used as input for what tuple size.
9953 /// you want. Also contains some sanity checks like
9954 /// data type. Generally should be the same struct
9955 /// returned by ::HAPI_GetAttributeInfo().
9956 ///
9957 /// @param[in] data_array
9958 /// A integer array at least the size of
9959 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9960 ///
9961 /// @param[in] data_length
9962 /// An integer of at least the size of
9963 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9964 ///
9965 /// @param[in] start_index
9966 /// First index of range. Must be at least 0 and at
9967 /// most ::HAPI_AttributeInfo::count - 1.
9968 /// <!-- default 0 -->
9969 ///
9970 /// @param[in] num_indices
9971 /// Must be at least 0 and at most
9972 /// ::HAPI_AttributeInfo::count - @p start_index.
9973 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9974 ///
9975 /// @param[out] job_id
9976 /// The id assigned to the job.
9977 ///
9979  const HAPI_Session* session,
9980  HAPI_NodeId node_id,
9981  HAPI_PartId part_id,
9982  const char* name,
9983  const HAPI_AttributeInfo* attr_info,
9984  const HAPI_Int64* data_array,
9985  int data_length,
9986  int start_index,
9987  int num_indices,
9988  int * job_id );
9989 
9990 /// @brief Set multiple attribute float data to the same unique value
9991 /// asynchronously.
9992 ///
9993 /// @ingroup GeometrySetters Attributes
9994 ///
9995 /// @param[in] session
9996 /// The session of Houdini you are interacting with.
9997 /// See @ref HAPI_Sessions for more on sessions.
9998 /// Pass NULL to just use the default in-process session.
9999 /// <!-- default NULL -->
10000 ///
10001 /// @param[in] node_id
10002 /// The SOP node id.
10003 ///
10004 /// @param[in] part_id
10005 /// Currently not used. Just pass 0.
10006 ///
10007 /// @param[in] name
10008 /// Attribute name.
10009 ///
10010 /// @param[in] attr_info
10011 /// ::HAPI_AttributeInfo used as input for what tuple size.
10012 /// you want. Also contains some sanity checks like
10013 /// data type. Generally should be the same struct
10014 /// returned by ::HAPI_GetAttributeInfo().
10015 ///
10016 /// @param[in] data_array
10017 /// A floating point array at least the size of
10018 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10019 ///
10020 /// @param[in] data_length
10021 /// An integer of at least the size of
10022 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10023 ///
10024 /// @param[in] start_index
10025 /// First index of range. Must be at least 0 and at
10026 /// most ::HAPI_AttributeInfo::count - 1.
10027 /// <!-- default 0 -->
10028 ///
10029 /// @param[in] num_indices
10030 /// Must be at least 0 and at most
10031 /// ::HAPI_AttributeInfo::count - @p start_index.
10032 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10033 ///
10034 /// @param[out] job_id
10035 /// The id assigned to the job.
10036 ///
10038  const HAPI_Session* session,
10039  HAPI_NodeId node_id,
10040  HAPI_PartId part_id,
10041  const char* name,
10042  const HAPI_AttributeInfo* attr_info,
10043  const float* data_array,
10044  int data_length,
10045  int start_index,
10046  int num_indices,
10047  int * job_id );
10048 
10049 /// @brief Set multiple attribute 64-bit float data to the same unique
10050 /// asynchronously.
10051 ///
10052 /// @ingroup GeometrySetters Attributes
10053 ///
10054 /// @param[in] session
10055 /// The session of Houdini you are interacting with.
10056 /// See @ref HAPI_Sessions for more on sessions.
10057 /// Pass NULL to just use the default in-process session.
10058 /// <!-- default NULL -->
10059 ///
10060 /// @param[in] node_id
10061 /// The SOP node id.
10062 ///
10063 /// @param[in] part_id
10064 /// Currently not used. Just pass 0.
10065 ///
10066 /// @param[in] name
10067 /// Attribute name.
10068 ///
10069 /// @param[in] attr_info
10070 /// ::HAPI_AttributeInfo used as input for what tuple size.
10071 /// you want. Also contains some sanity checks like
10072 /// data type. Generally should be the same struct
10073 /// returned by ::HAPI_GetAttributeInfo().
10074 ///
10075 /// @param[in] data_array
10076 /// A floating point array at least the size of
10077 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10078 ///
10079 /// @param[in] data_length
10080 /// An integer of at least the size of
10081 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10082 ///
10083 /// @param[in] start_index
10084 /// First index of range. Must be at least 0 and at
10085 /// most ::HAPI_AttributeInfo::count - 1.
10086 /// <!-- default 0 -->
10087 ///
10088 /// @param[in] num_indices
10089 /// Must be at least 0 and at most
10090 /// ::HAPI_AttributeInfo::count - @p start_index.
10091 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10092 ///
10093 /// @param[out] job_id
10094 /// The id assigned to the job.
10095 ///
10097  const HAPI_Session* session,
10098  HAPI_NodeId node_id,
10099  HAPI_PartId part_id,
10100  const char* name,
10101  const HAPI_AttributeInfo* attr_info,
10102  const double* data_array,
10103  int data_length,
10104  int start_index,
10105  int num_indices,
10106  int * job_id );
10107 
10108 /// @brief Set attribute dictionary data asynchronously. The dictionary data
10109 /// should be provided as JSON-encoded strings.
10110 ///
10111 /// @ingroup GeometrySetters Attributes
10112 ///
10113 /// @param[in] session
10114 /// The session of Houdini you are interacting with.
10115 /// See @ref HAPI_Sessions for more on sessions.
10116 /// Pass NULL to just use the default in-process session.
10117 /// <!-- default NULL -->
10118 ///
10119 /// @param[in] node_id
10120 /// The SOP node id.
10121 ///
10122 /// @param[in] part_id
10123 /// Currently not used. Just pass 0.
10124 ///
10125 /// @param[in] name
10126 /// Attribute name.
10127 ///
10128 /// @param[in] attr_info
10129 /// ::HAPI_AttributeInfo used as input for what tuple size
10130 /// you want. Also contains some sanity checks like
10131 /// data type. Generally should be the same struct
10132 /// returned by ::HAPI_GetAttributeInfo().
10133 ///
10134 /// @param[in] data_array
10135 /// An ::HAPI_StringHandle array at least the size of
10136 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
10137 ///
10138 /// @param[in] start
10139 /// First index of range. Must be at least 0 and at
10140 /// most ::HAPI_AttributeInfo::count - 1.
10141 /// <!-- default 0 -->
10142 ///
10143 /// @param[in] length
10144 /// Must be at least 0 and at most
10145 /// ::HAPI_AttributeInfo::count - @p start.
10146 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10147 ///
10148 /// @param[out] job_id
10149 /// The id assigned to the job.
10150 ///
10152  const HAPI_Session* session,
10153  HAPI_NodeId node_id,
10154  HAPI_PartId part_id,
10155  const char* name,
10156  const HAPI_AttributeInfo* attr_info,
10157  const char** data_array,
10158  int start, int length,
10159  int * job_id );
10160 
10161 /// @brief Set integer array attribute data asynchronously.
10162 ///
10163 /// @ingroup GeometrySetters Attributes
10164 ///
10165 /// @param[in] session
10166 /// The session of Houdini you are interacting with.
10167 /// See @ref HAPI_Sessions for more on sessions.
10168 /// Pass NULL to just use the default in-process session.
10169 /// <!-- default NULL -->
10170 ///
10171 /// @param[in] node_id
10172 /// The SOP node id.
10173 ///
10174 /// @param[in] part_id
10175 /// Currently not used. Just pass 0.
10176 ///
10177 /// @param[in] name
10178 /// Attribute name.
10179 ///
10180 /// @param[in] attr_info
10181 /// ::HAPI_AttributeInfo that contains the description for the
10182 /// attribute that is being set.
10183 ///
10184 /// @param[in] data_fixed_array
10185 /// An array containing the int values of the attribute.
10186 ///
10187 /// @param[in] data_fixed_length
10188 /// The total size of the data array. The size can be no greater
10189 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10190 /// of the attribute.
10191 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10192 ///
10193 /// @param[in] sizes_fixed_array
10194 /// An array of integers that contains the sizes of each
10195 /// attribute array. This is required because the attribute
10196 /// array for each geometry component can be of variable size.
10197 ///
10198 /// @param[in] start
10199 /// First index of range. Must be at least 0 and at most
10200 /// ::HAPI_AttributeInfo::count - 1.
10201 /// <!-- default 0 -->
10202 ///
10203 /// @param[in] sizes_fixed_length
10204 /// Must be at least 0 and at most
10205 /// ::HAPI_AttributeInfo::count - @p start.
10206 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10207 ///
10208 /// @param[out] job_id
10209 /// The id assigned to the job.
10210 ///
10212  const HAPI_Session * session,
10213  HAPI_NodeId node_id,
10214  HAPI_PartId part_id,
10215  const char * name,
10216  const HAPI_AttributeInfo * attr_info,
10217  const int * data_fixed_array,
10218  int data_fixed_length,
10219  const int * sizes_fixed_array,
10220  int start,
10221  int sizes_fixed_length,
10222  int * job_id );
10223 
10224 /// @brief Set unsigned 8-bit integer array attribute data asynchronously.
10225 ///
10226 /// @ingroup GeometrySetters Attributes
10227 ///
10228 /// @param[in] session
10229 /// The session of Houdini you are interacting with.
10230 /// See @ref HAPI_Sessions for more on sessions.
10231 /// Pass NULL to just use the default in-process session.
10232 /// <!-- default NULL -->
10233 ///
10234 /// @param[in] node_id
10235 /// The SOP node id.
10236 ///
10237 /// @param[in] part_id
10238 /// Currently not used. Just pass 0.
10239 ///
10240 /// @param[in] name
10241 /// Attribute name.
10242 ///
10243 /// @param[in] attr_info
10244 /// ::HAPI_AttributeInfo that contains the description for the
10245 /// attribute that is being set.
10246 ///
10247 /// @param[in] data_fixed_array
10248 /// An array containing the HAPI_UInt8 values of the attribute.
10249 ///
10250 /// @param[in] data_fixed_length
10251 /// The total size of the data array. The size can be no greater
10252 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10253 /// of the attribute.
10254 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10255 ///
10256 /// @param[in] sizes_fixed_array
10257 /// An array of integers that contains the sizes of each
10258 /// attribute array. This is required because the attribute
10259 /// array for each geometry component can be of variable size.
10260 ///
10261 /// @param[in] start
10262 /// First index of range. Must be at least 0 and at most
10263 /// ::HAPI_AttributeInfo::count - 1.
10264 /// <!-- default 0 -->
10265 ///
10266 /// @param[in] sizes_fixed_length
10267 /// Must be at least 0 and at most
10268 /// ::HAPI_AttributeInfo::count - @p start.
10269 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10270 ///
10271 /// @param[out] job_id
10272 /// The id assigned to the job.
10273 ///
10275  const HAPI_Session * session,
10276  HAPI_NodeId node_id,
10277  HAPI_PartId part_id,
10278  const char * name,
10279  const HAPI_AttributeInfo * attr_info,
10280  const HAPI_UInt8 * data_fixed_array,
10281  int data_fixed_length,
10282  const int * sizes_fixed_array,
10283  int start,
10284  int sizes_fixed_length,
10285  int * job_id );
10286 
10287 /// @brief Set 8-bit integer array attribute data asynchronously.
10288 ///
10289 /// @ingroup GeometrySetters Attributes
10290 ///
10291 /// @param[in] session
10292 /// The session of Houdini you are interacting with.
10293 /// See @ref HAPI_Sessions for more on sessions.
10294 /// Pass NULL to just use the default in-process session.
10295 /// <!-- default NULL -->
10296 ///
10297 /// @param[in] node_id
10298 /// The SOP node id.
10299 ///
10300 /// @param[in] part_id
10301 /// Currently not used. Just pass 0.
10302 ///
10303 /// @param[in] name
10304 /// Attribute name.
10305 ///
10306 /// @param[in] attr_info
10307 /// ::HAPI_AttributeInfo that contains the description for the
10308 /// attribute that is being set.
10309 ///
10310 /// @param[in] data_fixed_array
10311 /// An array containing the HAPI_Int8 values of the attribute.
10312 ///
10313 /// @param[in] data_fixed_length
10314 /// The total size of the data array. The size can be no greater
10315 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10316 /// of the attribute.
10317 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10318 ///
10319 /// @param[in] sizes_fixed_array
10320 /// An array of integers that contains the sizes of each
10321 /// attribute array. This is required because the attribute
10322 /// array for each geometry component can be of variable size.
10323 ///
10324 /// @param[in] start
10325 /// First index of range. Must be at least 0 and at most
10326 /// ::HAPI_AttributeInfo::count - 1.
10327 /// <!-- default 0 -->
10328 ///
10329 /// @param[in] sizes_fixed_length
10330 /// Must be at least 0 and at most
10331 /// ::HAPI_AttributeInfo::count - @p start.
10332 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10333 ///
10334 /// @param[out] job_id
10335 /// The id assigned to the job.
10336 ///
10338  const HAPI_Session * session,
10339  HAPI_NodeId node_id,
10340  HAPI_PartId part_id,
10341  const char * name,
10342  const HAPI_AttributeInfo * attr_info,
10343  const HAPI_Int8 * data_fixed_array,
10344  int data_fixed_length,
10345  const int * sizes_fixed_array,
10346  int start,
10347  int sizes_fixed_length,
10348  int * job_id );
10349 
10350 /// @brief Set 16-bit integer array attribute data asynchronously.
10351 ///
10352 /// @ingroup GeometrySetters Attributes
10353 ///
10354 /// @param[in] session
10355 /// The session of Houdini you are interacting with.
10356 /// See @ref HAPI_Sessions for more on sessions.
10357 /// Pass NULL to just use the default in-process session.
10358 /// <!-- default NULL -->
10359 ///
10360 /// @param[in] node_id
10361 /// The SOP node id.
10362 ///
10363 /// @param[in] part_id
10364 /// Currently not used. Just pass 0.
10365 ///
10366 /// @param[in] name
10367 /// Attribute name.
10368 ///
10369 /// @param[in] attr_info
10370 /// ::HAPI_AttributeInfo that contains the description for the
10371 /// attribute that is being set.
10372 ///
10373 /// @param[in] data_fixed_array
10374 /// An array containing the HAPI_Int16 values of the attribute.
10375 ///
10376 /// @param[in] data_fixed_length
10377 /// The total size of the data array. The size can be no greater
10378 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10379 /// of the attribute.
10380 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10381 ///
10382 /// @param[in] sizes_fixed_array
10383 /// An array of integers that contains the sizes of each
10384 /// attribute array. This is required because the attribute
10385 /// array for each geometry component can be of variable size.
10386 ///
10387 /// @param[in] start
10388 /// First index of range. Must be at least 0 and at most
10389 /// ::HAPI_AttributeInfo::count - 1.
10390 /// <!-- default 0 -->
10391 ///
10392 /// @param[in] sizes_fixed_length
10393 /// Must be at least 0 and at most
10394 /// ::HAPI_AttributeInfo::count - @p start.
10395 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10396 ///
10397 /// @param[out] job_id
10398 /// The id assigned to the job.
10399 ///
10401  const HAPI_Session * session,
10402  HAPI_NodeId node_id,
10403  HAPI_PartId part_id,
10404  const char * name,
10405  const HAPI_AttributeInfo * attr_info,
10406  const HAPI_Int16 * data_fixed_array,
10407  int data_fixed_length,
10408  const int * sizes_fixed_array,
10409  int start,
10410  int sizes_fixed_length,
10411  int * job_id );
10412 
10413 /// @brief Set 64-bit integer array attribute data asynchronously.
10414 ///
10415 /// @ingroup GeometrySetters Attributes
10416 ///
10417 /// @param[in] session
10418 /// The session of Houdini you are interacting with.
10419 /// See @ref HAPI_Sessions for more on sessions.
10420 /// Pass NULL to just use the default in-process session.
10421 /// <!-- default NULL -->
10422 ///
10423 /// @param[in] node_id
10424 /// The SOP node id.
10425 ///
10426 /// @param[in] part_id
10427 /// Currently not used. Just pass 0.
10428 ///
10429 /// @param[in] name
10430 /// Attribute name.
10431 ///
10432 /// @param[in] attr_info
10433 /// ::HAPI_AttributeInfo that contains the description for the
10434 /// attribute that is being set.
10435 ///
10436 /// @param[in] data_fixed_array
10437 /// An array containing the HAPI_Int64 values of the attribute.
10438 ///
10439 /// @param[in] data_fixed_length
10440 /// The total size of the data array. The size can be no greater
10441 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10442 /// of the attribute.
10443 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10444 ///
10445 /// @param[in] sizes_fixed_array
10446 /// An array of integers that contains the sizes of each
10447 /// attribute array. This is required because the attribute
10448 /// array for each geometry component can be of variable size.
10449 ///
10450 /// @param[in] start
10451 /// First index of range. Must be at least 0 and at most
10452 /// ::HAPI_AttributeInfo::count - 1.
10453 /// <!-- default 0 -->
10454 ///
10455 /// @param[in] sizes_fixed_length
10456 /// Must be at least 0 and at most
10457 /// ::HAPI_AttributeInfo::count - @p start.
10458 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10459 ///
10460 /// @param[out] job_id
10461 /// The id assigned to the job.
10462 ///
10464  const HAPI_Session * session,
10465  HAPI_NodeId node_id,
10466  HAPI_PartId part_id,
10467  const char * name,
10468  const HAPI_AttributeInfo * attr_info,
10469  const HAPI_Int64 * data_fixed_array,
10470  int data_fixed_length,
10471  const int * sizes_fixed_array,
10472  int start,
10473  int sizes_fixed_length,
10474  int * job_id );
10475 
10476 /// @brief Set float array attribute data asynchronously.
10477 ///
10478 /// @ingroup GeometrySetters Attributes
10479 ///
10480 /// @param[in] session
10481 /// The session of Houdini you are interacting with.
10482 /// See @ref HAPI_Sessions for more on sessions.
10483 /// Pass NULL to just use the default in-process session.
10484 /// <!-- default NULL -->
10485 ///
10486 /// @param[in] node_id
10487 /// The SOP node id.
10488 ///
10489 /// @param[in] part_id
10490 /// Currently not used. Just pass 0.
10491 ///
10492 /// @param[in] name
10493 /// Attribute name.
10494 ///
10495 /// @param[in] attr_info
10496 /// ::HAPI_AttributeInfo that contains the description for the
10497 /// attribute that is being set.
10498 ///
10499 /// @param[in] data_fixed_array
10500 /// An array containing the float values of the attribute.
10501 ///
10502 /// @param[in] data_fixed_length
10503 /// The total size of the data array. The size can be no greater
10504 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10505 /// of the attribute.
10506 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10507 ///
10508 /// @param[in] sizes_fixed_array
10509 /// An array of integers that contains the sizes of each
10510 /// attribute array. This is required because the attribute
10511 /// array for each geometry component can be of variable size.
10512 ///
10513 /// @param[in] start
10514 /// First index of range. Must be at least 0 and at most
10515 /// ::HAPI_AttributeInfo::count - 1.
10516 /// <!-- default 0 -->
10517 ///
10518 /// @param[in] sizes_fixed_length
10519 /// Must be at least 0 and at most
10520 /// ::HAPI_AttributeInfo::count - @p start.
10521 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10522 ///
10523 /// @param[out] job_id
10524 /// The id assigned to the job.
10525 ///
10527  const HAPI_Session * session,
10528  HAPI_NodeId node_id,
10529  HAPI_PartId part_id,
10530  const char * name,
10531  const HAPI_AttributeInfo * attr_info,
10532  const float * data_fixed_array,
10533  int data_fixed_length,
10534  const int * sizes_fixed_array,
10535  int start,
10536  int sizes_fixed_length,
10537  int * job_id );
10538 
10539 /// @brief Set 64-bit float array attribute data asynchronously.
10540 ///
10541 /// @ingroup GeometrySetters Attributes
10542 ///
10543 /// @param[in] session
10544 /// The session of Houdini you are interacting with.
10545 /// See @ref HAPI_Sessions for more on sessions.
10546 /// Pass NULL to just use the default in-process session.
10547 /// <!-- default NULL -->
10548 ///
10549 /// @param[in] node_id
10550 /// The SOP node id.
10551 ///
10552 /// @param[in] part_id
10553 /// Currently not used. Just pass 0.
10554 ///
10555 /// @param[in] name
10556 /// Attribute name.
10557 ///
10558 /// @param[in] attr_info
10559 /// ::HAPI_AttributeInfo that contains the description for the
10560 /// attribute that is being set.
10561 ///
10562 /// @param[in] data_fixed_array
10563 /// An array containing the double values of the attribute.
10564 ///
10565 /// @param[in] data_fixed_length
10566 /// The total size of the data array. The size can be no greater
10567 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10568 /// of the attribute.
10569 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10570 ///
10571 /// @param[in] sizes_fixed_array
10572 /// An array of integers that contains the sizes of each
10573 /// attribute array. This is required because the attribute
10574 /// array for each geometry component can be of variable size.
10575 ///
10576 /// @param[in] start
10577 /// First index of range. Must be at least 0 and at most
10578 /// ::HAPI_AttributeInfo::count - 1.
10579 /// <!-- default 0 -->
10580 ///
10581 /// @param[in] sizes_fixed_length
10582 /// Must be at least 0 and at most
10583 /// ::HAPI_AttributeInfo::count - @p start.
10584 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10585 ///
10586 /// @param[out] job_id
10587 /// The id assigned to the job.
10588 ///
10590  const HAPI_Session * session,
10591  HAPI_NodeId node_id,
10592  HAPI_PartId part_id,
10593  const char * name,
10594  const HAPI_AttributeInfo * attr_info,
10595  const double * data_fixed_array,
10596  int data_fixed_length,
10597  const int * sizes_fixed_array,
10598  int start,
10599  int sizes_fixed_length,
10600  int * job_id );
10601 
10602 /// @brief Set string array attribute data asynchronously.
10603 ///
10604 /// @ingroup GeometrySetters Attributes
10605 ///
10606 /// @param[in] session
10607 /// The session of Houdini you are interacting with.
10608 /// See @ref HAPI_Sessions for more on sessions.
10609 /// Pass NULL to just use the default in-process session.
10610 /// <!-- default NULL -->
10611 ///
10612 /// @param[in] node_id
10613 /// The SOP node id.
10614 ///
10615 /// @param[in] part_id
10616 /// Currently not used. Just pass 0.
10617 ///
10618 /// @param[in] name
10619 /// Attribute name.
10620 ///
10621 /// @param[in] attr_info
10622 /// ::HAPI_AttributeInfo that contains the description for the
10623 /// attribute that is being set.
10624 ///
10625 /// @param[in] data_fixed_array
10626 /// An array containing the string values of the attribute.
10627 ///
10628 /// @param[in] data_fixed_length
10629 /// The total size of the data array. The size can be no greater
10630 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10631 /// of the attribute.
10632 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10633 ///
10634 /// @param[in] sizes_fixed_array
10635 /// An array of integers that contains the sizes of each
10636 /// attribute array. This is required because the attribute
10637 /// array for each geometry component can be of variable size.
10638 ///
10639 /// @param[in] start
10640 /// First index of range. Must be at least 0 and at most
10641 /// ::HAPI_AttributeInfo::count - 1.
10642 /// <!-- default 0 -->
10643 ///
10644 /// @param[in] sizes_fixed_length
10645 /// Must be at least 0 and at most
10646 /// ::HAPI_AttributeInfo::count - @p start.
10647 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10648 ///
10649 /// @param[out] job_id
10650 /// The id assigned to the job.
10651 ///
10653  const HAPI_Session * session,
10654  HAPI_NodeId node_id,
10655  HAPI_PartId part_id,
10656  const char * name,
10657  const HAPI_AttributeInfo * attr_info,
10658  const char ** data_fixed_array,
10659  int data_fixed_length,
10660  const int * sizes_fixed_array,
10661  int start,
10662  int sizes_fixed_length,
10663  int * job_id );
10664 
10665 /// @brief Set attribute dictionary array data asynchronously. The dictionary
10666 /// should be provided as JSON-encoded strings.
10667 ///
10668 /// @ingroup GeometrySetters Attributes
10669 ///
10670 /// @param[in] session
10671 /// The session of Houdini you are interacting with.
10672 /// See @ref HAPI_Sessions for more on sessions.
10673 /// Pass NULL to just use the default in-process session.
10674 /// <!-- default NULL -->
10675 ///
10676 /// @param[in] node_id
10677 /// The SOP node id.
10678 ///
10679 /// @param[in] part_id
10680 /// Currently not used. Just pass 0.
10681 ///
10682 /// @param[in] name
10683 /// Attribute name.
10684 ///
10685 /// @param[in] attr_info
10686 /// ::HAPI_AttributeInfo that contains the description for the
10687 /// attribute that is being set.
10688 ///
10689 /// @param[in] data_fixed_array
10690 /// An array containing the dictionary values of the attribute.
10691 ///
10692 /// @param[in] data_fixed_length
10693 /// The total size of the data array. The size can be no greater
10694 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10695 /// of the attribute.
10696 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10697 ///
10698 /// @param[in] sizes_fixed_array
10699 /// An array of integers that contains the sizes of each
10700 /// attribute array. This is required because the attribute
10701 /// array for each geometry component can be of variable size.
10702 ///
10703 /// @param[in] start
10704 /// First index of range. Must be at least 0 and at most
10705 /// ::HAPI_AttributeInfo::count - 1.
10706 /// <!-- default 0 -->
10707 ///
10708 /// @param[in] sizes_fixed_length
10709 /// Must be at least 0 and at most
10710 /// ::HAPI_AttributeInfo::count - @p start.
10711 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10712 ///
10713 /// @param[out] job_id
10714 /// The id assigned to the job.
10715 ///
10717  const HAPI_Session * session,
10718  HAPI_NodeId node_id,
10719  HAPI_PartId part_id,
10720  const char * name,
10721  const HAPI_AttributeInfo * attr_info,
10722  const char ** data_fixed_array,
10723  int data_fixed_length,
10724  const int * sizes_fixed_array,
10725  int start,
10726  int sizes_fixed_length,
10727  int * job_id );
10728 
10729 /// @brief Add a group to the input geo with the given type and name.
10730 ///
10731 /// @ingroup GeometrySetters
10732 ///
10733 /// @param[in] session
10734 /// The session of Houdini you are interacting with.
10735 /// See @ref HAPI_Sessions for more on sessions.
10736 /// Pass NULL to just use the default in-process session.
10737 /// <!-- default NULL -->
10738 ///
10739 /// @param[in] node_id
10740 /// The SOP node id.
10741 ///
10742 /// @param[in] part_id
10743 /// Currently not used. Just pass 0.
10744 ///
10745 /// @param[in] group_type
10746 /// The group type.
10747 ///
10748 /// @param[in] group_name
10749 /// Name of new group to be added.
10750 ///
10751 HAPI_DECL HAPI_AddGroup( const HAPI_Session * session,
10752  HAPI_NodeId node_id,
10753  HAPI_PartId part_id,
10754  HAPI_GroupType group_type,
10755  const char * group_name );
10756 
10757 /// @brief Remove a group from the input geo with the given type and name.
10758 ///
10759 /// @ingroup GeometrySetters
10760 ///
10761 /// @param[in] session
10762 /// The session of Houdini you are interacting with.
10763 /// See @ref HAPI_Sessions for more on sessions.
10764 /// Pass NULL to just use the default in-process session.
10765 /// <!-- default NULL -->
10766 ///
10767 /// @param[in] node_id
10768 /// The SOP node id.
10769 ///
10770 /// @param[in] part_id
10771 /// Currently not used. Just pass 0.
10772 ///
10773 /// @param[in] group_type
10774 /// The group type.
10775 ///
10776 /// @param[in] group_name
10777 /// Name of the group to be removed
10778 ///
10779 HAPI_DECL HAPI_DeleteGroup( const HAPI_Session * session,
10780  HAPI_NodeId node_id,
10781  HAPI_PartId part_id,
10782  HAPI_GroupType group_type,
10783  const char * group_name );
10784 
10785 /// @brief Set group membership.
10786 ///
10787 /// @ingroup GeometrySetters
10788 ///
10789 /// @param[in] session
10790 /// The session of Houdini you are interacting with.
10791 /// See @ref HAPI_Sessions for more on sessions.
10792 /// Pass NULL to just use the default in-process session.
10793 /// <!-- default NULL -->
10794 ///
10795 /// @param[in] node_id
10796 /// The SOP node id.
10797 ///
10798 /// @param[in] part_id
10799 /// Currently not used. Just pass 0.
10800 /// <!-- default 0 -->
10801 ///
10802 /// @param[in] group_type
10803 /// The group type.
10804 ///
10805 /// @param[in] group_name
10806 /// The group name.
10807 ///
10808 /// @param[in] membership_array
10809 /// Array of ints that represent the membership of this
10810 /// group. Should be the size given by
10811 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
10812 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
10813 ///
10814 /// @param[in] start
10815 /// Start offset into the membership array. Must be
10816 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
10817 /// <!-- default 0 -->
10818 ///
10819 /// @param[in] length
10820 /// Should be less than or equal to the size
10821 /// of @p membership_array. When setting edge group membership,
10822 /// this parameter should be set to the number of points (which
10823 /// are used to implictly define the edges), not to the number
10824 /// edges in the group.
10825 /// <!-- source ::HAPI_PartInfo_GetElementCountByGroupType -->
10826 ///
10828  HAPI_NodeId node_id,
10829  HAPI_PartId part_id,
10830  HAPI_GroupType group_type,
10831  const char * group_name,
10832  const int * membership_array,
10833  int start, int length );
10834 
10835 /// @brief Commit the current input geometry to the cook engine. Nodes
10836 /// that use this geometry node will re-cook using the input
10837 /// geometry given through the geometry setter API calls.
10838 ///
10839 /// @ingroup GeometrySetters
10840 ///
10841 /// @param[in] session
10842 /// The session of Houdini you are interacting with.
10843 /// See @ref HAPI_Sessions for more on sessions.
10844 /// Pass NULL to just use the default in-process session.
10845 /// <!-- default NULL -->
10846 ///
10847 /// @param[in] node_id
10848 /// The SOP node id.
10849 ///
10850 HAPI_DECL HAPI_CommitGeo( const HAPI_Session * session,
10851  HAPI_NodeId node_id );
10852 
10853 /// @brief Remove all changes that have been committed to this
10854 /// geometry. If this is an intermediate result node (Edit SOP), all
10855 /// deltas will be removed. If it's any other type of node, the node
10856 /// will be unlocked if it is locked.
10857 ///
10858 /// @ingroup GeometrySetters
10859 ///
10860 /// @param[in] session
10861 /// The session of Houdini you are interacting with.
10862 /// See @ref HAPI_Sessions for more on sessions.
10863 /// Pass NULL to just use the default in-process session.
10864 /// <!-- default NULL -->
10865 ///
10866 /// @param[in] node_id
10867 /// The SOP node id.
10868 ///
10869 HAPI_DECL HAPI_RevertGeo( const HAPI_Session * session,
10870  HAPI_NodeId node_id );
10871 
10872 /// @defgroup Materials
10873 /// Functions for working with materials
10874 
10875 /// @brief Get material ids by face/primitive. The material ids returned
10876 /// will be valid as long as the asset is alive. You should query
10877 /// this list after every cook to see if the material assignments
10878 /// have changed. You should also query each material individually
10879 /// using ::HAPI_GetMaterialInfo() to see if it is dirty and needs
10880 /// to be re-imported.
10881 ///
10882 /// @ingroup Materials
10883 ///
10884 /// @param[in] session
10885 /// The session of Houdini you are interacting with.
10886 /// See @ref HAPI_Sessions for more on sessions.
10887 /// Pass NULL to just use the default in-process session.
10888 /// <!-- default NULL -->
10889 ///
10890 /// @param[in] geometry_node_id
10891 /// The geometry node id.
10892 ///
10893 /// @param[in] part_id
10894 /// The part id.
10895 ///
10896 /// @param[out] are_all_the_same
10897 /// (optional) If true, all faces on this part have the
10898 /// same material assignment. You can pass NULL here.
10899 ///
10900 /// @param[out] material_ids_array
10901 /// An array of ::HAPI_NodeId at least the size of
10902 /// @p length and at most the size of
10903 /// ::HAPI_PartInfo::faceCount.
10904 ///
10905 /// @param[in] start
10906 /// The starting index into the list of faces from which
10907 /// you wish to get the material ids from. Note that
10908 /// this should be less than ::HAPI_PartInfo::faceCount.
10909 /// <!-- default 0 -->
10910 ///
10911 /// @param[in] length
10912 /// The number of material ids you wish to get. Note that
10913 /// this should be at most:
10914 /// ::HAPI_PartInfo::faceCount - @p start.
10915 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
10916 ///
10918  HAPI_NodeId geometry_node_id,
10919  HAPI_PartId part_id,
10920  HAPI_Bool * are_all_the_same,
10921  HAPI_NodeId * material_ids_array,
10922  int start, int length );
10923 
10924 /// @brief Get the material info.
10925 ///
10926 /// @ingroup Materials
10927 ///
10928 /// @param[in] session
10929 /// The session of Houdini you are interacting with.
10930 /// See @ref HAPI_Sessions for more on sessions.
10931 /// Pass NULL to just use the default in-process session.
10932 /// <!-- default NULL -->
10933 ///
10934 /// @param[in] material_node_id
10935 /// The material node id.
10936 ///
10937 /// @param[out] material_info
10938 /// The returned material info.
10939 ///
10941  HAPI_NodeId material_node_id,
10942  HAPI_MaterialInfo * material_info );
10943 
10944 /// @brief Render a single texture from a COP to an image for
10945 /// later extraction.
10946 ///
10947 /// @ingroup Materials
10948 ///
10949 /// Note that you must call this first for any of the other material
10950 /// APIs to work.
10951 ///
10952 /// @param[in] session
10953 /// The session of Houdini you are interacting with.
10954 /// See @ref HAPI_Sessions for more on sessions.
10955 /// Pass NULL to just use the default in-process session.
10956 /// <!-- default NULL -->
10957 ///
10958 /// @param[in] cop_node_id
10959 /// The COP node id.
10960 ///
10962  HAPI_NodeId cop_node_id );
10963 
10964 /// @brief Render only a single texture to an image for later extraction.
10965 /// An example use of this method might be to render the diffuse,
10966 /// normal, and bump texture maps of a material to individual
10967 /// texture files for use within the client application.
10968 ///
10969 /// Note that you must call this first for any of the other material
10970 /// APIs to work.
10971 ///
10972 /// @ingroup Materials
10973 ///
10974 /// @param[in] session
10975 /// The session of Houdini you are interacting with.
10976 /// See @ref HAPI_Sessions for more on sessions.
10977 /// Pass NULL to just use the default in-process session.
10978 /// <!-- default NULL -->
10979 ///
10980 /// @param[in] material_node_id
10981 /// The material node id.
10982 ///
10983 /// @param[in] parm_id
10984 /// This is the index in the parameter list of the
10985 /// material_id's node of the parameter containing the
10986 /// texture map file path.
10987 ///
10989  HAPI_NodeId material_node_id,
10990  HAPI_ParmId parm_id );
10991 
10992 /// @brief Get information about the image that was just rendered, like
10993 /// resolution and default file format. This information will be
10994 /// used when extracting planes to an image.
10995 ///
10996 /// Note that you must call ::HAPI_RenderTextureToImage() first for
10997 /// this method call to make sense.
10998 ///
10999 /// @ingroup Materials
11000 ///
11001 /// @param[in] session
11002 /// The session of Houdini you are interacting with.
11003 /// See @ref HAPI_Sessions for more on sessions.
11004 /// Pass NULL to just use the default in-process session.
11005 /// <!-- default NULL -->
11006 ///
11007 /// @param[in] material_node_id
11008 /// The material node id.
11009 ///
11010 /// @param[out] image_info
11011 /// The struct containing the image information.
11012 ///
11013 HAPI_DECL HAPI_GetImageInfo( const HAPI_Session * session,
11014  HAPI_NodeId material_node_id,
11015  HAPI_ImageInfo * image_info );
11016 
11017 /// @brief Set image information like resolution and file format.
11018 /// This information will be used when extracting planes to
11019 /// an image.
11020 ///
11021 /// Note that you must call ::HAPI_RenderTextureToImage() first for
11022 /// this method call to make sense.
11023 ///
11024 /// You should also first call ::HAPI_GetImageInfo() to get the
11025 /// current Image Info and change only the properties
11026 /// you don't like.
11027 ///
11028 /// @ingroup Materials
11029 ///
11030 /// @param[in] session
11031 /// The session of Houdini you are interacting with.
11032 /// See @ref HAPI_Sessions for more on sessions.
11033 /// Pass NULL to just use the default in-process session.
11034 /// <!-- default NULL -->
11035 ///
11036 /// @param[in] material_node_id
11037 /// The material node id.
11038 ///
11039 /// @param[in] image_info
11040 /// The struct containing the new image information.
11041 ///
11042 HAPI_DECL HAPI_SetImageInfo( const HAPI_Session * session,
11043  HAPI_NodeId material_node_id,
11044  const HAPI_ImageInfo * image_info );
11045 
11046 /// @brief Get the number of image planes for the just rendered image.
11047 ///
11048 /// Note that you must call ::HAPI_RenderTextureToImage() first for
11049 /// this method call to make sense.
11050 ///
11051 /// @ingroup Materials
11052 ///
11053 /// @param[in] session
11054 /// The session of Houdini you are interacting with.
11055 /// See @ref HAPI_Sessions for more on sessions.
11056 /// Pass NULL to just use the default in-process session.
11057 /// <!-- default NULL -->
11058 ///
11059 /// @param[in] material_node_id
11060 /// The material node id.
11061 ///
11062 /// @param[out] image_plane_count
11063 /// The number of image planes.
11064 ///
11066  HAPI_NodeId material_node_id,
11067  int * image_plane_count );
11068 
11069 /// @brief Get the names of the image planes of the just rendered image.
11070 ///
11071 /// Note that you must call ::HAPI_RenderTextureToImage() first for
11072 /// this method call to make sense.
11073 ///
11074 /// You should also call ::HAPI_GetImagePlaneCount() first to get
11075 /// the total number of image planes so you know how large the
11076 /// image_planes string handle array should be.
11077 ///
11078 /// @ingroup Materials
11079 ///
11080 /// @param[in] session
11081 /// The session of Houdini you are interacting with.
11082 /// See @ref HAPI_Sessions for more on sessions.
11083 /// Pass NULL to just use the default in-process session.
11084 /// <!-- default NULL -->
11085 ///
11086 /// @param[in] material_node_id
11087 /// The material node id.
11088 ///
11089 /// @param[out] image_planes_array
11090 /// The image plane names.
11091 ///
11092 /// @param[in] image_plane_count
11093 /// The number of image planes to get names for. This
11094 /// must be less than or equal to the count returned
11095 /// by ::HAPI_GetImagePlaneCount().
11096 /// <!-- source ::HAPI_GetImagePlaneCount -->
11097 ///
11098 HAPI_DECL HAPI_GetImagePlanes( const HAPI_Session * session,
11099  HAPI_NodeId material_node_id,
11100  HAPI_StringHandle * image_planes_array,
11101  int image_plane_count );
11102 
11103 /// @brief Extract a rendered image to a file.
11104 ///
11105 /// Note that you must call ::HAPI_RenderTextureToImage() first for
11106 /// this method call to make sense.
11107 ///
11108 /// @ingroup Materials
11109 ///
11110 /// @param[in] session
11111 /// The session of Houdini you are interacting with.
11112 /// See @ref HAPI_Sessions for more on sessions.
11113 /// Pass NULL to just use the default in-process session.
11114 /// <!-- default NULL -->
11115 ///
11116 /// @param[in] material_node_id
11117 /// The material node id.
11118 ///
11119 /// @param[in] image_file_format_name
11120 /// The image file format name you wish the image to be
11121 /// extracted as. You can leave this parameter NULL to
11122 /// get the image in the original format if it comes from
11123 /// another texture file or in the default HAPI format,
11124 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
11125 /// is generated.
11126 ///
11127 /// You can get some of the very common standard image
11128 /// file format names from HAPI_Common.h under the
11129 /// "Defines" section.
11130 ///
11131 /// You can also get a list of all supported file formats
11132 /// (and the exact names this parameter expects)
11133 /// by using ::HAPI_GetSupportedImageFileFormats(). This
11134 /// list will include custom file formats you created via
11135 /// custom DSOs (see HDK docs about IMG_Format). You will
11136 /// get back a list of ::HAPI_ImageFileFormat. This
11137 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
11138 /// of a given image file format.
11139 ///
11140 /// @param[in] image_planes
11141 /// The image planes you wish to extract into the file.
11142 /// Multiple image planes should be separated by spaces.
11143 ///
11144 /// @param[in] destination_folder_path
11145 /// The folder where the image file should be created.
11146 ///
11147 /// @param[in] destination_file_name
11148 /// Optional parameter to overwrite the name of the
11149 /// extracted texture file. This should NOT include
11150 /// the extension as the file type will be decided
11151 /// by the ::HAPI_ImageInfo you can set using
11152 /// ::HAPI_SetImageInfo(). You still have to use
11153 /// destination_file_path to get the final file path.
11154 ///
11155 /// Pass in NULL to have the file name be automatically
11156 /// generated from the name of the material SHOP node,
11157 /// the name of the texture map parameter if the
11158 /// image was rendered from a texture, and the image
11159 /// plane names specified.
11160 ///
11161 /// @param[out] destination_file_path
11162 /// The full path string handle, including the
11163 /// destination_folder_path and the texture file name,
11164 /// to the extracted file. Note that this string handle
11165 /// will only be valid until the next call to
11166 /// this function.
11167 ///
11169  HAPI_NodeId material_node_id,
11170  const char * image_file_format_name,
11171  const char * image_planes,
11172  const char * destination_folder_path,
11173  const char * destination_file_name,
11174  int * destination_file_path );
11175 /// @brief Get the file name that this image would be saved to
11176 ///
11177 /// Check to see what file path HAPI_ExtractImageToFile would have
11178 /// saved to given the same parms. Perhaps you might wish to see
11179 /// if it already exists before extracting.
11180 ///
11181 /// @ingroup Materials
11182 ///
11183 /// @param[in] session
11184 /// The session of Houdini you are interacting with.
11185 /// See @ref HAPI_Sessions for more on sessions.
11186 /// Pass NULL to just use the default in-process session.
11187 /// <!-- default NULL -->
11188 ///
11189 /// @param[in] material_node_id
11190 /// The material node id.
11191 ///
11192 /// @param[in] image_file_format_name
11193 /// The image file format name you wish the image to be
11194 /// extracted as. See HAPI_ExtractImageToFile for more information.
11195 ///
11196 /// @param[in] image_planes
11197 /// The image planes you wish to extract into the file.
11198 /// Multiple image planes should be separated by spaces.
11199 ///
11200 /// @param[in] destination_folder_path
11201 /// The folder where the image file sould be created.
11202 ///
11203 /// @param[in] destination_file_name
11204 /// Optional parameter to overwrite the name of the
11205 /// extracted texture file. See HAPI_ExtractImageToFile for more information.
11206 ///
11207 /// @param[in] texture_parm_id
11208 /// The index in the parameter list of the material node.
11209 /// of the parameter containing the texture map file path
11210 ///
11211 /// @param[out] destination_file_path
11212 /// The full path string handle, including the
11213 /// destination_folder_path and the texture file name,
11214 /// to the extracted file. Note that this string handle
11215 /// will only be valid until the next call to
11216 /// this function.
11217 ///
11219  HAPI_NodeId material_node_id,
11220  const char * image_file_format_name,
11221  const char * image_planes,
11222  const char * destination_folder_path,
11223  const char * destination_file_name,
11224  HAPI_ParmId texture_parm_id,
11225  int * destination_file_path );
11226 
11227 /// @brief Extract a rendered image to memory.
11228 ///
11229 /// Note that you must call ::HAPI_RenderTextureToImage() first for
11230 /// this method call to make sense.
11231 ///
11232 /// Also note that this function will do all the work of
11233 /// extracting and compositing the image into a memory buffer
11234 /// but will not return to you that buffer, only its size. Use
11235 /// the returned size to allocated a sufficiently large buffer
11236 /// and call ::HAPI_GetImageMemoryBuffer() to fill your buffer
11237 /// with the just extracted image.
11238 ///
11239 /// @ingroup Materials
11240 ///
11241 /// @param[in] session
11242 /// The session of Houdini you are interacting with.
11243 /// See @ref HAPI_Sessions for more on sessions.
11244 /// Pass NULL to just use the default in-process session.
11245 /// <!-- default NULL -->
11246 ///
11247 /// @param[in] material_node_id
11248 /// The material node id.
11249 ///
11250 /// @param[in] image_file_format_name
11251 /// The image file format name you wish the image to be
11252 /// extracted as. You can leave this parameter NULL to
11253 /// get the image in the original format if it comes from
11254 /// another texture file or in the default HAPI format,
11255 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
11256 /// is generated.
11257 ///
11258 /// You can get some of the very common standard image
11259 /// file format names from HAPI_Common.h under the
11260 /// "Defines" section.
11261 ///
11262 /// You can also get a list of all supported file formats
11263 /// (and the exact names this parameter expects)
11264 /// by using ::HAPI_GetSupportedImageFileFormats(). This
11265 /// list will include custom file formats you created via
11266 /// custom DSOs (see HDK docs about IMG_Format). You will
11267 /// get back a list of ::HAPI_ImageFileFormat. This
11268 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
11269 /// of a given image file format.
11270 ///
11271 /// @param[in] image_planes
11272 /// The image planes you wish to extract into the file.
11273 /// Multiple image planes should be separated by spaces.
11274 ///
11275 /// @param[out] buffer_size
11276 /// The extraction will be done to an internal buffer
11277 /// who's size you get via this parameter. Use the
11278 /// returned buffer_size when calling
11279 /// ::HAPI_GetImageMemoryBuffer() to get the image
11280 /// buffer you just extracted.
11281 ///
11283  HAPI_NodeId material_node_id,
11284  const char * image_file_format_name,
11285  const char * image_planes,
11286  int * buffer_size );
11287 
11288 /// @brief Fill your allocated buffer with the just extracted
11289 /// image buffer.
11290 ///
11291 /// Note that you must call ::HAPI_RenderTextureToImage() first for
11292 /// this method call to make sense.
11293 ///
11294 /// Also note that you must call ::HAPI_ExtractImageToMemory()
11295 /// first in order to perform the extraction and get the
11296 /// extracted image buffer size that you need to know how much
11297 /// memory to allocated to fit your extracted image.
11298 ///
11299 /// @ingroup Materials
11300 ///
11301 /// @param[in] session
11302 /// The session of Houdini you are interacting with.
11303 /// See @ref HAPI_Sessions for more on sessions.
11304 /// Pass NULL to just use the default in-process session.
11305 /// <!-- default NULL -->
11306 ///
11307 /// @param[in] material_node_id
11308 /// The material node id.
11309 ///
11310 /// @param[out] buffer
11311 /// The buffer passed in here will be filled with the
11312 /// image buffer created during the call to
11313 /// ::HAPI_ExtractImageToMemory().
11314 ///
11315 /// @param[in] length
11316 /// Sanity check. This size should be the same as the
11317 /// size allocated for the buffer passed in and should
11318 /// be at least as large as the buffer_size returned by
11319 /// the call to ::HAPI_ExtractImageToMemory().
11320 /// <!-- source ::HAPI_ExtractImageToMemory -->
11321 ///
11323  HAPI_NodeId material_node_id,
11324  char * buffer, int length );
11325 
11326 /// @brief Get the number of supported texture file formats.
11327 ///
11328 /// @ingroup Materials
11329 ///
11330 /// @param[in] session
11331 /// The session of Houdini you are interacting with.
11332 /// See @ref HAPI_Sessions for more on sessions.
11333 /// Pass NULL to just use the default in-process session.
11334 /// <!-- default NULL -->
11335 ///
11336 /// @param[out] file_format_count
11337 /// The number of supported texture file formats.
11338 ///
11340  int * file_format_count );
11341 
11342 /// @brief Get a list of support image file formats - their names,
11343 /// descriptions and a list of recognized extensions.
11344 ///
11345 /// Note that you MUST call
11346 /// ::HAPI_GetSupportedImageFileFormatCount()
11347 /// before calling this function for the first time.
11348 ///
11349 /// @ingroup Materials
11350 ///
11351 /// @param[in] session
11352 /// The session of Houdini you are interacting with.
11353 /// See @ref HAPI_Sessions for more on sessions.
11354 /// Pass NULL to just use the default in-process session.
11355 /// <!-- default NULL -->
11356 ///
11357 /// @param[out] formats_array
11358 /// The list of ::HAPI_ImageFileFormat structs to
11359 /// be filled.
11360 ///
11361 /// @param[in] file_format_count
11362 /// The number of supported texture file formats. This
11363 /// should be at least as large as the count returned
11364 /// by ::HAPI_GetSupportedImageFileFormatCount().
11365 /// <!-- source ::HAPI_GetSupportedImageFileFormatCount -->
11366 ///
11368  const HAPI_Session * session,
11369  HAPI_ImageFileFormat * formats_array,
11370  int file_format_count );
11371 
11372 /// @defgroup Animation
11373 /// Functions for working with animation.
11374 
11375 /// @brief Set an animation curve on a parameter of an exposed node.
11376 ///
11377 /// @ingroup Animation
11378 ///
11379 /// @param[in] session
11380 /// The session of Houdini you are interacting with.
11381 /// See @ref HAPI_Sessions for more on sessions.
11382 /// Pass NULL to just use the default in-process session.
11383 /// <!-- default NULL -->
11384 ///
11385 /// @param[in] node_id
11386 /// The exposed node id.
11387 ///
11388 /// @param[in] parm_id
11389 /// The id of an exposed parameter within the node.
11390 /// @param[in] parm_index
11391 /// The index of the parameter, if it is for example
11392 /// a 3 tuple
11393 ///
11394 /// @param[in] curve_keyframes_array
11395 /// An array of ::HAPI_Keyframe structs that describes
11396 /// the keys on this curve.
11397 ///
11398 /// @param[in] keyframe_count
11399 /// The number of keys on the curve.
11400 ///
11401 HAPI_DECL HAPI_SetAnimCurve( const HAPI_Session * session,
11402  HAPI_NodeId node_id, HAPI_ParmId parm_id,
11403  int parm_index,
11404  const HAPI_Keyframe * curve_keyframes_array,
11405  int keyframe_count );
11406 
11407 /// @brief A specialized convenience function to set the T,R,S values
11408 /// on an exposed node.
11409 ///
11410 /// @ingroup Animation
11411 ///
11412 /// @param[in] session
11413 /// The session of Houdini you are interacting with.
11414 /// See @ref HAPI_Sessions for more on sessions.
11415 /// Pass NULL to just use the default in-process session.
11416 /// <!-- default NULL -->
11417 ///
11418 /// @param[in] node_id
11419 /// The exposed node id.
11420 ///
11421 /// @param[in] trans_comp
11422 /// A value of ::HAPI_TransformComponent that
11423 /// identifies the particular component of the
11424 /// transform to attach the curve to, for example
11425 /// ::HAPI_TRANSFORM_TX.
11426 ///
11427 /// @param[in] curve_keyframes_array
11428 /// An array of ::HAPI_Keyframe structs that describes
11429 /// the keys on this curve.
11430 ///
11431 /// @param[in] keyframe_count
11432 /// The number of keys on the curve.
11433 ///
11435  const HAPI_Session * session,
11436  HAPI_NodeId node_id,
11437  HAPI_TransformComponent trans_comp,
11438  const HAPI_Keyframe * curve_keyframes_array,
11439  int keyframe_count );
11440 
11441 /// @brief Resets the simulation cache of the asset. This is very useful
11442 /// for assets that use dynamics, to be called after some
11443 /// setup has changed for the asset - for example, asset inputs
11444 ///
11445 /// @ingroup Time
11446 ///
11447 /// @param[in] session
11448 /// The session of Houdini you are interacting with.
11449 /// See @ref HAPI_Sessions for more on sessions.
11450 /// Pass NULL to just use the default in-process session.
11451 /// <!-- default NULL -->
11452 ///
11453 /// @param[in] node_id
11454 /// The asset node id.
11455 ///
11457  HAPI_NodeId node_id );
11458 
11459 /// @defgroup Volumes
11460 /// Functions for working with Volume data
11461 
11462 /// @brief Retrieve any meta-data about the volume primitive, including
11463 /// its transform, location, scale, taper, resolution.
11464 ///
11465 /// @ingroup Volumes
11466 ///
11467 /// @param[in] session
11468 /// The session of Houdini you are interacting with.
11469 /// See @ref HAPI_Sessions for more on sessions.
11470 /// Pass NULL to just use the default in-process session.
11471 /// <!-- default NULL -->
11472 ///
11473 /// @param[in] node_id
11474 /// The node id.
11475 ///
11476 /// @param[in] part_id
11477 /// The part id.
11478 ///
11479 /// @param[out] volume_info
11480 /// The meta-data associated with the volume on the
11481 /// part specified by the previous parameters.
11482 ///
11483 HAPI_DECL HAPI_GetVolumeInfo( const HAPI_Session * session,
11484  HAPI_NodeId node_id,
11485  HAPI_PartId part_id,
11486  HAPI_VolumeInfo * volume_info );
11487 
11488 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
11489 /// Start iterating through the value of the volume at part_id.
11490 ///
11491 /// @ingroup Volumes
11492 ///
11493 /// @param[in] session
11494 /// The session of Houdini you are interacting with.
11495 /// See @ref HAPI_Sessions for more on sessions.
11496 /// Pass NULL to just use the default in-process session.
11497 /// <!-- default NULL -->
11498 ///
11499 /// @param[in] node_id
11500 /// The node id.
11501 ///
11502 /// @param[in] part_id
11503 /// The part id.
11504 ///
11505 /// @param[out] tile
11506 /// The tile info referring to the first tile in the
11507 /// volume at part_id.
11508 ///
11510  HAPI_NodeId node_id,
11511  HAPI_PartId part_id,
11512  HAPI_VolumeTileInfo * tile );
11513 
11514 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
11515 /// Continue iterating through the value of the volume at part_id.
11516 ///
11517 /// @ingroup Volumes
11518 ///
11519 /// @param[in] session
11520 /// The session of Houdini you are interacting with.
11521 /// See @ref HAPI_Sessions for more on sessions.
11522 /// Pass NULL to just use the default in-process session.
11523 /// <!-- default NULL -->
11524 ///
11525 /// @param[in] node_id
11526 /// The node id.
11527 ///
11528 /// @param[in] part_id
11529 /// The part id.
11530 ///
11531 /// @param[out] tile
11532 /// The tile info referring to the next tile in the
11533 /// set of tiles associated with the volume at this part.
11534 ///
11536  HAPI_NodeId node_id,
11537  HAPI_PartId part_id,
11538  HAPI_VolumeTileInfo * tile );
11539 
11540 /// @brief Retrieve floating point values of the voxel at a specific
11541 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
11542 /// to this call.
11543 ///
11544 /// @ingroup Volumes
11545 ///
11546 /// @param[in] session
11547 /// The session of Houdini you are interacting with.
11548 /// See @ref HAPI_Sessions for more on sessions.
11549 /// Pass NULL to just use the default in-process session.
11550 /// <!-- default NULL -->
11551 ///
11552 /// @param[in] node_id
11553 /// The node id.
11554 ///
11555 /// @param[in] part_id
11556 /// The part id.
11557 ///
11558 /// @param[in] x_index
11559 /// The x index/coordinate of the voxel.
11560 ///
11561 /// @param[in] y_index
11562 /// The y index/coordinate of the voxel.
11563 ///
11564 /// @param[in] z_index
11565 /// The z index/coordinate of the voxel.
11566 ///
11567 /// @param[out] values_array
11568 /// The values of the voxel.
11569 ///
11570 /// @param[in] value_count
11571 /// Should be equal to the volume's
11572 /// ::HAPI_VolumeInfo::tupleSize.
11573 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11574 ///
11576  HAPI_NodeId node_id,
11577  HAPI_PartId part_id,
11578  int x_index,
11579  int y_index,
11580  int z_index,
11581  float * values_array,
11582  int value_count );
11583 
11584 /// @brief Retrieve floating point values of the voxels pointed to
11585 /// by a tile. Note that a tile may extend beyond the limits
11586 /// of the volume so not all values in the given buffer will
11587 /// be written to. Voxels outside the volume will be initialized
11588 /// to the given fill value.
11589 ///
11590 /// @ingroup Volumes
11591 ///
11592 /// @param[in] session
11593 /// The session of Houdini you are interacting with.
11594 /// See @ref HAPI_Sessions for more on sessions.
11595 /// Pass NULL to just use the default in-process session.
11596 /// <!-- default NULL -->
11597 ///
11598 /// @param[in] node_id
11599 /// The node id.
11600 ///
11601 /// @param[in] part_id
11602 /// The part id.
11603 ///
11604 /// @param[in] fill_value
11605 /// Value that will be used to fill the @p values_array.
11606 /// This is useful so that you can see what values
11607 /// have actually been written to.
11608 ///
11609 /// @param[in] tile
11610 /// The tile to retrieve.
11611 ///
11612 /// @param[out] values_array
11613 /// The values of the tile.
11614 ///
11615 /// @param[in] length
11616 /// The length should be ( 8 ^ 3 ) * tupleSize.
11617 ///
11619  HAPI_NodeId node_id,
11620  HAPI_PartId part_id,
11621  float fill_value,
11622  const HAPI_VolumeTileInfo * tile,
11623  float * values_array,
11624  int length );
11625 
11626 /// @brief Retrieve integer point values of the voxel at a specific
11627 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
11628 /// to this call.
11629 ///
11630 /// @ingroup Volumes
11631 ///
11632 /// @param[in] session
11633 /// The session of Houdini you are interacting with.
11634 /// See @ref HAPI_Sessions for more on sessions.
11635 /// Pass NULL to just use the default in-process session.
11636 /// <!-- default NULL -->
11637 ///
11638 /// @param[in] node_id
11639 /// The node id.
11640 ///
11641 /// @param[in] part_id
11642 /// The part id.
11643 ///
11644 /// @param[in] x_index
11645 /// The x index/coordinate of the voxel.
11646 ///
11647 /// @param[in] y_index
11648 /// The y index/coordinate of the voxel.
11649 ///
11650 /// @param[in] z_index
11651 /// The z index/coordinate of the voxel.
11652 ///
11653 /// @param[out] values_array
11654 /// The values of the voxel.
11655 ///
11656 /// @param[in] value_count
11657 /// Should be equal to the volume's
11658 /// ::HAPI_VolumeInfo::tupleSize.
11659 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11660 ///
11662  HAPI_NodeId node_id,
11663  HAPI_PartId part_id,
11664  int x_index,
11665  int y_index,
11666  int z_index,
11667  int * values_array,
11668  int value_count );
11669 
11670 /// @brief Retrieve integer point values of the voxels pointed to
11671 /// by a tile. Note that a tile may extend beyond the limits
11672 /// of the volume so not all values in the given buffer will
11673 /// be written to. Voxels outside the volume will be initialized
11674 /// to the given fill value.
11675 ///
11676 /// @ingroup Volumes
11677 ///
11678 /// @param[in] session
11679 /// The session of Houdini you are interacting with.
11680 /// See @ref HAPI_Sessions for more on sessions.
11681 /// Pass NULL to just use the default in-process session.
11682 /// <!-- default NULL -->
11683 ///
11684 /// @param[in] node_id
11685 /// The node id.
11686 ///
11687 /// @param[in] part_id
11688 /// The part id.
11689 ///
11690 /// @param[in] fill_value
11691 /// Value that will be used to fill the @p values_array.
11692 /// This is useful so that you can see what values
11693 /// have actually been written to.
11694 ///
11695 /// @param[in] tile
11696 /// The tile to retrieve.
11697 ///
11698 /// @param[out] values_array
11699 /// The values of the tile.
11700 ///
11701 /// @param[in] length
11702 /// The length should be ( 8 ^ 3 ) * tupleSize.
11703 ///
11705  HAPI_NodeId node_id,
11706  HAPI_PartId part_id,
11707  int fill_value,
11708  const HAPI_VolumeTileInfo * tile,
11709  int * values_array,
11710  int length );
11711 
11712 /// @brief Get the height field data for a terrain volume as a flattened
11713 /// 2D array of float heights. Should call ::HAPI_GetVolumeInfo()
11714 /// first to make sure the volume info is initialized.
11715 ///
11716 /// @ingroup Volumes
11717 ///
11718 /// @param[in] session
11719 /// The session of Houdini you are interacting with.
11720 /// See @ref HAPI_Sessions for more on sessions.
11721 /// Pass NULL to just use the default in-process session.
11722 /// <!-- default NULL -->
11723 ///
11724 /// @param[in] node_id
11725 /// The node id.
11726 ///
11727 /// @param[in] part_id
11728 /// The part id.
11729 ///
11730 /// @param[out] values_array
11731 /// Heightfield flattened array. Should be at least the size of
11732 /// @p start + @p length.
11733 ///
11734 /// @param[in] start
11735 /// The start at least 0 and at most
11736 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength )
11737 /// - @p length.
11738 ///
11739 /// @param[in] length
11740 /// The length should be at least 1 or at most
11741 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength )
11742 /// - @p start.
11743 ///
11745  HAPI_NodeId node_id,
11746  HAPI_PartId part_id,
11747  float * values_array,
11748  int start, int length );
11749 
11750 /// @brief Set the volume info of a geo on a geo input.
11751 ///
11752 /// @ingroup Volumes
11753 ///
11754 /// @param[in] session
11755 /// The session of Houdini you are interacting with.
11756 /// See @ref HAPI_Sessions for more on sessions.
11757 /// Pass NULL to just use the default in-process session.
11758 /// <!-- default NULL -->
11759 ///
11760 /// @param[in] node_id
11761 /// The node id.
11762 ///
11763 /// @param[in] part_id
11764 /// The part id.
11765 ///
11766 /// @param[in] volume_info
11767 /// All volume information that can be specified per
11768 /// volume. This includes the position, orientation, scale,
11769 /// data format, tuple size, and taper. The tile size is
11770 /// always 8x8x8.
11771 ///
11772 HAPI_DECL HAPI_SetVolumeInfo( const HAPI_Session * session,
11773  HAPI_NodeId node_id,
11774  HAPI_PartId part_id,
11775  const HAPI_VolumeInfo * volume_info );
11776 
11777 /// @brief Set the values of a float tile: this is an 8x8x8 subsection of
11778 /// the volume.
11779 ///
11780 /// @ingroup Volumes
11781 ///
11782 /// @param[in] session
11783 /// The session of Houdini you are interacting with.
11784 /// See @ref HAPI_Sessions for more on sessions.
11785 /// Pass NULL to just use the default in-process session.
11786 /// <!-- default NULL -->
11787 ///
11788 /// @param[in] node_id
11789 /// The node id.
11790 ///
11791 /// @param[in] part_id
11792 /// The part id.
11793 ///
11794 /// @param[in] tile
11795 /// The tile that the volume will be input into.
11796 ///
11797 /// @param[in] values_array
11798 /// The values of the individual voxel tiles in the
11799 /// volume. The length of this array should
11800 /// be ( 8 ^ 3 ) * tupleSize.
11801 ///
11802 /// @param[in] length
11803 /// The length should be ( 8 ^ 3 ) * tupleSize.
11804 ///
11806  HAPI_NodeId node_id,
11807  HAPI_PartId part_id,
11808  const HAPI_VolumeTileInfo * tile,
11809  const float * values_array,
11810  int length );
11811 
11812 /// @brief Set the values of an int tile: this is an 8x8x8 subsection of
11813 /// the volume.
11814 ///
11815 /// @ingroup Volumes
11816 ///
11817 /// @param[in] session
11818 /// The session of Houdini you are interacting with.
11819 /// See @ref HAPI_Sessions for more on sessions.
11820 /// Pass NULL to just use the default in-process session.
11821 /// <!-- default NULL -->
11822 ///
11823 /// @param[in] node_id
11824 /// The node id.
11825 ///
11826 /// @param[in] part_id
11827 /// The part id.
11828 ///
11829 /// @param[in] tile
11830 /// The tile that the volume will be input into.
11831 ///
11832 /// @param[in] values_array
11833 /// The values of the individual voxel tiles in the
11834 /// volume. The length of this array should
11835 /// be ( 8 ^ 3 ) * tupleSize.
11836 ///
11837 /// @param[in] length
11838 /// The length should be ( 8 ^ 3 ) * tupleSize.
11839 ///
11841  HAPI_NodeId node_id,
11842  HAPI_PartId part_id,
11843  const HAPI_VolumeTileInfo * tile,
11844  const int * values_array,
11845  int length );
11846 
11847 /// @brief Set the values of a float voxel in the volume.
11848 ///
11849 /// @ingroup Volumes
11850 ///
11851 /// @param[in] session
11852 /// The session of Houdini you are interacting with.
11853 /// See @ref HAPI_Sessions for more on sessions.
11854 /// Pass NULL to just use the default in-process session.
11855 /// <!-- default NULL -->
11856 ///
11857 /// @param[in] node_id
11858 /// The node id.
11859 ///
11860 /// @param[in] part_id
11861 /// The part id.
11862 ///
11863 /// @param[in] x_index
11864 /// The x index/coordinate of the voxel.
11865 ///
11866 /// @param[in] y_index
11867 /// The y index/coordinate of the voxel.
11868 ///
11869 /// @param[in] z_index
11870 /// The z index/coordinate of the voxel.
11871 ///
11872 /// @param[in] values_array
11873 /// The values of the voxel.
11874 ///
11875 /// @param[in] value_count
11876 /// Should be equal to the volume's
11877 /// ::HAPI_VolumeInfo::tupleSize.
11878 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11879 ///
11881  HAPI_NodeId node_id,
11882  HAPI_PartId part_id,
11883  int x_index,
11884  int y_index,
11885  int z_index,
11886  const float * values_array,
11887  int value_count );
11888 
11889 /// @brief Set the values of a integer voxel in the volume.
11890 ///
11891 /// @ingroup Volumes
11892 ///
11893 /// @param[in] session
11894 /// The session of Houdini you are interacting with.
11895 /// See @ref HAPI_Sessions for more on sessions.
11896 /// Pass NULL to just use the default in-process session.
11897 /// <!-- default NULL -->
11898 ///
11899 /// @param[in] node_id
11900 /// The node id.
11901 ///
11902 /// @param[in] part_id
11903 /// The part id.
11904 ///
11905 /// @param[in] x_index
11906 /// The x index/coordinate of the voxel.
11907 ///
11908 /// @param[in] y_index
11909 /// The y index/coordinate of the voxel.
11910 ///
11911 /// @param[in] z_index
11912 /// The z index/coordinate of the voxel.
11913 ///
11914 /// @param[in] values_array
11915 /// The values of the voxel.
11916 ///
11917 /// @param[in] value_count
11918 /// Should be equal to the volume's
11919 /// ::HAPI_VolumeInfo::tupleSize.
11920 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11921 ///
11923  HAPI_NodeId node_id,
11924  HAPI_PartId part_id,
11925  int x_index,
11926  int y_index,
11927  int z_index,
11928  const int * values_array,
11929  int value_count );
11930 
11931 /// @brief Get the bounding values of a volume.
11932 ///
11933 /// @ingroup Volumes
11934 ///
11935 /// @param[in] session
11936 /// The session of Houdini you are interacting with.
11937 /// See @ref HAPI_Sessions for more on sessions.
11938 /// Pass NULL to just use the default in-process session.
11939 /// <!-- default NULL -->
11940 ///
11941 /// @param[in] node_id
11942 /// The node id.
11943 ///
11944 /// @param[in] part_id
11945 /// The part id.
11946 ///
11947 /// @param[out] x_min
11948 /// The minimum x value of the volume's bounding box.
11949 /// Can be null if you do not want this value.
11950 ///
11951 /// @param[out] y_min
11952 /// The minimum y value of the volume's bounding box.
11953 /// Can be null if you do not want this value.
11954 ///
11955 /// @param[out] z_min
11956 /// The minimum z value of the volume's bounding box.
11957 /// Can be null if you do not want this value.
11958 ///
11959 /// @param[out] x_max
11960 /// The maximum x value of the volume's bounding box.
11961 /// Can be null if you do not want this value.
11962 ///
11963 /// @param[out] y_max
11964 /// The maximum y value of the volume's bounding box.
11965 /// Can be null if you do not want this value.
11966 ///
11967 /// @param[out] z_max
11968 /// The maximum z value of the volume's bounding box.
11969 /// Can be null if you do not want this value.
11970 ///
11971 /// @param[out] x_center
11972 /// The x value of the volume's bounding box center.
11973 /// Can be null if you do not want this value.
11974 ///
11975 /// @param[out] y_center
11976 /// The y value of the volume's bounding box center.
11977 /// Can be null if you do not want this value.
11978 ///
11979 /// @param[out] z_center
11980 /// The z value of the volume's bounding box center.
11981 /// Can be null if you do not want this value.
11982 ///
11984  HAPI_NodeId node_id,
11985  HAPI_PartId part_id,
11986  float * x_min, float * y_min, float * z_min,
11987  float * x_max, float * y_max, float * z_max,
11988  float * x_center, float * y_center, float * z_center );
11989 
11990 /// @brief Set the height field data for a terrain volume with the values from
11991 /// a flattened 2D array of float.
11992 /// ::HAPI_SetVolumeInfo() should be called first to make sure that the
11993 /// volume and its info are initialized.
11994 ///
11995 /// @ingroup Volumes
11996 ///
11997 /// @param[in] session
11998 /// The session of Houdini you are interacting with.
11999 /// See @ref HAPI_Sessions for more on sessions.
12000 /// Pass NULL to just use the default in-process session.
12001 /// <!-- default NULL -->
12002 ///
12003 /// @param[in] node_id
12004 /// The node id.
12005 ///
12006 /// @param[in] part_id
12007 /// The part id.
12008 ///
12009 /// @param[in] values_array
12010 /// Heightfield flattened array. Should be at least the size of
12011 /// @p start + @p length.
12012 ///
12013 /// @param[in] start
12014 /// The start at least 0 and at most
12015 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength ) - @p length.
12016 ///
12017 /// @param[in] length
12018 /// The length should be at least 1 or at most
12019 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength ) - @p start.
12020 ///
12021 /// @param[in] name
12022 /// The name of the volume used for the heightfield.
12023 /// If set to "height" the values will be used for height information,
12024 /// if not, the data will used as a mask.
12025 ///
12027  HAPI_NodeId node_id,
12028  HAPI_PartId part_id,
12029  const char * name,
12030  const float * values_array,
12031  int start, int length );
12032 
12033 /// @brief Retrieve the visualization meta-data of the volume.
12034 ///
12035 /// @ingroup Volumes
12036 ///
12037 /// @param[in] session
12038 /// The session of Houdini you are interacting with.
12039 /// See @ref HAPI_Sessions for more on sessions.
12040 /// Pass NULL to just use the default in-process session.
12041 /// <!-- default NULL -->
12042 ///
12043 /// @param[in] node_id
12044 /// The node id.
12045 ///
12046 /// @param[in] part_id
12047 /// The part id.
12048 ///
12049 /// @param[out] visual_info
12050 /// The meta-data associated with the visualization
12051 /// settings of the part specified by the previous
12052 /// parameters.
12053 ///
12055  HAPI_NodeId node_id,
12056  HAPI_PartId part_id,
12057  HAPI_VolumeVisualInfo * visual_info );
12058 
12059 /// @defgroup Curves
12060 /// Functions for working with curves
12061 
12062 /// @brief Retrieve any meta-data about the curves, including the
12063 /// curve's type, order, and periodicity.
12064 ///
12065 /// @ingroup Curves
12066 ///
12067 /// @param[in] session
12068 /// The session of Houdini you are interacting with.
12069 /// See @ref HAPI_Sessions for more on sessions.
12070 /// Pass NULL to just use the default in-process session.
12071 /// <!-- default NULL -->
12072 ///
12073 /// @param[in] node_id
12074 /// The node id.
12075 ///
12076 /// @param[in] part_id
12077 /// The part id.
12078 ///
12079 /// @param[out] info
12080 /// The curve info represents the meta-data about
12081 /// the curves, including the type, order,
12082 /// and periodicity.
12083 ///
12084 HAPI_DECL HAPI_GetCurveInfo( const HAPI_Session * session,
12085  HAPI_NodeId node_id,
12086  HAPI_PartId part_id,
12087  HAPI_CurveInfo * info );
12088 
12089 /// @brief Retrieve the number of vertices for each curve in the part.
12090 ///
12091 /// @ingroup Curves
12092 ///
12093 /// @param[in] session
12094 /// The session of Houdini you are interacting with.
12095 /// See @ref HAPI_Sessions for more on sessions.
12096 /// Pass NULL to just use the default in-process session.
12097 /// <!-- default NULL -->
12098 ///
12099 /// @param[in] node_id
12100 /// The node id.
12101 ///
12102 /// @param[in] part_id
12103 /// The part id.
12104 ///
12105 /// @param[out] counts_array
12106 /// The number of cvs each curve contains
12107 ///
12108 /// @param[in] start
12109 /// The index of the first curve.
12110 /// <!-- default 0 -->
12111 ///
12112 /// @param[in] length
12113 /// The number of curves' counts to retrieve.
12114 ///
12115 HAPI_DECL HAPI_GetCurveCounts( const HAPI_Session * session,
12116  HAPI_NodeId node_id,
12117  HAPI_PartId part_id,
12118  int * counts_array,
12119  int start, int length );
12120 
12121 /// @brief Retrieve the orders for each curve in the part if the
12122 /// curve has varying order.
12123 ///
12124 /// @ingroup Curves
12125 ///
12126 /// @param[in] session
12127 /// The session of Houdini you are interacting with.
12128 /// See @ref HAPI_Sessions for more on sessions.
12129 /// Pass NULL to just use the default in-process session.
12130 /// <!-- default NULL -->
12131 ///
12132 /// @param[in] node_id
12133 /// The node id.
12134 ///
12135 /// @param[in] part_id
12136 /// The part id.
12137 ///
12138 /// @param[out] orders_array
12139 /// The order of each curve will be returned in this
12140 /// array.
12141 ///
12142 /// @param[in] start
12143 /// The index of the first curve.
12144 /// <!-- default 0 -->
12145 ///
12146 /// @param[in] length
12147 /// The number of curves' orders to retrieve.
12148 ///
12149 HAPI_DECL HAPI_GetCurveOrders( const HAPI_Session * session,
12150  HAPI_NodeId node_id,
12151  HAPI_PartId part_id,
12152  int * orders_array,
12153  int start, int length );
12154 
12155 /// @brief Retrieve the knots of the curves in this part.
12156 ///
12157 /// @ingroup Curves
12158 ///
12159 /// @param[in] session
12160 /// The session of Houdini you are interacting with.
12161 /// See @ref HAPI_Sessions for more on sessions.
12162 /// Pass NULL to just use the default in-process session.
12163 /// <!-- default NULL -->
12164 ///
12165 /// @param[in] node_id
12166 /// The node id.
12167 ///
12168 /// @param[in] part_id
12169 /// The part id.
12170 ///
12171 /// @param[out] knots_array
12172 /// The knots of each curve will be returned in this
12173 /// array.
12174 ///
12175 /// @param[in] start
12176 /// The index of the first curve.
12177 /// <!-- default 0 -->
12178 ///
12179 /// @param[in] length
12180 /// The number of curves' knots to retrieve. The
12181 /// length of all the knots on a single curve is
12182 /// the order of that curve plus the number of
12183 /// vertices (see ::HAPI_GetCurveOrders(),
12184 /// and ::HAPI_GetCurveCounts()).
12185 ///
12186 HAPI_DECL HAPI_GetCurveKnots( const HAPI_Session * session,
12187  HAPI_NodeId node_id,
12188  HAPI_PartId part_id,
12189  float * knots_array,
12190  int start, int length );
12191 
12192 /// @brief Set meta-data for the curve mesh, including the
12193 /// curve type, order, and periodicity.
12194 ///
12195 /// @ingroup Curves
12196 ///
12197 /// @param[in] session
12198 /// The session of Houdini you are interacting with.
12199 /// See @ref HAPI_Sessions for more on sessions.
12200 /// Pass NULL to just use the default in-process session.
12201 /// <!-- default NULL -->
12202 ///
12203 /// @param[in] node_id
12204 /// The node id.
12205 ///
12206 /// @param[in] part_id
12207 /// Currently unused. Input asset geos are assumed
12208 /// to have only one part.
12209 ///
12210 /// @param[in] info
12211 /// The curve info represents the meta-data about
12212 /// the curves, including the type, order,
12213 /// and periodicity.
12214 ///
12215 HAPI_DECL HAPI_SetCurveInfo( const HAPI_Session * session,
12216  HAPI_NodeId node_id,
12217  HAPI_PartId part_id,
12218  const HAPI_CurveInfo * info );
12219 
12220 /// @brief Set the number of vertices for each curve in the part.
12221 ///
12222 /// @ingroup Curves
12223 ///
12224 /// @param[in] session
12225 /// The session of Houdini you are interacting with.
12226 /// See @ref HAPI_Sessions for more on sessions.
12227 /// Pass NULL to just use the default in-process session.
12228 /// <!-- default NULL -->
12229 ///
12230 /// @param[in] node_id
12231 /// The node id.
12232 ///
12233 /// @param[in] part_id
12234 /// Currently unused. Input asset geos are assumed
12235 /// to have only one part.
12236 ///
12237 /// @param[in] counts_array
12238 /// The number of cvs each curve contains.
12239 ///
12240 /// @param[in] start
12241 /// The index of the first curve.
12242 /// <!-- default 0 -->
12243 ///
12244 /// @param[in] length
12245 /// The number of curves' counts to set.
12246 /// <!-- source arglength(counts_array) -->
12247 ///
12248 HAPI_DECL HAPI_SetCurveCounts( const HAPI_Session * session,
12249  HAPI_NodeId node_id,
12250  HAPI_PartId part_id,
12251  const int * counts_array,
12252  int start, int length );
12253 
12254 /// @brief Set the orders for each curve in the part if the
12255 /// curve has varying order.
12256 ///
12257 /// @ingroup Curves
12258 ///
12259 /// @param[in] session
12260 /// The session of Houdini you are interacting with.
12261 /// See @ref HAPI_Sessions for more on sessions.
12262 /// Pass NULL to just use the default in-process session.
12263 /// <!-- default NULL -->
12264 ///
12265 /// @param[in] node_id
12266 /// The node id.
12267 ///
12268 /// @param[in] part_id
12269 /// Currently unused. Input asset geos are assumed
12270 /// to have only one part.
12271 ///
12272 /// @param[in] orders_array
12273 /// The orders of each curve.
12274 ///
12275 /// @param[in] start
12276 /// The index of the first curve.
12277 /// <!-- default 0 -->
12278 ///
12279 /// @param[in] length
12280 /// The number of curves' orders to retrieve.
12281 /// <!-- source arglength(orders_array) -->
12282 ///
12283 HAPI_DECL HAPI_SetCurveOrders( const HAPI_Session * session,
12284  HAPI_NodeId node_id,
12285  HAPI_PartId part_id,
12286  const int * orders_array,
12287  int start, int length );
12288 
12289 /// @brief Set the knots of the curves in this part.
12290 ///
12291 /// @ingroup Curves
12292 ///
12293 /// @param[in] session
12294 /// The session of Houdini you are interacting with.
12295 /// See @ref HAPI_Sessions for more on sessions.
12296 /// Pass NULL to just use the default in-process session.
12297 /// <!-- default NULL -->
12298 ///
12299 /// @param[in] node_id
12300 /// The node id.
12301 ///
12302 /// @param[in] part_id
12303 /// Currently unused. Input asset geos are assumed
12304 /// to have only one part.
12305 ///
12306 /// @param[in] knots_array
12307 /// The knots of each curve.
12308 ///
12309 /// @param[in] start
12310 /// The index of the first curve.
12311 /// <!-- default 0 -->
12312 ///
12313 /// @param[in] length
12314 /// The number of curves' knots to set. The
12315 /// length of all the knots on a single curve is
12316 /// the order of that curve plus the number of
12317 /// vertices (see ::HAPI_SetCurveOrders(),
12318 /// and ::HAPI_SetCurveCounts()).
12319 ///
12320 HAPI_DECL HAPI_SetCurveKnots( const HAPI_Session * session,
12321  HAPI_NodeId node_id,
12322  HAPI_PartId part_id,
12323  const float * knots_array,
12324  int start, int length );
12325 
12326 // INPUT CURVE INFO ---------------------------------------------------------
12327 
12328 /// @defgroup InputCurves
12329 /// Functions for working with curves
12330 
12331 /// @brief Retrieve meta-data about the input curves, including the
12332 /// curve's type, order, and whether or not the curve is closed and reversed.
12333 ///
12334 /// @ingroup InputCurves
12335 ///
12336 /// @param[in] session
12337 /// The session of Houdini you are interacting with.
12338 /// See @ref HAPI_Sessions for more on sessions.
12339 /// Pass NULL to just use the default in-process session.
12340 /// <!-- default NULL -->
12341 ///
12342 /// @param[in] node_id
12343 /// The node id.
12344 ///
12345 /// @param[in] part_id
12346 /// The part id.
12347 ///
12348 /// @param[out] info
12349 /// The curve info represents the meta-data about
12350 /// the curves, including the type, order,
12351 /// and closed and reversed values.
12352 ///
12354  HAPI_NodeId node_id,
12355  HAPI_PartId part_id,
12356  HAPI_InputCurveInfo * info );
12357 
12358 /// @brief Set meta-data for the input curves, including the
12359 /// curve type, order, reverse and closed properties.
12360 ///
12361 /// @ingroup InputCurves
12362 ///
12363 /// @param[in] session
12364 /// The session of Houdini you are interacting with.
12365 /// See @ref HAPI_Sessions for more on sessions.
12366 /// Pass NULL to just use the default in-process session.
12367 /// <!-- default NULL -->
12368 ///
12369 /// @param[in] node_id
12370 /// The node id.
12371 ///
12372 /// @param[in] part_id
12373 /// Currently unused. Input asset geos are assumed
12374 /// to have only one part.
12375 ///
12376 /// @param[in] info
12377 /// The curve info represents the meta-data about
12378 /// the curves, including the type, order,
12379 /// and closed and reverse properties.
12380 ///
12382  HAPI_NodeId node_id,
12383  HAPI_PartId part_id,
12384  const HAPI_InputCurveInfo * info );
12385 
12386 /// @brief Sets the positions for input curves, doing checks for
12387 /// curve validity, and adjusting the curve settings accordingly.
12388 /// Will also cook the node.
12389 ///
12390 /// @ingroup InputCurves
12391 ///
12392 /// @param[in] session
12393 /// The session of Houdini you are interacting with.
12394 /// See @ref HAPI_Sessions for more on sessions.
12395 /// Pass NULL to just use the default in-process session.
12396 /// <!-- default NULL -->
12397 ///
12398 /// @param[in] node_id
12399 /// The node id.
12400 ///
12401 /// @param[in] part_id
12402 /// Currently unused. Input asset geos are assumed
12403 /// to have only one part.
12404 ///
12405 /// @param[in] positions_array
12406 /// A float array representing the positions attribute.
12407 /// It will read the array assuming a tuple size of 3.
12408 /// Note that this function does not do any coordinate axes
12409 /// conversion.
12410 ///
12411 /// @param[in] start
12412 /// The index of the first position in positions_array.
12413 /// <!-- default 0 -->
12414 ///
12415 /// @param[in] length
12416 /// The size of the positions array.
12417 /// <!-- source arglength(positions_array) -->
12418 ///
12420  const HAPI_Session* session,
12421  HAPI_NodeId node_id,
12422  HAPI_PartId part_id,
12423  const float* positions_array,
12424  int start,
12425  int length);
12426 
12427 /// @brief Sets the positions for input curves, doing checks for
12428 /// curve validity, and adjusting the curve settings accordingly.
12429 /// Will also cook the node. Additionally, adds rotation and scale
12430 /// attributes to the curve.
12431 ///
12432 /// @ingroup InputCurves
12433 ///
12434 /// @param[in] session
12435 /// The session of Houdini you are interacting with.
12436 /// See @ref HAPI_Sessions for more on sessions.
12437 /// Pass NULL to just use the default in-process session.
12438 /// <!-- default NULL -->
12439 ///
12440 /// @param[in] node_id
12441 /// The node id.
12442 ///
12443 /// @param[in] part_id
12444 /// Currently unused. Input asset geos are assumed
12445 /// to have only one part.
12446 ///
12447 /// @param[in] positions_array
12448 /// A float array representing the positions attribute.
12449 /// It will read the array assuming a tuple size of 3.
12450 /// Note that this function does not do any coordinate axes
12451 /// conversion.
12452 ///
12453 /// @param[in] positions_array
12454 /// A float array representing the positions attribute.
12455 /// It will read the array assuming a tuple size of 3.
12456 /// Note that this function does not do any coordinate axes
12457 /// conversion.
12458 ///
12459 /// @param[in] positions_start
12460 /// The index of the first position in positions_array.
12461 /// <!-- default 0 -->
12462 ///
12463 /// @param[in] positions_length
12464 /// The size of the positions array.
12465 /// <!-- source arglength(positions_array) -->
12466 ///
12467 /// @param[in] rotations_array
12468 /// A float array representing the rotation (rot) attribute.
12469 /// It will read the array assuming a tuple size of 4
12470 /// representing quaternion values
12471 ///
12472 /// @param[in] rotations_start
12473 /// The index of the first rotation in rotations_array.
12474 /// <!-- default 0 -->
12475 ///
12476 /// @param[in] rotations_length
12477 /// The size of the rotations array.
12478 /// <!-- source arglength(rotations_array) -->
12479 ///
12480 /// @param[in] scales_array
12481 /// A float array representing the scale attribute.
12482 /// It will read the array assuming a tuple size of 3
12483 ///
12484 /// @param[in] scales_start
12485 /// The index of the first scale in scales_array.
12486 /// <!-- default 0 -->
12487 ///
12488 /// @param[in] scales_length
12489 /// The size of the scales array.
12490 /// <!-- source arglength(scales_array) -->
12491 ///
12493  const HAPI_Session* session,
12494  HAPI_NodeId node_id,
12495  HAPI_PartId part_id,
12496  const float* positions_array,
12497  int positions_start,
12498  int positions_length,
12499  const float* rotations_array,
12500  int rotations_start,
12501  int rotations_length,
12502  const float * scales_array,
12503  int scales_start,
12504  int scales_length);
12505 
12506 // BASIC PRIMITIVES ---------------------------------------------------------
12507 
12508 /// @brief Get the box info on a geo part (if the part is a box).
12509 ///
12510 /// @ingroup Geometry
12511 ///
12512 /// @param[in] session
12513 /// The session of Houdini you are interacting with.
12514 /// See @ref HAPI_Sessions for more on sessions.
12515 /// Pass NULL to just use the default in-process session.
12516 /// <!-- default NULL -->
12517 ///
12518 /// @param[in] geo_node_id
12519 /// The geo node id.
12520 ///
12521 /// @param[in] part_id
12522 /// The part id of the
12523 ///
12524 /// @param[out] box_info
12525 /// The returned box info.
12526 ///
12527 HAPI_DECL HAPI_GetBoxInfo( const HAPI_Session * session,
12528  HAPI_NodeId geo_node_id,
12529  HAPI_PartId part_id,
12530  HAPI_BoxInfo * box_info );
12531 
12532 /// @brief Get the sphere info on a geo part (if the part is a sphere).
12533 ///
12534 /// @ingroup Geometry
12535 ///
12536 /// @param[in] session
12537 /// The session of Houdini you are interacting with.
12538 /// See @ref HAPI_Sessions for more on sessions.
12539 /// Pass NULL to just use the default in-process session.
12540 /// <!-- default NULL -->
12541 ///
12542 /// @param[in] geo_node_id
12543 /// The geo node id.
12544 ///
12545 /// @param[in] part_id
12546 /// The part id of the
12547 ///
12548 /// @param[out] sphere_info
12549 /// The returned sphere info.
12550 ///
12551 HAPI_DECL HAPI_GetSphereInfo( const HAPI_Session * session,
12552  HAPI_NodeId geo_node_id,
12553  HAPI_PartId part_id,
12554  HAPI_SphereInfo * sphere_info );
12555 
12556 /// @defgroup Caching
12557 /// Functions for working with memory and file caches
12558 
12559 /// @brief Get the number of currently active caches.
12560 ///
12561 /// @ingroup Caching
12562 ///
12563 /// @param[in] session
12564 /// The session of Houdini you are interacting with.
12565 /// See @ref HAPI_Sessions for more on sessions.
12566 /// Pass NULL to just use the default in-process session.
12567 /// <!-- default NULL -->
12568 ///
12569 /// @param[out] active_cache_count
12570 /// The number of currently active caches.
12571 ///
12573  int * active_cache_count );
12574 
12575 /// @brief Get the names of the currently active caches.
12576 ///
12577 /// Requires a valid active cache count which you get from:
12578 /// ::HAPI_GetActiveCacheCount().
12579 ///
12580 /// @ingroup Caching
12581 ///
12582 /// @param[in] session
12583 /// The session of Houdini you are interacting with.
12584 /// See @ref HAPI_Sessions for more on sessions.
12585 /// Pass NULL to just use the default in-process session.
12586 /// <!-- default NULL -->
12587 ///
12588 /// @param[out] cache_names_array
12589 /// String array with the returned cache names. Must be
12590 /// at least the size of @a active_cache_count.
12591 ///
12592 /// @param[in] active_cache_count
12593 /// The count returned by ::HAPI_GetActiveCacheCount().
12594 /// <!-- source ::HAPI_GetActiveCacheCount -->
12595 ///
12597  HAPI_StringHandle * cache_names_array,
12598  int active_cache_count );
12599 
12600 /// @brief Lets you inspect specific properties of the different memory
12601 /// caches in the current Houdini context.
12602 ///
12603 /// @ingroup Caching
12604 ///
12605 /// @param[in] session
12606 /// The session of Houdini you are interacting with.
12607 /// See @ref HAPI_Sessions for more on sessions.
12608 /// Pass NULL to just use the default in-process session.
12609 /// <!-- default NULL -->
12610 ///
12611 /// @param[in] cache_name
12612 /// Cache name from ::HAPI_GetActiveCacheNames().
12613 ///
12614 /// @param[in] cache_property
12615 /// The specific property of the cache to get the value for.
12616 ///
12617 /// @param[out] property_value
12618 /// Returned property value.
12619 ///
12621  const char * cache_name,
12622  HAPI_CacheProperty cache_property,
12623  int * property_value );
12624 
12625 /// @brief Lets you modify specific properties of the different memory
12626 /// caches in the current Houdini context. This includes clearing
12627 /// caches, reducing their memory use, or changing how memory limits
12628 /// are respected by a cache.
12629 ///
12630 /// @ingroup Caching
12631 ///
12632 /// @param[in] session
12633 /// The session of Houdini you are interacting with.
12634 /// See @ref HAPI_Sessions for more on sessions.
12635 /// Pass NULL to just use the default in-process session.
12636 /// <!-- default NULL -->
12637 ///
12638 /// @param[in] cache_name
12639 /// Cache name from ::HAPI_GetActiveCacheNames().
12640 ///
12641 /// @param[in] cache_property
12642 /// The specific property of the cache to modify.
12643 ///
12644 /// @param[in] property_value
12645 /// The new property value.
12646 ///
12648  const char * cache_name,
12649  HAPI_CacheProperty cache_property,
12650  int property_value );
12651 
12652 /// @brief Saves a geometry to file. The type of file to save is
12653 /// to be determined by the extension ie. .bgeo, .obj
12654 ///
12655 /// @ingroup Caching
12656 ///
12657 /// @param[in] session
12658 /// The session of Houdini you are interacting with.
12659 /// See @ref HAPI_Sessions for more on sessions.
12660 /// Pass NULL to just use the default in-process session.
12661 /// <!-- default NULL -->
12662 ///
12663 /// @param[in] node_id
12664 /// The node id.
12665 ///
12666 /// @param[in] file_name
12667 /// The name of the file to be saved. The extension
12668 /// of the file determines its type.
12669 ///
12670 HAPI_DECL HAPI_SaveGeoToFile( const HAPI_Session * session,
12671  HAPI_NodeId node_id,
12672  const char * file_name );
12673 
12674 /// @brief Loads a geometry file and put its contents onto a SOP
12675 /// node.
12676 ///
12677 /// @ingroup Caching
12678 ///
12679 /// @param[in] session
12680 /// The session of Houdini you are interacting with.
12681 /// See @ref HAPI_Sessions for more on sessions.
12682 /// Pass NULL to just use the default in-process session.
12683 /// <!-- default NULL -->
12684 ///
12685 /// @param[in] node_id
12686 /// The node id.
12687 ///
12688 /// @param[in] file_name
12689 /// The name of the file to be loaded
12690 ///
12692  HAPI_NodeId node_id,
12693  const char * file_name );
12694 
12695 /// @brief Saves the node and all its contents to file.
12696 /// The saved file can be loaded by calling ::HAPI_LoadNodeFromFile.
12697 ///
12698 /// @ingroup Caching
12699 ///
12700 /// @param[in] session
12701 /// The session of Houdini you are interacting with.
12702 /// See @ref HAPI_Sessions for more on sessions.
12703 /// Pass NULL to just use the default in-process session.
12704 /// <!-- default NULL -->
12705 ///
12706 /// @param[in] node_id
12707 /// The node id.
12708 ///
12709 /// @param[in] file_name
12710 /// The name of the file to be saved. The extension
12711 /// of the file determines its type.
12712 ///
12713 HAPI_DECL HAPI_SaveNodeToFile( const HAPI_Session * session,
12714  HAPI_NodeId node_id,
12715  const char * file_name );
12716 
12717 /// @brief Loads and creates a previously saved node and all
12718 /// its contents from given file.
12719 /// The saved file must have been created by calling
12720 /// ::HAPI_SaveNodeToFile.
12721 ///
12722 /// @ingroup Caching
12723 ///
12724 /// @param[in] session
12725 /// The session of Houdini you are interacting with.
12726 /// See @ref HAPI_Sessions for more on sessions.
12727 /// Pass NULL to just use the default in-process session.
12728 /// <!-- default NULL -->
12729 ///
12730 /// @param[in] file_name
12731 /// The name of the file to be loaded
12732 ///
12733 /// @param[in] parent_node_id
12734 /// The parent node id of the Geometry object.
12735 ///
12736 /// @param[in] node_label
12737 /// The name of the new Geometry object.
12738 ///
12739 /// @param[in] cook_on_load
12740 /// Set to true if you wish the nodes to cook as soon
12741 /// as they are created. Otherwise, you will have to
12742 /// call ::HAPI_CookNode() explicitly for each after you
12743 /// call this function.
12744 ///
12745 /// @param[out] new_node_id
12746 /// The newly created node id.
12747 ///
12749  const char * file_name,
12750  HAPI_NodeId parent_node_id,
12751  const char * node_label,
12752  HAPI_Bool cook_on_load,
12753  HAPI_NodeId * new_node_id );
12754 
12755 /// @brief Cache the current state of the geo to memory, given the
12756 /// format, and return the size. Use this size with your call
12757 /// to ::HAPI_SaveGeoToMemory() to copy the cached geo to your
12758 /// buffer. It is guaranteed that the size will not change between
12759 /// your call to ::HAPI_GetGeoSize() and ::HAPI_SaveGeoToMemory().
12760 ///
12761 /// @ingroup Caching
12762 ///
12763 /// @param[in] session
12764 /// The session of Houdini you are interacting with.
12765 /// See @ref HAPI_Sessions for more on sessions.
12766 /// Pass NULL to just use the default in-process session.
12767 /// <!-- default NULL -->
12768 ///
12769 /// @param[in] node_id
12770 /// The node id.
12771 ///
12772 /// @param[in] format
12773 /// The file format, ie. ".obj", ".bgeo.sc" etc.
12774 ///
12775 /// @param[out] size
12776 /// The size of the buffer required to hold the output.
12777 ///
12778 HAPI_DECL HAPI_GetGeoSize( const HAPI_Session * session,
12779  HAPI_NodeId node_id,
12780  const char * format,
12781  int * size );
12782 
12783 /// @brief Saves the cached geometry to your buffer in memory,
12784 /// whose format and required size is identified by the call to
12785 /// ::HAPI_GetGeoSize(). The call to ::HAPI_GetGeoSize() is
12786 /// required as ::HAPI_GetGeoSize() does the actual saving work.
12787 ///
12788 /// Also note that this call to ::HAPI_SaveGeoToMemory will delete
12789 /// the internal geo buffer that was cached in the previous call
12790 /// to ::HAPI_GetGeoSize(). This means that you will need to call
12791 /// ::HAPI_GetGeoSize() again before you can call this function.
12792 ///
12793 /// @ingroup Caching
12794 ///
12795 /// @param[in] session
12796 /// The session of Houdini you are interacting with.
12797 /// See @ref HAPI_Sessions for more on sessions.
12798 /// Pass NULL to just use the default in-process session.
12799 /// <!-- default NULL -->
12800 ///
12801 /// @param[in] node_id
12802 /// The node id.
12803 ///
12804 /// @param[out] buffer
12805 /// The buffer we will write into.
12806 ///
12807 /// @param[in] length
12808 /// The size of the buffer passed in.
12809 /// <!-- source ::HAPI_GetGeoSize -->
12810 ///
12812  HAPI_NodeId node_id,
12813  char * buffer,
12814  int length );
12815 
12816 /// @brief Loads a geometry from memory and put its
12817 /// contents onto a SOP node.
12818 ///
12819 /// @ingroup Caching
12820 ///
12821 /// @param[in] session
12822 /// The session of Houdini you are interacting with.
12823 /// See @ref HAPI_Sessions for more on sessions.
12824 /// Pass NULL to just use the default in-process session.
12825 /// <!-- default NULL -->
12826 ///
12827 /// @param[in] node_id
12828 /// The node id.
12829 ///
12830 /// @param[in] format
12831 /// The file format, ie. "obj", "bgeo" etc.
12832 ///
12833 /// @param[in] buffer
12834 /// The buffer we will read the geometry from.
12835 ///
12836 /// @param[in] length
12837 /// The size of the buffer passed in.
12838 /// <!-- source arglength(buffer) -->
12839 ///
12841  HAPI_NodeId node_id,
12842  const char * format,
12843  const char * buffer,
12844  int length );
12845 
12846 /// @brief Set the specified node's display flag.
12847 ///
12848 /// @ingroup Nodes
12849 ///
12850 /// @param[in] session
12851 /// The session of Houdini you are interacting with.
12852 /// See @ref HAPI_Sessions for more on sessions.
12853 /// Pass NULL to just use the default in-process session.
12854 /// <!-- default NULL -->
12855 ///
12856 /// @param[in] node_id
12857 /// The node id.
12858 ///
12859 /// @param[in] onOff
12860 /// Display flag.
12861 ///
12862 HAPI_DECL HAPI_SetNodeDisplay( const HAPI_Session * session,
12863  HAPI_NodeId node_id,
12864  int onOff );
12865 
12866 /// @brief Get the specified node's total cook count, including
12867 /// its children, if specified.
12868 ///
12869 /// @ingroup Nodes
12870 ///
12871 /// @param[in] session
12872 /// The session of Houdini you are interacting with.
12873 /// See @ref HAPI_Sessions for more on sessions.
12874 /// Pass NULL to just use the default in-process session.
12875 /// <!-- default NULL -->
12876 ///
12877 /// @param[in] node_id
12878 /// The node id.
12879 ///
12880 /// @param[in] node_type_filter
12881 /// The node type by which to filter the children.
12882 ///
12883 /// @param[in] node_flags_filter
12884 /// The node flags by which to filter the children.
12885 ///
12886 /// @param[in] recursive
12887 /// Whether or not to include the specified node's
12888 /// children cook count in the tally.
12889 ///
12890 /// @param[out] count
12891 /// The number of cooks in total for this session.
12892 ///
12894  HAPI_NodeId node_id,
12895  HAPI_NodeTypeBits node_type_filter,
12896  HAPI_NodeFlagsBits node_flags_filter,
12897  HAPI_Bool recursive,
12898  int * count );
12899 
12900 /// @defgroup SessionSync
12901 /// Functions for working with SessionSync
12902 
12903 /// @brief Enable or disable SessionSync mode.
12904 ///
12905 /// @ingroup SessionSync
12906 ///
12907 /// @param[in] session
12908 /// The session of Houdini you are interacting with.
12909 /// See @ref HAPI_Sessions for more on sessions.
12910 /// Pass NULL to just use the default in-process session.
12911 /// <!-- default NULL -->
12912 ///
12913 /// @param[in] enable
12914 /// Enable or disable SessionSync mode.
12915 ///
12916 HAPI_DECL HAPI_SetSessionSync( const HAPI_Session * session,
12917  HAPI_Bool enable );
12918 
12919 /// @brief Get the ::HAPI_Viewport info for synchronizing viewport in
12920 /// SessionSync. When SessionSync is running this will
12921 /// return Houdini's current viewport information.
12922 ///
12923 /// @ingroup SessionSync
12924 ///
12925 /// @param[in] session
12926 /// The session of Houdini you are interacting with.
12927 /// See @ref HAPI_Sessions for more on sessions.
12928 /// Pass NULL to just use the default in-process session.
12929 ///
12930 /// @param[out] viewport
12931 /// The output ::HAPI_Viewport.
12932 ///
12933 HAPI_DECL HAPI_GetViewport( const HAPI_Session * session,
12934  HAPI_Viewport * viewport );
12935 
12936 /// @brief Set the ::HAPI_Viewport info for synchronizing viewport in
12937 /// SessionSync. When SessionSync is running, this can be
12938 /// used to set the viewport information which Houdini
12939 /// will then synchronizse with for its viewport.
12940 ///
12941 /// @ingroup SessionSync
12942 ///
12943 /// @param[in] session
12944 /// The session of Houdini you are interacting with.
12945 /// See @ref HAPI_Sessions for more on sessions.
12946 /// Pass NULL to just use the default in-process session.
12947 ///
12948 /// @param[in] viewport
12949 /// A ::HAPI_Viewport that stores the viewport.
12950 ///
12951 HAPI_DECL HAPI_SetViewport( const HAPI_Session * session,
12952  const HAPI_Viewport * viewport );
12953 
12954 /// @brief Get the ::HAPI_SessionSyncInfo for synchronizing SessionSync
12955 /// state between Houdini and Houdini Engine integrations.
12956 ///
12957 /// @ingroup SessionSync
12958 ///
12959 /// @param[in] session
12960 /// The session of Houdini you are interacting with.
12961 /// See @ref HAPI_Sessions for more on sessions.
12962 /// Pass NULL to just use the default in-process session.
12963 ///
12964 /// @param[out] session_sync_info
12965 /// The output ::HAPI_SessionSyncInfo.
12966 ///
12968  const HAPI_Session * session,
12969  HAPI_SessionSyncInfo * session_sync_info );
12970 
12971 /// @brief Set the ::HAPI_SessionSyncInfo for synchronizing SessionSync
12972 /// state between Houdini and Houdini Engine integrations.
12973 ///
12974 /// @ingroup SessionSync
12975 ///
12976 /// @param[in] session
12977 /// The session of Houdini you are interacting with.
12978 /// See @ref HAPI_Sessions for more on sessions.
12979 /// Pass NULL to just use the default in-process session.
12980 ///
12981 /// @param[in] session_sync_info
12982 /// A ::HAPI_SessionSyncInfo that stores the state.
12983 ///
12985  const HAPI_Session * session,
12986  const HAPI_SessionSyncInfo * session_sync_info );
12987 
12988 /// @defgroup PDG PDG/TOPs
12989 /// Functions for working with PDG/TOPs
12990 
12991 /// @brief Return an array of PDG graph context names and ids, the first
12992 /// count names will be returned. These ids can be used
12993 /// with ::HAPI_GetPDGEvents and ::HAPI_GetPDGState. The values
12994 /// of the names can be retrieved with ::HAPI_GetString.
12995 ///
12996 /// @ingroup PDG
12997 ///
12998 /// @param[in] session
12999 /// The session of Houdini you are interacting with.
13000 /// See @ref HAPI_Sessions for more on sessions.
13001 /// Pass NULL to just use the default in-process session.
13002 /// <!-- default NULL -->
13003 ///
13004 /// @param[out] context_names_array
13005 /// Array of context names stored as ::HAPI_StringHandle
13006 /// at least the size of length. These can be used
13007 /// with ::HAPI_GetString() and are valid until the
13008 /// next call to this function.
13009 ///
13010 /// @param[out] context_id_array
13011 /// Array of graph context ids at least the size of length.
13012 ///
13013 /// @param[in] start
13014 /// First index of range. Must be at least @c 0 and at most
13015 /// @c context_count - 1 where @c context_count is the count
13016 /// returned by ::HAPI_GetPDGGraphContextsCount()
13017 /// <!-- min 0 -->
13018 /// <!-- max ::HAPI_GetPDGGraphContextsCount -->
13019 /// <!-- default 0 -->
13020 ///
13021 /// @param[in] length
13022 /// Given @c num_contexts returned by ::HAPI_GetPDGGraphContextsCount(),
13023 /// length should be at least @c 0 and at most <tt>num_contexts - start.</tt>
13024 /// <!-- default 0 -->
13026  HAPI_StringHandle * context_names_array,
13027  HAPI_PDG_GraphContextId * context_id_array,
13028  int start,
13029  int length );
13030 
13031 /// @brief Return the total number of PDG graph contexts found.
13032 ///
13033 /// @ingroup PDG
13034 ///
13035 /// @param[in] session
13036 /// The session of Houdini you are interacting with.
13037 /// See @ref HAPI_Sessions for more on sessions.
13038 /// Pass NULL to just use the default in-process session.
13039 /// <!-- default NULL -->
13040 ///
13041 /// @param[out] num_contexts
13042 /// Total PDG graph contexts count.
13043 ///
13045  const HAPI_Session* session,
13046  int* num_contexts );
13047 
13048 /// @brief Get the PDG graph context for the specified TOP node.
13049 ///
13050 /// @ingroup PDG
13051 ///
13052 /// @param[in] session
13053 /// The session of Houdini you are interacting with.
13054 /// See @ref HAPI_Sessions for more on sessions.
13055 /// Pass NULL to just use the default in-process session.
13056 /// <!-- default NULL -->
13057 ///
13058 /// @param[in] top_node_id
13059 /// The id of the TOP node to query its graph context.
13060 ///
13061 /// @param[out] context_id
13062 /// The PDG graph context id.
13063 ///
13065  HAPI_NodeId top_node_id,
13066  HAPI_PDG_GraphContextId * context_id );
13067 
13068 /// @brief Starts a PDG cooking operation. This can be asynchronous.
13069 /// Progress can be checked with ::HAPI_GetPDGState() and
13070 /// ::HAPI_GetPDGState(). Events generated during this cook can be
13071 /// collected with ::HAPI_GetPDGEvents(). Any uncollected events will be
13072 /// discarded at the start of the cook.
13073 ///
13074 /// If there are any $HIPFILE file dependencies on nodes involved in the cook
13075 /// a hip file will be automatically saved to $HOUDINI_TEMP_DIR directory so
13076 /// that it can be copied to the working directory by the scheduler. This means
13077 /// $HIP will be equal to $HOUDINI_TEMP_DIR.
13078 ///
13079 /// @ingroup PDG
13080 ///
13081 /// @param[in] session
13082 /// The session of Houdini you are interacting with.
13083 /// See @ref HAPI_Sessions for more on sessions.
13084 /// Pass NULL to just use the default in-process session.
13085 ///
13086 /// @param[in] cook_node_id
13087 /// The node id of a TOP node for the cook operation.
13088 ///
13089 /// @param[in] generate_only
13090 /// 1 means only static graph generation will done. 0 means
13091 /// a full graph cook. Generation is always blocking.
13092 ///
13093 /// @param[in] blocking
13094 /// 0 means return immediately and cooking will be done
13095 /// asynchronously. 1 means return when cooking completes.
13096 ///
13097 HAPI_DECL HAPI_CookPDG( const HAPI_Session * session,
13098  HAPI_NodeId cook_node_id,
13099  int generate_only,
13100  int blocking );
13101 
13102 /// @brief Starts a PDG cooking operation. This can be asynchronous.
13103 /// Progress can be checked with ::HAPI_GetPDGState() and
13104 /// ::HAPI_GetPDGState(). Events generated during this cook can be
13105 /// collected with ::HAPI_GetPDGEvents(). Any uncollected events will be
13106 /// discarded at the start of the cook.
13107 ///
13108 /// If there are any $HIPFILE file dependencies on nodes involved in the
13109 /// cook a hip file will be automatically saved to $HOUDINI_TEMP_DIR
13110 /// directory so that it can be copied to the working directory by the
13111 /// scheduler. This means $HIP will be equal to $HOUDINI_TEMP_DIR.
13112 ///
13113 /// If cook_node_id is a network / subnet, then if it has output nodes
13114 /// it cooks all of its output nodes and not just output 0. If it does
13115 /// not have output nodes it cooks the node with the output flag.
13116 ///
13117 /// @ingroup PDG
13118 ///
13119 /// @param[in] session
13120 /// The session of Houdini you are interacting with.
13121 /// See @ref HAPI_Sessions for more on sessions.
13122 /// Pass NULL to just use the default in-process session.
13123 ///
13124 /// @param[in] cook_node_id
13125 /// The node id of a TOP node for the cook operation.
13126 ///
13127 /// @param[in] generate_only
13128 /// 1 means only static graph generation will done. 0 means
13129 /// a full graph cook. Generation is always blocking.
13130 ///
13131 /// @param[in] blocking
13132 /// 0 means return immediately and cooking will be done
13133 /// asynchronously. 1 means return when cooking completes.
13134 ///
13136  const HAPI_Session* session,
13137  HAPI_NodeId cook_node_id,
13138  int generate_only,
13139  int blocking);
13140 
13141 /// @brief Returns PDG events that have been collected. Calling this function
13142 /// will remove those events from the queue. Events collection is restarted
13143 /// by calls to ::HAPI_CookPDG().
13144 ///
13145 /// @ingroup PDG
13146 ///
13147 ///
13148 /// @param[in] session
13149 /// The session of Houdini you are interacting with.
13150 /// See @ref HAPI_Sessions for more on sessions.
13151 /// Pass NULL to just use the default in-process session.
13152 /// <!-- default NULL -->
13153 ///
13154 /// @param[in] graph_context_id
13155 /// The id of the graph context
13156 ///
13157 /// @param[out] event_array
13158 /// buffer of ::HAPI_PDG_EventInfo of size at least length.
13159 ///
13160 /// @param[in] length
13161 /// The size of the buffer passed in.
13162 ///
13163 /// @param[out] event_count
13164 /// Number of events removed from queue and copied to buffer.
13165 ///
13166 /// @param[out] remaining_events
13167 /// Number of queued events remaining after this operation.
13168 ///
13169 HAPI_DECL HAPI_GetPDGEvents( const HAPI_Session * session,
13170  HAPI_PDG_GraphContextId graph_context_id,
13171  HAPI_PDG_EventInfo * event_array,
13172  int length,
13173  int * event_count,
13174  int * remaining_events );
13175 
13176 /// @brief Gets the state of a PDG graph
13177 ///
13178 /// @ingroup PDG
13179 ///
13180 ///
13181 /// @param[in] session
13182 /// The session of Houdini you are interacting with.
13183 /// See @ref HAPI_Sessions for more on sessions.
13184 /// Pass NULL to just use the default in-process session.
13185 /// <!-- default NULL -->
13186 ///
13187 /// @param[in] graph_context_id
13188 /// The graph context id
13189 ///
13190 /// @param[out] pdg_state
13191 /// One of ::HAPI_PDG_State.
13192 ///
13193 HAPI_DECL HAPI_GetPDGState( const HAPI_Session * session,
13194  HAPI_PDG_GraphContextId graph_context_id,
13195  int * pdg_state );
13196 
13197 /// @brief Creates a new pending workitem for the given node. The workitem
13198 /// will not be submitted to the graph until it is committed with
13199 /// ::HAPI_CommitWorkitems(). The node is expected to be a generator type.
13200 ///
13201 /// @ingroup PDG
13202 ///
13203 /// @param[in] session
13204 /// The session of Houdini you are interacting with.
13205 /// See @ref HAPI_Sessions for more on sessions.
13206 /// Pass NULL to just use the default in-process session.
13207 /// <!-- default NULL -->
13208 ///
13209 /// @param[in] node_id
13210 /// The node id.
13211 ///
13212 /// @param[out] workitem_id
13213 /// The id of the pending workitem.
13214 ///
13215 /// @param[in] name
13216 /// The null-terminated name of the workitem. The name will
13217 /// be automatically suffixed to make it unique.
13218 ///
13219 /// @param[in] index
13220 /// The index of the workitem. The semantics of the index
13221 /// are user defined.
13222 ///
13224 HAPI_CreateWorkitem( const HAPI_Session * session,
13225  HAPI_NodeId node_id,
13226  HAPI_PDG_WorkItemId * workitem_id,
13227  const char * name,
13228  int index );
13229 
13230 /// @brief Retrieves the info of a given workitem by id.
13231 ///
13232 /// @ingroup PDG
13233 ///
13234 /// @param[in] session
13235 /// The session of Houdini you are interacting with.
13236 /// See @ref HAPI_Sessions for more on sessions.
13237 /// Pass NULL to just use the default in-process session.
13238 /// <!-- default NULL -->
13239 ///
13240 /// @param[in] graph_context_id
13241 /// The graph context that the workitem is in.
13242 ///
13243 /// @param[in] workitem_id
13244 /// The id of the workitem.
13245 ///
13246 /// @param[out] workitem_info
13247 /// The returned ::HAPI_PDG_WorkItemInfo for the workitem. Note
13248 /// that the enclosed string handle is only valid until the next
13249 /// call to this function.
13250 ///
13252 HAPI_GetWorkitemInfo( const HAPI_Session * session,
13253  HAPI_PDG_GraphContextId graph_context_id,
13254  HAPI_PDG_WorkItemId workitem_id,
13255  HAPI_PDG_WorkItemInfo * workitem_info );
13256 
13257 /// @brief Adds integer data to a pending PDG workitem data member for the given node.
13258 ///
13259 /// @ingroup PDG
13260 ///
13261 /// @param[in] session
13262 /// The session of Houdini you are interacting with.
13263 /// See @ref HAPI_Sessions for more on sessions.
13264 /// Pass NULL to just use the default in-process session.
13265 /// <!-- default NULL -->
13266 ///
13267 /// @param[in] node_id
13268 /// The node id.
13269 ///
13270 /// @param[in] workitem_id
13271 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem()
13272 ///
13273 /// @param[in] data_name
13274 /// null-terminated name of the data member
13275 ///
13276 /// @param[in] values_array
13277 /// array of integer values
13278 ///
13279 /// @param[in] length
13280 /// number of values to copy from values_array to the parameter
13281 ///
13283 HAPI_SetWorkitemIntData( const HAPI_Session * session,
13284  HAPI_NodeId node_id,
13285  HAPI_PDG_WorkItemId workitem_id,
13286  const char * data_name,
13287  const int * values_array,
13288  int length );
13289 
13290 /// @brief Adds float data to a pending PDG workitem data member for the given node.
13291 ///
13292 /// @ingroup PDG
13293 ///
13294 /// @param[in] session
13295 /// The session of Houdini you are interacting with.
13296 /// See @ref HAPI_Sessions for more on sessions.
13297 /// Pass NULL to just use the default in-process session.
13298 /// <!-- default NULL -->
13299 ///
13300 /// @param[in] node_id
13301 /// The node id.
13302 ///
13303 /// @param[in] workitem_id
13304 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem()
13305 ///
13306 /// @param[in] data_name
13307 /// null-terminated name of the workitem data member
13308 ///
13309 /// @param[in] values_array
13310 /// array of float values
13311 ///
13312 /// @param[in] length
13313 /// number of values to copy from values_array to the parameter
13314 ///
13316 HAPI_SetWorkitemFloatData( const HAPI_Session * session,
13317  HAPI_NodeId node_id,
13318  HAPI_PDG_WorkItemId workitem_id,
13319  const char * data_name,
13320  const float * values_array,
13321  int length );
13322 
13323 /// @brief Adds integer data to a pending PDG workitem data member for the given node.
13324 ///
13325 /// @ingroup PDG
13326 ///
13327 /// @param[in] session
13328 /// The session of Houdini you are interacting with.
13329 /// See @ref HAPI_Sessions for more on sessions.
13330 /// Pass NULL to just use the default in-process session.
13331 /// <!-- default NULL -->
13332 ///
13333 /// @param[in] node_id
13334 /// The node id.
13335 ///
13336 /// @param[in] workitem_id
13337 /// The id of the created workitem returned by HAPI_CreateWorkitem()
13338 ///
13339 /// @param[in] data_name
13340 /// null-terminated name of the data member
13341 ///
13342 /// @param[in] data_index
13343 /// index of the string data member
13344 ///
13345 /// @param[in] value
13346 /// null-terminated string to copy to the workitem data member
13347 ///
13349 HAPI_SetWorkitemStringData( const HAPI_Session * session,
13350  HAPI_NodeId node_id,
13351  HAPI_PDG_WorkItemId workitem_id,
13352  const char * data_name,
13353  int data_index,
13354  const char * value );
13355 
13356 /// @brief Commits any pending workitems.
13357 ///
13358 /// @ingroup PDG
13359 ///
13360 /// @param[in] session
13361 /// The session of Houdini you are interacting with.
13362 /// See @ref HAPI_Sessions for more on sessions.
13363 /// Pass NULL to just use the default in-process session.
13364 /// <!-- default NULL -->
13365 ///
13366 /// @param[in] node_id
13367 /// The node id for which the pending workitems have been
13368 /// created but not yet injected.
13369 ///
13371 HAPI_CommitWorkitems( const HAPI_Session * session,
13372  HAPI_NodeId node_id );
13373 
13374 /// @brief Gets the number of workitems that are available on the given node.
13375 /// Should be used with ::HAPI_GetWorkitems.
13376 ///
13377 /// @ingroup PDG
13378 ///
13379 /// @param[in] session
13380 /// The session of Houdini you are interacting with.
13381 /// See @ref HAPI_Sessions for more on sessions.
13382 /// Pass NULL to just use the default in-process session.
13383 /// <!-- default NULL -->
13384 ///
13385 /// @param[in] node_id
13386 /// The node id.
13387 ///
13388 /// @param[out] num
13389 /// The number of workitems.
13390 ///
13392 HAPI_GetNumWorkitems( const HAPI_Session * session,
13393  HAPI_NodeId node_id,
13394  int * num );
13395 
13396 /// @brief Gets the list of work item ids for the given node
13397 ///
13398 /// @ingroup PDG
13399 ///
13400 /// @param[in] session
13401 /// The session of Houdini you are interacting with.
13402 /// See @ref HAPI_Sessions for more on sessions.
13403 /// Pass NULL to just use the default in-process session.
13404 /// <!-- default NULL -->
13405 ///
13406 /// @param[in] node_id
13407 /// The node id.
13408 ///
13409 /// @param[out] workitem_ids_array
13410 /// buffer for resulting array of ::HAPI_PDG_WorkItemId
13411 ///
13412 /// @param[in] length
13413 /// The length of the @p workitem_ids buffer
13414 ///
13416 HAPI_GetWorkitems( const HAPI_Session * session,
13417  HAPI_NodeId node_id,
13418  int * workitem_ids_array,
13419  int length );
13420 
13421 /// @brief Gets the length of the workitem data member.
13422 /// It is the length of the array of data.
13423 ///
13424 /// @ingroup PDG
13425 ///
13426 /// @param[in] session
13427 /// The session of Houdini you are interacting with.
13428 /// See @ref HAPI_Sessions for more on sessions.
13429 /// Pass NULL to just use the default in-process session.
13430 /// <!-- default NULL -->
13431 ///
13432 /// @param[in] node_id
13433 /// The node id.
13434 ///
13435 /// @param[in] workitem_id
13436 /// The id of the workitem
13437 ///
13438 /// @param[in] data_name
13439 /// null-terminated name of the data member
13440 ///
13441 /// @param[out] length
13442 /// The length of the data member array
13443 ///
13444 HAPI_DECL_DEPRECATED_REPLACE(5.0.0, 19.5.161, HAPI_GetWorkItemDataSize)
13445 HAPI_GetWorkitemDataLength( const HAPI_Session * session,
13446  HAPI_NodeId node_id,
13447  HAPI_PDG_WorkItemId workitem_id,
13448  const char * data_name,
13449  int * length );
13450 
13451 /// @brief Gets int data from a work item member.
13452 ///
13453 /// @ingroup PDG
13454 ///
13455 /// @param[in] session
13456 /// The session of Houdini you are interacting with.
13457 /// See @ref HAPI_Sessions for more on sessions.
13458 /// Pass NULL to just use the default in-process session.
13459 /// <!-- default NULL -->
13460 ///
13461 /// @param[in] node_id
13462 /// The node id.
13463 ///
13464 /// @param[in] workitem_id
13465 /// The id of the workitem
13466 ///
13467 /// @param[in] data_name
13468 /// null-terminated name of the data member
13469 ///
13470 /// @param[out] data_array
13471 /// buffer of at least size length to copy the data into. The required
13472 /// length should be determined by ::HAPI_GetWorkitemDataLength().
13473 ///
13474 /// @param[in] length
13475 /// The length of @p data_array
13476 ///
13478 HAPI_GetWorkitemIntData( const HAPI_Session * session,
13479  HAPI_NodeId node_id,
13480  HAPI_PDG_WorkItemId workitem_id,
13481  const char * data_name,
13482  int * data_array,
13483  int length );
13484 
13485 /// @brief Gets float data from a work item member.
13486 ///
13487 /// @ingroup PDG
13488 ///
13489 /// @param[in] session
13490 /// The session of Houdini you are interacting with.
13491 /// See @ref HAPI_Sessions for more on sessions.
13492 /// Pass NULL to just use the default in-process session.
13493 /// <!-- default NULL -->
13494 ///
13495 /// @param[in] node_id
13496 /// The node id.
13497 ///
13498 /// @param[in] workitem_id
13499 /// The id of the workitem
13500 ///
13501 /// @param[in] data_name
13502 /// null-terminated name of the data member
13503 ///
13504 /// @param[out] data_array
13505 /// buffer of at least size length to copy the data into. The required
13506 /// length should be determined by ::HAPI_GetWorkitemDataLength().
13507 ///
13508 /// @param[in] length
13509 /// The length of the @p data_array
13510 ///
13512 HAPI_GetWorkitemFloatData( const HAPI_Session * session,
13513  HAPI_NodeId node_id,
13514  HAPI_PDG_WorkItemId workitem_id,
13515  const char * data_name,
13516  float * data_array,
13517  int length );
13518 
13519 /// @brief Gets string ids from a work item member.
13520 ///
13521 /// @ingroup PDG
13522 ///
13523 /// @param[in] session
13524 /// The session of Houdini you are interacting with.
13525 /// See @ref HAPI_Sessions for more on sessions.
13526 /// Pass NULL to just use the default in-process session.
13527 /// <!-- default NULL -->
13528 ///
13529 /// @param[in] node_id
13530 /// The node id.
13531 ///
13532 /// @param[in] workitem_id
13533 /// The id of the workitem
13534 ///
13535 /// @param[in] data_name
13536 /// null-terminated name of the data member
13537 ///
13538 /// @param[out] data_array
13539 /// buffer of at least size length to copy the data into. The required
13540 /// length should be determined by ::HAPI_GetWorkitemDataLength().
13541 /// The data is an array of ::HAPI_StringHandle which can be used with
13542 /// ::HAPI_GetString(). The string handles are valid until the
13543 /// next call to this function.
13544 ///
13545 /// @param[in] length
13546 /// The length of @p data_array
13547 ///
13549 HAPI_GetWorkitemStringData( const HAPI_Session * session,
13550  HAPI_NodeId node_id,
13551  HAPI_PDG_WorkItemId workitem_id,
13552  const char * data_name,
13553  HAPI_StringHandle * data_array,
13554  int length );
13555 
13556 /// @brief Gets the info for workitem results.
13557 /// The number of workitem results is found on the ::HAPI_PDG_WorkItemInfo
13558 /// returned by ::HAPI_GetWorkitemInfo()
13559 ///
13560 /// @ingroup PDG
13561 ///
13562 /// @param[in] session
13563 /// The session of Houdini you are interacting with.
13564 /// See @ref HAPI_Sessions for more on sessions.
13565 /// Pass NULL to just use the default in-process session.
13566 /// <!-- default NULL -->
13567 ///
13568 /// @param[in] node_id
13569 /// The node id.
13570 ///
13571 /// @param[in] workitem_id
13572 /// The id of the workitem
13573 ///
13574 /// @param[out] resultinfo_array
13575 /// Buffer to fill with info structs. String handles are valid
13576 /// until the next call of this function.
13577 ///
13578 /// @param[in] resultinfo_count
13579 /// The length of @p resultinfo_array
13580 ///
13582 HAPI_GetWorkitemResultInfo( const HAPI_Session * session,
13583  HAPI_NodeId node_id,
13584  HAPI_PDG_WorkItemId workitem_id,
13585  HAPI_PDG_WorkItemOutputFile * resultinfo_array,
13586  int resultinfo_count );
13587 
13588 /// @brief Creates a new pending work item for the given node. The work item
13589 /// will not be submitted to the graph until it is committed with
13590 /// ::HAPI_CommitWorkItems(). The node is expected to be a generator type.
13591 ///
13592 /// @ingroup PDG
13593 ///
13594 /// @param[in] session
13595 /// The session of Houdini you are interacting with.
13596 /// See @ref HAPI_Sessions for more on sessions.
13597 /// Pass NULL to just use the default in-process session.
13598 /// <!-- default NULL -->
13599 ///
13600 /// @param[in] node_id
13601 /// The node id.
13602 ///
13603 /// @param[out] work_item_id
13604 /// The id of the pending workitem.
13605 ///
13606 /// @param[in] name
13607 /// The null-terminated name of the work item. The name will
13608 /// be automatically suffixed to make it unique.
13609 ///
13610 /// @param[in] index
13611 /// The index of the work item. The semantics of the index
13612 /// are user defined.
13613 ///
13614 HAPI_DECL HAPI_CreateWorkItem( const HAPI_Session * session,
13615  HAPI_NodeId node_id,
13616  HAPI_PDG_WorkItemId * work_item_id,
13617  const char * name,
13618  int index );
13619 
13620 /// @brief Retrieves the info of a given work item by id.
13621 ///
13622 /// @ingroup PDG
13623 ///
13624 /// @param[in] session
13625 /// The session of Houdini you are interacting with.
13626 /// See @ref HAPI_Sessions for more on sessions.
13627 /// Pass NULL to just use the default in-process session.
13628 /// <!-- default NULL -->
13629 ///
13630 /// @param[in] graph_context_id
13631 /// The graph context that the work item is in.
13632 ///
13633 /// @param[in] work_item_id
13634 /// The id of the work item.
13635 ///
13636 /// @param[out] work_item_info
13637 /// The returned ::HAPI_PDG_WorkItemInfo for the work item. Note
13638 /// that the enclosed string handle is only valid until the next
13639 /// call to this function.
13640 ///
13642  HAPI_PDG_GraphContextId graph_context_id,
13643  HAPI_PDG_WorkItemId work_item_id,
13644  HAPI_PDG_WorkItemInfo * work_item_info );
13645 
13646 /// @brief Adds integer data to a pending PDG work item attribute for the given node.
13647 ///
13648 /// @ingroup PDG
13649 ///
13650 /// @param[in] session
13651 /// The session of Houdini you are interacting with.
13652 /// See @ref HAPI_Sessions for more on sessions.
13653 /// Pass NULL to just use the default in-process session.
13654 /// <!-- default NULL -->
13655 ///
13656 /// @param[in] node_id
13657 /// The node id.
13658 ///
13659 /// @param[in] work_item_id
13660 /// The id of the pending work item returned by ::HAPI_CreateWorkItem()
13661 ///
13662 /// @param[in] attribute_name
13663 /// null-terminated name of the work item attribute
13664 ///
13665 /// @param[in] values_array
13666 /// array of integer values
13667 ///
13668 /// @param[in] length
13669 /// number of values to copy from values_array to the parameter
13670 ///
13672  HAPI_NodeId node_id,
13673  HAPI_PDG_WorkItemId work_item_id,
13674  const char * attribute_name,
13675  const int * values_array,
13676  int length );
13677 
13678 /// @brief Adds float data to a pending PDG work item attribute for the given node.
13679 ///
13680 /// @ingroup PDG
13681 ///
13682 /// @param[in] session
13683 /// The session of Houdini you are interacting with.
13684 /// See @ref HAPI_Sessions for more on sessions.
13685 /// Pass NULL to just use the default in-process session.
13686 /// <!-- default NULL -->
13687 ///
13688 /// @param[in] node_id
13689 /// The node id.
13690 ///
13691 /// @param[in] work_item_id
13692 /// The id of the pending work item returned by ::HAPI_CreateWorkItem()
13693 ///
13694 /// @param[in] attribute_name
13695 /// null-terminated name of the work item attribute
13696 ///
13697 /// @param[in] values_array
13698 /// array of float values
13699 ///
13700 /// @param[in] length
13701 /// number of values to copy from values_array to the parameter
13702 ///
13704  HAPI_NodeId node_id,
13705  HAPI_PDG_WorkItemId work_item_id,
13706  const char * attribute_name,
13707  const float * values_array,
13708  int length );
13709 
13710 /// @brief Adds integer data to a pending PDG work item attribute for the given node.
13711 ///
13712 /// @ingroup PDG
13713 ///
13714 /// @param[in] session
13715 /// The session of Houdini you are interacting with.
13716 /// See @ref HAPI_Sessions for more on sessions.
13717 /// Pass NULL to just use the default in-process session.
13718 /// <!-- default NULL -->
13719 ///
13720 /// @param[in] node_id
13721 /// The node id.
13722 ///
13723 /// @param[in] work_item_id
13724 /// The id of the created work item returned by HAPI_CreateWorkItem()
13725 ///
13726 /// @param[in] attribute_name
13727 /// null-terminated name of the work item attribute
13728 ///
13729 /// @param[in] data_index
13730 /// index of the string data member
13731 ///
13732 /// @param[in] value
13733 /// null-terminated string to copy to the work item data member
13734 ///
13736  HAPI_NodeId node_id,
13737  HAPI_PDG_WorkItemId work_item_id,
13738  const char * attribute_name,
13739  int data_index,
13740  const char * value );
13741 
13742 /// @brief Commits any pending work items.
13743 ///
13744 /// @ingroup PDG
13745 ///
13746 /// @param[in] session
13747 /// The session of Houdini you are interacting with.
13748 /// See @ref HAPI_Sessions for more on sessions.
13749 /// Pass NULL to just use the default in-process session.
13750 /// <!-- default NULL -->
13751 ///
13752 /// @param[in] node_id
13753 /// The node id for which the pending work items have been
13754 /// created but not yet injected.
13755 ///
13757  HAPI_NodeId node_id );
13758 
13759 /// @brief Gets the number of work items that are available on the given node.
13760 /// Should be used with ::HAPI_GetWorkItems.
13761 ///
13762 /// @ingroup PDG
13763 ///
13764 /// @param[in] session
13765 /// The session of Houdini you are interacting with.
13766 /// See @ref HAPI_Sessions for more on sessions.
13767 /// Pass NULL to just use the default in-process session.
13768 /// <!-- default NULL -->
13769 ///
13770 /// @param[in] node_id
13771 /// The node id.
13772 ///
13773 /// @param[out] num
13774 /// The number of work items.
13775 ///
13777  HAPI_NodeId node_id,
13778  int * num );
13779 
13780 /// @brief Gets the list of work item ids for the given node
13781 ///
13782 /// @ingroup PDG
13783 ///
13784 /// @param[in] session
13785 /// The session of Houdini you are interacting with.
13786 /// See @ref HAPI_Sessions for more on sessions.
13787 /// Pass NULL to just use the default in-process session.
13788 /// <!-- default NULL -->
13789 ///
13790 /// @param[in] node_id
13791 /// The node id.
13792 ///
13793 /// @param[out] work_item_ids_array
13794 /// buffer for resulting array of ::HAPI_PDG_WorkItemId
13795 ///
13796 /// @param[in] length
13797 /// The length of the @p work_item_ids buffer
13798 ///
13799 HAPI_DECL HAPI_GetWorkItems( const HAPI_Session * session,
13800  HAPI_NodeId node_id,
13801  int * work_item_ids_array,
13802  int length );
13803 
13804 /// @brief Gets the size of the work item attribute.
13805 /// It is the length of the array of data.
13806 ///
13807 /// @ingroup PDG
13808 ///
13809 /// @param[in] session
13810 /// The session of Houdini you are interacting with.
13811 /// See @ref HAPI_Sessions for more on sessions.
13812 /// Pass NULL to just use the default in-process session.
13813 /// <!-- default NULL -->
13814 ///
13815 /// @param[in] node_id
13816 /// The node id.
13817 ///
13818 /// @param[in] work_item_id
13819 /// The id of the work item
13820 ///
13821 /// @param[in] attribute_name
13822 /// null-terminated name of the work item attribute
13823 ///
13824 /// @param[out] length
13825 /// The length of the data member array
13826 ///
13828  HAPI_NodeId node_id,
13829  HAPI_PDG_WorkItemId work_item_id,
13830  const char * attribute_name,
13831  int * length );
13832 
13833 /// @brief Gets int data from a work item attribute.
13834 ///
13835 /// @ingroup PDG
13836 ///
13837 /// @param[in] session
13838 /// The session of Houdini you are interacting with.
13839 /// See @ref HAPI_Sessions for more on sessions.
13840 /// Pass NULL to just use the default in-process session.
13841 /// <!-- default NULL -->
13842 ///
13843 /// @param[in] node_id
13844 /// The node id.
13845 ///
13846 /// @param[in] work_item_id
13847 /// The id of the work_item
13848 ///
13849 /// @param[in] attribute_name
13850 /// null-terminated name of the work item attribute
13851 ///
13852 /// @param[out] data_array
13853 /// buffer of at least size length to copy the data into. The required
13854 /// length should be determined by ::HAPI_GetWorkItemDataLength().
13855 ///
13856 /// @param[in] length
13857 /// The length of @p data_array
13858 ///
13860  HAPI_NodeId node_id,
13861  HAPI_PDG_WorkItemId work_item_id,
13862  const char * attribute_name,
13863  int * data_array,
13864  int length );
13865 
13866 /// @brief Gets float data from a work item attribute.
13867 ///
13868 /// @ingroup PDG
13869 ///
13870 /// @param[in] session
13871 /// The session of Houdini you are interacting with.
13872 /// See @ref HAPI_Sessions for more on sessions.
13873 /// Pass NULL to just use the default in-process session.
13874 /// <!-- default NULL -->
13875 ///
13876 /// @param[in] node_id
13877 /// The node id.
13878 ///
13879 /// @param[in] work_item_id
13880 /// The id of the work_item
13881 ///
13882 /// @param[in] attribute_name
13883 /// null-terminated name of the work item attribute
13884 ///
13885 /// @param[out] data_array
13886 /// buffer of at least size length to copy the data into. The required
13887 /// length should be determined by ::HAPI_GetWorkItemDataLength().
13888 ///
13889 /// @param[in] length
13890 /// The length of the @p data_array
13891 ///
13893  HAPI_NodeId node_id,
13894  HAPI_PDG_WorkItemId work_item_id,
13895  const char * attribute_name,
13896  float * data_array,
13897  int length );
13898 
13899 /// @brief Gets string ids from a work item attribute.
13900 ///
13901 /// @ingroup PDG
13902 ///
13903 /// @param[in] session
13904 /// The session of Houdini you are interacting with.
13905 /// See @ref HAPI_Sessions for more on sessions.
13906 /// Pass NULL to just use the default in-process session.
13907 /// <!-- default NULL -->
13908 ///
13909 /// @param[in] node_id
13910 /// The node id.
13911 ///
13912 /// @param[in] work_item_id
13913 /// The id of the work item
13914 ///
13915 /// @param[in] attribute_name
13916 /// null-terminated name of the work item attribute
13917 ///
13918 /// @param[out] data_array
13919 /// buffer of at least size length to copy the data into. The required
13920 /// length should be determined by ::HAPI_GetWorkItemDataLength().
13921 /// The data is an array of ::HAPI_StringHandle which can be used with
13922 /// ::HAPI_GetString(). The string handles are valid until the
13923 /// next call to this function.
13924 ///
13925 /// @param[in] length
13926 /// The length of @p data_array
13927 ///
13929  HAPI_NodeId node_id,
13930  HAPI_PDG_WorkItemId work_item_id,
13931  const char * attribute_name,
13932  HAPI_StringHandle * data_array,
13933  int length );
13934 
13935 /// @brief Gets the info for work item output files.
13936 /// The number of work item results is found on the ::HAPI_PDG_WorkItemInfo
13937 /// returned by ::HAPI_GetWorkItemInfo()
13938 ///
13939 /// @ingroup PDG
13940 ///
13941 /// @param[in] session
13942 /// The session of Houdini you are interacting with.
13943 /// See @ref HAPI_Sessions for more on sessions.
13944 /// Pass NULL to just use the default in-process session.
13945 /// <!-- default NULL -->
13946 ///
13947 /// @param[in] node_id
13948 /// The node id.
13949 ///
13950 /// @param[in] work_item_id
13951 /// The id of the work item
13952 ///
13953 /// @param[out] resultinfo_array
13954 /// Buffer to fill with info structs. String handles are valid
13955 /// until the next call of this function.
13956 ///
13957 /// @param[in] resultinfo_count
13958 /// The length of @p resultinfo_array
13959 ///
13961  HAPI_NodeId node_id,
13962  HAPI_PDG_WorkItemId work_item_id,
13963  HAPI_PDG_WorkItemOutputFile * resultinfo_array,
13964  int resultinfo_count );
13965 
13966 /// @brief Dirties the given node. Cancels the cook if necessary and then
13967 /// deletes all workitems on the node.
13968 ///
13969 /// @ingroup PDG
13970 ///
13971 /// @param[in] session
13972 /// The session of Houdini you are interacting with.
13973 /// See @ref HAPI_Sessions for more on sessions.
13974 /// Pass NULL to just use the default in-process session.
13975 /// <!-- default NULL -->
13976 ///
13977 /// @param[in] node_id
13978 /// The node id.
13979 ///
13980 /// @param[in] clean_results
13981 /// Remove the results generated by the node.
13982 /// <!-- default 0 -->
13983 ///
13984 HAPI_DECL HAPI_DirtyPDGNode( const HAPI_Session * session,
13985  HAPI_NodeId node_id,
13986  HAPI_Bool clean_results );
13987 
13988 /// @brief Pause the PDG cooking operation.
13989 ///
13990 /// @ingroup PDG
13991 ///
13992 /// @param[in] session
13993 /// The session of Houdini you are interacting with.
13994 /// See @ref HAPI_Sessions for more on sessions.
13995 /// Pass NULL to just use the default in-process session.
13996 /// <!-- default NULL -->
13997 ///
13998 /// @param[in] graph_context_id
13999 /// The id of the graph context
14000 ///
14001 HAPI_DECL HAPI_PausePDGCook( const HAPI_Session * session,
14002  HAPI_PDG_GraphContextId graph_context_id );
14003 
14004 /// @brief Cancel the PDG cooking operation.
14005 ///
14006 /// @ingroup PDG
14007 ///
14008 /// @param[in] session
14009 /// The session of Houdini you are interacting with.
14010 /// See @ref HAPI_Sessions for more on sessions.
14011 /// Pass NULL to just use the default in-process session.
14012 /// <!-- default NULL -->
14013 ///
14014 /// @param[in] graph_context_id
14015 /// The id of the graph context
14016 ///
14017 HAPI_DECL HAPI_CancelPDGCook( const HAPI_Session * session,
14018  HAPI_PDG_GraphContextId graph_context_id );
14019 
14020 #endif // __HAPI_h__
HAPI_DECL HAPI_SetAttributeInt64ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int64 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set 64-bit integer array attribute data asynchronously.
HAPI_DECL HAPI_DeleteNode(const HAPI_Session *session, HAPI_NodeId node_id)
Delete a node from a node network. Only nodes with their HAPI_NodeInfo::createdPostAssetLoad set to t...
HAPI_DECL HAPI_AddAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info)
Add an attribute.
HAPI_DECL HAPI_GetWorkItemFloatAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, float *data_array, int length)
Gets float data from a work item attribute.
HAPI_DECL HAPI_SetAttributeFloatDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const float *data_array, int start, int length, int *job_id)
Set attribute float data asynchronously.
HAPI_DECL HAPI_GetAttributeStringData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_array, int start, int length)
Get attribute string data. Note that the string handles returned are only valid until the next time t...
HAPI_DECL HAPI_GetVolumeTileFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, float fill_value, const HAPI_VolumeTileInfo *tile, float *values_array, int length)
Retrieve floating point values of the voxels pointed to by a tile. Note that a tile may extend beyond...
HAPI_DECL HAPI_SetParmIntValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, int value)
Set single parm int value by name.
HAPI_DECL HAPI_GetSphereInfo(const HAPI_Session *session, HAPI_NodeId geo_node_id, HAPI_PartId part_id, HAPI_SphereInfo *sphere_info)
Get the sphere info on a geo part (if the part is a sphere).
HAPI_DECL HAPI_GetParmInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, HAPI_ParmInfo *parm_info)
Get the parm info of a parameter by parm id.
Data for an image, used with HAPI_GetImageInfo() and HAPI_SetImageInfo()
Definition: HAPI_Common.h:1840
HAPI_DECL HAPI_SetAttributeInt8DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int8 *data_array, int start, int length, int *job_id)
Set 8-bit attribute integer data asynchronously.
HAPI_DECL HAPI_GetImageFilePath(const HAPI_Session *session, HAPI_NodeId material_node_id, const char *image_file_format_name, const char *image_planes, const char *destination_folder_path, const char *destination_file_name, HAPI_ParmId texture_parm_id, int *destination_file_path)
Get the file name that this image would be saved to.
HAPI_DECL HAPI_GetAttributeInt16ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, HAPI_Int16 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute 16-bit integer data asynchronously. Each entry in an array attribute can have var...
HAPI_DECL HAPI_LoadNodeFromFile(const HAPI_Session *session, const char *file_name, HAPI_NodeId parent_node_id, const char *node_label, HAPI_Bool cook_on_load, HAPI_NodeId *new_node_id)
Loads and creates a previously saved node and all its contents from given file. The saved file must h...
HAPI_DECL HAPI_GetStringBatchSize(const HAPI_Session *session, const int *string_handle_array, int string_handle_count, int *string_buffer_size)
Gives back the length of the buffer needed to hold all the values null-separated for the given string...
HAPI_DECL HAPI_GetNodeFromPath(const HAPI_Session *session, const HAPI_NodeId parent_node_id, const char *path, HAPI_NodeId *node_id)
Get the id of the node with the specified path.
HAPI_DECL HAPI_GetStringBatch(const HAPI_Session *session, char *char_buffer, int char_array_length)
Gives back the values of the given string handles. The given char array is filled with null-separated...
HAPI_DECL HAPI_SetAnimCurve(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int parm_index, const HAPI_Keyframe *curve_keyframes_array, int keyframe_count)
Set an animation curve on a parameter of an exposed node.
HAPI_DECL HAPI_SetAttributeUInt8UniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute unsigned 8-bit int data to the same unique value asynchronously.
HAPI_DECL HAPI_SaveGeoToFile(const HAPI_Session *session, HAPI_NodeId node_id, const char *file_name)
Saves a geometry to file. The type of file to save is to be determined by the extension ie...
HAPI_DECL HAPI_GetAttributeUInt8ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_UInt8 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute unsigned 8-bit integer data. Each entry in an array attribute can have varying ar...
HAPI_JobStatus
Definition: HAPI_Common.h:232
HAPI_DECL HAPI_SetNodeDisplay(const HAPI_Session *session, HAPI_NodeId node_id, int onOff)
Set the specified node's display flag.
HAPI_DECL HAPI_GetNodeCookResultLength(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_StatusVerbosity verbosity, int *buffer_length)
Gets the length of the cook result string (errors and warnings) of a specific node.
HAPI_DECL HAPI_SetAttributeInt64UniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int64 *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute 64-bit int data to the same unique value.
int HAPI_NodeTypeBits
Definition: HAPI_Common.h:516
HAPI_DECL HAPI_GetPDGGraphContextId(const HAPI_Session *session, HAPI_NodeId top_node_id, HAPI_PDG_GraphContextId *context_id)
Get the PDG graph context for the specified TOP node.
HAPI_DECL HAPI_GetServerEnvVarList(const HAPI_Session *session, HAPI_StringHandle *values_array, int start, int length)
Provides a list of all of the environment variables in the server's process.
HAPI_DECL HAPI_GetAttributeInt8DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int8 *data_array, int start, int length, int *job_id)
Get attribute 8-bit integer data asynchronously.
int16_t HAPI_Int16
Definition: HAPI_Common.h:142
Data for a PDG output file.
Definition: HAPI_Common.h:2086
HAPI_DECL HAPI_AddGroup(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_GroupType group_type, const char *group_name)
Add a group to the input geo with the given type and name.
HAPI_DECL HAPI_GetGroupNames(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_GroupType group_type, HAPI_StringHandle *group_names_array, int group_count)
Get group names for an entire geo. Please note that this function is NOT per-part, but it is per-geo. The companion function HAPI_GetGroupMembership() IS per-part. Also keep in mind that the name string handles are only valid until the next time this function is called.
HAPI_GetWorkitemStringData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, HAPI_StringHandle *data_array, int length)
Gets string ids from a work item member.
HAPI_DECL HAPI_LoadGeoFromMemory(const HAPI_Session *session, HAPI_NodeId node_id, const char *format, const char *buffer, int length)
Loads a geometry from memory and put its contents onto a SOP node.
HAPI_DECL HAPI_SetAttributeDictionaryData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_array, int start, int length)
Set attribute dictionary data. The dictionary data should be provided as JSON-encoded strings...
HAPI_DECL HAPI_SetParmExpression(const HAPI_Session *session, HAPI_NodeId node_id, const char *value, HAPI_ParmId parm_id, int index)
Set (push) an expression string. We can only set a single value at a time because we want to avoid fi...
HAPI_DECL HAPI_GetParmFloatValues(const HAPI_Session *session, HAPI_NodeId node_id, float *values_array, int start, int length)
Fill an array of parameter float values. This is more efficient than calling HAPI_GetParmFloatValue()...
HAPI_DECL HAPI_GetAttributeInt16ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_Int16 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute 16-bit integer data. Each entry in an array attribute can have varying array leng...
HAPI_DECL HAPI_GetActiveCacheNames(const HAPI_Session *session, HAPI_StringHandle *cache_names_array, int active_cache_count)
Get the names of the currently active caches.
int HAPI_PDG_WorkItemId
Use this with PDG functions.
Definition: HAPI_Common.h:176
HAPI_DECL HAPI_GetMessageNodeIds(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_NodeId *message_node_ids_array, int count)
Get the ids of message nodes set in the "Type Properties".
HAPI_DECL HAPI_GetAttributeFloatDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, float *data_array, int start, int length, int *job_id)
Get attribute float data asynchronously.
HAPI_DECL HAPI_GetParameters(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmInfo *parm_infos_array, int start, int length)
Fill an array of HAPI_ParmInfo structs with parameter information from the asset instance node...
HAPI_DECL HAPI_ConvertTransformEulerToMatrix(const HAPI_Session *session, const HAPI_TransformEuler *transform, float *matrix)
Converts HAPI_TransformEuler into a 4x4 transform matrix.
HAPI_DECL HAPI_ParmHasExpression(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, HAPI_Bool *has_expression)
See if a parameter has an expression.
HAPI_SetWorkitemFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, const float *values_array, int length)
Adds float data to a pending PDG workitem data member for the given node.
int HAPI_PDG_GraphContextId
Use this with PDG functions.
Definition: HAPI_Common.h:182
HAPI_DECL HAPI_GetPDGGraphContexts(const HAPI_Session *session, HAPI_StringHandle *context_names_array, HAPI_PDG_GraphContextId *context_id_array, int start, int length)
Return an array of PDG graph context names and ids, the first count names will be returned...
HAPI_DECL HAPI_ConvertTransform(const HAPI_Session *session, const HAPI_TransformEuler *transform_in, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, HAPI_TransformEuler *transform_out)
Converts the transform described by a HAPI_TransformEuler struct into a different transform and rotat...
HAPI_DECL HAPI_SetAttributeIntArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const int *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set integer array attribute data asynchronously.
HAPI_DECL HAPI_GetAttributeStringArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute string data asynchronously. Each entry in an array attribute can have varying arr...
HAPI_SessionEnvIntType
Definition: HAPI_Common.h:861
HAPI_DECL HAPI_RevertGeo(const HAPI_Session *session, HAPI_NodeId node_id)
Remove all changes that have been committed to this geometry. If this is an intermediate result node ...
HAPI_DECL HAPI_GetAvailableAssetCount(const HAPI_Session *session, HAPI_AssetLibraryId library_id, int *asset_count)
Get the number of assets contained in an asset library. You should call HAPI_LoadAssetLibraryFromFile...
HAPI_DECL HAPI_GetAttributeInt64ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_Int64 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute 64-bit integer data. Each entry in an array attribute can have varying array leng...
HAPI_DECL HAPI_GetGroupMembership(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_GroupType group_type, const char *group_name, HAPI_Bool *membership_array_all_equal, int *membership_array, int start, int length)
Get group membership.
HAPI_DECL HAPI_GetParmIdFromName(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, HAPI_ParmId *parm_id)
All parameter APIs require a HAPI_ParmId but if you know the parameter you wish to operate on by name...
HAPI_DECL HAPI_SetParmIntValues(const HAPI_Session *session, HAPI_NodeId node_id, const int *values_array, int start, int length)
Set (push) an array of parameter int values.
HAPI_DECL HAPI_GetAttributeFloat64DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, double *data_array, int start, int length, int *job_id)
Get attribute 64-bit float data asynchronously.
HAPI_DECL HAPI_GetAttributeDictionaryDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_array, int start, int length, int *job_id)
Get attribute dictionary data asynchronously.
HAPI_DECL HAPI_SetCacheProperty(const HAPI_Session *session, const char *cache_name, HAPI_CacheProperty cache_property, int property_value)
Lets you modify specific properties of the different memory caches in the current Houdini context...
HAPI_DECL HAPI_GetTime(const HAPI_Session *session, float *time)
Gets the global time of the scene. All API calls deal with this time to cook.
HAPI_DECL HAPI_SetAttributeInt8ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int8 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set 8-bit integer array attribute data.
HAPI_DECL HAPI_ConvertTransformQuatToMatrix(const HAPI_Session *session, const HAPI_Transform *transform, float *matrix)
Converts HAPI_Transform into a 4x4 transform matrix.
HAPI_DECL HAPI_GetAttributeFloat64ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, double *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute 64-bit float data asynchronously. Each entry in an array attribute can have varyi...
HAPI_DECL HAPI_Cleanup(const HAPI_Session *session)
Clean up memory. This will unload all assets and you will need to call HAPI_Initialize() again to be ...
HAPI_DECL HAPI_SetAttributeFloatUniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const float *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute float data to the same unique value.
HAPI_DECL HAPI_GetAssetInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_AssetInfo *asset_info)
Fill an asset_info struct from a node.
HAPI_DECL HAPI_GetAttributeUInt8ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, HAPI_UInt8 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute unsigned 8-bit integer data asynchronously. Each entry in an array attribute can ...
HAPI_DECL HAPI_IsSessionValid(const HAPI_Session *session)
Checks whether the session identified by HAPI_Session::id is a valid session opened in the implementa...
HAPI_DECL HAPI_GetAttributeStringArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute string data. Each entry in an array attribute can have varying array lengths...
HAPI_DECL HAPI_SetParmFloatValues(const HAPI_Session *session, HAPI_NodeId node_id, const float *values_array, int start, int length)
Set (push) an array of parameter float values.
HAPI_DECL HAPI_GetFirstVolumeTile(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_VolumeTileInfo *tile)
Iterate through a volume based on 8x8x8 sections of the volume Start iterating through the value of t...
HAPI_DECL HAPI_GetServerEnvString(const HAPI_Session *session, const char *variable_name, HAPI_StringHandle *value)
Get environment variable from the server process as a string.
HAPI_DECL HAPI_GetFaceCounts(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int *face_counts_array, int start, int length)
Get the array of faces where the nth integer in the array is the number of vertices the nth face has...
HAPI_DECL HAPI_CreateThriftSharedMemorySession(HAPI_Session *session, const char *shared_mem_name, const HAPI_SessionInfo *session_info)
Creates a Thrift RPC session using a shared memory buffer as the transport mechanism.
HAPI_DECL HAPI_SetVertexList(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const int *vertex_list_array, int start, int length)
Set array containing the vertex-point associations where the ith element in the array is the point in...
HAPI_DECL HAPI_GetInputCurveInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_InputCurveInfo *info)
Retrieve meta-data about the input curves, including the curve's type, order, and whether or not the ...
HAPI_DECL HAPI_GetNumWorkItems(const HAPI_Session *session, HAPI_NodeId node_id, int *num)
Gets the number of work items that are available on the given node. Should be used with HAPI_GetWorkI...
HAPI_DECL HAPI_SetVolumeTileFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const HAPI_VolumeTileInfo *tile, const float *values_array, int length)
Set the values of a float tile: this is an 8x8x8 subsection of the volume.
HAPI_DECL HAPI_GetGeoSize(const HAPI_Session *session, HAPI_NodeId node_id, const char *format, int *size)
Cache the current state of the geo to memory, given the format, and return the size. Use this size with your call to HAPI_SaveGeoToMemory() to copy the cached geo to your buffer. It is guaranteed that the size will not change between your call to HAPI_GetGeoSize() and HAPI_SaveGeoToMemory().
HAPI_RSTOrder
Definition: HAPI_Common.h:766
HAPI_DECL HAPI_SetAttributeUInt8Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_array, int start, int length)
Set unsigned 8-bit attribute integer data.
HAPI_DECL HAPI_GetParmFloatValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, float *value)
Get single parm float value by name.
HAPI_DECL HAPI_SetAttributeFloatArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const float *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set float array attribute data asynchronously.
HAPI_DECL HAPI_GetImagePlaneCount(const HAPI_Session *session, HAPI_NodeId material_node_id, int *image_plane_count)
Get the number of image planes for the just rendered image.
HAPI_DECL HAPI_CreateHeightFieldInput(const HAPI_Session *session, HAPI_NodeId parent_node_id, const char *name, int xsize, int ysize, float voxelsize, HAPI_HeightFieldSampling sampling, HAPI_NodeId *heightfield_node_id, HAPI_NodeId *height_node_id, HAPI_NodeId *mask_node_id, HAPI_NodeId *merge_node_id)
Creates the required node hierarchy needed for heightfield inputs.
HAPI_DECL HAPI_GetVertexList(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int *vertex_list_array, int start, int length)
Get array containing the vertex-point associations where the ith element in the array is the point in...
HAPI_DECL HAPI_GetVolumeVisualInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_VolumeVisualInfo *visual_info)
Retrieve the visualization meta-data of the volume.
int HAPI_HIPFileId
Definition: HAPI_Common.h:186
HAPI_DECL HAPI_SetCompositorOptions(const HAPI_Session *session, const HAPI_CompositorOptions *compositor_options)
Sets the global compositor options.
HAPI_DECL HAPI_SetAttributeStringUniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute string data to the same unique value asynchronously.
HAPI_DECL HAPI_GetStringBufLength(const HAPI_Session *session, HAPI_StringHandle string_handle, int *buffer_length)
Gives back the string length of the string with the given handle.
HAPI_DECL HAPI_GetComposedChildNodeList(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_NodeId *child_node_ids_array, int count)
Get the composed list of child node ids from the previous call to HAPI_ComposeChildNodeList().
HAPI_DECL HAPI_GetStatusStringBufLength(const HAPI_Session *session, HAPI_StatusType status_type, HAPI_StatusVerbosity verbosity, int *buffer_length)
Return length of string buffer storing status string message.
HAPI_EnvIntType
Definition: HAPI_Common.h:828
HAPI_DECL HAPI_CreateWorkItem(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId *work_item_id, const char *name, int index)
Creates a new pending work item for the given node. The work item will not be submitted to the graph ...
HAPI_DECL HAPI_GetSupportedImageFileFormats(const HAPI_Session *session, HAPI_ImageFileFormat *formats_array, int file_format_count)
Get a list of support image file formats - their names, descriptions and a list of recognized extensi...
HAPI_DECL HAPI_SetAttributeFloat64ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const double *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set 64-bit float array attribute data.
HAPI_GetNumWorkitems(const HAPI_Session *session, HAPI_NodeId node_id, int *num)
Gets the number of workitems that are available on the given node. Should be used with HAPI_GetWorkit...
HAPI_DECL HAPI_StartThriftNamedPipeServer(const HAPI_ThriftServerOptions *options, const char *pipe_name, HAPI_ProcessId *process_id, const char *log_file)
Starts a Thrift RPC server process on the local host serving clients on a Windows named pipe or a Uni...
HAPI_DECL HAPI_GetParmNodeValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, HAPI_NodeId *value)
Get a single node id parm value of an Op Path parameter. This is how you see which node is connected ...
HAPI_DECL HAPI_SetCustomString(const HAPI_Session *session, const char *string_value, HAPI_StringHandle *handle_value)
Adds the given string to the string table and returns the handle. It is the responsibility of the cal...
HAPI_DECL HAPI_SetParmNodeValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, HAPI_NodeId value)
Set a node id parm value of an Op Path parameter. For example, This is how you connect the geometry o...
HAPI_DECL HAPI_RevertParmToDefault(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index)
Revert single parm by name to default.
HAPI_DECL HAPI_GetPDGState(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id, int *pdg_state)
Gets the state of a PDG graph.
HAPI_DECL HAPI_SetAttributeIntDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const int *data_array, int start, int length, int *job_id)
Set attribute integer data asynchronously.
HAPI_DECL HAPI_SetAttributeIntUniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const int *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute int data to the same unique value.
HAPI_DECL HAPI_GetBoxInfo(const HAPI_Session *session, HAPI_NodeId geo_node_id, HAPI_PartId part_id, HAPI_BoxInfo *box_info)
Get the box info on a geo part (if the part is a box).
HAPI_GetWorkitemFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, float *data_array, int length)
Gets float data from a work item member.
HAPI_DECL HAPI_GetMessageNodeCount(const HAPI_Session *session, HAPI_NodeId node_id, int *count)
Get the number of message nodes set in "Type Properties".
HAPI_DECL HAPI_ExtractImageToFile(const HAPI_Session *session, HAPI_NodeId material_node_id, const char *image_file_format_name, const char *image_planes, const char *destination_folder_path, const char *destination_file_name, int *destination_file_path)
Extract a rendered image to a file.
HAPI_DECL HAPI_SetVolumeTileIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const HAPI_VolumeTileInfo *tile, const int *values_array, int length)
Set the values of an int tile: this is an 8x8x8 subsection of the volume.
HAPI_DECL HAPI_GetHandleBindingInfo(const HAPI_Session *session, HAPI_NodeId node_id, int handle_index, HAPI_HandleBindingInfo *handle_binding_infos_array, int start, int length)
Fill an array of HAPI_HandleBindingInfo structs with information about the binding of a particular ha...
HAPI_DECL HAPI_GetAttributeInt16Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int16 *data_array, int start, int length)
Get attribute 16-bit integer data.
HAPI_DECL HAPI_Shutdown(const HAPI_Session *session)
When using an in-process session, this method must be called in order for the host process to shutdow...
HAPI_DECL HAPI_QueryNodeOutputConnectedCount(const HAPI_Session *session, HAPI_NodeId node_id, int output_idx, HAPI_Bool into_subnets, HAPI_Bool through_dots, int *connected_count)
Get the number of nodes currently connected to the given node at the output index.
Info for a PDG work item.
Definition: HAPI_Common.h:2069
HAPI_CreateWorkitem(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId *workitem_id, const char *name, int index)
Creates a new pending workitem for the given node. The workitem will not be submitted to the graph un...
HAPI_DECL HAPI_SetAttributeInt8ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int8 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set 8-bit integer array attribute data asynchronously.
HAPI_DECL HAPI_SetAttributeInt64DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int64 *data_array, int start, int length, int *job_id)
Set 64-bit attribute integer data asynchronously.
HAPI_DECL HAPI_GetImageInfo(const HAPI_Session *session, HAPI_NodeId material_node_id, HAPI_ImageInfo *image_info)
Get information about the image that was just rendered, like resolution and default file format...
HAPI_DECL HAPI_GetImagePlanes(const HAPI_Session *session, HAPI_NodeId material_node_id, HAPI_StringHandle *image_planes_array, int image_plane_count)
Get the names of the image planes of the just rendered image.
HAPI_DECL HAPI_SetTimelineOptions(const HAPI_Session *session, const HAPI_TimelineOptions *timeline_options)
Sets the global timeline options.
HAPI_DECL HAPI_SetAttributeIntArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const int *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set integer array attribute data.
HAPI_DECL HAPI_SetAttributeStringData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_array, int start, int length)
Set attribute string data.
HAPI_DECL HAPI_GetObjectInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ObjectInfo *object_info)
Get the object info on an OBJ node.
HAPI_DECL HAPI_GetAttributeIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, int *data_array, int start, int length)
Get attribute integer data.
HAPI_DECL HAPI_GetParmIntValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, int *value)
Get single parm int value by name.
HAPI_DECL HAPI_SetViewport(const HAPI_Session *session, const HAPI_Viewport *viewport)
Set the HAPI_Viewport info for synchronizing viewport in SessionSync. When SessionSync is running...
HAPI_DECL HAPI_GetCookingTotalCount(const HAPI_Session *session, int *count)
Get total number of nodes that need to cook in the current session.
HAPI_DECL HAPI_GetNodePath(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_NodeId relative_to_node_id, HAPI_StringHandle *path)
Get the node absolute path in the Houdini node network or a relative path any other node...
HAPI_DECL HAPI_GetOutputGeoInfos(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_GeoInfo *geo_infos_array, int count)
Gets the geometry info structs (HAPI_GeoInfo) for a node's main geometry outputs. This method can onl...
HAPI_DECL HAPI_GetAttributeInt8Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int8 *data_array, int start, int length)
Get attribute 8-bit integer data.
HAPI_DECL HAPI_GetAttributeFloat64ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, double *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute 64-bit float data. Each entry in an array attribute can have varying array length...
HAPI_DECL HAPI_ConvertMatrixToQuat(const HAPI_Session *session, const float *matrix, HAPI_RSTOrder rst_order, HAPI_Transform *transform_out)
Converts a 4x4 matrix into its TRS form.
HAPI_GetWorkitemDataLength(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, int *length)
Gets the length of the workitem data member. It is the length of the array of data.
HAPI_DECL HAPI_GetParmTagName(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int tag_index, HAPI_StringHandle *tag_name)
Get the tag name on a parameter given an index.
Meta-data about an HDA, returned by HAPI_GetAssetInfo()
Definition: HAPI_Common.h:1187
HAPI_DECL HAPI_SetAttributeInt16Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int16 *data_array, int start, int length)
Set 16-bit attribute integer data.
HAPI_DECL HAPI_DeleteAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info)
Delete an attribute from an input geo.
HAPI_AttributeOwner
Definition: HAPI_Common.h:568
HAPI_DECL HAPI_ResetSimulation(const HAPI_Session *session, HAPI_NodeId node_id)
Resets the simulation cache of the asset. This is very useful for assets that use dynamics...
HAPI_DECL HAPI_GetAttributeIntDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, int *data_array, int start, int length, int *job_id)
Get attribute integer data asynchronously.
HAPI_DECL HAPI_GetAssetDefinitionParmCounts(const HAPI_Session *session, HAPI_AssetLibraryId library_id, const char *asset_name, int *parm_count, int *int_value_count, int *float_value_count, int *string_value_count, int *choice_value_count)
Get the number of asset parameters contained in an asset library, as well as the number of parameter ...
HAPI_DECL HAPI_GetInstancerPartTransforms(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_RSTOrder rst_order, HAPI_Transform *transforms_array, int start, int length)
Get the instancer part's list of transforms on which to instance the instanced parts you got from HAP...
HAPI_DECL HAPI_CloseSession(const HAPI_Session *session)
Closes a session. If the session has been established using RPC, then the RPC connection is closed...
HAPI_DECL HAPI_GetOutputGeoCount(const HAPI_Session *session, HAPI_NodeId node_id, int *count)
A helper method that gets the number of main geometry outputs inside an Object node or SOP node...
HAPI_DECL HAPI_GetTimelineOptions(const HAPI_Session *session, HAPI_TimelineOptions *timeline_options)
Gets the current global timeline options.
HAPI_DECL HAPI_ComposeChildNodeList(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_NodeTypeBits node_type_filter, HAPI_NodeFlagsBits node_flags_filter, HAPI_Bool recursive, int *count)
Compose a list of child nodes based on given filters.
HAPI_DECL HAPI_SetAttributeInt8UniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int8 *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute 8-bit int data to the same unique value.
HAPI_DECL HAPI_GetImageMemoryBuffer(const HAPI_Session *session, HAPI_NodeId material_node_id, char *buffer, int length)
Fill your allocated buffer with the just extracted image buffer.
HAPI_DECL HAPI_SetAttributeDictionaryArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set attribute dictionary array data. The dictionary data should be provided as JSON-encoded strings...
HAPI_DECL HAPI_StartPerformanceMonitorProfile(const HAPI_Session *session, const char *title, int *profile_id)
Start a Houdini Performance Monitor profile. A profile records time and memory statistics from events...
HAPI_DECL HAPI_GetAttributeFloatArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, float *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute float data asynchronously. Each entry in an array attribute can have varying arra...
HAPI_DECL HAPI_SetInputCurveInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const HAPI_InputCurveInfo *info)
Set meta-data for the input curves, including the curve type, order, reverse and closed properties...
HAPI_DECL HAPI_GetComposedObjectTransforms(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_RSTOrder rst_order, HAPI_Transform *transform_array, int start, int length)
Fill an array of HAPI_Transform structs.
HAPI_DECL HAPI_SetAttributeDictionaryDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_array, int start, int length, int *job_id)
Set attribute dictionary data asynchronously. The dictionary data should be provided as JSON-encoded ...
HAPI_DECL HAPI_PythonThreadInterpreterLock(const HAPI_Session *session, HAPI_Bool locked)
Acquires or releases the Python interpreter lock. This is needed if HAPI is called from Python and HA...
Meta-data for an OBJ Node.
Definition: HAPI_Common.h:1621
HAPI_DECL HAPI_GetAttributeInt8ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_Int8 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute 8-bit integer data. Each entry in an array attribute can have varying array lengt...
HAPI_NodeType
Definition: HAPI_Common.h:501
HAPI_DECL HAPI_GetAttributeFloatArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, float *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute float data. Each entry in an array attribute can have varying array lengths...
HAPI_DECL HAPI_ComposeObjectList(const HAPI_Session *session, HAPI_NodeId parent_node_id, const char *categories, int *object_count)
Compose a list of child object nodes given a parent node id.
HAPI_DECL HAPI_GetAttributeFloat64Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, double *data_array, int start, int length)
Get 64-bit attribute float data.
HAPI_DECL HAPI_GetAttributeUInt8DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_UInt8 *data_array, int start, int length, int *job_id)
Get attribute unsigned 8-bit integer data asynchronously.
HAPI_DECL HAPI_GetVolumeVoxelFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int x_index, int y_index, int z_index, float *values_array, int value_count)
Retrieve floating point values of the voxel at a specific index. Note that you must call HAPI_GetVolu...
HAPI_DECL HAPI_DeleteGroup(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_GroupType group_type, const char *group_name)
Remove a group from the input geo with the given type and name.
int HAPI_StringHandle
Definition: HAPI_Common.h:160
HAPI_DECL HAPI_SetWorkItemFloatAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, const float *values_array, int length)
Adds float data to a pending PDG work item attribute for the given node.
HAPI_StatusVerbosity
Definition: HAPI_Common.h:215
HAPI_DECL HAPI_RenameNode(const HAPI_Session *session, HAPI_NodeId node_id, const char *new_name)
Rename a node that you created. Only nodes with their HAPI_NodeInfo::createdPostAssetLoad set to true...
HAPI_DECL HAPI_GetVolumeInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_VolumeInfo *volume_info)
Retrieve any meta-data about the volume primitive, including its transform, location, scale, taper, resolution.
HAPI_DECL HAPI_SetCurveKnots(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const float *knots_array, int start, int length)
Set the knots of the curves in this part.
HAPI_DECL HAPI_DisconnectNodeOutputsAt(const HAPI_Session *session, HAPI_NodeId node_id, int output_index)
Disconnect all of the node's output connections at the output index.
HAPI_DECL HAPI_GetAttributeDictionaryData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_array, int start, int length)
Get attribute dictionary data.
HAPI_DECL HAPI_RenderTextureToImage(const HAPI_Session *session, HAPI_NodeId material_node_id, HAPI_ParmId parm_id)
Render only a single texture to an image for later extraction. An example use of this method might be...
Options to configure a Thrift server being started from HARC.
Definition: HAPI_Common.h:1144
HAPI_DECL HAPI_CreateThriftNamedPipeSession(HAPI_Session *session, const char *pipe_name, const HAPI_SessionInfo *session_info)
Creates a Thrift RPC session using a Windows named pipe or a Unix domain socket as transport...
HAPI_DECL HAPI_SetAttributeIntUniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const int *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute int data to the same unique value asynchronously.
HAPI_DECL HAPI_CreateInputCurveNode(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_NodeId *node_id, const char *name)
Helper for creating specifically creating a curve input geometry SOP. Inside the specified parent nod...
HAPI_DECL HAPI_SetCurveInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const HAPI_CurveInfo *info)
Set meta-data for the curve mesh, including the curve type, order, and periodicity.
HAPI_DECL HAPI_GetGroupNamesOnPackedInstancePart(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_GroupType group_type, HAPI_StringHandle *group_names_array, int group_count)
Get the group names for a packed instance part This functions allows you to get the group name for a ...
HAPI_GetWorkitemResultInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, HAPI_PDG_WorkItemOutputFile *resultinfo_array, int resultinfo_count)
Gets the info for workitem results. The number of workitem results is found on the HAPI_PDG_WorkItemI...
HAPI_DECL HAPI_SetAttributeInt8Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int8 *data_array, int start, int length)
Set 8-bit attribute integer data.
HAPI_DECL HAPI_SetInputCurvePositionsRotationsScales(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const float *positions_array, int positions_start, int positions_length, const float *rotations_array, int rotations_start, int rotations_length, const float *scales_array, int scales_start, int scales_length)
Sets the positions for input curves, doing checks for curve validity, and adjusting the curve setting...
HAPI_DECL HAPI_SetVolumeVoxelFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int x_index, int y_index, int z_index, const float *values_array, int value_count)
Set the values of a float voxel in the volume.
HAPI_DECL HAPI_GetVolumeBounds(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, float *x_min, float *y_min, float *z_min, float *x_max, float *y_max, float *z_max, float *x_center, float *y_center, float *z_center)
Get the bounding values of a volume.
HAPI_DECL HAPI_GetPreset(const HAPI_Session *session, HAPI_NodeId node_id, char *buffer, int buffer_length)
Generates a preset for the given asset.
HAPI_XYZOrder
Definition: HAPI_Common.h:779
Data associated with a PDG Event.
Definition: HAPI_Common.h:2043
HAPI_DECL HAPI_GetSessionSyncInfo(const HAPI_Session *session, HAPI_SessionSyncInfo *session_sync_info)
Get the HAPI_SessionSyncInfo for synchronizing SessionSync state between Houdini and Houdini Engine i...
HAPI_DECL HAPI_SetAttributeUInt8DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_array, int start, int length, int *job_id)
Set unsigned 8-bit attribute integer data asynchronously.
HAPI_DECL HAPI_GetAttributeFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, float *data_array, int start, int length)
Get attribute float data.
HAPI_DECL HAPI_GetString(const HAPI_Session *session, HAPI_StringHandle string_handle, char *string_value, int length)
Gives back the string value of the string with the given handle.
HAPI_DECL HAPI_GetCurveInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_CurveInfo *info)
Retrieve any meta-data about the curves, including the curve's type, order, and periodicity.
HAPI_DECL HAPI_SetParmStringValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *value, HAPI_ParmId parm_id, int index)
Set (push) a string value. We can only set a single value at a time because we want to avoid fixed si...
HAPI_DECL HAPI_MergeHIPFile(const HAPI_Session *session, const char *file_name, HAPI_Bool cook_on_load, HAPI_HIPFileId *file_id)
Loads a .hip file into the main Houdini scene.
int HAPI_ParmId
Definition: HAPI_Common.h:169
HAPI_DECL HAPI_SetSessionSync(const HAPI_Session *session, HAPI_Bool enable)
Enable or disable SessionSync mode.
Meta-data describing a Geo Part.
Definition: HAPI_Common.h:1714
HAPI_DECL HAPI_CommitGeo(const HAPI_Session *session, HAPI_NodeId node_id)
Commit the current input geometry to the cook engine. Nodes that use this geometry node will re-cook ...
#define HAPI_DECL_DEPRECATED_REPLACE(hapi_ver, houdini_ver, replacement)
Definition: HAPI_API.h:102
HAPI_DECL HAPI_SetAttributeUInt8ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set unsigned 8-bit integer array attribute data asynchronously.
int HAPI_ErrorCodeBits
Definition: HAPI_Common.h:276
HAPI_DECL HAPI_SaveGeoToMemory(const HAPI_Session *session, HAPI_NodeId node_id, char *buffer, int length)
Saves the cached geometry to your buffer in memory, whose format and required size is identified by t...
HAPI_DECL HAPI_QueryNodeInput(const HAPI_Session *session, HAPI_NodeId node_to_query, int input_index, HAPI_NodeId *connected_node_id)
Query which node is connected to another node's input.
HAPI_DECL HAPI_RemoveMultiparmInstance(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int instance_position)
Remove the instance of a multiparm given by instance_position.
HAPI_DECL HAPI_GetPDGEvents(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id, HAPI_PDG_EventInfo *event_array, int length, int *event_count, int *remaining_events)
Returns PDG events that have been collected. Calling this function will remove those events from the ...
HAPI_DECL HAPI_ParmHasTag(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, const char *tag_name, HAPI_Bool *has_tag)
See if a parameter has a specific tag.
HAPI_DECL HAPI_GetParmChoiceLists(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmChoiceInfo *parm_choices_array, int start, int length)
Fill an array of HAPI_ParmChoiceInfo structs with parameter choice list information from the asset in...
HAPI_DECL HAPI_LoadHIPFile(const HAPI_Session *session, const char *file_name, HAPI_Bool cook_on_load)
Loads a .hip file into the main Houdini scene.
HAPI_DECL HAPI_GetAssetLibraryIds(const HAPI_Session *session, HAPI_AssetLibraryId *asset_library_ids_array, int start, int length)
Gets the HAPI_AssetLibraryId's for HDAs that are loaded in Houdini.
HAPI_DECL HAPI_GetJobStatus(const HAPI_Session *session, int job_id, HAPI_JobStatus *job_status)
Get status of a job.
Meta-data for a Houdini Node.
Definition: HAPI_Common.h:1345
HAPI_DECL HAPI_GetWorkItemIntAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, int *data_array, int length)
Gets int data from a work item attribute.
HAPI_DECL HAPI_SetAttributeInt16UniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int16 *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute 16-bit int data to the same unique value.
HAPI_SessionType
Definition: HAPI_Common.h:278
HAPI_DECL HAPI_SetWorkItemIntAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, const int *values_array, int length)
Adds integer data to a pending PDG work item attribute for the given node.
HAPI_DECL HAPI_GetOutputNodeId(const HAPI_Session *session, HAPI_NodeId node_id, int output, HAPI_NodeId *output_node_id)
Gets the node id of an output node in a SOP network.
HAPI_DECL HAPI_GetAttributeStringDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_array, int start, int length, int *job_id)
Get attribute string data asynchronously.
HAPI_DECL HAPI_GetHeightFieldData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, float *values_array, int start, int length)
Get the height field data for a terrain volume as a flattened 2D array of float heights. Should call HAPI_GetVolumeInfo() first to make sure the volume info is initialized.
HAPI_SetWorkitemStringData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, int data_index, const char *value)
Adds integer data to a pending PDG workitem data member for the given node.
HAPI_DECL HAPI_SetAttributeStringDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_array, int start, int length, int *job_id)
Set attribute string data asynchronously.
Configuration options for Houdini's compositing context.
Definition: HAPI_Common.h:2151
HAPI_DECL HAPI_GetAttributeDictionaryArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute dictionary data. Each entry in an array attribute can have varying array lengths...
HAPI_DECL HAPI_GetParmExpression(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, HAPI_StringHandle *value)
Get single integer or float parm expression by name or Null string if no expression is present...
HAPI_GetWorkitemIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, int *data_array, int length)
Gets int data from a work item member.
HAPI_DECL HAPI_GetWorkItemOutputFiles(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, HAPI_PDG_WorkItemOutputFile *resultinfo_array, int resultinfo_count)
Gets the info for work item output files. The number of work item results is found on the HAPI_PDG_Wo...
HAPI_DECL HAPI_GetAttributeInt64DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int64 *data_array, int start, int length, int *job_id)
Get attribute 64-bit integer data asynchronously.
HAPI_DECL HAPI_SetGroupMembership(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_GroupType group_type, const char *group_name, const int *membership_array, int start, int length)
Set group membership.
HAPI_DECL HAPI_GetParmStringValues(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_Bool evaluate, HAPI_StringHandle *values_array, int start, int length)
Fill an array of parameter string handles. These handles must be used in conjunction with HAPI_GetStr...
HAPI_DECL HAPI_SetServerEnvString(const HAPI_Session *session, const char *variable_name, const char *value)
Set environment variable for the server process as a string.
HAPI_DECL HAPI_SetPartInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const HAPI_PartInfo *part_info)
Set the main part info struct (HAPI_PartInfo).
HAPI_DECL HAPI_SetAttributeInt16UniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int16 *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute 16-bit int data to the same unique value asynchronously.
HAPI_DECL HAPI_CreateHeightfieldInputVolumeNode(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_NodeId *new_node_id, const char *name, int xsize, int ysize, float voxelsize)
Creates a volume input node that can be used with Heightfields.
HAPI_DECL HAPI_SetParmFloatValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, float value)
Set single parm float value by name.
HAPI_DECL HAPI_CancelPDGCook(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id)
Cancel the PDG cooking operation.
HAPI_DECL HAPI_ComposeNodeCookResult(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_StatusVerbosity verbosity, int *buffer_length)
Compose the cook result string (errors and warnings) of a specific node.
HAPI_DECL HAPI_CheckForSpecificErrors(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ErrorCodeBits errors_to_look_for, HAPI_ErrorCodeBits *errors_found)
Recursively check for specific errors by error code on a node.
HAPI_DECL HAPI_GetManagerNodeId(const HAPI_Session *session, HAPI_NodeType node_type, HAPI_NodeId *node_id)
Get the root node of a particular network type (ie. OBJ).
HAPI_DECL HAPI_SetAttributeDictionaryArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set attribute dictionary array data asynchronously. The dictionary should be provided as JSON-encoded...
HAPI_HeightFieldSampling
Type of sampling for heightfield.
Definition: HAPI_Common.h:906
HAPI_DECL HAPI_SetVolumeVoxelIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int x_index, int y_index, int z_index, const int *values_array, int value_count)
Set the values of a integer voxel in the volume.
HAPI_DECL HAPI_SetServerEnvInt(const HAPI_Session *session, const char *variable_name, int value)
Set environment variable for the server process as an integer.
HAPI_DECL HAPI_GetAttributeIntArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute integer data. Each entry in an array attribute can have varying array lengths...
HAPI_DECL HAPI_SetAttributeInt16DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int16 *data_array, int start, int length, int *job_id)
Set 16-bit attribute integer data asynchronously.
HAPI_DECL HAPI_GetAttributeDictionaryArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, HAPI_StringHandle *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute dictionary data asynchronously. Each entry in an array attribute can have varying...
int HAPI_ProcessId
Definition: HAPI_Common.h:152
HAPI_DECL HAPI_CreateThriftSocketSession(HAPI_Session *session, const char *host_name, int port, const HAPI_SessionInfo *session_info)
Creates a Thrift RPC session using a TCP socket as transport.
HAPI_DECL HAPI_GetNodeInputName(const HAPI_Session *session, HAPI_NodeId node_id, int input_idx, HAPI_StringHandle *name)
Get the name of an node's input. This function will return a string handle for the name which will be...
HAPI_DECL HAPI_SetSessionSyncInfo(const HAPI_Session *session, const HAPI_SessionSyncInfo *session_sync_info)
Set the HAPI_SessionSyncInfo for synchronizing SessionSync state between Houdini and Houdini Engine i...
HAPI_DECL HAPI_GetMaterialInfo(const HAPI_Session *session, HAPI_NodeId material_node_id, HAPI_MaterialInfo *material_info)
Get the material info.
Configurations for sessions.
Definition: HAPI_Common.h:1117
HAPI_DECL HAPI_CreateCustomSession(HAPI_SessionType session_type, void *session_info, HAPI_Session *session)
Creates a new session using a custom implementation. Note that the implementation DLL must already ha...
Options which affect how nodes are cooked.
Definition: HAPI_Common.h:1246
HAPI_DECL HAPI_SetHeightFieldData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const float *values_array, int start, int length)
Set the height field data for a terrain volume with the values from a flattened 2D array of float...
HAPI_DECL HAPI_SetAttributeStringArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set string array attribute data asynchronously.
HAPI_DECL HAPI_GetStatus(const HAPI_Session *session, HAPI_StatusType status_type, int *status)
Gives back the status code for a specific status type.
HAPI_DECL HAPI_GetConnectionError(char *string_value, int length, HAPI_Bool clear)
Return the connection error message.
HAPI_DECL HAPI_SetAttributeUInt8UniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute unsigned 8-bit int data to the same unique value.
HAPI_DECL HAPI_GetCurveOrders(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int *orders_array, int start, int length)
Retrieve the orders for each curve in the part if the curve has varying order.
HAPI_DECL HAPI_GetCurveKnots(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, float *knots_array, int start, int length)
Retrieve the knots of the curves in this part.
HAPI_DECL HAPI_GetAttributeInt64ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, HAPI_Int64 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute 64-bit integer data asynchronously. Each entry in an array attribute can have var...
HAPI_DECL HAPI_GetAttributeInt64Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int64 *data_array, int start, int length)
Get attribute 64-bit integer data.
HAPI_DECL HAPI_SetAttributeFloat64ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const double *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set 64-bit float array attribute data asynchronously.
HAPI_DECL HAPI_GetParmWithTag(const HAPI_Session *session, HAPI_NodeId node_id, const char *tag_name, HAPI_ParmId *parm_id)
Get the first parm with a specific, ideally unique, tag on it. This is particularly useful for gettin...
HAPI_SetWorkitemIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, const int *values_array, int length)
Adds integer data to a pending PDG workitem data member for the given node.
HAPI_DECL HAPI_SetAttributeStringArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set string array attribute data.
HAPI_DECL HAPI_SetObjectTransform(const HAPI_Session *session, HAPI_NodeId node_id, const HAPI_TransformEuler *trans)
Set the transform of an individual object. Note that the object nodes have to either be editable or h...
HAPI_DECL HAPI_GetPDGGraphContextsCount(const HAPI_Session *session, int *num_contexts)
Return the total number of PDG graph contexts found.
HAPI_DECL HAPI_ConvertMatrixToEuler(const HAPI_Session *session, const float *matrix, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, HAPI_TransformEuler *transform_out)
Converts a 4x4 matrix into its TRS form.
HAPI_DECL HAPI_GetAvailableAssets(const HAPI_Session *session, HAPI_AssetLibraryId library_id, HAPI_StringHandle *asset_names_array, int asset_count)
Get the names of the assets contained in an asset library.
HAPI_DECL HAPI_RemoveCustomString(const HAPI_Session *session, const HAPI_StringHandle string_handle)
Removes the specified string from the server and invalidates the handle.
HAPI_DECL HAPI_GetAttributeInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeOwner owner, HAPI_AttributeInfo *attr_info)
Get the attribute info struct for the attribute specified by name.
HAPI_DECL HAPI_GetAssetDefinitionParmInfos(const HAPI_Session *session, HAPI_AssetLibraryId library_id, const char *asset_name, HAPI_ParmInfo *parm_infos_array, int start, int length)
Fill an array of HAPI_ParmInfo structs with parameter information for the specified asset in the spec...
HAPI_DECL HAPI_StartThriftSocketServer(const HAPI_ThriftServerOptions *options, int port, HAPI_ProcessId *process_id, const char *log_file)
Starts a Thrift RPC server process on the local host serving clients on a TCP socket and waits for it...
HAPI_DECL HAPI_RemoveParmExpression(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int index)
Remove the expression string, leaving the value of the parm at the current value of the expression...
HAPI_DECL HAPI_SetAttributeIndexedStringDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **string_array, int string_count, const int *indices_array, int indices_start, int indices_length, int *job_id)
Set attribute string data by index asynchronously.
HAPI_DECL HAPI_InsertMultiparmInstance(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int instance_position)
Insert an instance of a multiparm before instance_position.
HAPI_DECL HAPI_GetAssetDefinitionParmTagName(const HAPI_Session *session, HAPI_AssetLibraryId library_id, const char *asset_name, HAPI_ParmId parm_id, int tag_index, HAPI_StringHandle *tag_name)
HAPI_DECL HAPI_Initialize(const HAPI_Session *session, const HAPI_CookOptions *cook_options, HAPI_Bool use_cooking_thread, int cooking_thread_stack_size, const char *houdini_environment_files, const char *otl_search_path, const char *dso_search_path, const char *image_dso_search_path, const char *audio_dso_search_path)
Create the asset manager, set up environment variables, and initialize the main Houdini scene...
Identifies a session.
Definition: HAPI_Common.h:1104
#define HAPI_DECL
Definition: HAPI_API.h:108
HAPI_DECL HAPI_SetInputCurvePositions(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const float *positions_array, int start, int length)
Sets the positions for input curves, doing checks for curve validity, and adjusting the curve setting...
HAPI_DECL HAPI_GetHIPFileNodeCount(const HAPI_Session *session, HAPI_HIPFileId id, int *count)
Gets the number of nodes that were created as a result of loading a .hip file.
HAPI_DECL HAPI_GetWorkItemInfo(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id, HAPI_PDG_WorkItemId work_item_id, HAPI_PDG_WorkItemInfo *work_item_info)
Retrieves the info of a given work item by id.
HAPI_DECL HAPI_CookNode(const HAPI_Session *session, HAPI_NodeId node_id, const HAPI_CookOptions *cook_options)
Initiate a cook on this node. Note that this may trigger cooks on other nodes if they are connected...
HAPI_DECL HAPI_GetAttributeNames(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_AttributeOwner owner, HAPI_StringHandle *attribute_names_array, int count)
Get list of attribute names by attribute owner. Note that the name string handles are only valid unti...
HAPI_DECL HAPI_SetPreset(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PresetType preset_type, const char *preset_name, const char *buffer, int buffer_length)
Sets a particular asset to a given preset.
Meta-data for a SOP Node.
Definition: HAPI_Common.h:1670
HAPI_DECL HAPI_GetAssetDefinitionParmValues(const HAPI_Session *session, HAPI_AssetLibraryId library_id, const char *asset_name, int *int_values_array, int int_start, int int_length, float *float_values_array, int float_start, int float_length, HAPI_Bool string_evaluate, HAPI_StringHandle *string_values_array, int string_start, int string_length, HAPI_ParmChoiceInfo *choice_values_array, int choice_start, int choice_length)
Fill arrays of parameter int values, float values, string values, and choice values for parameters in...
HAPI_DECL HAPI_SetAttributeFloat64Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const double *data_array, int start, int length)
Set 64-bit attribute float data.
HAPI_DECL HAPI_ExtractImageToMemory(const HAPI_Session *session, HAPI_NodeId material_node_id, const char *image_file_format_name, const char *image_planes, int *buffer_size)
Extract a rendered image to memory.
HAPI_DECL HAPI_GetMaterialNodeIdsOnFaces(const HAPI_Session *session, HAPI_NodeId geometry_node_id, HAPI_PartId part_id, HAPI_Bool *are_all_the_same, HAPI_NodeId *material_ids_array, int start, int length)
Get material ids by face/primitive. The material ids returned will be valid as long as the asset is a...
A Transform with Euler rotation.
Definition: HAPI_Common.h:1089
HAPI_DECL HAPI_GetParmFile(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, const char *destination_directory, const char *destination_file_name)
Extract a file specified by path on a parameter. This will copy the file to the destination directory...
HAPI_DECL HAPI_GetTotalCookCount(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_NodeTypeBits node_type_filter, HAPI_NodeFlagsBits node_flags_filter, HAPI_Bool recursive, int *count)
Get the specified node's total cook count, including its children, if specified.
HAPI_DECL HAPI_SetAttributeInt16ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int16 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Set 16-bit integer array attribute data asynchronously.
HAPI_DECL HAPI_QueryNodeOutputConnectedNodes(const HAPI_Session *session, HAPI_NodeId node_id, int output_idx, HAPI_Bool into_subnets, HAPI_Bool through_dots, HAPI_NodeId *connected_node_ids_array, int start, int length)
Get the ids of nodes currently connected to the given node at the output index.
HAPI_DECL HAPI_GetWorkItemAttributeSize(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, int *length)
Gets the size of the work item attribute. It is the length of the array of data.
HAPI_DECL HAPI_CreateInProcessSession(HAPI_Session *session, const HAPI_SessionInfo *session_info)
Creates a new in-process session. There can only be one such session per host process.
HAPI_DECL HAPI_GetViewport(const HAPI_Session *session, HAPI_Viewport *viewport)
Get the HAPI_Viewport info for synchronizing viewport in SessionSync. When SessionSync is running thi...
int64_t HAPI_Int64
Definition: HAPI_Common.h:144
HAPI_DECL HAPI_GetGroupMembershipOnPackedInstancePart(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_GroupType group_type, const char *group_name, HAPI_Bool *membership_array_all_equal, int *membership_array, int start, int length)
Get group membership for a packed instance part This functions allows you to get the group membership...
Data for global timeline, used with HAPI_SetTimelineOptions()
Definition: HAPI_Common.h:1175
HAPI_DECL HAPI_GetVolumeVoxelIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int x_index, int y_index, int z_index, int *values_array, int value_count)
Retrieve integer point values of the voxel at a specific index. Note that you must call HAPI_GetVolum...
HAPI_DECL HAPI_SetAttributeInt64ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int64 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set 64-bit integer array attribute data.
HAPI_DECL HAPI_GetInstanceTransformsOnPart(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_RSTOrder rst_order, HAPI_Transform *transforms_array, int start, int length)
Fill an array of HAPI_Transform structs with the transforms of each instance of this instancer object...
HAPI_DECL HAPI_SetTime(const HAPI_Session *session, float time)
Sets the global time of the scene. All API calls will deal with this time to cook.
HAPI_DECL HAPI_CookPDGAllOutputs(const HAPI_Session *session, HAPI_NodeId cook_node_id, int generate_only, int blocking)
Starts a PDG cooking operation. This can be asynchronous. Progress can be checked with HAPI_GetPDGSta...
HAPI_DECL HAPI_GetComposedObjectList(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_ObjectInfo *object_infos_array, int start, int length)
Fill an array of HAPI_ObjectInfo structs.
HAPI_DECL HAPI_DirtyPDGNode(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_Bool clean_results)
Dirties the given node. Cancels the cook if necessary and then deletes all workitems on the node...
HAPI_DECL HAPI_SetWorkItemStringAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, int data_index, const char *value)
Adds integer data to a pending PDG work item attribute for the given node.
HAPI_DECL HAPI_GetCacheProperty(const HAPI_Session *session, const char *cache_name, HAPI_CacheProperty cache_property, int *property_value)
Lets you inspect specific properties of the different memory caches in the current Houdini context...
HAPI_DECL HAPI_SetCurveOrders(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const int *orders_array, int start, int length)
Set the orders for each curve in the part if the curve has varying order.
HAPI_DECL HAPI_BindCustomImplementation(HAPI_SessionType session_type, const char *dll_path)
Binds a new implementation DLL to one of the custom session slots.
HAPI_DECL HAPI_GetNodeCookResult(const HAPI_Session *session, char *string_value, int length)
Return the cook result string that was composed during a call to HAPI_GetNodeCookResultLength().
HAPI_DECL HAPI_SetAttributeFloat64DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const double *data_array, int start, int length, int *job_id)
Set 64-bit attribute float data asynchronously.
HAPI_DECL HAPI_GetAttributeIntArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, int *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute integer data asynchronously. Each entry in an array attribute can have varying ar...
HAPI_GetWorkitems(const HAPI_Session *session, HAPI_NodeId node_id, int *workitem_ids_array, int length)
Gets the list of work item ids for the given node.
HAPI_DECL HAPI_GetCompositorOptions(const HAPI_Session *session, HAPI_CompositorOptions *compositor_options)
Gets the global compositor options.
HAPI_DECL HAPI_SaveHIPFile(const HAPI_Session *session, const char *file_path, HAPI_Bool lock_nodes)
Saves a .hip file of the current Houdini scene.
HAPI_DECL HAPI_GetPresetCount(const HAPI_Session *session, const char *buffer, int buffer_length, int *count)
Gets the number of presets in an IDX file. When this method is called, the names of the presets are s...
HAPI_DECL HAPI_SetFaceCounts(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const int *face_counts_array, int start, int length)
Set the array of faces where the nth integer in the array is the number of vertices the nth face has...
HAPI_DECL HAPI_SetAttributeInt16ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int16 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set 16-bit integer array attribute data.
HAPI_DECL HAPI_CreateInputNode(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_NodeId *node_id, const char *name)
Creates a simple geometry SOP node that can accept geometry input. Inside the specified parent node...
HAPI_DECL HAPI_PausePDGCook(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id)
Pause the PDG cooking operation.
HAPI_DECL HAPI_CreateNode(const HAPI_Session *session, HAPI_NodeId parent_node_id, const char *operator_name, const char *node_label, HAPI_Bool cook_on_creation, HAPI_NodeId *new_node_id)
Create a node inside a node network. Nodes created this way will have their HAPI_NodeInfo::createdPos...
HAPI_DECL HAPI_SetImageInfo(const HAPI_Session *session, HAPI_NodeId material_node_id, const HAPI_ImageInfo *image_info)
Set image information like resolution and file format. This information will be used when extracting ...
HAPI_DECL HAPI_SetAttributeInt64Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int64 *data_array, int start, int length)
Set 64-bit attribute integer data.
char HAPI_Bool
Definition: HAPI_Common.h:119
HAPI_DECL HAPI_GetParmInfoFromName(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, HAPI_ParmInfo *parm_info)
Get the parm info of a parameter by name.
HAPI_DECL HAPI_CommitWorkItems(const HAPI_Session *session, HAPI_NodeId node_id)
Commits any pending work items.
HAPI_DECL HAPI_GetAttributeInt16DataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int16 *data_array, int start, int length, int *job_id)
Get attribute 16-bit integer data asynchronously.
HAPI_DECL HAPI_GetAttributeUInt8Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_UInt8 *data_array, int start, int length)
Get attribute unsigned 8-bit integer data.
HAPI_DECL HAPI_GetActiveCacheCount(const HAPI_Session *session, int *active_cache_count)
Get the number of currently active caches.
HAPI_DECL HAPI_LoadAssetLibraryFromMemory(const HAPI_Session *session, const char *library_buffer, int library_buffer_length, HAPI_Bool allow_overwrite, HAPI_AssetLibraryId *library_id)
Loads a Houdini asset library (OTL) from memory. It does NOT create anything inside the Houdini scene...
HAPI_StatusType
Definition: HAPI_Common.h:206
HAPI_DECL HAPI_ClearConnectionError()
Clears the connection error. Should be used before starting or creating Thrift server.
HAPI_DECL HAPI_SetAttributeFloat64UniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const double *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute 64-bit float data to the same unique value.
HAPI_DECL HAPI_GetServerEnvInt(const HAPI_Session *session, const char *variable_name, int *value)
Get environment variable from the server process as an integer.
HAPI_DECL HAPI_GetNodeInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_NodeInfo *node_info)
Fill an HAPI_NodeInfo struct.
HAPI_DECL HAPI_GetObjectTransform(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_NodeId relative_to_node_id, HAPI_RSTOrder rst_order, HAPI_Transform *transform)
Get the tranform of an OBJ node.
HAPI_PresetType
Definition: HAPI_Common.h:490
Data for a Box Part.
Definition: HAPI_Common.h:2024
HAPI_DECL HAPI_GetUseHoudiniTime(const HAPI_Session *session, HAPI_Bool *enabled)
Returns whether the Houdini session will use the current time in Houdini when cooking and retrieving ...
HAPI_DECL HAPI_SetAttributeUInt8ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set unsigned 8-bit integer array attribute data.
HAPI_DECL HAPI_SetAttributeFloatData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const float *data_array, int start, int length)
Set attribute float data.
HAPI_DECL HAPI_GetVolumeTileIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int fill_value, const HAPI_VolumeTileInfo *tile, int *values_array, int length)
Retrieve integer point values of the voxels pointed to by a tile. Note that a tile may extend beyond ...
HAPI_DECL HAPI_GetAssetDefinitionParmTagValue(const HAPI_Session *session, HAPI_AssetLibraryId library_id, const char *asset_name, HAPI_ParmId parm_id, const char *tag_name, HAPI_StringHandle *tag_value)
HAPI_DECL HAPI_GetSupportedImageFileFormatCount(const HAPI_Session *session, int *file_format_count)
Get the number of supported texture file formats.
HAPI_DECL HAPI_GetParmIntValues(const HAPI_Session *session, HAPI_NodeId node_id, int *values_array, int start, int length)
Fill an array of parameter int values. This is more efficient than calling HAPI_GetParmIntValue() ind...
HAPI_DECL HAPI_IsInitialized(const HAPI_Session *session)
Check whether the runtime has been initialized yet using HAPI_Initialize(). Function will return HAPI...
HAPI_DECL HAPI_Interrupt(const HAPI_Session *session)
Interrupt a cook or load operation.
HAPI_DECL HAPI_GetGeoInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_GeoInfo *geo_info)
Get the geometry info struct (HAPI_GeoInfo) on a SOP node.
HAPI_DECL HAPI_GetHIPFileNodeIds(const HAPI_Session *session, HAPI_HIPFileId id, HAPI_NodeId *node_ids, int length)
Fills an array of HAPI_NodeId of nodes that were created as a result of loading the HIP file specifie...
HAPI_DECL HAPI_GetConnectionErrorLength(int *buffer_length)
Return the length of string buffer storing connection error message.
HAPI_DECL HAPI_GetHandleInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_HandleInfo *handle_infos_array, int start, int length)
Fill an array of HAPI_HandleInfo structs with information about every exposed user manipulation handl...
HAPI_DECL HAPI_GetNextVolumeTile(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_VolumeTileInfo *tile)
Iterate through a volume based on 8x8x8 sections of the volume Continue iterating through the value o...
HAPI_DECL HAPI_GetSessionEnvInt(const HAPI_Session *session, HAPI_SessionEnvIntType int_type, int *value)
Gives back a certain session-specific environment integers like current license type being used...
HAPI_DECL HAPI_GetNodeOutputName(const HAPI_Session *session, HAPI_NodeId node_id, int output_idx, HAPI_StringHandle *name)
Get the name of an node's output. This function will return a string handle for the name which will b...
HAPI_DECL HAPI_RenderCOPToImage(const HAPI_Session *session, HAPI_NodeId cop_node_id)
Render a single texture from a COP to an image for later extraction.
HAPI_DECL HAPI_SetCurveCounts(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const int *counts_array, int start, int length)
Set the number of vertices for each curve in the part.
HAPI_DECL HAPI_GetWorkItemStringAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, HAPI_StringHandle *data_array, int length)
Gets string ids from a work item attribute.
HAPI_DECL HAPI_GetCookingCurrentCount(const HAPI_Session *session, int *count)
Get current number of nodes that have already cooked in the current session. Note that this is a very...
HAPI_DECL HAPI_GetComposedNodeCookResult(const HAPI_Session *session, char *string_value, int length)
Return cook result string message on a single node.
HAPI_DECL HAPI_SetAttributeFloat64UniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const double *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute 64-bit float data to the same unique asynchronously.
HAPI_DECL HAPI_GetPresetBufLength(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PresetType preset_type, const char *preset_name, int *buffer_length)
Generate a preset blob of the current state of all the parameter values, cache it, and return its size in bytes.
HAPI_DECL HAPI_GetEdgeCountOfEdgeGroup(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *group_name, int *edge_count)
Gets the number of edges that belong to an edge group on a geometry part.
int HAPI_NodeFlagsBits
Definition: HAPI_Common.h:556
Data for a Sphere Part.
Definition: HAPI_Common.h:2033
HAPI_DECL HAPI_GetPresetNames(const HAPI_Session *session, const char *buffer, int buffer_length, HAPI_StringHandle *preset_names_array, int preset_names_count)
Gets the names of presets in an IDX file. HAPI_GetPresetCount() must be called before calling this me...
A Transform with Quaternion rotation.
Definition: HAPI_Common.h:1077
HAPI_DECL HAPI_DisconnectNodeInput(const HAPI_Session *session, HAPI_NodeId node_id, int input_index)
Disconnect a node input.
HAPI_GetWorkitemInfo(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id, HAPI_PDG_WorkItemId workitem_id, HAPI_PDG_WorkItemInfo *workitem_info)
Retrieves the info of a given workitem by id.
HAPI_DECL HAPI_SetAttributeInt8UniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int8 *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute 8-bit int data to the same unique value asynchronously.
HAPI_DECL HAPI_SetTransformAnimCurve(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_TransformComponent trans_comp, const HAPI_Keyframe *curve_keyframes_array, int keyframe_count)
A specialized convenience function to set the T,R,S values on an exposed node.
HAPI_GroupType
Definition: HAPI_Common.h:558
HAPI_DECL HAPI_GetAttributeInt8ArrayDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *attr_name, HAPI_AttributeInfo *attr_info, HAPI_Int8 *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length, int *job_id)
Get array attribute 8-bit integer data asynchronously. Each entry in an array attribute can have vary...
HAPI_DECL HAPI_GetPartInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_PartInfo *part_info)
Get a particular part info struct.
HAPI_DECL HAPI_GetLoadedAssetLibraryCount(const HAPI_Session *session, int *count)
Gets the number of HDAs that have been loaded by Houdini.
HAPI_DECL HAPI_GetStatusString(const HAPI_Session *session, HAPI_StatusType status_type, char *string_value, int length)
Return status string message.
HAPI_DECL HAPI_GetServerEnvVarCount(const HAPI_Session *session, int *env_count)
Provides the number of environment variables that are in the server environment's process...
HAPI_DECL HAPI_SetAttributeFloatUniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const float *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute float data to the same unique value asynchronously.
int HAPI_NodeId
See Nodes Basics.
Definition: HAPI_Common.h:165
Describes an image format, used with HAPI_GetSupportedImageFileFormats()
Definition: HAPI_Common.h:1831
HAPI_DECL HAPI_StopPerformanceMonitorProfile(const HAPI_Session *session, int profile_id, const char *file_path)
Stop the Performance Monitor profile that matches the given profile id and save out the profile's sta...
HAPI_CacheProperty
Identifies a memory cache.
Definition: HAPI_Common.h:873
HAPI_DECL HAPI_SetAttributeIndexedStringData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **string_array, int string_count, const int *indices_array, int indices_start, int indices_length)
Set attribute string data by index.
HAPI_DECL HAPI_SetAttributeInt64UniqueDataAsync(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_Int64 *data_array, int data_length, int start_index, int num_indices, int *job_id)
Set multiple attribute 64-bit int data to the same unique value asynchronously.
HAPI_DECL HAPI_SetVolumeInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const HAPI_VolumeInfo *volume_info)
Set the volume info of a geo on a geo input.
HAPI_DECL HAPI_SetUseHoudiniTime(const HAPI_Session *session, HAPI_Bool enabled)
Sets whether the Houdini session should use the current time in Houdini when cooking and retrieving d...
Data for a single Key Frame.
Definition: HAPI_Common.h:1869
HAPI_DECL HAPI_GetGroupCountOnPackedInstancePart(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int *pointGroupCount, int *primitiveGroupCount)
Get group counts for a specific packed instanced part.
HAPI_DECL HAPI_ConnectNodeInput(const HAPI_Session *session, HAPI_NodeId node_id, int input_index, HAPI_NodeId node_id_to_connect, int output_index)
Connect two nodes together.
HAPI_DECL HAPI_CookPDG(const HAPI_Session *session, HAPI_NodeId cook_node_id, int generate_only, int blocking)
Starts a PDG cooking operation. This can be asynchronous. Progress can be checked with HAPI_GetPDGSta...
HAPI_DECL HAPI_GetCurveCounts(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int *counts_array, int start, int length)
Retrieve the number of vertices for each curve in the part.
HAPI_DECL HAPI_LoadAssetLibraryFromFile(const HAPI_Session *session, const char *file_path, HAPI_Bool allow_overwrite, HAPI_AssetLibraryId *library_id)
Loads a Houdini asset library (OTL) from a .otl file. It does NOT create anything inside the Houdini ...
int HAPI_AssetLibraryId
Definition: HAPI_Common.h:162
HAPI_DECL HAPI_LoadGeoFromFile(const HAPI_Session *session, HAPI_NodeId node_id, const char *file_name)
Loads a geometry file and put its contents onto a SOP node.
HAPI_DECL HAPI_SetAttributeFloatArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const float *data_fixed_array, int data_fixed_length, const int *sizes_fixed_array, int start, int sizes_fixed_length)
Set float array attribute data.
HAPI_DECL HAPI_GetAssetLibraryFilePath(const HAPI_Session *session, HAPI_AssetLibraryId asset_library_id, HAPI_StringHandle *file_path_sh)
Gets the HAPI_StringHandle for the file path of a loaded asset library.
HAPI_TransformComponent
Definition: HAPI_Common.h:748
HAPI_DECL HAPI_GetParmStringValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, HAPI_Bool evaluate, HAPI_StringHandle *value)
Get single parm string value by name.
HAPI_DECL HAPI_GetEnvInt(HAPI_EnvIntType int_type, int *value)
Gives back a certain environment integers like version number. Note that you do not need a session fo...
HAPI_DECL HAPI_GetInstancedObjectIds(const HAPI_Session *session, HAPI_NodeId object_node_id, HAPI_NodeId *instanced_node_id_array, int start, int length)
Get the node ids for the objects being instanced by an Instance OBJ node.
HAPI_DECL HAPI_IsNodeValid(const HAPI_Session *session, HAPI_NodeId node_id, int unique_node_id, HAPI_Bool *answer)
Determine if your instance of the node actually still exists inside the Houdini scene. This is what can be used to determine when the Houdini scene needs to be re-populated using the host application's instances of the nodes. Note that this function will ALWAYS return HAPI_RESULT_SUCCESS.
HAPI_DECL HAPI_StartThriftSharedMemoryServer(const HAPI_ThriftServerOptions *options, const char *shared_mem_name, HAPI_ProcessId *process_id, const char *log_file)
Starts a Thrift RPC server process on the localhost serving clients by utilizing shared memory to tra...
HAPI_DECL HAPI_GetDisplayGeoInfo(const HAPI_Session *session, HAPI_NodeId object_node_id, HAPI_GeoInfo *geo_info)
Get the display geo (SOP) node inside an Object node. If there there are multiple display SOP nodes...
int8_t HAPI_Int8
Definition: HAPI_Common.h:140
HAPI_DECL HAPI_RevertParmToDefaults(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name)
Revert all instances of the parm by name to defaults.
HAPI_DECL HAPI_SetAttributeStringUniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute string data to the same unique value.
Meta-data for a combo-box / choice parm.
Definition: HAPI_Common.h:1576
HAPI_CommitWorkitems(const HAPI_Session *session, HAPI_NodeId node_id)
Commits any pending workitems.
int HAPI_PartId
Definition: HAPI_Common.h:173
HAPI_DECL HAPI_GetInstancedPartIds(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_PartId *instanced_parts_array, int start, int length)
Get the part ids that this instancer part is instancing.
HAPI_DECL HAPI_GetParmTagValue(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, const char *tag_name, HAPI_StringHandle *tag_value)
Get the tag value on a parameter given the tag name.
HAPI_DECL HAPI_GetWorkItems(const HAPI_Session *session, HAPI_NodeId node_id, int *work_item_ids_array, int length)
Gets the list of work item ids for the given node.
HAPI_DECL HAPI_SaveNodeToFile(const HAPI_Session *session, HAPI_NodeId node_id, const char *file_name)
Saves the node and all its contents to file. The saved file can be loaded by calling HAPI_LoadNodeFro...
HAPI_DECL HAPI_SetAttributeIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const int *data_array, int start, int length)
Set attribute integer data.
uint8_t HAPI_UInt8
Definition: HAPI_Common.h:135