HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends 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,
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 ///
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,
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, double * 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, double 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 are creating an Object or SOP node, you can pass
2472 /// parent_node_id == -1 as long as you include the table name
2473 /// (ie. Object/ or Sop/) as a prefix to the operator_name.
2474 /// This covenience is only available for Object or SOP nodes.
2475 /// This is the common case for when creating asset nodes
2476 /// from a loaded asset library. In that case, just pass
2477 /// whatever ::HAPI_GetAvailableAssets() returns.
2478 ///
2479 /// If you have a parent_node_id then you should
2480 /// include only the namespace, name, and version.
2481 ///
2482 /// For example, lets say you have an Object type asset, in
2483 /// the "hapi" namespace, of version 2.0, named "foo". If
2484 /// you pass parent_node_id == -1, then set the operator_name
2485 /// as "Object/hapi::foo::2.0". Otherwise, if you have a valid
2486 /// parent_node_id, then just pass operator_name as
2487 /// "hapi::foo::2.0".
2488 ///
2489 /// @param[in] node_label
2490 /// (Optional) The label of the newly created node.
2491 /// <!-- default NULL -->
2492 ///
2493 /// @param[in] cook_on_creation
2494 /// Set whether the node should cook once created or not.
2495 /// <!-- default false -->
2496 ///
2497 /// @param[out] new_node_id
2498 /// The returned node id of the just-created node.
2499 ///
2500 HAPI_DECL HAPI_CreateNode( const HAPI_Session * session,
2501  HAPI_NodeId parent_node_id,
2502  const char * operator_name,
2503  const char * node_label,
2504  HAPI_Bool cook_on_creation,
2505  HAPI_NodeId * new_node_id );
2506 
2507 /// @brief Creates a simple geometry SOP node that can accept geometry input.
2508 /// Inside the specified parent node, this will create a Null SOP
2509 /// you can set the geometry of using the geometry SET APIs.
2510 /// You can then connect this node to any other node as a geometry
2511 /// input.
2512 ///
2513 /// Note that when saving the Houdini scene using
2514 /// ::HAPI_SaveHIPFile() the nodes created with this
2515 /// method will be green and will start with the name "input".
2516 ///
2517 /// @ingroup Nodes
2518 ///
2519 /// @param[in] session
2520 /// The session of Houdini you are interacting with.
2521 /// See @ref HAPI_Sessions for more on sessions.
2522 /// Pass NULL to just use the default in-process session.
2523 /// <!-- default NULL -->
2524 ///
2525 /// @param[in] parent_node_id
2526 /// The node id of the parent OBJ node or SOP subnetwork node in
2527 /// which the input node should be created, or -1 to create a
2528 /// new dummy parent OBJ node for this input node.
2529 /// <!-- min -1 -->
2530 /// <!-- default -1 -->
2531 ///
2532 /// @param[out] node_id
2533 /// Newly created node's id. Use ::HAPI_GetNodeInfo()
2534 /// to get more information about the node.
2535 ///
2536 /// @param[in] name
2537 /// Give this input node a name for easy debugging.
2538 /// The node's parent OBJ node and the Null SOP node will both
2539 /// get this given name with "input_" prepended.
2540 /// You can also pass NULL in which case the name will
2541 /// be "input#" where # is some number.
2542 /// <!-- default NULL -->
2543 ///
2545  HAPI_NodeId parent_node_id,
2546  HAPI_NodeId * node_id,
2547  const char * name );
2548 
2549 /// @brief Helper for creating specifically creating a curve input geometry SOP.
2550 /// Inside the specified parent node, this will create a Null SOP that
2551 /// contains the the HAPI_ATTRIB_INPUT_CURVE_COORDS attribute.
2552 /// It will setup the node as a curve part with no points.
2553 /// In addition to creating the input node, it will also commit and cook
2554 /// the geometry.
2555 ///
2556 /// Note that when saving the Houdini scene using
2557 /// ::HAPI_SaveHIPFile() the nodes created with this
2558 /// method will be green and will start with the name "input".
2559 ///
2560 /// @ingroup InputCurves
2561 ///
2562 /// @param[in] session
2563 /// The session of Houdini you are interacting with.
2564 /// See @ref HAPI_Sessions for more on sessions.
2565 /// Pass NULL to just use the default in-process session.
2566 /// <!-- default NULL -->
2567 ///
2568 /// @param[in] parent_node_id
2569 /// The node id of the parent OBJ node or SOP subnetwork node in
2570 /// which the input node should be created, or -1 to create a
2571 /// new dummy parent OBJ node for this input node.
2572 /// <!-- min -1 -->
2573 /// <!-- default -1 -->
2574 ///
2575 /// @param[out] node_id
2576 /// Newly created node's id. Use ::HAPI_GetNodeInfo()
2577 /// to get more information about the node.
2578 ///
2579 /// @param[in] name
2580 /// Give this input node a name for easy debugging.
2581 /// The node's parent OBJ node and the Null SOP node will both
2582 /// get this given name with "input_" prepended.
2583 /// You can also pass NULL in which case the name will
2584 /// be "input#" where # is some number.
2585 /// <!-- default NULL -->
2586 ///
2588  HAPI_NodeId parent_node_id,
2589  HAPI_NodeId * node_id,
2590  const char * name );
2591 
2592 
2593 /// @defgroup HeightFields Height Fields
2594 /// Functions for creating and inspecting HAPI session state.
2595 
2596 /// @brief Creates the required node hierarchy needed for heightfield inputs.
2597 ///
2598 /// Note that when saving the Houdini scene using
2599 /// ::HAPI_SaveHIPFile() the nodes created with this
2600 /// method will be green and will start with the name "input".
2601 ///
2602 /// @ingroup HeightFields
2603 ///
2604 /// @param[in] session
2605 /// The session of Houdini you are interacting with.
2606 /// See @ref HAPI_Sessions for more on sessions.
2607 /// Pass NULL to just use the default in-process session.
2608 /// <!-- default NULL -->
2609 ///
2610 /// @param[in] parent_node_id
2611 /// The parent node network's node id or -1 if the parent
2612 /// network is the manager (top-level) node. In that case,
2613 /// the manager must be identified by the table name in the
2614 /// operator_name.
2615 /// <!-- min -1 -->
2616 /// <!-- default -1 -->
2617 ///
2618 /// @param[in] name
2619 /// Give this input node a name for easy debugging.
2620 /// The node's parent OBJ node and the Null SOP node will both
2621 /// get this given name with "input_" prepended.
2622 /// You can also pass NULL in which case the name will
2623 /// be "input#" where # is some number.
2624 /// <!-- default NULL -->
2625 ///
2626 /// @param[in] xsize
2627 /// size of the heightfield in X
2628 ///
2629 /// @param[in] ysize
2630 /// size of the heightfield in y
2631 ///
2632 /// @param[in] voxelsize
2633 /// Size of the voxel
2634 ///
2635 /// @param[in] sampling
2636 /// Type of sampling which should be either center or corner.
2637 ///
2638 /// @param[out] heightfield_node_id
2639 /// Newly created node id for the heightfield node.
2640 /// Use ::HAPI_GetNodeInfo() to get more information about
2641 /// the node.
2642 ///
2643 /// @param[out] height_node_id
2644 /// Newly created node id for the height volume.
2645 /// Use ::HAPI_GetNodeInfo() to get more information about the node.
2646 ///
2647 /// @param[out] mask_node_id
2648 /// Newly created node id for the mask volume.
2649 /// Use ::HAPI_GetNodeInfo() to get more information about the
2650 /// node.
2651 ///
2652 /// @param[out] merge_node_id
2653 /// Newly created merge node id.
2654 /// The merge node can be used to connect additional input masks.
2655 /// Use ::HAPI_GetNodeInfo() to get more information about the node.
2656 ///
2658  HAPI_NodeId parent_node_id,
2659  const char * name,
2660  int xsize,
2661  int ysize,
2662  float voxelsize,
2663  HAPI_HeightFieldSampling sampling,
2664  HAPI_NodeId * heightfield_node_id,
2665  HAPI_NodeId * height_node_id,
2666  HAPI_NodeId * mask_node_id,
2667  HAPI_NodeId * merge_node_id );
2668 
2669 /// @brief Creates a volume input node that can be used with Heightfields
2670 ///
2671 /// Note that when saving the Houdini scene using
2672 /// ::HAPI_SaveHIPFile() the nodes created with this
2673 /// method will be green and will start with the name "input".
2674 ///
2675 /// @ingroup HeightFields
2676 ///
2677 /// @param[in] session
2678 /// The session of Houdini you are interacting with.
2679 /// See @ref HAPI_Sessions for more on sessions.
2680 /// Pass NULL to just use the default in-process session.
2681 /// <!-- default NULL -->
2682 ///
2683 /// @param[in] parent_node_id
2684 /// The parent node network's node id or -1 if the parent
2685 /// network is the manager (top-level) node. In that case,
2686 /// the manager must be identified by the table name in the
2687 /// operator_name.
2688 /// <!-- min -1 -->
2689 /// <!-- default -1 -->
2690 ///
2691 /// @param[out] new_node_id
2692 /// Newly created node id for the volume.
2693 /// Use ::HAPI_GetNodeInfo() to get more information about the
2694 /// node.
2695 ///
2696 /// @param[in] name
2697 /// The name of the volume to create.
2698 /// You can also pass NULL in which case the name will
2699 /// be "input#" where # is some number.
2700 /// <!-- default NULL -->
2701 ///
2702 /// @param[in] xsize
2703 /// size of the heightfield in X
2704 ///
2705 /// @param[in] ysize
2706 /// size of the heightfield in y
2707 ///
2708 /// @param[in] voxelsize
2709 /// Size of the voxel
2710 ///
2712  HAPI_NodeId parent_node_id,
2713  HAPI_NodeId * new_node_id,
2714  const char * name,
2715  int xsize,
2716  int ysize,
2717  float voxelsize );
2718 
2719 /// @brief Initiate a cook on this node. Note that this may trigger
2720 /// cooks on other nodes if they are connected.
2721 ///
2722 /// @note In threaded mode, this is an _async call_!
2723 ///
2724 /// This API will invoke the cooking thread if threading is
2725 /// enabled. This means it will return immediately. Use
2726 /// the status and cooking count APIs under DIAGNOSTICS to get
2727 /// a sense of the progress. All other API calls will block
2728 /// until the cook operation has finished.
2729 ///
2730 /// Also note that the cook result won't be of type
2731 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2732 /// Whenever the threading cook is done it will fill the
2733 /// @a cook result which is queried using
2734 /// ::HAPI_STATUS_COOK_RESULT.
2735 ///
2736 /// @ingroup Nodes
2737 ///
2738 /// @param[in] session
2739 /// The session of Houdini you are interacting with.
2740 /// See @ref HAPI_Sessions for more on sessions.
2741 /// Pass NULL to just use the default in-process session.
2742 /// <!-- default NULL -->
2743 ///
2744 /// @param[in] node_id
2745 /// The node id.
2746 ///
2747 /// @param[in] cook_options
2748 /// The cook options. Pass in NULL to use the global
2749 /// cook options that you specified when calling
2750 /// ::HAPI_Initialize().
2751 /// <!-- default NULL -->
2752 ///
2753 HAPI_DECL HAPI_CookNode( const HAPI_Session * session,
2754  HAPI_NodeId node_id,
2755  const HAPI_CookOptions * cook_options );
2756 
2757 /// @brief Delete a node from a node network. Only nodes with their
2758 /// ::HAPI_NodeInfo::createdPostAssetLoad set to true can be
2759 /// deleted this way.
2760 ///
2761 /// @ingroup Nodes
2762 ///
2763 /// @param[in] session
2764 /// The session of Houdini you are interacting with.
2765 /// See @ref HAPI_Sessions for more on sessions.
2766 /// Pass NULL to just use the default in-process session.
2767 /// <!-- default NULL -->
2768 ///
2769 /// @param[in] node_id
2770 /// The node to delete.
2771 ///
2772 HAPI_DECL HAPI_DeleteNode( const HAPI_Session * session,
2773  HAPI_NodeId node_id );
2774 
2775 /// @brief Rename a node that you created. Only nodes with their
2776 /// ::HAPI_NodeInfo::createdPostAssetLoad set to true can be
2777 /// renamed this way.
2778 ///
2779 /// @ingroup Nodes
2780 ///
2781 /// @param[in] session
2782 /// The session of Houdini you are interacting with.
2783 /// See @ref HAPI_Sessions for more on sessions.
2784 /// Pass NULL to just use the default in-process session.
2785 /// <!-- default NULL -->
2786 ///
2787 /// @param[in] node_id
2788 /// The node to rename.
2789 ///
2790 /// @param[in] new_name
2791 /// The new node name.
2792 ///
2793 HAPI_DECL HAPI_RenameNode( const HAPI_Session * session,
2794  HAPI_NodeId node_id,
2795  const char * new_name );
2796 
2797 /// @brief Connect two nodes together.
2798 ///
2799 /// @param[in] session
2800 /// The session of Houdini you are interacting with.
2801 /// See @ref HAPI_Sessions for more on sessions.
2802 /// Pass NULL to just use the default in-process session.
2803 /// <!-- default NULL -->
2804 ///
2805 /// @ingroup Nodes
2806 ///
2807 /// @param[in] node_id
2808 /// The node whom's input to connect to.
2809 ///
2810 /// @param[in] input_index
2811 /// The input index. Should be between 0 and the
2812 /// to_node's ::HAPI_NodeInfo::inputCount - 1.
2813 /// <!-- min 0 -->
2814 ///
2815 /// @param[in] node_id_to_connect
2816 /// The node to connect to node_id's input.
2817 ///
2818 /// @param[in] output_index
2819 /// The output index. Should be between 0 and the
2820 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2821 /// <!-- min 0 -->
2822 ///
2824  HAPI_NodeId node_id,
2825  int input_index,
2826  HAPI_NodeId node_id_to_connect,
2827  int output_index );
2828 
2829 /// @brief Disconnect a node input.
2830 ///
2831 /// @param[in] session
2832 /// The session of Houdini you are interacting with.
2833 /// See @ref HAPI_Sessions for more on sessions.
2834 /// Pass NULL to just use the default in-process session.
2835 /// <!-- default NULL -->
2836 ///
2837 /// @ingroup Nodes
2838 ///
2839 /// @param[in] node_id
2840 /// The node whom's input to disconnect.
2841 ///
2842 /// @param[in] input_index
2843 /// The input index. Should be between 0 and the
2844 /// to_node's ::HAPI_NodeInfo::inputCount - 1.
2845 /// <!-- min 0 -->
2846 ///
2848  HAPI_NodeId node_id,
2849  int input_index );
2850 
2851 /// @brief Query which node is connected to another node's input.
2852 ///
2853 /// @param[in] session
2854 /// The session of Houdini you are interacting with.
2855 /// See @ref HAPI_Sessions for more on sessions.
2856 /// Pass NULL to just use the default in-process session.
2857 /// <!-- default NULL -->
2858 ///
2859 /// @ingroup Nodes
2860 ///
2861 /// @param[in] node_to_query
2862 /// The node to query.
2863 ///
2864 /// @param[in] input_index
2865 /// The input index. Should be between 0 and the
2866 /// to_node's ::HAPI_NodeInfo::inputCount - 1.
2867 /// <!-- min 0 -->
2868 ///
2869 /// @param[out] connected_node_id
2870 /// The node id of the connected node to this input. If
2871 /// nothing is connected then -1 will be returned.
2872 ///
2873 HAPI_DECL HAPI_QueryNodeInput( const HAPI_Session * session,
2874  HAPI_NodeId node_to_query,
2875  int input_index,
2876  HAPI_NodeId * connected_node_id );
2877 
2878 /// @brief Get the name of an node's input. This function will return
2879 /// a string handle for the name which will be valid (persist)
2880 /// until the next call to this function.
2881 ///
2882 /// @ingroup Nodes
2883 ///
2884 /// @param[in] session
2885 /// The session of Houdini you are interacting with.
2886 /// See @ref HAPI_Sessions for more on sessions.
2887 /// Pass NULL to just use the default in-process session.
2888 /// <!-- default NULL -->
2889 ///
2890 /// @param[in] node_id
2891 /// The node id.
2892 ///
2893 /// @param[in] input_idx
2894 /// The input index. Should be between 0 and the
2895 /// node_to_query's ::HAPI_NodeInfo::inputCount - 1.
2896 /// <!-- min 0 -->
2897 ///
2898 /// @param[out] name
2899 /// Input name string handle return value - valid until
2900 /// the next call to this function.
2901 ///
2903  HAPI_NodeId node_id,
2904  int input_idx,
2905  HAPI_StringHandle * name );
2906 
2907 /// @brief Disconnect all of the node's output connections at the output index.
2908 ///
2909 /// @ingroup Nodes
2910 ///
2911 /// @param[in] session
2912 /// The session of Houdini you are interacting with.
2913 /// See @ref HAPI_Sessions for more on sessions.
2914 /// Pass NULL to just use the default in-process session.
2915 /// <!-- default NULL -->
2916 ///
2917 /// @param[in] node_id
2918 /// The node whom's outputs to disconnect.
2919 ///
2920 /// @param[in] output_index
2921 /// The output index. Should be between 0 and the
2922 /// to_node's ::HAPI_NodeInfo::outputCount.
2923 /// <!-- min 0 -->
2924 ///
2926  HAPI_NodeId node_id,
2927  int output_index );
2928 
2929 /// @brief Get the number of nodes currently connected to the given node at
2930 /// the output index.
2931 ///
2932 /// @ingroup Nodes
2933 ///
2934 /// Use the @c count returned by this function to get the
2935 /// ::HAPI_NodeId of connected nodes using
2936 /// ::HAPI_QueryNodeOutputConnectedNodes().
2937 ///
2938 /// @param[in] session
2939 /// The session of Houdini you are interacting with.
2940 /// See @ref HAPI_Sessions for more on sessions.
2941 /// Pass NULL to just use the default in-process session.
2942 /// <!-- default NULL -->
2943 ///
2944 /// @param[in] node_id
2945 /// The node id.
2946 ///
2947 /// @param[in] output_idx
2948 /// The output index. Should be between 0 and the
2949 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2950 /// <!-- min 0 -->
2951 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
2952 ///
2953 /// @param[in] into_subnets
2954 /// Whether to search by diving into subnets.
2955 /// <!-- default true -->
2956 ///
2957 /// @param[in] through_dots
2958 /// Whether to search through dots.
2959 /// <!-- default true -->
2960 ///
2961 /// @param[out] connected_count
2962 /// The number of nodes currently connected to this node at
2963 /// given output index. Use this count with a call to
2964 /// ::HAPI_QueryNodeOutputConnectedNodes() to get list of
2965 /// connected nodes.
2966 ///
2968  HAPI_NodeId node_id,
2969  int output_idx,
2970  HAPI_Bool into_subnets,
2971  HAPI_Bool through_dots,
2972  int * connected_count );
2973 
2974 /// @brief Get the ids of nodes currently connected to the given node
2975 /// at the output index.
2976 ///
2977 /// Use the @c connected_count returned by
2978 /// ::HAPI_QueryNodeOutputConnectedCount().
2979 ///
2980 /// @ingroup Nodes
2981 ///
2982 /// @param[in] session
2983 /// The session of Houdini you are interacting with.
2984 /// See @ref HAPI_Sessions for more on sessions.
2985 /// Pass NULL to just use the default in-process session.
2986 /// <!-- default NULL -->
2987 ///
2988 /// @param[in] node_id
2989 /// The node id.
2990 ///
2991 /// @param[in] output_idx
2992 /// The output index. Should be between 0 and the
2993 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2994 /// <!-- min 0 -->
2995 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
2996 ///
2997 /// @param[in] into_subnets
2998 /// Whether to search by diving into subnets.
2999 /// <!-- default true -->
3000 ///
3001 /// @param[in] through_dots
3002 /// Whether to search through dots.
3003 /// <!-- default true -->
3004 ///
3005 /// @param[out] connected_node_ids_array
3006 /// Array of ::HAPI_NodeId at least the size of @c length.
3007 ///
3008 /// @param[in] start
3009 /// At least @c 0 and at most @c connected_count returned by
3010 /// ::HAPI_QueryNodeOutputConnectedCount().
3011 /// <!-- min 0 -->
3012 /// <!-- max ::HAPI_QueryNodeOutputConnectedCount -->
3013 /// <!-- default 0 -->
3014 ///
3015 /// @param[in] length
3016 /// Given @c connected_count returned by
3017 /// ::HAPI_QueryNodeOutputConnectedCount(), @c length should
3018 /// be at least @c 1 and at most <tt>connected_count - start</tt>.
3019 /// <!-- min 1 -->
3020 /// <!-- max ::HAPI_QueryNodeOutputConnectedCount - start -->
3021 /// <!-- source ::HAPI_QueryNodeOutputConnectedCount - start -->
3022 ///
3024  HAPI_NodeId node_id,
3025  int output_idx,
3026  HAPI_Bool into_subnets,
3027  HAPI_Bool through_dots,
3028  HAPI_NodeId * connected_node_ids_array,
3029  int start, int length );
3030 
3031 /// @brief Get the name of an node's output. This function will return
3032 /// a string handle for the name which will be valid (persist)
3033 /// until the next call to this function.
3034 ///
3035 /// @ingroup Nodes
3036 ///
3037 /// @param[in] session
3038 /// The session of Houdini you are interacting with.
3039 /// See @ref HAPI_Sessions for more on sessions.
3040 /// Pass NULL to just use the default in-process session.
3041 /// <!-- default NULL -->
3042 ///
3043 /// @param[in] node_id
3044 /// The node id.
3045 ///
3046 /// @param[in] output_idx
3047 /// The output index. Should be between 0 and the
3048 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
3049 /// <!-- min 0 -->
3050 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
3051 ///
3052 /// @param[out] name
3053 /// Output name string handle return value - valid until
3054 /// the next call to this function.
3055 ///
3057  HAPI_NodeId node_id,
3058  int output_idx,
3059  HAPI_StringHandle * name );
3060 
3061 /// @brief Get the id of the node with the specified path.
3062 ///
3063 /// @ingroup Nodes
3064 ///
3065 /// @param[in] session
3066 /// The session of Houdini you are interacting with.
3067 /// See @ref HAPI_Sessions for more on sessions.
3068 /// Pass NULL to just use the default in-process session.
3069 /// <!-- default NULL -->
3070 ///
3071 /// @param[in] parent_node_id
3072 /// If @c path does not start with "/", search for the path
3073 /// relative to this node. Provide -1 if @c path is an absolute
3074 /// path.
3075 ///
3076 /// @param[in] path
3077 /// The path of the node. If the path does not start with "/",
3078 /// it is treated as a relative path from the node specified in
3079 /// @c parent_node_id.
3080 ///
3081 /// @param[out] node_id
3082 /// The id of the found node.
3083 ///
3085  const HAPI_NodeId parent_node_id,
3086  const char * path,
3087  HAPI_NodeId * node_id );
3088 
3089 /// @brief Gets the node id of an output node in a SOP network.
3090 ///
3091 /// @ingroup Nodes
3092 ///
3093 /// @param[in] session
3094 /// The session of Houdini you are interacting with.
3095 /// See @ref HAPI_Sessions for more on sessions.
3096 /// Pass NULL to just use the default in-process session.
3097 /// <!-- default NULL -->
3098 ///
3099 /// @param[in] node_id
3100 /// The node id of a SOP node with at least one output node. The
3101 /// total number of node outputs can be found from the node's
3102 /// ::HAPI_NodeInfo::outputCount
3103 ///
3104 /// @param[in] output
3105 /// The output index. Should be between 0 and the node's
3106 /// ::HAPI_NodeInfo::outputCount - 1.
3107 /// <!-- min 0 -->
3108 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
3109 ///
3110 /// @param[out] output_node_id
3111 /// Pointer to a HAPI_NodeId where the node id of the output
3112 /// node will be stored.
3114  HAPI_NodeId node_id,
3115  int output,
3116  HAPI_NodeId * output_node_id );
3117 
3118 /// @defgroup Parms Parms
3119 /// Functions for wroking with Node parameters (parms)
3120 
3121 /// @brief Fill an array of ::HAPI_ParmInfo structs with parameter
3122 /// information from the asset instance node.
3123 ///
3124 /// @ingroup Parms
3125 ///
3126 /// @param[in] session
3127 /// The session of Houdini you are interacting with.
3128 /// See @ref HAPI_Sessions for more on sessions.
3129 /// Pass NULL to just use the default in-process session.
3130 /// <!-- default NULL -->
3131 ///
3132 /// @param[in] node_id
3133 /// The node id.
3134 ///
3135 /// @param[out] parm_infos_array
3136 /// Array of ::HAPI_ParmInfo at least the size of
3137 /// length.
3138 ///
3139 /// @param[in] start
3140 /// First index of range. Must be at least 0 and at
3141 /// most ::HAPI_NodeInfo::parmCount - 1.
3142 /// <!-- min 0 -->
3143 /// <!-- max ::HAPI_NodeInfo::parmCount - 1 -->
3144 /// <!-- default 0 -->
3145 ///
3146 /// @param[in] length
3147 /// Must be at least 1 and at most
3148 /// ::HAPI_NodeInfo::parmCount - start.
3149 /// <!-- min 1 -->
3150 /// <!-- max ::HAPI_NodeInfo::parmCount - start -->
3151 /// <!-- source ::HAPI_NodeInfo::parmCount - start -->
3152 ///
3153 HAPI_DECL HAPI_GetParameters( const HAPI_Session * session,
3154  HAPI_NodeId node_id,
3155  HAPI_ParmInfo * parm_infos_array,
3156  int start, int length );
3157 
3158 /// @brief Get the parm info of a parameter by parm id.
3159 ///
3160 /// @ingroup Parms
3161 ///
3162 /// @param[in] session
3163 /// The session of Houdini you are interacting with.
3164 /// See @ref HAPI_Sessions for more on sessions.
3165 /// Pass NULL to just use the default in-process session.
3166 /// <!-- default NULL -->
3167 ///
3168 /// @param[in] node_id
3169 /// The node id.
3170 ///
3171 /// @param[in] parm_id
3172 /// The parm id.
3173 ///
3174 /// @param[out] parm_info
3175 /// The returned parm info.
3176 ///
3177 HAPI_DECL HAPI_GetParmInfo( const HAPI_Session * session,
3178  HAPI_NodeId node_id,
3179  HAPI_ParmId parm_id,
3180  HAPI_ParmInfo * parm_info );
3181 
3182 /// @brief All parameter APIs require a ::HAPI_ParmId but if you know the
3183 /// parameter you wish to operate on by name than you can use
3184 /// this function to get its ::HAPI_ParmId. If the parameter with
3185 /// the given name is not found the parameter id returned
3186 /// will be -1.
3187 ///
3188 /// @ingroup Parms
3189 ///
3190 /// @param[in] session
3191 /// The session of Houdini you are interacting with.
3192 /// See @ref HAPI_Sessions for more on sessions.
3193 /// Pass NULL to just use the default in-process session.
3194 /// <!-- default NULL -->
3195 ///
3196 /// @param[in] node_id
3197 /// The node id.
3198 ///
3199 /// @param[in] parm_name
3200 /// The parm name.
3201 ///
3202 /// @param[out] parm_id
3203 /// The return value. The parameter's ::HAPI_ParmId. If
3204 /// the parameter with the given name is not found the
3205 /// parameter id returned will be -1.
3206 ///
3208  HAPI_NodeId node_id,
3209  const char * parm_name,
3210  HAPI_ParmId * parm_id );
3211 
3212 /// @brief Get the parm info of a parameter by name.
3213 ///
3214 /// @ingroup Parms
3215 ///
3216 /// @param[in] session
3217 /// The session of Houdini you are interacting with.
3218 /// See @ref HAPI_Sessions for more on sessions.
3219 /// Pass NULL to just use the default in-process session.
3220 /// <!-- default NULL -->
3221 ///
3222 /// @param[in] node_id
3223 /// The node id.
3224 ///
3225 /// @param[in] parm_name
3226 /// The parm name.
3227 ///
3228 /// @param[out] parm_info
3229 /// The returned parm info.
3230 ///
3232  HAPI_NodeId node_id,
3233  const char * parm_name,
3234  HAPI_ParmInfo * parm_info );
3235 
3236 /// @brief Get the tag name on a parameter given an index.
3237 ///
3238 /// @ingroup Parms
3239 ///
3240 /// @param[in] session
3241 /// The session of Houdini you are interacting with.
3242 /// See @ref HAPI_Sessions for more on sessions.
3243 /// Pass NULL to just use the default in-process session.
3244 /// <!-- default NULL -->
3245 ///
3246 /// @param[in] node_id
3247 /// The node id.
3248 ///
3249 /// @param[in] parm_id
3250 /// The parm id.
3251 ///
3252 /// @param[in] tag_index
3253 /// The tag index, which should be between 0 and
3254 /// ::HAPI_ParmInfo::tagCount - 1.
3255 /// @note These indices are invalidated whenever tags are added
3256 /// to parameters. Do not store these or expect them to be the
3257 /// same if the scene is modified.
3258 /// <!-- min 0 -->
3259 /// <!-- max ::HAPI_ParmInfo::tagCount - 1 -->
3260 ///
3261 /// @param[out] tag_name
3262 /// The returned tag name. This string handle will be valid
3263 /// until another call to ::HAPI_GetParmTagName().
3264 ///
3265 HAPI_DECL HAPI_GetParmTagName( const HAPI_Session * session,
3266  HAPI_NodeId node_id,
3267  HAPI_ParmId parm_id,
3268  int tag_index,
3269  HAPI_StringHandle * tag_name );
3270 
3271 /// @brief Get the tag value on a parameter given the tag name.
3272 ///
3273 /// @ingroup Parms
3274 ///
3275 /// @param[in] session
3276 /// The session of Houdini you are interacting with.
3277 /// See @ref HAPI_Sessions for more on sessions.
3278 /// Pass NULL to just use the default in-process session.
3279 /// <!-- default NULL -->
3280 ///
3281 /// @param[in] node_id
3282 /// The node id.
3283 ///
3284 /// @param[in] parm_id
3285 /// The parm id.
3286 ///
3287 /// @param[in] tag_name
3288 /// The tag name, either known or returned by
3289 /// ::HAPI_GetParmTagName().
3290 ///
3291 /// @param[out] tag_value
3292 /// The returned tag value. This string handle will be valid
3293 /// until another call to ::HAPI_GetParmTagValue().
3294 ///
3296  HAPI_NodeId node_id,
3297  HAPI_ParmId parm_id,
3298  const char * tag_name,
3299  HAPI_StringHandle * tag_value );
3300 
3301 /// @brief See if a parameter has a specific tag.
3302 ///
3303 /// @ingroup Parms
3304 ///
3305 /// @param[in] session
3306 /// The session of Houdini you are interacting with.
3307 /// See @ref HAPI_Sessions for more on sessions.
3308 /// Pass NULL to just use the default in-process session.
3309 /// <!-- default NULL -->
3310 ///
3311 /// @param[in] node_id
3312 /// The node id.
3313 ///
3314 /// @param[in] parm_id
3315 /// The parm id.
3316 ///
3317 /// @param[in] tag_name
3318 /// The tag name to look for.
3319 ///
3320 /// @param[out] has_tag
3321 /// True if the tag exists on the parameter, false otherwise.
3322 ///
3323 HAPI_DECL HAPI_ParmHasTag( const HAPI_Session * session,
3324  HAPI_NodeId node_id,
3325  HAPI_ParmId parm_id,
3326  const char * tag_name,
3327  HAPI_Bool * has_tag );
3328 
3329 /// @brief See if a parameter has an expression
3330 ///
3331 /// @ingroup Parms
3332 ///
3333 /// @param[in] session
3334 /// The session of Houdini you are interacting with.
3335 /// See @ref HAPI_Sessions for more on sessions.
3336 /// Pass NULL to just use the default in-process session.
3337 /// <!-- default NULL -->
3338 ///
3339 /// @param[in] node_id
3340 /// The node id.
3341 ///
3342 /// @param[in] parm_name
3343 /// The parm name.
3344 ///
3345 /// @param[in] index
3346 /// The parm index.
3347 ///
3348 /// @param[out] has_expression
3349 /// True if an expression exists on the parameter, false otherwise.
3350 ///
3352  HAPI_NodeId node_id,
3353  const char * parm_name,
3354  int index,
3355  HAPI_Bool * has_expression );
3356 
3357 /// @brief Get the first parm with a specific, ideally unique, tag on it.
3358 /// This is particularly useful for getting the ogl parameters on a
3359 /// material node.
3360 ///
3361 /// @ingroup Parms
3362 ///
3363 /// @param[in] session
3364 /// The session of Houdini you are interacting with.
3365 /// See @ref HAPI_Sessions for more on sessions.
3366 /// Pass NULL to just use the default in-process session.
3367 /// <!-- default NULL -->
3368 ///
3369 /// @param[in] node_id
3370 /// The node id.
3371 ///
3372 /// @param[in] tag_name
3373 /// The tag name to look for.
3374 ///
3375 /// @param[out] parm_id
3376 /// The returned parm id. This will be -1 if no parm was found
3377 /// with this tag.
3378 ///
3379 HAPI_DECL HAPI_GetParmWithTag( const HAPI_Session * session,
3380  HAPI_NodeId node_id,
3381  const char * tag_name,
3382  HAPI_ParmId * parm_id );
3383 
3384 /// @brief Get single integer or float parm expression by name
3385 /// or Null string if no expression is present
3386 ///
3387 /// @ingroup Parms
3388 ///
3389 /// @param[in] session
3390 /// The session of Houdini you are interacting with.
3391 /// See @ref HAPI_Sessions for more on sessions.
3392 /// Pass NULL to just use the default in-process session.
3393 /// <!-- default NULL -->
3394 ///
3395 /// @param[in] node_id
3396 /// The node id.
3397 ///
3398 /// @param[in] parm_name
3399 /// The parm name.
3400 ///
3401 /// @param[in] index
3402 /// Index within the parameter's values tuple.
3403 ///
3404 /// @param[out] value
3405 /// The returned string value.
3406 ///
3408  HAPI_NodeId node_id,
3409  const char * parm_name,
3410  int index,
3412 
3413 /// @brief Revert single parm by name to default
3414 ///
3415 /// @ingroup Parms
3416 ///
3417 /// @param[in] session
3418 /// The session of Houdini you are interacting with.
3419 /// See @ref HAPI_Sessions for more on sessions.
3420 /// Pass NULL to just use the default in-process session.
3421 /// <!-- default NULL -->
3422 ///
3423 /// @param[in] node_id
3424 /// The node id.
3425 ///
3426 /// @param[in] parm_name
3427 /// The parm name.
3428 ///
3429 /// @param[in] index
3430 /// Index within the parameter's values tuple.
3431 ///
3433  HAPI_NodeId node_id,
3434  const char * parm_name,
3435  int index );
3436 
3437 /// @brief Revert all instances of the parm by name to defaults
3438 ///
3439 /// @ingroup Parms
3440 ///
3441 /// @param[in] session
3442 /// The session of Houdini you are interacting with.
3443 /// See @ref HAPI_Sessions for more on sessions.
3444 /// Pass NULL to just use the default in-process session.
3445 /// <!-- default NULL -->
3446 ///
3447 /// @param[in] node_id
3448 /// The node id.
3449 ///
3450 /// @param[in] parm_name
3451 /// The parm name.
3452 ///
3454  HAPI_NodeId node_id,
3455  const char * parm_name );
3456 
3457 /// @brief Set (push) an expression string. We can only set a single value at
3458 /// a time because we want to avoid fixed size string buffers.
3459 ///
3460 /// @note Regardless of the value, when calling this function
3461 /// on a parameter, if that parameter has a callback function
3462 /// attached to it, that callback function will be called. For
3463 /// example, if the parameter is a button the button will be
3464 /// pressed.
3465 ///
3466 /// @note In threaded mode, this is an _async call_!
3467 ///
3468 /// This API will invoke the cooking thread if threading is
3469 /// enabled. This means it will return immediately. Use
3470 /// the status and cooking count APIs under DIAGNOSTICS to get
3471 /// a sense of the progress. All other API calls will block
3472 /// until the cook operation has finished.
3473 ///
3474 /// Also note that the cook result won't be of type
3475 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3476 /// Whenever the threading cook is done it will fill the
3477 /// @a cook result which is queried using
3478 /// ::HAPI_STATUS_COOK_RESULT.
3479 ///
3480 /// @ingroup Parms
3481 ///
3482 /// @param[in] session
3483 /// The session of Houdini you are interacting with.
3484 /// See @ref HAPI_Sessions for more on sessions.
3485 /// Pass NULL to just use the default in-process session.
3486 /// <!-- default NULL -->
3487 ///
3488 /// @param[in] node_id
3489 /// The node id.
3490 ///
3491 /// @param[in] value
3492 /// The expression string.
3493 ///
3494 /// @param[in] parm_id
3495 /// Parameter id of the parameter being updated.
3496 ///
3497 /// @param[in] index
3498 /// Index within the parameter's values tuple.
3499 ///
3501  HAPI_NodeId node_id,
3502  const char * value,
3503  HAPI_ParmId parm_id, int index );
3504 
3505 /// @brief Remove the expression string, leaving the value of the
3506 /// parm at the current value of the expression
3507 ///
3508 /// @note Regardless of the value, when calling this function
3509 /// on a parameter, if that parameter has a callback function
3510 /// attached to it, that callback function will be called. For
3511 /// example, if the parameter is a button the button will be
3512 /// pressed.
3513 ///
3514 /// @note In threaded mode, this is an _async call_!
3515 ///
3516 /// This API will invoke the cooking thread if threading is
3517 /// enabled. This means it will return immediately. Use
3518 /// the status and cooking count APIs under DIAGNOSTICS to get
3519 /// a sense of the progress. All other API calls will block
3520 /// until the cook operation has finished.
3521 ///
3522 /// Also note that the cook result won't be of type
3523 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3524 /// Whenever the threading cook is done it will fill the
3525 /// @a cook result which is queried using
3526 /// ::HAPI_STATUS_COOK_RESULT.
3527 ///
3528 /// @ingroup Parms
3529 ///
3530 /// @param[in] session
3531 /// The session of Houdini you are interacting with.
3532 /// See @ref HAPI_Sessions for more on sessions.
3533 /// Pass NULL to just use the default in-process session.
3534 /// <!-- default NULL -->
3535 ///
3536 /// @param[in] node_id
3537 /// The node id.
3538 ///
3539 /// @param[in] parm_id
3540 /// Parameter id of the parameter being updated.
3541 ///
3542 /// @param[in] index
3543 /// Index within the parameter's values tuple.
3544 ///
3546  HAPI_NodeId node_id,
3547  HAPI_ParmId parm_id, int index );
3548 
3549 /// @brief Get single parm int value by name.
3550 ///
3551 /// @ingroup Parms
3552 ///
3553 /// @param[in] session
3554 /// The session of Houdini you are interacting with.
3555 /// See @ref HAPI_Sessions for more on sessions.
3556 /// Pass NULL to just use the default in-process session.
3557 /// <!-- default NULL -->
3558 ///
3559 /// @param[in] node_id
3560 /// The node id.
3561 ///
3562 /// @param[in] parm_name
3563 /// The parm name.
3564 ///
3565 /// @param[in] index
3566 /// Index within the parameter's values tuple.
3567 ///
3568 /// @param[out] value
3569 /// The returned int value.
3570 ///
3572  HAPI_NodeId node_id,
3573  const char * parm_name,
3574  int index,
3575  int * value );
3576 
3577 /// @brief Fill an array of parameter int values. This is more efficient
3578 /// than calling ::HAPI_GetParmIntValue() individually for each
3579 /// parameter value.
3580 ///
3581 /// @ingroup Parms
3582 ///
3583 /// @param[in] session
3584 /// The session of Houdini you are interacting with.
3585 /// See @ref HAPI_Sessions for more on sessions.
3586 /// Pass NULL to just use the default in-process session.
3587 /// <!-- default NULL -->
3588 ///
3589 /// @param[in] node_id
3590 /// The node id.
3591 ///
3592 /// @param[out] values_array
3593 /// Array of ints at least the size of length.
3594 ///
3595 /// @param[in] start
3596 /// First index of range. Must be at least 0 and at
3597 /// most ::HAPI_NodeInfo::parmIntValueCount - 1.
3598 /// <!-- min 0 -->
3599 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - 1 -->
3600 /// <!-- default 0 -->
3601 ///
3602 /// @param[in] length
3603 /// Must be at least 1 and at most
3604 /// ::HAPI_NodeInfo::parmIntValueCount - start.
3605 /// <!-- min 1 -->
3606 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - start -->
3607 /// <!-- source ::HAPI_NodeInfo::parmIntValueCount - start -->
3608 ///
3610  HAPI_NodeId node_id,
3611  int * values_array,
3612  int start, int length );
3613 
3614 /// @brief Get single parm float value by name.
3615 ///
3616 /// @ingroup Parms
3617 ///
3618 /// @param[in] session
3619 /// The session of Houdini you are interacting with.
3620 /// See @ref HAPI_Sessions for more on sessions.
3621 /// Pass NULL to just use the default in-process session.
3622 /// <!-- default NULL -->
3623 ///
3624 /// @param[in] node_id
3625 /// The node id.
3626 ///
3627 /// @param[in] parm_name
3628 /// The parm name.
3629 ///
3630 /// @param[in] index
3631 /// Index within the parameter's values tuple.
3632 ///
3633 /// @param[out] value
3634 /// The returned float value.
3635 ///
3637  HAPI_NodeId node_id,
3638  const char * parm_name,
3639  int index,
3640  float * value );
3641 
3642 /// @brief Fill an array of parameter float values. This is more efficient
3643 /// than calling ::HAPI_GetParmFloatValue() individually for each
3644 /// parameter value.
3645 ///
3646 /// @ingroup Parms
3647 ///
3648 /// @param[in] session
3649 /// The session of Houdini you are interacting with.
3650 /// See @ref HAPI_Sessions for more on sessions.
3651 /// Pass NULL to just use the default in-process session.
3652 /// <!-- default NULL -->
3653 ///
3654 /// @param[in] node_id
3655 /// The node id.
3656 ///
3657 /// @param[out] values_array
3658 /// Array of floats at least the size of length.
3659 ///
3660 /// @param[in] start
3661 /// First index of range. Must be at least 0 and at
3662 /// most ::HAPI_NodeInfo::parmFloatValueCount - 1.
3663 /// <!-- min 0 -->
3664 /// <!-- max ::HAPI_NodeInfo::parmFloatValueCount - 1 -->
3665 /// <!-- default 0 -->
3666 ///
3667 /// @param[in] length
3668 /// Must be at least 1 and at most
3669 /// ::HAPI_NodeInfo::parmFloatValueCount - start.
3670 /// <!-- min 1 -->
3671 /// <!-- max ::HAPI_NodeInfo::parmFloatValueCount - start -->
3672 /// <!-- source ::HAPI_NodeInfo::parmFloatValueCount - start -->
3673 ///
3675  HAPI_NodeId node_id,
3676  float * values_array,
3677  int start, int length );
3678 
3679 /// @brief Get single parm string value by name.
3680 ///
3681 /// @ingroup Parms
3682 ///
3683 /// @param[in] session
3684 /// The session of Houdini you are interacting with.
3685 /// See @ref HAPI_Sessions for more on sessions.
3686 /// Pass NULL to just use the default in-process session.
3687 /// <!-- default NULL -->
3688 ///
3689 /// @param[in] node_id
3690 /// The node id.
3691 ///
3692 /// @param[in] parm_name
3693 /// The name of the parameter.
3694 ///
3695 /// @param[in] index
3696 /// Index within the parameter's values tuple.
3697 ///
3698 /// @param[in] evaluate
3699 /// Whether or not to evaluate the string expression.
3700 /// For example, the string "$F" would evaluate to the
3701 /// current frame number. So, passing in evaluate = false
3702 /// would give you back the string "$F" and passing
3703 /// in evaluate = true would give you back "1" (assuming
3704 /// the current frame is 1).
3705 /// <!-- default true -->
3706 ///
3707 /// @param[out] value
3708 /// The returned string value.
3709 ///
3711  HAPI_NodeId node_id,
3712  const char * parm_name,
3713  int index,
3714  HAPI_Bool evaluate,
3716 
3717 /// @brief Fill an array of parameter string handles. These handles must
3718 /// be used in conjunction with ::HAPI_GetString() to get the
3719 /// actual string values. This is more efficient than calling
3720 /// ::HAPI_GetParmStringValue() individually for each
3721 /// parameter value.
3722 ///
3723 /// @ingroup Parms
3724 ///
3725 /// @param[in] session
3726 /// The session of Houdini you are interacting with.
3727 /// See @ref HAPI_Sessions for more on sessions.
3728 /// Pass NULL to just use the default in-process session.
3729 /// <!-- default NULL -->
3730 ///
3731 /// @param[in] node_id
3732 /// The node id.
3733 ///
3734 /// @param[in] evaluate
3735 /// Whether or not to evaluate the string expression.
3736 /// For example, the string "$F" would evaluate to the
3737 /// current frame number. So, passing in evaluate = false
3738 /// would give you back the string "$F" and passing
3739 /// in evaluate = true would give you back "1" (assuming
3740 /// the current frame is 1).
3741 ///
3742 /// @param[out] values_array
3743 /// Array of integers at least the size of length.
3744 ///
3745 /// @param[in] start
3746 /// First index of range. Must be at least 0 and at
3747 /// most ::HAPI_NodeInfo::parmStringValueCount - 1.
3748 /// <!-- min 0 -->
3749 /// <!-- max ::HAPI_NodeInfo::parmStringValueCount - 1 -->
3750 /// <!-- default 0 -->
3751 ///
3752 /// @param[in] length
3753 /// Must be at least 1 and at most
3754 /// ::HAPI_NodeInfo::parmStringValueCount - start.
3755 /// <!-- min 1 -->
3756 /// <!-- max ::HAPI_NodeInfo::parmStringValueCount - start -->
3757 /// <!-- source ::HAPI_NodeInfo::parmStringValueCount - start -->
3758 ///
3760  HAPI_NodeId node_id,
3761  HAPI_Bool evaluate,
3762  HAPI_StringHandle * values_array,
3763  int start, int length );
3764 
3765 /// @brief Get a single node id parm value of an Op Path parameter. This is
3766 /// how you see which node is connected as an input for the current
3767 /// node (via parameter).
3768 ///
3769 /// @ingroup Parms
3770 ///
3771 /// @param[in] session
3772 /// The session of Houdini you are interacting with.
3773 /// See @ref HAPI_Sessions for more on sessions.
3774 /// Pass NULL to just use the default in-process session.
3775 /// <!-- default NULL -->
3776 ///
3777 /// @param[in] node_id
3778 /// The node id.
3779 ///
3780 /// @param[in] parm_name
3781 /// The name of the parameter.
3782 ///
3783 /// @param[out] value
3784 /// The node id of the node being pointed to by the parm.
3785 /// If there is no node found, -1 will be returned.
3786 ///
3788  HAPI_NodeId node_id,
3789  const char * parm_name,
3790  HAPI_NodeId * value );
3791 
3792 /// @brief Extract a file specified by path on a parameter. This will copy
3793 /// the file to the destination directory from wherever it might be,
3794 /// inlcuding inside the asset definition or online.
3795 ///
3796 /// @ingroup Parms
3797 ///
3798 /// @param[in] session
3799 /// The session of Houdini you are interacting with.
3800 /// See @ref HAPI_Sessions for more on sessions.
3801 /// Pass NULL to just use the default in-process session.
3802 /// <!-- default NULL -->
3803 ///
3804 /// @param[in] node_id
3805 /// The node id.
3806 ///
3807 /// @param[in] parm_name
3808 /// The name of the parameter.
3809 ///
3810 /// @param[in] destination_directory
3811 /// The destination directory to copy the file to.
3812 ///
3813 /// @param[in] destination_file_name
3814 /// The destination file name.
3815 ///
3816 HAPI_DECL HAPI_GetParmFile( const HAPI_Session * session,
3817  HAPI_NodeId node_id,
3818  const char * parm_name,
3819  const char * destination_directory,
3820  const char * destination_file_name );
3821 
3822 /// @brief Fill an array of ::HAPI_ParmChoiceInfo structs with parameter
3823 /// choice list information from the asset instance node.
3824 ///
3825 /// @ingroup Parms
3826 ///
3827 /// @param[in] session
3828 /// The session of Houdini you are interacting with.
3829 /// See @ref HAPI_Sessions for more on sessions.
3830 /// Pass NULL to just use the default in-process session.
3831 /// <!-- default NULL -->
3832 ///
3833 /// @param[in] node_id
3834 /// The node id.
3835 ///
3836 /// @param[out] parm_choices_array
3837 /// Array of ::HAPI_ParmChoiceInfo exactly the size of
3838 /// length.
3839 ///
3840 /// @param[in] start
3841 /// First index of range. Must be at least 0 and at
3842 /// most ::HAPI_NodeInfo::parmChoiceCount - 1.
3843 /// <!-- min 0 -->
3844 /// <!-- max ::HAPI_NodeInfo::parmChoiceCount - 1 -->
3845 /// <!-- default 0 -->
3846 ///
3847 /// @param[in] length
3848 /// Must be at least 1 and at most
3849 /// ::HAPI_NodeInfo::parmChoiceCount - start.
3850 /// <!-- min 1 -->
3851 /// <!-- max ::HAPI_NodeInfo::parmChoiceCount - start -->
3852 /// <!-- source ::HAPI_NodeInfo::parmChoiceCount - start -->
3853 ///
3855  HAPI_NodeId node_id,
3856  HAPI_ParmChoiceInfo * parm_choices_array,
3857  int start, int length );
3858 
3859 /// @brief Set single parm int value by name.
3860 ///
3861 /// @note Regardless of the value, when calling this function
3862 /// on a parameter, if that parameter has a callback function
3863 /// attached to it, that callback function will be called. For
3864 /// example, if the parameter is a button the button will be
3865 /// pressed.
3866 ///
3867 /// @note In threaded mode, this is an _async call_!
3868 ///
3869 /// This API will invoke the cooking thread if threading is
3870 /// enabled. This means it will return immediately. Use
3871 /// the status and cooking count APIs under DIAGNOSTICS to get
3872 /// a sense of the progress. All other API calls will block
3873 /// until the cook operation has finished.
3874 ///
3875 /// Also note that the cook result won't be of type
3876 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3877 /// Whenever the threading cook is done it will fill the
3878 /// @a cook result which is queried using
3879 /// ::HAPI_STATUS_COOK_RESULT.
3880 ///
3881 /// @ingroup Parms
3882 ///
3883 /// @param[in] session
3884 /// The session of Houdini you are interacting with.
3885 /// See @ref HAPI_Sessions for more on sessions.
3886 /// Pass NULL to just use the default in-process session.
3887 /// <!-- default NULL -->
3888 ///
3889 /// @param[in] node_id
3890 /// The node id.
3891 ///
3892 /// @param[in] parm_name
3893 /// The parm name.
3894 ///
3895 /// @param[in] index
3896 /// Index within the parameter's values tuple.
3897 ///
3898 /// @param[in] value
3899 /// The int value.
3900 ///
3902  HAPI_NodeId node_id,
3903  const char * parm_name,
3904  int index,
3905  int value );
3906 
3907 /// @brief Set (push) an array of parameter int values.
3908 ///
3909 /// @note Regardless of the values, when calling this function
3910 /// on a set of parameters, if any parameter has a callback
3911 /// function attached to it, that callback function will be called.
3912 /// For example, if the parameter is a button the button will be
3913 /// pressed.
3914 ///
3915 /// @note In threaded mode, this is an _async call_!
3916 ///
3917 /// This API will invoke the cooking thread if threading is
3918 /// enabled. This means it will return immediately. Use
3919 /// the status and cooking count APIs under DIAGNOSTICS to get
3920 /// a sense of the progress. All other API calls will block
3921 /// until the cook operation has finished.
3922 ///
3923 /// Also note that the cook result won't be of type
3924 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3925 /// Whenever the threading cook is done it will fill the
3926 /// @a cook result which is queried using
3927 /// ::HAPI_STATUS_COOK_RESULT.
3928 ///
3929 /// @ingroup Parms
3930 ///
3931 /// @param[in] session
3932 /// The session of Houdini you are interacting with.
3933 /// See @ref HAPI_Sessions for more on sessions.
3934 /// Pass NULL to just use the default in-process session.
3935 /// <!-- default NULL -->
3936 ///
3937 /// @param[in] node_id
3938 /// The node id.
3939 ///
3940 /// @param[in] values_array
3941 /// Array of integers at least the size of length.
3942 /// <!-- min length -->
3943 ///
3944 /// @param[in] start
3945 /// First index of range. Must be at least 0 and at
3946 /// most ::HAPI_NodeInfo::parmIntValueCount - 1.
3947 /// <!-- min 0 -->
3948 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - 1 -->
3949 /// <!-- default 0 -->
3950 ///
3951 /// @param[in] length
3952 /// Must be at least 1 and at most
3953 /// ::HAPI_NodeInfo::parmIntValueCount - start.
3954 /// <!-- min 1 -->
3955 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - start -->
3956 /// <!-- source ::HAPI_NodeInfo::parmIntValueCount - start -->
3957 ///
3959  HAPI_NodeId node_id,
3960  const int * values_array,
3961  int start, int length );
3962 
3963 /// @brief Set single parm float value by name.
3964 ///
3965 /// @note Regardless of the value, when calling this function
3966 /// on a parameter, if that parameter has a callback function
3967 /// attached to it, that callback function will be called. For
3968 /// example, if the parameter is a button the button will be
3969 /// pressed.
3970 ///
3971 /// @note In threaded mode, this is an _async call_!
3972 ///
3973 /// This API will invoke the cooking thread if threading is
3974 /// enabled. This means it will return immediately. Use
3975 /// the status and cooking count APIs under DIAGNOSTICS to get
3976 /// a sense of the progress. All other API calls will block
3977 /// until the cook operation has finished.
3978 ///
3979 /// Also note that the cook result won't be of type
3980 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3981 /// Whenever the threading cook is done it will fill the
3982 /// @a cook result which is queried using
3983 /// ::HAPI_STATUS_COOK_RESULT.
3984 ///
3985 /// @ingroup Parms
3986 ///
3987 /// @param[in] session
3988 /// The session of Houdini you are interacting with.
3989 /// See @ref HAPI_Sessions for more on sessions.
3990 /// Pass NULL to just use the default in-process session.
3991 /// <!-- default NULL -->
3992 ///
3993 /// @param[in] node_id
3994 /// The node id.
3995 ///
3996 /// @param[in] parm_name
3997 /// The parm name.
3998 ///
3999 /// @param[in] index
4000 /// Index within the parameter's values tuple.
4001 ///
4002 /// @param[in] value
4003 /// The float value.
4004 ///
4006  HAPI_NodeId node_id,
4007  const char * parm_name,
4008  int index,
4009  float value );
4010 
4011 /// @brief Set (push) an array of parameter float values.
4012 ///
4013 /// @note Regardless of the values, when calling this function
4014 /// on a set of parameters, if any parameter has a callback
4015 /// function attached to it, that callback function will be called.
4016 /// For example, if the parameter is a button the button will be
4017 /// pressed.
4018 ///
4019 /// @note In threaded mode, this is an _async call_!
4020 ///
4021 /// This API will invoke the cooking thread if threading is
4022 /// enabled. This means it will return immediately. Use
4023 /// the status and cooking count APIs under DIAGNOSTICS to get
4024 /// a sense of the progress. All other API calls will block
4025 /// until the cook operation has finished.
4026 ///
4027 /// Also note that the cook result won't be of type
4028 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
4029 /// Whenever the threading cook is done it will fill the
4030 /// @a cook result which is queried using
4031 /// ::HAPI_STATUS_COOK_RESULT.
4032 ///
4033 /// @ingroup Parms
4034 ///
4035 /// @param[in] session
4036 /// The session of Houdini you are interacting with.
4037 /// See @ref HAPI_Sessions for more on sessions.
4038 /// Pass NULL to just use the default in-process session.
4039 /// <!-- default NULL -->
4040 ///
4041 /// @param[in] node_id
4042 /// The node id.
4043 ///
4044 /// @param[in] values_array
4045 /// Array of floats at least the size of length.
4046 ///
4047 /// @param[in] start
4048 /// First index of range. Must be at least 0 and at
4049 /// most ::HAPI_NodeInfo::parmFloatValueCount - 1.
4050 ///
4051 /// @param[in] length
4052 /// Must be at least 1 and at most
4053 /// ::HAPI_NodeInfo::parmFloatValueCount - start.
4054 ///
4056  HAPI_NodeId node_id,
4057  const float * values_array,
4058  int start, int length );
4059 
4060 /// @brief Set (push) a string value. We can only set a single value at
4061 /// a time because we want to avoid fixed size string buffers.
4062 ///
4063 /// @note Regardless of the value, when calling this function
4064 /// on a parameter, if that parameter has a callback function
4065 /// attached to it, that callback function will be called. For
4066 /// example, if the parameter is a button the button will be
4067 /// pressed.
4068 ///
4069 /// @note In threaded mode, this is an _async call_!
4070 ///
4071 /// This API will invoke the cooking thread if threading is
4072 /// enabled. This means it will return immediately. Use
4073 /// the status and cooking count APIs under DIAGNOSTICS to get
4074 /// a sense of the progress. All other API calls will block
4075 /// until the cook operation has finished.
4076 ///
4077 /// Also note that the cook result won't be of type
4078 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
4079 /// Whenever the threading cook is done it will fill the
4080 /// @a cook result which is queried using
4081 /// ::HAPI_STATUS_COOK_RESULT.
4082 ///
4083 /// @ingroup Parms
4084 ///
4085 /// @param[in] session
4086 /// The session of Houdini you are interacting with.
4087 /// See @ref HAPI_Sessions for more on sessions.
4088 /// Pass NULL to just use the default in-process session.
4089 /// <!-- default NULL -->
4090 ///
4091 /// @param[in] node_id
4092 /// The node id.
4093 ///
4094 /// @param[in] value
4095 /// The string value.
4096 ///
4097 /// @param[in] parm_id
4098 /// Parameter id of the parameter being updated.
4099 ///
4100 /// @param[in] index
4101 /// Index within the parameter's values tuple.
4102 ///
4104  HAPI_NodeId node_id,
4105  const char * value,
4106  HAPI_ParmId parm_id, int index );
4107 
4108 /// @brief Set a node id parm value of an Op Path parameter. For example,
4109 /// This is how you connect the geometry output of an asset to the
4110 /// geometry input of another asset - whether the input is a parameter
4111 /// or a node input (the top of the node). Node inputs get converted
4112 /// top parameters in HAPI.
4113 ///
4114 /// @ingroup Parms
4115 ///
4116 /// @param[in] session
4117 /// The session of Houdini you are interacting with.
4118 /// See @ref HAPI_Sessions for more on sessions.
4119 /// Pass NULL to just use the default in-process session.
4120 /// <!-- default NULL -->
4121 ///
4122 /// @param[in] node_id
4123 /// The node id.
4124 ///
4125 /// @param[in] parm_name
4126 /// The name of the parameter.
4127 ///
4128 /// @param[in] value
4129 /// The node id of the node being connected. Pass -1 to
4130 /// disconnect.
4131 ///
4133  HAPI_NodeId node_id,
4134  const char * parm_name,
4135  HAPI_NodeId value );
4136 
4137 /// @brief Insert an instance of a multiparm before instance_position.
4138 ///
4139 /// @ingroup Parms
4140 ///
4141 /// @param[in] session
4142 /// The session of Houdini you are interacting with.
4143 /// See @ref HAPI_Sessions for more on sessions.
4144 /// Pass NULL to just use the default in-process session.
4145 /// <!-- default NULL -->
4146 ///
4147 /// @param[in] node_id
4148 /// The node id.
4149 ///
4150 /// @param[in] parm_id
4151 /// A parm id given by a ::HAPI_ParmInfo struct that
4152 /// has type ::HAPI_PARMTYPE_MULTIPARMLIST.
4153 ///
4154 /// @param[in] instance_position
4155 /// The new instance will be inserted at this position
4156 /// index. Do note the multiparms can start at position
4157 /// 1 or 0. Use ::HAPI_ParmInfo::instanceStartOffset to
4158 /// distinguish.
4159 ///
4161  HAPI_NodeId node_id,
4162  HAPI_ParmId parm_id,
4163  int instance_position );
4164 
4165 /// @brief Remove the instance of a multiparm given by instance_position.
4166 ///
4167 /// @ingroup Parms
4168 ///
4169 /// @param[in] session
4170 /// The session of Houdini you are interacting with.
4171 /// See @ref HAPI_Sessions for more on sessions.
4172 /// Pass NULL to just use the default in-process session.
4173 /// <!-- default NULL -->
4174 ///
4175 /// @param[in] node_id
4176 /// The node id.
4177 ///
4178 /// @param[in] parm_id
4179 /// A parm id given by a ::HAPI_ParmInfo struct that
4180 /// has type ::HAPI_PARMTYPE_MULTIPARMLIST.
4181 ///
4182 /// @param[in] instance_position
4183 /// The instance at instance_position will removed.
4184 ///
4186  HAPI_NodeId node_id,
4187  HAPI_ParmId parm_id,
4188  int instance_position );
4189 
4190 // HANDLES ------------------------------------------------------------------
4191 
4192 /// @brief Fill an array of ::HAPI_HandleInfo structs with information
4193 /// about every exposed user manipulation handle on the node.
4194 ///
4195 /// @ingroup Parms
4196 ///
4197 /// @param[in] session
4198 /// The session of Houdini you are interacting with.
4199 /// See @ref HAPI_Sessions for more on sessions.
4200 /// Pass NULL to just use the default in-process session.
4201 /// <!-- default NULL -->
4202 ///
4203 /// @param[in] node_id
4204 /// The node id.
4205 ///
4206 /// @param[out] handle_infos_array
4207 /// Array of ::HAPI_HandleInfo at least the size of length.
4208 ///
4209 /// @param[in] start
4210 /// First index of range. Must be at least 0 and at
4211 /// most ::HAPI_AssetInfo::handleCount - 1.
4212 /// <!-- default 0 -->
4213 ///
4214 /// @param[in] length
4215 /// Must be at least 1 and at most
4216 /// ::HAPI_AssetInfo::handleCount - start.
4217 /// <!-- source ::HAPI_AssetInfo::handleCount - start -->
4218 ///
4219 HAPI_DECL HAPI_GetHandleInfo( const HAPI_Session * session,
4220  HAPI_NodeId node_id,
4221  HAPI_HandleInfo * handle_infos_array,
4222  int start, int length );
4223 
4224 /// @brief Fill an array of ::HAPI_HandleBindingInfo structs with information
4225 /// about the binding of a particular handle on the given node.
4226 ///
4227 /// @ingroup Parms
4228 ///
4229 /// @param[in] session
4230 /// The session of Houdini you are interacting with.
4231 /// See @ref HAPI_Sessions for more on sessions.
4232 /// Pass NULL to just use the default in-process session.
4233 /// <!-- default NULL -->
4234 ///
4235 /// @param[in] node_id
4236 /// The node id.
4237 ///
4238 /// @param[in] handle_index
4239 /// The index of the handle, from 0 to handleCount - 1
4240 /// from the call to ::HAPI_GetAssetInfo().
4241 ///
4242 /// @param[out] handle_binding_infos_array
4243 /// Array of ::HAPI_HandleBindingInfo at least the size
4244 /// of length.
4245 ///
4246 /// @param[in] start
4247 /// First index of range. Must be at least 0 and at
4248 /// most ::HAPI_HandleInfo::bindingsCount - 1.
4249 /// <!-- default 0 -->
4250 ///
4251 /// @param[in] length
4252 /// Must be at least 1 and at most
4253 /// ::HAPI_HandleInfo::bindingsCount - start.
4254 /// <!-- source ::HAPI_AssetInfo::bindingsCount - start -->
4255 ///
4257  const HAPI_Session * session,
4258  HAPI_NodeId node_id,
4259  int handle_index,
4260  HAPI_HandleBindingInfo * handle_binding_infos_array,
4261  int start, int length );
4262 
4263 /// @defgroup Presets Presets
4264 /// Functions for working with Node presets
4265 
4266 /// @brief Generate a preset blob of the current state of all the
4267 /// parameter values, cache it, and return its size in bytes.
4268 ///
4269 /// @ingroup Presets
4270 ///
4271 /// @param[in] session
4272 /// The session of Houdini you are interacting with.
4273 /// See @ref HAPI_Sessions for more on sessions.
4274 /// Pass NULL to just use the default in-process session.
4275 /// <!-- default NULL -->
4276 ///
4277 /// @param[in] node_id
4278 /// The exposed node id.
4279 ///
4280 /// @param[in] preset_type
4281 /// The preset type.
4282 ///
4283 /// @param[in] preset_name
4284 /// Optional. This is only used if the @p preset_type is
4285 /// ::HAPI_PRESETTYPE_IDX. If NULL is given, the preset
4286 /// name will be the same as the name of the node with
4287 /// the given @p node_id.
4288 ///
4289 /// @param[out] buffer_length
4290 /// Size of the buffer.
4291 ///
4293  HAPI_NodeId node_id,
4294  HAPI_PresetType preset_type,
4295  const char * preset_name,
4296  int * buffer_length );
4297 
4298 /// @brief Generates a preset for the given asset.
4299 ///
4300 /// @ingroup Presets
4301 ///
4302 /// @param[in] session
4303 /// The session of Houdini you are interacting with.
4304 /// See @ref HAPI_Sessions for more on sessions.
4305 /// Pass NULL to just use the default in-process session.
4306 /// <!-- default NULL -->
4307 ///
4308 /// @param[in] node_id
4309 /// The exposed node id.
4310 ///
4311 /// @param[out] buffer
4312 /// Buffer to hold the preset data.
4313 ///
4314 /// @param[in] buffer_length
4315 /// Size of the buffer. Should be the same as the length
4316 /// returned by ::HAPI_GetPresetBufLength().
4317 ///
4318 HAPI_DECL HAPI_GetPreset( const HAPI_Session * session,
4319  HAPI_NodeId node_id,
4320  char * buffer,
4321  int buffer_length );
4322 
4323 /// @brief Sets a particular asset to a given preset.
4324 ///
4325 /// @ingroup Presets
4326 ///
4327 /// @param[in] session
4328 /// The session of Houdini you are interacting with.
4329 /// See @ref HAPI_Sessions for more on sessions.
4330 /// Pass NULL to just use the default in-process session.
4331 /// <!-- default NULL -->
4332 ///
4333 /// @param[in] node_id
4334 /// The exposed node id.
4335 ///
4336 /// @param[in] preset_type
4337 /// The preset type.
4338 ///
4339 /// @param[in] preset_name
4340 /// Optional. This is only used if the @p preset_type is
4341 /// ::HAPI_PRESETTYPE_IDX. If NULL is give, the first
4342 /// preset in the IDX file will be chosen.
4343 /// <!-- default NULL -->
4344 ///
4345 /// @param[in] buffer
4346 /// Buffer to hold the preset data.
4347 ///
4348 /// @param[in] buffer_length
4349 /// Size of the buffer.
4350 ///
4351 HAPI_DECL HAPI_SetPreset( const HAPI_Session * session,
4352  HAPI_NodeId node_id,
4353  HAPI_PresetType preset_type,
4354  const char * preset_name,
4355  const char * buffer,
4356  int buffer_length );
4357 
4358 /// @brief Gets the number of presets in an IDX file. When this method is
4359 /// called, the names of the presets are stored in a single internal
4360 /// buffer from which they can be retrieved by calling
4361 /// HAPI_GetPresetNames().
4362 ///
4363 /// Note that calling HAPI_GetPresetCount() will overwrite the preset
4364 /// names that were previously stored in the internal buffer. Therefore,
4365 /// ensure that you have called HAPI_GetPresetNames() before calling
4366 /// HAPI_GetPresetCount() again.
4367 ///
4368 /// @ingroup Presets
4369 ///
4370 /// @param[in] session
4371 /// The session of Houdini you are interacting with.
4372 /// See @ref HAPI_Sessions for more on sessions.
4373 /// Pass NULL to just use the default in-process session.
4374 /// <!-- default NULL -->
4375 ///
4376 /// @param[in] buffer
4377 /// A buffer containing the raw binary data of the .idx file.
4378 ///
4379 /// @param[in] buffer_length
4380 /// Size of the buffer.
4381 ///
4382 /// @param[out] count
4383 /// Number of presets in the file.
4384 ///
4385 HAPI_DECL HAPI_GetPresetCount( const HAPI_Session * session,
4386  const char * buffer,
4387  int buffer_length,
4388  int * count );
4389 
4390 /// @brief Gets the names of presets in an IDX file. HAPI_GetPresetCount() must
4391 /// be called before calling this method. See the HAPI_GetPresetCount()
4392 /// documentation for more information.
4393 ///
4394 /// @ingroup Presets
4395 ///
4396 /// @param[in] session
4397 /// The session of Houdini you are interacting with.
4398 /// See @ref HAPI_Sessions for more on sessions.
4399 /// Pass NULL to just use the default in-process session.
4400 /// <!-- default NULL -->
4401 ///
4402 /// @param[in] buffer
4403 /// A buffer containing the raw binary data of the .idx file.
4404 /// This should be the same buffer that was passed into
4405 /// HAPI_GetPresetCount().
4406 ///
4407 /// @param[in] buffer_length
4408 /// Size of the buffer.
4409 ///
4410 /// @param[out] preset_names_array
4411 /// Array of preset names to be filled
4412 ///
4413 /// @param[in] preset_names_count
4414 /// Number of presets in the file. Should be the same as
4415 /// the count returned by ::HAPI_GetPresetCount()
4416 ///
4417 HAPI_DECL HAPI_GetPresetNames( const HAPI_Session * session,
4418  const char * buffer,
4419  int buffer_length,
4420  HAPI_StringHandle * preset_names_array,
4421  int preset_names_count );
4422 
4423 /// @defgroup Objects
4424 /// Functions for working with OBJ Nodes
4425 
4426 /// @brief Get the object info on an OBJ node.
4427 ///
4428 /// @ingroup Objects
4429 ///
4430 /// @param[in] session
4431 /// The session of Houdini you are interacting with.
4432 /// See @ref HAPI_Sessions for more on sessions.
4433 /// Pass NULL to just use the default in-process session.
4434 /// <!-- default NULL -->
4435 ///
4436 /// @param[in] node_id
4437 /// The node id.
4438 ///
4439 /// @param[out] object_info
4440 /// The output ::HAPI_ObjectInfo.
4441 ///
4442 HAPI_DECL HAPI_GetObjectInfo( const HAPI_Session * session,
4443  HAPI_NodeId node_id,
4444  HAPI_ObjectInfo * object_info );
4445 
4446 /// @brief Get the tranform of an OBJ node.
4447 ///
4448 /// @ingroup Objects
4449 ///
4450 /// @param[in] session
4451 /// The session of Houdini you are interacting with.
4452 /// See @ref HAPI_Sessions for more on sessions.
4453 /// Pass NULL to just use the default in-process session.
4454 /// <!-- default NULL -->
4455 ///
4456 /// @param[in] node_id
4457 /// The object node id.
4458 ///
4459 /// @param[in] relative_to_node_id
4460 /// The object node id for the object to which the returned
4461 /// transform will be relative to. Pass -1 or the node_id
4462 /// to just get the object's local transform.
4463 ///
4464 /// @param[in] rst_order
4465 /// The order of application of translation, rotation and
4466 /// scale.
4467 ///
4468 /// @param[out] transform
4469 /// The output ::HAPI_Transform transform.
4470 ///
4472  HAPI_NodeId node_id,
4473  HAPI_NodeId relative_to_node_id,
4474  HAPI_RSTOrder rst_order,
4476 
4477 /// @brief Compose a list of child object nodes given a parent node id.
4478 ///
4479 /// Use the @c object_count returned by this function to get the
4480 /// ::HAPI_ObjectInfo structs for each child object using
4481 /// ::HAPI_GetComposedObjectList().
4482 ///
4483 /// Note, if not using the @c categories arg, this is equivalent to:
4484 /// @code
4485 /// HAPI_ComposeChildNodeList(
4486 /// session, parent_node_id,
4487 /// HAPI_NODETYPE_OBJ,
4488 /// HAPI_NODEFLAGS_OBJ_GEOMETRY,
4489 /// true, &object_count );
4490 /// @endcode
4491 ///
4492 /// @ingroup Objects
4493 ///
4494 /// @param[in] session
4495 /// The session of Houdini you are interacting with.
4496 /// See @ref HAPI_Sessions for more on sessions.
4497 /// Pass NULL to just use the default in-process session.
4498 /// <!-- default NULL -->
4499 ///
4500 /// @param[in] parent_node_id
4501 /// The parent node id.
4502 ///
4503 /// @param[in] categories
4504 /// (Optional) Lets you filter object nodes by their render
4505 /// categories. This is a standard OBJ parameter, usually
4506 /// under the Render > Shading tab. If an OBJ node does not
4507 /// have this parameter, one can always add it as a spare.
4508 ///
4509 /// The value of this string argument should be NULL if not
4510 /// used or a space-separated list of category names.
4511 /// Multiple category names will be treated as an AND op.
4512 /// <!-- default NULL -->
4513 ///
4514 /// @param[out] object_count
4515 /// The number of object nodes currently under the parent.
4516 /// Use this count with a call to
4517 /// ::HAPI_GetComposedObjectList() to get the object infos.
4518 ///
4520  HAPI_NodeId parent_node_id,
4521  const char * categories,
4522  int * object_count );
4523 
4524 /// @brief Fill an array of ::HAPI_ObjectInfo structs.
4525 ///
4526 /// This is best used with ::HAPI_ComposeObjectList() with.
4527 ///
4528 /// @ingroup Objects
4529 ///
4530 /// @param[in] session
4531 /// The session of Houdini you are interacting with.
4532 /// See @ref HAPI_Sessions for more on sessions.
4533 /// Pass NULL to just use the default in-process session.
4534 /// <!-- default NULL -->
4535 ///
4536 /// @param[in] parent_node_id
4537 /// The parent node id.
4538 ///
4539 /// @param[out] object_infos_array
4540 /// Array of ::HAPI_ObjectInfo at least the size of
4541 /// @c length.
4542 ///
4543 /// @param[in] start
4544 /// At least @c 0 and at most @c object_count returned by
4545 /// ::HAPI_ComposeObjectList().
4546 /// <!-- default 0 -->
4547 ///
4548 /// @param[in] length
4549 /// Given @c object_count returned by
4550 /// ::HAPI_ComposeObjectList(), @c length should be at least
4551 /// @c 0 and at most <tt>object_count - start</tt>.
4552 /// <!-- source ::HAPI_ComposeObjectList - start -->
4553 ///
4555  HAPI_NodeId parent_node_id,
4556  HAPI_ObjectInfo * object_infos_array,
4557  int start, int length );
4558 
4559 /// @brief Fill an array of ::HAPI_Transform structs.
4560 ///
4561 /// This is best used with ::HAPI_ComposeObjectList() with.
4562 ///
4563 /// Note that these transforms will be relative to the
4564 /// @c parent_node_id originally given to ::HAPI_ComposeObjectList()
4565 /// and expected to be the same with this call. If @c parent_node_id
4566 /// is not an OBJ node, the transforms will be given as they are on
4567 /// the object node itself.
4568 ///
4569 /// @ingroup Objects
4570 ///
4571 /// @param[in] session
4572 /// The session of Houdini you are interacting with.
4573 /// See @ref HAPI_Sessions for more on sessions.
4574 /// Pass NULL to just use the default in-process session.
4575 /// <!-- default NULL -->
4576 ///
4577 /// @param[in] parent_node_id
4578 /// The parent node id. The object transforms will be
4579 /// relative to this node unless this node is not an OBJ.
4580 ///
4581 /// @param[in] rst_order
4582 /// The order of application of translation, rotation and
4583 /// scale.
4584 ///
4585 /// @param[out] transform_array
4586 /// Array of ::HAPI_Transform at least the size of
4587 /// length.
4588 ///
4589 /// @param[in] start
4590 /// At least @c 0 and at most @c object_count returned by
4591 /// ::HAPI_ComposeObjectList().
4592 /// <!-- default 0 -->
4593 ///
4594 /// @param[in] length
4595 /// Given @c object_count returned by
4596 /// ::HAPI_ComposeObjectList(), @c length should be at least
4597 /// @c 0 and at most <tt>object_count - start</tt>.
4598 /// <!-- source ::HAPI_ComposeObjectList - start -->
4599 ///
4601  HAPI_NodeId parent_node_id,
4602  HAPI_RSTOrder rst_order,
4603  HAPI_Transform * transform_array,
4604  int start, int length );
4605 
4606 /// @brief Get the node ids for the objects being instanced by an
4607 /// Instance OBJ node.
4608 ///
4609 /// @ingroup Objects
4610 ///
4611 /// @param[in] session
4612 /// The session of Houdini you are interacting with.
4613 /// See @ref HAPI_Sessions for more on sessions.
4614 /// Pass NULL to just use the default in-process session.
4615 /// <!-- default NULL -->
4616 ///
4617 /// @param[in] object_node_id
4618 /// The object node id.
4619 ///
4620 /// @param[out] instanced_node_id_array
4621 /// Array of ::HAPI_NodeId at least the size of length.
4622 ///
4623 /// @param[in] start
4624 /// At least @c 0 and at most @c object_count returned by
4625 /// ::HAPI_ComposeObjectList().
4626 /// <!-- default 0 -->
4627 ///
4628 /// @param[in] length
4629 /// Given @c object_count returned by
4630 /// ::HAPI_ComposeObjectList(), @c length should be at least
4631 /// @c 0 and at most <tt>object_count - start</tt>.
4632 /// <!-- source ::HAPI_ComposeObjectList - start -->
4633 ///
4635  HAPI_NodeId object_node_id,
4636  HAPI_NodeId * instanced_node_id_array,
4637  int start, int length );
4638 
4639 /// @brief Fill an array of ::HAPI_Transform structs with the transforms
4640 /// of each instance of this instancer object for a given part.
4641 ///
4642 /// @ingroup Objects
4643 ///
4644 /// @param[in] session
4645 /// The session of Houdini you are interacting with.
4646 /// See @ref HAPI_Sessions for more on sessions.
4647 /// Pass NULL to just use the default in-process session.
4648 /// <!-- default NULL -->
4649 ///
4650 /// @param[in] node_id
4651 /// The object node id.
4652 ///
4653 /// @param[in] part_id
4654 /// The part id.
4655 ///
4656 /// @param[in] rst_order
4657 /// The order of application of translation, rotation and
4658 /// scale.
4659 ///
4660 /// @param[out] transforms_array
4661 /// Array of ::HAPI_Transform at least the size of length.
4662 ///
4663 /// @param[in] start
4664 /// First index of range. Must be at least 0 and at
4665 /// most ::HAPI_PartInfo::pointCount - 1. This is the 0th
4666 /// part of the display geo of the instancer object node.
4667 /// <!-- default 0 -->
4668 ///
4669 /// @param[in] length
4670 /// Must be at least 0 and at most
4671 /// ::HAPI_PartInfo::pointCount - @p start. This is the 0th
4672 /// part of the display geo of the instancer object node.
4673 /// <!-- source ::HAPI_PartInfo::pointCount - start -->
4674 ///
4676  HAPI_NodeId node_id,
4677  HAPI_PartId part_id,
4678  HAPI_RSTOrder rst_order,
4679  HAPI_Transform * transforms_array,
4680  int start, int length );
4681 
4682 /// @brief Set the transform of an individual object. Note that the object
4683 /// nodes have to either be editable or have their transform
4684 /// parameters exposed at the asset level. This won't work otherwise.
4685 ///
4686 /// @ingroup Objects
4687 ///
4688 /// @param[in] session
4689 /// The session of Houdini you are interacting with.
4690 /// See @ref HAPI_Sessions for more on sessions.
4691 /// Pass NULL to just use the default in-process session.
4692 /// <!-- default NULL -->
4693 ///
4694 /// @param[in] node_id
4695 /// The object node id.
4696 ///
4697 /// @param[in] trans
4698 /// A ::HAPI_TransformEuler that stores the transform.
4699 ///
4701  HAPI_NodeId node_id,
4702  const HAPI_TransformEuler * trans );
4703 
4704 /// @defgroup GeometryGetters Geometry Getters
4705 /// Functions for reading Geometry (SOP) data
4706 
4707 /// @brief Get the display geo (SOP) node inside an Object node. If there
4708 /// there are multiple display SOP nodes, only the first one is
4709 /// returned. If the node is a display SOP itself, even if a network,
4710 /// it will return its own geo info. If the node is a SOP but not
4711 /// a network and not the display SOP, this function will fail.
4712 ///
4713 /// The above implies that you can safely call this function on both
4714 /// OBJ and SOP asset nodes and get the same (equivalent) geometry
4715 /// display node back. SOP asset nodes will simply return themselves.
4716 ///
4717 /// @ingroup GeometryGetters
4718 ///
4719 /// @param[in] session
4720 /// The session of Houdini you are interacting with.
4721 /// See @ref HAPI_Sessions for more on sessions.
4722 /// Pass NULL to just use the default in-process session.
4723 /// <!-- default NULL -->
4724 ///
4725 /// @param[in] object_node_id
4726 /// The object node id.
4727 ///
4728 /// @param[out] geo_info
4729 /// ::HAPI_GeoInfo return value.
4730 ///
4732  HAPI_NodeId object_node_id,
4733  HAPI_GeoInfo * geo_info );
4734 
4735 /// @brief A helper method that gets the number of main geometry outputs inside
4736 /// an Object node or SOP node. If the node is an Object node, this
4737 /// method will return the cumulative number of geometry outputs for all
4738 /// geometry nodes that it contains. When searching for output geometry,
4739 /// this method will only consider subnetworks that have their display
4740 /// flag enabled.
4741 ///
4742 /// This method must be called before HAPI_GetOutputGeoInfos() is
4743 /// called.
4744 ///
4745 /// @ingroup GeometryGetters
4746 ///
4747 /// @param[in] session
4748 /// The session of Houdini you are interacting with.
4749 /// See @ref HAPI_Sessions for more on sessions.
4750 /// Pass NULL to just use the default in-process session.
4751 /// <!-- default NULL -->
4752 ///
4753 /// @param[in] node_id
4754 /// The node id of the Object or SOP node to get the geometry
4755 /// output count of.
4756 ///
4757 /// @param[out] count
4758 /// The number of geometry (SOP) outputs.
4760  HAPI_NodeId node_id,
4761  int* count);
4762 
4763 /// @brief Gets the geometry info structs (::HAPI_GeoInfo) for a node's
4764 /// main geometry outputs. This method can only be called after
4765 /// HAPI_GetOutputGeoCount() has been called with the same node id.
4766 ///
4767 /// @ingroup GeometryGetters
4768 ///
4769 /// @param[in] session
4770 /// The session of Houdini you are interacting with.
4771 /// See @ref HAPI_Sessions for more on sessions.
4772 /// Pass NULL to just use the default in-process session.
4773 /// <!-- default NULL -->
4774 ///
4775 /// @param[in] node_id
4776 /// The node id of the Object or SOP node to get the output
4777 /// geometry info structs (::HAPI_GeoInfo) for.
4778 ///
4779 /// @param[out] geo_infos_array
4780 /// Output array where the output geometry info structs will be
4781 /// stored. The size of the array must match the count argument
4782 /// returned by the HAPI_GetOutputGeoCount() method.
4783 ///
4784 /// @param[in] count
4785 /// Sanity check count. The count must be equal to the count
4786 /// returned by the HAPI_GetOutputGeoCount() method.
4788  HAPI_NodeId node_id,
4789  HAPI_GeoInfo* geo_infos_array,
4790  int count );
4791 
4792 /// @brief Get the geometry info struct (::HAPI_GeoInfo) on a SOP node.
4793 ///
4794 /// @ingroup GeometryGetters
4795 ///
4796 /// @param[in] session
4797 /// The session of Houdini you are interacting with.
4798 /// See @ref HAPI_Sessions for more on sessions.
4799 /// Pass NULL to just use the default in-process session.
4800 /// <!-- default NULL -->
4801 ///
4802 /// @param[in] node_id
4803 /// The node id.
4804 ///
4805 /// @param[out] geo_info
4806 /// ::HAPI_GeoInfo return value.
4807 ///
4808 HAPI_DECL HAPI_GetGeoInfo( const HAPI_Session * session,
4809  HAPI_NodeId node_id,
4810  HAPI_GeoInfo * geo_info );
4811 
4812 /// @brief Get a particular part info struct.
4813 ///
4814 /// @ingroup GeometryGetters
4815 ///
4816 /// @param[in] session
4817 /// The session of Houdini you are interacting with.
4818 /// See @ref HAPI_Sessions for more on sessions.
4819 /// Pass NULL to just use the default in-process session.
4820 /// <!-- default NULL -->
4821 ///
4822 /// @param[in] node_id
4823 /// The SOP node id.
4824 ///
4825 /// @param[in] part_id
4826 /// The part id.
4827 ///
4828 /// @param[out] part_info
4829 /// ::HAPI_PartInfo return value.
4830 ///
4831 HAPI_DECL HAPI_GetPartInfo( const HAPI_Session * session,
4832  HAPI_NodeId node_id,
4833  HAPI_PartId part_id,
4834  HAPI_PartInfo * part_info );
4835 
4836 
4837 /// @brief Gets the number of edges that belong to an edge group on a geometry
4838 /// part.
4839 ///
4840 /// @ingroup GeometryGetters
4841 ///
4842 /// @param[in] session
4843 /// The session of Houdini you are interacting with.
4844 /// See @ref HAPI_Sessions for more on sessions.
4845 /// Pass NULL to just use the default in-process session.
4846 /// <!-- default NULL -->
4847 ///
4848 /// @param[in] node_id
4849 /// The SOP node id.
4850 ///
4851 /// @param[in] part_id
4852 /// The part id.
4853 ///
4854 /// @param[in] group_name
4855 /// The name of the edge group.
4856 ///
4857 /// @param[out] edge_count
4858 /// The number of edges that belong to the group.
4859 ///
4861  HAPI_NodeId node_id,
4862  HAPI_PartId part_id,
4863  const char * group_name,
4864  int * edge_count );
4865 
4866 /// @brief Get the array of faces where the nth integer in the array is
4867 /// the number of vertices the nth face has.
4868 ///
4869 /// @ingroup GeometryGetters
4870 ///
4871 /// @param[in] session
4872 /// The session of Houdini you are interacting with.
4873 /// See @ref HAPI_Sessions for more on sessions.
4874 /// Pass NULL to just use the default in-process session.
4875 /// <!-- default NULL -->
4876 ///
4877 /// @param[in] node_id
4878 /// The node id.
4879 ///
4880 /// @param[in] part_id
4881 /// The part id.
4882 ///
4883 /// @param[out] face_counts_array
4884 /// An integer array at least the size of length.
4885 ///
4886 /// @param[in] start
4887 /// First index of range. Must be at least 0 and at
4888 /// most ::HAPI_PartInfo::faceCount - 1.
4889 /// <!-- default 0 -->
4890 ///
4891 /// @param[in] length
4892 /// Must be at least 0 and at most
4893 /// ::HAPI_PartInfo::faceCount - @p start.
4894 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
4895 ///
4896 HAPI_DECL HAPI_GetFaceCounts( const HAPI_Session * session,
4897  HAPI_NodeId node_id,
4898  HAPI_PartId part_id,
4899  int * face_counts_array,
4900  int start, int length );
4901 
4902 /// @brief Get array containing the vertex-point associations where the
4903 /// ith element in the array is the point index the ith vertex
4904 /// associates with.
4905 ///
4906 /// @ingroup GeometryGetters
4907 ///
4908 /// @param[in] session
4909 /// The session of Houdini you are interacting with.
4910 /// See @ref HAPI_Sessions for more on sessions.
4911 /// Pass NULL to just use the default in-process session.
4912 /// <!-- default NULL -->
4913 ///
4914 /// @param[in] node_id
4915 /// The node id.
4916 ///
4917 /// @param[in] part_id
4918 /// The part id.
4919 ///
4920 /// @param[out] vertex_list_array
4921 /// An integer array at least the size of length.
4922 ///
4923 /// @param[in] start
4924 /// First index of range. Must be at least 0 and at
4925 /// most ::HAPI_PartInfo::vertexCount - 1.
4926 /// <!-- default 0 -->
4927 ///
4928 /// @param[in] length
4929 /// Must be at least 0 and at most
4930 /// ::HAPI_PartInfo::vertexCount - @p start.
4931 /// <!-- source ::HAPI_PartInfo::vertexCount - start -->
4932 ///
4933 HAPI_DECL HAPI_GetVertexList( const HAPI_Session * session,
4934  HAPI_NodeId node_id,
4935  HAPI_PartId part_id,
4936  int * vertex_list_array,
4937  int start, int length );
4938 
4939 /// @defgroup Attributes
4940 /// Functions for working with attributes.
4941 
4942 /// @brief Get the attribute info struct for the attribute specified by name.
4943 ///
4944 /// @ingroup Attributes
4945 ///
4946 /// @param[in] session
4947 /// The session of Houdini you are interacting with.
4948 /// See @ref HAPI_Sessions for more on sessions.
4949 /// Pass NULL to just use the default in-process session.
4950 /// <!-- default NULL -->
4951 ///
4952 /// @param[in] node_id
4953 /// The node id.
4954 ///
4955 /// @param[in] part_id
4956 /// The part id.
4957 ///
4958 /// @param[in] name
4959 /// Attribute name.
4960 ///
4961 /// @param[in] owner
4962 /// Attribute owner.
4963 ///
4964 /// @param[out] attr_info
4965 /// ::HAPI_AttributeInfo to be filled. Check
4966 /// ::HAPI_AttributeInfo::exists to see if this attribute
4967 /// exists.
4968 ///
4970  HAPI_NodeId node_id,
4971  HAPI_PartId part_id,
4972  const char * name,
4973  HAPI_AttributeOwner owner,
4974  HAPI_AttributeInfo * attr_info );
4975 
4976 /// @brief Get list of attribute names by attribute owner. Note that the
4977 /// name string handles are only valid until the next time this
4978 /// function is called.
4979 ///
4980 /// @ingroup Attributes
4981 ///
4982 /// @param[in] session
4983 /// The session of Houdini you are interacting with.
4984 /// See @ref HAPI_Sessions for more on sessions.
4985 /// Pass NULL to just use the default in-process session.
4986 /// <!-- default NULL -->
4987 ///
4988 /// @param[in] node_id
4989 /// The node id.
4990 ///
4991 /// @param[in] part_id
4992 /// The part id.
4993 ///
4994 /// @param[in] owner
4995 /// The ::HAPI_AttributeOwner enum value specifying the
4996 /// owner of the attribute.
4997 ///
4998 /// @param[out] attribute_names_array
4999 /// Array of ints (string handles) to house the
5000 /// attribute names. Should be exactly the size of the
5001 /// appropriate attribute owner type count
5002 /// in ::HAPI_PartInfo.
5003 ///
5004 /// @param[in] count
5005 /// Sanity check count. Must be equal to the appropriate
5006 /// attribute owner type count in ::HAPI_PartInfo.
5007 ///
5009  HAPI_NodeId node_id,
5010  HAPI_PartId part_id,
5011  HAPI_AttributeOwner owner,
5012  HAPI_StringHandle * attribute_names_array,
5013  int count );
5014 
5015 /// @brief Get attribute integer data.
5016 ///
5017 /// @ingroup GeometryGetters Attributes
5018 ///
5019 /// @param[in] session
5020 /// The session of Houdini you are interacting with.
5021 /// See @ref HAPI_Sessions for more on sessions.
5022 /// Pass NULL to just use the default in-process session.
5023 /// <!-- default NULL -->
5024 ///
5025 /// @param[in] node_id
5026 /// The node id.
5027 ///
5028 /// @param[in] part_id
5029 /// The part id.
5030 ///
5031 /// @param[in] name
5032 /// Attribute name.
5033 ///
5034 /// @param[in] attr_info
5035 /// ::HAPI_AttributeInfo used as input for what tuple size.
5036 /// you want. Also contains some sanity checks like
5037 /// data type. Generally should be the same struct
5038 /// returned by ::HAPI_GetAttributeInfo().
5039 ///
5040 /// @param[in] stride
5041 /// Specifies how many items to skip over for each element.
5042 /// With a stride of -1, the stride will be set to
5043 /// @c attr_info->tuple_size. Otherwise, the stride will be
5044 /// set to the maximum of @c attr_info->tuple_size and
5045 /// @c stride.
5046 ///
5047 /// @param[out] data_array
5048 /// An integer array at least the size of
5049 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5050 ///
5051 /// @param[in] start
5052 /// First index of range. Must be at least 0 and at
5053 /// most ::HAPI_AttributeInfo::count - 1.
5054 /// <!-- default 0 -->
5055 ///
5056 /// @param[in] length
5057 /// Must be at least 0 and at most
5058 /// ::HAPI_AttributeInfo::count - @p start.
5059 /// Note, if 0 is passed for length, the function will just
5060 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5061 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5062 ///
5064  HAPI_NodeId node_id,
5065  HAPI_PartId part_id,
5066  const char * name,
5067  HAPI_AttributeInfo * attr_info,
5068  int stride,
5069  int * data_array,
5070  int start, int length );
5071 
5072 /// @brief Get array attribute integer data.
5073 /// Each entry in an array attribute can have varying array lengths.
5074 /// Therefore the array values are returned as a flat array, with
5075 /// another sizes array containing the lengths of each array entry.
5076 ///
5077 /// @ingroup GeometryGetters Attributes
5078 ///
5079 /// @param[in] session
5080 /// The session of Houdini you are interacting with.
5081 /// See @ref HAPI_Sessions for more on sessions.
5082 /// Pass NULL to just use the default in-process session.
5083 /// <!-- default NULL -->
5084 ///
5085 /// @param[in] node_id
5086 /// The node id.
5087 ///
5088 /// @param[in] part_id
5089 /// The part id.
5090 ///
5091 /// @param[in] name
5092 /// Attribute name.
5093 ///
5094 /// @param[in] attr_info
5095 /// ::HAPI_AttributeInfo used as input for what tuple size.
5096 /// you want. Also contains some sanity checks like
5097 /// data type. Generally should be the same struct
5098 /// returned by ::HAPI_GetAttributeInfo().
5099 ///
5100 /// @param[out] data_fixed_array
5101 /// An integer array at least the size of
5102 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5103 ///
5104 /// @param[in] data_fixed_length
5105 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5106 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5107 ///
5108 /// @param[out] sizes_fixed_array
5109 /// An integer array at least the size of
5110 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5111 /// <!-- source ::HAPI_AttributeInfo::count -->
5112 ///
5113 /// @param[in] start
5114 /// First index of range. Must be at least 0 and at
5115 /// most ::HAPI_AttributeInfo::count - 1.
5116 /// <!-- default 0 -->
5117 ///
5118 /// @param[in] sizes_fixed_length
5119 /// Must be at least 0 and at most
5120 /// ::HAPI_AttributeInfo::count - @p start.
5121 /// Note, if 0 is passed for length, the function will just
5122 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5123 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5124 ///
5126  HAPI_NodeId node_id,
5127  HAPI_PartId part_id,
5128  const char * name,
5129  HAPI_AttributeInfo * attr_info,
5130  int * data_fixed_array,
5131  int data_fixed_length,
5132  int * sizes_fixed_array,
5133  int start, int sizes_fixed_length );
5134 
5135 /// @brief Get attribute unsigned 8-bit integer data.
5136 ///
5137 /// @ingroup GeometryGetters Attributes
5138 ///
5139 /// @param[in] session
5140 /// The session of Houdini you are interacting with.
5141 /// See @ref HAPI_Sessions for more on sessions.
5142 /// Pass NULL to just use the default in-process session.
5143 /// <!-- default NULL -->
5144 ///
5145 /// @param[in] node_id
5146 /// The node id.
5147 ///
5148 /// @param[in] part_id
5149 /// The part id.
5150 ///
5151 /// @param[in] name
5152 /// Attribute name.
5153 ///
5154 /// @param[in] attr_info
5155 /// ::HAPI_AttributeInfo used as input for what tuple size.
5156 /// you want. Also contains some sanity checks like
5157 /// data type. Generally should be the same struct
5158 /// returned by ::HAPI_GetAttributeInfo().
5159 ///
5160 /// @param[in] stride
5161 /// Specifies how many items to skip over for each element.
5162 /// With a stride of -1, the stride will be set to
5163 /// @c attr_info->tuple_size. Otherwise, the stride will be
5164 /// set to the maximum of @c attr_info->tuple_size and
5165 /// @c stride.
5166 ///
5167 /// @param[out] data_array
5168 /// An unsigned 8-bit integer array at least the size of
5169 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5170 ///
5171 /// @param[in] start
5172 /// First index of range. Must be at least 0 and at
5173 /// most ::HAPI_AttributeInfo::count - 1.
5174 /// <!-- default 0 -->
5175 ///
5176 /// @param[in] length
5177 /// Must be at least 0 and at most
5178 /// ::HAPI_AttributeInfo::count - @p start.
5179 /// Note, if 0 is passed for length, the function will just
5180 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5181 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5182 ///
5184  HAPI_NodeId node_id,
5185  HAPI_PartId part_id,
5186  const char * name,
5187  HAPI_AttributeInfo * attr_info,
5188  int stride,
5189  HAPI_UInt8 * data_array,
5190  int start, int length );
5191 
5192 /// @brief Get array attribute unsigned 8-bit integer data.
5193 /// Each entry in an array attribute can have varying array lengths.
5194 /// Therefore the array values are returned as a flat array, with
5195 /// another sizes array containing the lengths of each array entry.
5196 ///
5197 /// @ingroup GeometryGetters Attributes
5198 ///
5199 /// @param[in] session
5200 /// The session of Houdini you are interacting with.
5201 /// See @ref HAPI_Sessions for more on sessions.
5202 /// Pass NULL to just use the default in-process session.
5203 /// <!-- default NULL -->
5204 ///
5205 /// @param[in] node_id
5206 /// The node id.
5207 ///
5208 /// @param[in] part_id
5209 /// The part id.
5210 ///
5211 /// @param[in] name
5212 /// Attribute name.
5213 ///
5214 /// @param[in] attr_info
5215 /// ::HAPI_AttributeInfo used as input for what tuple size.
5216 /// you want. Also contains some sanity checks like
5217 /// data type. Generally should be the same struct
5218 /// returned by ::HAPI_GetAttributeInfo().
5219 ///
5220 /// @param[out] data_fixed_array
5221 /// An unsigned 8-bit integer array at least the size of
5222 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5223 ///
5224 /// @param[in] data_fixed_length
5225 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5226 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5227 ///
5228 /// @param[out] sizes_fixed_array
5229 /// An integer array at least the size of
5230 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5231 ///
5232 /// @param[in] start
5233 /// First index of range. Must be at least 0 and at
5234 /// most ::HAPI_AttributeInfo::count - 1.
5235 /// <!-- default 0 -->
5236 ///
5237 /// @param[in] sizes_fixed_length
5238 /// Must be at least 0 and at most
5239 /// ::HAPI_AttributeInfo::count - @p start.
5240 /// Note, if 0 is passed for length, the function will just
5241 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5242 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5243 ///
5245  HAPI_NodeId node_id,
5246  HAPI_PartId part_id,
5247  const char * name,
5248  HAPI_AttributeInfo * attr_info,
5249  HAPI_UInt8 * data_fixed_array,
5250  int data_fixed_length,
5251  int * sizes_fixed_array,
5252  int start, int sizes_fixed_length );
5253 
5254 /// @brief Get attribute 8-bit integer data.
5255 ///
5256 /// @ingroup GeometryGetters Attributes
5257 ///
5258 /// @param[in] session
5259 /// The session of Houdini you are interacting with.
5260 /// See @ref HAPI_Sessions for more on sessions.
5261 /// Pass NULL to just use the default in-process session.
5262 /// <!-- default NULL -->
5263 ///
5264 /// @param[in] node_id
5265 /// The node id.
5266 ///
5267 /// @param[in] part_id
5268 /// The part id.
5269 ///
5270 /// @param[in] name
5271 /// Attribute name.
5272 ///
5273 /// @param[in] attr_info
5274 /// ::HAPI_AttributeInfo used as input for what tuple size.
5275 /// you want. Also contains some sanity checks like
5276 /// data type. Generally should be the same struct
5277 /// returned by ::HAPI_GetAttributeInfo().
5278 ///
5279 /// @param[in] stride
5280 /// Specifies how many items to skip over for each element.
5281 /// With a stride of -1, the stride will be set to
5282 /// @c attr_info->tuple_size. Otherwise, the stride will be
5283 /// set to the maximum of @c attr_info->tuple_size and
5284 /// @c stride.
5285 ///
5286 /// @param[out] data_array
5287 /// An 8-bit integer array at least the size of
5288 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5289 ///
5290 /// @param[in] start
5291 /// First index of range. Must be at least 0 and at
5292 /// most ::HAPI_AttributeInfo::count - 1.
5293 /// <!-- default 0 -->
5294 ///
5295 /// @param[in] length
5296 /// Must be at least 0 and at most
5297 /// ::HAPI_AttributeInfo::count - @p start.
5298 /// Note, if 0 is passed for length, the function will just
5299 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5300 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5301 ///
5303  HAPI_NodeId node_id,
5304  HAPI_PartId part_id,
5305  const char * name,
5306  HAPI_AttributeInfo * attr_info,
5307  int stride,
5308  HAPI_Int8 * data_array,
5309  int start, int length );
5310 
5311 /// @brief Get array attribute 8-bit integer data.
5312 /// Each entry in an array attribute can have varying array lengths.
5313 /// Therefore the array values are returned as a flat array, with
5314 /// another sizes array containing the lengths of each array entry.
5315 ///
5316 /// @ingroup GeometryGetters Attributes
5317 ///
5318 /// @param[in] session
5319 /// The session of Houdini you are interacting with.
5320 /// See @ref HAPI_Sessions for more on sessions.
5321 /// Pass NULL to just use the default in-process session.
5322 /// <!-- default NULL -->
5323 ///
5324 /// @param[in] node_id
5325 /// The node id.
5326 ///
5327 /// @param[in] part_id
5328 /// The part id.
5329 ///
5330 /// @param[in] name
5331 /// Attribute name.
5332 ///
5333 /// @param[in] attr_info
5334 /// ::HAPI_AttributeInfo used as input for what tuple size.
5335 /// you want. Also contains some sanity checks like
5336 /// data type. Generally should be the same struct
5337 /// returned by ::HAPI_GetAttributeInfo().
5338 ///
5339 /// @param[out] data_fixed_array
5340 /// An 8-bit integer array at least the size of
5341 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5342 ///
5343 /// @param[in] data_fixed_length
5344 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5345 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5346 ///
5347 /// @param[out] sizes_fixed_array
5348 /// An integer array at least the size of
5349 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5350 ///
5351 /// @param[in] start
5352 /// First index of range. Must be at least 0 and at
5353 /// most ::HAPI_AttributeInfo::count - 1.
5354 /// <!-- default 0 -->
5355 ///
5356 /// @param[in] sizes_fixed_length
5357 /// Must be at least 0 and at most
5358 /// ::HAPI_AttributeInfo::count - @p start.
5359 /// Note, if 0 is passed for length, the function will just
5360 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5361 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5362 ///
5364  HAPI_NodeId node_id,
5365  HAPI_PartId part_id,
5366  const char * name,
5367  HAPI_AttributeInfo * attr_info,
5368  HAPI_Int8 * data_fixed_array,
5369  int data_fixed_length,
5370  int * sizes_fixed_array,
5371  int start, int sizes_fixed_length );
5372 
5373 /// @brief Get attribute 16-bit integer data.
5374 ///
5375 /// @ingroup GeometryGetters Attributes
5376 ///
5377 /// @param[in] session
5378 /// The session of Houdini you are interacting with.
5379 /// See @ref HAPI_Sessions for more on sessions.
5380 /// Pass NULL to just use the default in-process session.
5381 /// <!-- default NULL -->
5382 ///
5383 /// @param[in] node_id
5384 /// The node id.
5385 ///
5386 /// @param[in] part_id
5387 /// The part id.
5388 ///
5389 /// @param[in] name
5390 /// Attribute name.
5391 ///
5392 /// @param[in] attr_info
5393 /// ::HAPI_AttributeInfo used as input for what tuple size.
5394 /// you want. Also contains some sanity checks like
5395 /// data type. Generally should be the same struct
5396 /// returned by ::HAPI_GetAttributeInfo().
5397 ///
5398 /// @param[in] stride
5399 /// Specifies how many items to skip over for each element.
5400 /// With a stride of -1, the stride will be set to
5401 /// @c attr_info->tuple_size. Otherwise, the stride will be
5402 /// set to the maximum of @c attr_info->tuple_size and
5403 /// @c stride.
5404 ///
5405 /// @param[out] data_array
5406 /// An 16-bit integer array at least the size of
5407 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5408 ///
5409 /// @param[in] start
5410 /// First index of range. Must be at least 0 and at
5411 /// most ::HAPI_AttributeInfo::count - 1.
5412 /// <!-- default 0 -->
5413 ///
5414 /// @param[in] length
5415 /// Must be at least 0 and at most
5416 /// ::HAPI_AttributeInfo::count - @p start.
5417 /// Note, if 0 is passed for length, the function will just
5418 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5419 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5420 ///
5422  HAPI_NodeId node_id,
5423  HAPI_PartId part_id,
5424  const char * name,
5425  HAPI_AttributeInfo * attr_info,
5426  int stride,
5427  HAPI_Int16 * data_array,
5428  int start, int length );
5429 
5430 /// @brief Get array attribute 16-bit integer data.
5431 /// Each entry in an array attribute can have varying array lengths.
5432 /// Therefore the array values are returned as a flat array, with
5433 /// another sizes array containing the lengths of each array entry.
5434 ///
5435 /// @ingroup GeometryGetters Attributes
5436 ///
5437 /// @param[in] session
5438 /// The session of Houdini you are interacting with.
5439 /// See @ref HAPI_Sessions for more on sessions.
5440 /// Pass NULL to just use the default in-process session.
5441 /// <!-- default NULL -->
5442 ///
5443 /// @param[in] node_id
5444 /// The node id.
5445 ///
5446 /// @param[in] part_id
5447 /// The part id.
5448 ///
5449 /// @param[in] name
5450 /// Attribute name.
5451 ///
5452 /// @param[in] attr_info
5453 /// ::HAPI_AttributeInfo used as input for what tuple size.
5454 /// you want. Also contains some sanity checks like
5455 /// data type. Generally should be the same struct
5456 /// returned by ::HAPI_GetAttributeInfo().
5457 ///
5458 /// @param[out] data_fixed_array
5459 /// An 16-bit integer array at least the size of
5460 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5461 ///
5462 /// @param[in] data_fixed_length
5463 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5464 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5465 ///
5466 /// @param[out] sizes_fixed_array
5467 /// An integer array at least the size of
5468 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5469 ///
5470 /// @param[in] start
5471 /// First index of range. Must be at least 0 and at
5472 /// most ::HAPI_AttributeInfo::count - 1.
5473 /// <!-- default 0 -->
5474 ///
5475 /// @param[in] sizes_fixed_length
5476 /// Must be at least 0 and at most
5477 /// ::HAPI_AttributeInfo::count - @p start.
5478 /// Note, if 0 is passed for length, the function will just
5479 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5480 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5481 ///
5483  HAPI_NodeId node_id,
5484  HAPI_PartId part_id,
5485  const char * name,
5486  HAPI_AttributeInfo * attr_info,
5487  HAPI_Int16 * data_fixed_array,
5488  int data_fixed_length,
5489  int * sizes_fixed_array,
5490  int start, int sizes_fixed_length );
5491 
5492 /// @brief Get attribute 64-bit integer data.
5493 ///
5494 /// @ingroup GeometryGetters Attributes
5495 ///
5496 /// @param[in] session
5497 /// The session of Houdini you are interacting with.
5498 /// See @ref HAPI_Sessions for more on sessions.
5499 /// Pass NULL to just use the default in-process session.
5500 /// <!-- default NULL -->
5501 ///
5502 /// @param[in] node_id
5503 /// The node id.
5504 ///
5505 /// @param[in] part_id
5506 /// The part id.
5507 ///
5508 /// @param[in] name
5509 /// Attribute name.
5510 ///
5511 /// @param[in] attr_info
5512 /// ::HAPI_AttributeInfo used as input for what tuple size.
5513 /// you want. Also contains some sanity checks like
5514 /// data type. Generally should be the same struct
5515 /// returned by ::HAPI_GetAttributeInfo().
5516 ///
5517 /// @param[in] stride
5518 /// Specifies how many items to skip over for each element.
5519 /// With a stride of -1, the stride will be set to
5520 /// @c attr_info->tuple_size. Otherwise, the stride will be
5521 /// set to the maximum of @c attr_info->tuple_size and
5522 /// @c stride.
5523 ///
5524 /// @param[out] data_array
5525 /// An 64-bit integer array at least the size of
5526 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5527 ///
5528 /// @param[in] start
5529 /// First index of range. Must be at least 0 and at
5530 /// most ::HAPI_AttributeInfo::count - 1.
5531 /// <!-- default 0 -->
5532 ///
5533 /// @param[in] length
5534 /// Must be at least 0 and at most
5535 /// ::HAPI_AttributeInfo::count - @p start.
5536 /// Note, if 0 is passed for length, the function will just
5537 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5538 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5539 ///
5541  HAPI_NodeId node_id,
5542  HAPI_PartId part_id,
5543  const char * name,
5544  HAPI_AttributeInfo * attr_info,
5545  int stride,
5546  HAPI_Int64 * data_array,
5547  int start, int length );
5548 
5549 /// @brief Get array attribute 64-bit integer data.
5550 /// Each entry in an array attribute can have varying array lengths.
5551 /// Therefore the array values are returned as a flat array, with
5552 /// another sizes array containing the lengths of each array entry.
5553 ///
5554 /// @ingroup GeometryGetters Attributes
5555 ///
5556 /// @param[in] session
5557 /// The session of Houdini you are interacting with.
5558 /// See @ref HAPI_Sessions for more on sessions.
5559 /// Pass NULL to just use the default in-process session.
5560 /// <!-- default NULL -->
5561 ///
5562 /// @param[in] node_id
5563 /// The node id.
5564 ///
5565 /// @param[in] part_id
5566 /// The part id.
5567 ///
5568 /// @param[in] name
5569 /// Attribute name.
5570 ///
5571 /// @param[in] attr_info
5572 /// ::HAPI_AttributeInfo used as input for what tuple size.
5573 /// you want. Also contains some sanity checks like
5574 /// data type. Generally should be the same struct
5575 /// returned by ::HAPI_GetAttributeInfo().
5576 ///
5577 /// @param[out] data_fixed_array
5578 /// An 64-bit integer array at least the size of
5579 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5580 ///
5581 /// @param[in] data_fixed_length
5582 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5583 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5584 ///
5585 /// @param[out] sizes_fixed_array
5586 /// An integer array at least the size of
5587 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5588 ///
5589 /// @param[in] start
5590 /// First index of range. Must be at least 0 and at
5591 /// most ::HAPI_AttributeInfo::count - 1.
5592 /// <!-- default 0 -->
5593 ///
5594 /// @param[in] sizes_fixed_length
5595 /// Must be at least 0 and at most
5596 /// ::HAPI_AttributeInfo::count - @p start.
5597 /// Note, if 0 is passed for length, the function will just
5598 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5599 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5600 ///
5602  HAPI_NodeId node_id,
5603  HAPI_PartId part_id,
5604  const char * name,
5605  HAPI_AttributeInfo * attr_info,
5606  HAPI_Int64 * data_fixed_array,
5607  int data_fixed_length,
5608  int * sizes_fixed_array,
5609  int start, int sizes_fixed_length );
5610 
5611 /// @brief Get attribute float data.
5612 ///
5613 /// @ingroup GeometryGetters Attributes
5614 ///
5615 /// @param[in] session
5616 /// The session of Houdini you are interacting with.
5617 /// See @ref HAPI_Sessions for more on sessions.
5618 /// Pass NULL to just use the default in-process session.
5619 /// <!-- default NULL -->
5620 ///
5621 /// @param[in] node_id
5622 /// The node id.
5623 ///
5624 /// @param[in] part_id
5625 /// The part id.
5626 ///
5627 /// @param[in] name
5628 /// Attribute name.
5629 ///
5630 /// @param[in] attr_info
5631 /// ::HAPI_AttributeInfo used as input for what tuple size.
5632 /// you want. Also contains some sanity checks like
5633 /// data type. Generally should be the same struct
5634 /// returned by ::HAPI_GetAttributeInfo().
5635 ///
5636 /// @param[in] stride
5637 /// Specifies how many items to skip over for each element.
5638 /// With a stride of -1, the stride will be set to
5639 /// @c attr_info->tuple_size. Otherwise, the stride will be
5640 /// set to the maximum of @c attr_info->tuple_size and
5641 /// @c stride.
5642 ///
5643 /// @param[out] data_array
5644 /// An float array at least the size of
5645 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5646 ///
5647 /// @param[in] start
5648 /// First index of range. Must be at least 0 and at
5649 /// most ::HAPI_AttributeInfo::count - 1.
5650 /// <!-- default 0 -->
5651 ///
5652 /// @param[in] length
5653 /// Must be at least 0 and at most
5654 /// ::HAPI_AttributeInfo::count - @p start.
5655 /// Note, if 0 is passed for length, the function will just
5656 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5657 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5658 ///
5660  HAPI_NodeId node_id,
5661  HAPI_PartId part_id,
5662  const char * name,
5663  HAPI_AttributeInfo * attr_info,
5664  int stride,
5665  float * data_array,
5666  int start, int length );
5667 
5668 /// @brief Get array attribute float data.
5669 /// Each entry in an array attribute can have varying array lengths.
5670 /// Therefore the array values are returned as a flat array, with
5671 /// another sizes array containing the lengths of each array entry.
5672 ///
5673 /// @ingroup GeometryGetters Attributes
5674 ///
5675 /// @param[in] session
5676 /// The session of Houdini you are interacting with.
5677 /// See @ref HAPI_Sessions for more on sessions.
5678 /// Pass NULL to just use the default in-process session.
5679 /// <!-- default NULL -->
5680 ///
5681 /// @param[in] node_id
5682 /// The node id.
5683 ///
5684 /// @param[in] part_id
5685 /// The part id.
5686 ///
5687 /// @param[in] name
5688 /// Attribute name.
5689 ///
5690 /// @param[in] attr_info
5691 /// ::HAPI_AttributeInfo used as input for what tuple size.
5692 /// you want. Also contains some sanity checks like
5693 /// data type. Generally should be the same struct
5694 /// returned by ::HAPI_GetAttributeInfo().
5695 ///
5696 /// @param[out] data_fixed_array
5697 /// An float array at least the size of
5698 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5699 ///
5700 /// @param[in] data_fixed_length
5701 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5702 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5703 ///
5704 /// @param[out] sizes_fixed_array
5705 /// An integer array at least the size of
5706 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5707 ///
5708 /// @param[in] start
5709 /// First index of range. Must be at least 0 and at
5710 /// most ::HAPI_AttributeInfo::count - 1.
5711 /// <!-- default 0 -->
5712 ///
5713 /// @param[in] sizes_fixed_length
5714 /// Must be at least 0 and at most
5715 /// ::HAPI_AttributeInfo::count - @p start.
5716 /// Note, if 0 is passed for length, the function will just
5717 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5718 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5719 ///
5721  HAPI_NodeId node_id,
5722  HAPI_PartId part_id,
5723  const char * name,
5724  HAPI_AttributeInfo * attr_info,
5725  float * data_fixed_array,
5726  int data_fixed_length,
5727  int * sizes_fixed_array,
5728  int start, int sizes_fixed_length );
5729 
5730 /// @brief Get 64-bit attribute float data.
5731 ///
5732 /// @ingroup GeometryGetters Attributes
5733 ///
5734 /// @param[in] session
5735 /// The session of Houdini you are interacting with.
5736 /// See @ref HAPI_Sessions for more on sessions.
5737 /// Pass NULL to just use the default in-process session.
5738 /// <!-- default NULL -->
5739 ///
5740 /// @param[in] node_id
5741 /// The node id.
5742 ///
5743 /// @param[in] part_id
5744 /// The part id.
5745 ///
5746 /// @param[in] name
5747 /// Attribute name.
5748 ///
5749 /// @param[in] attr_info
5750 /// ::HAPI_AttributeInfo used as input for what tuple size.
5751 /// you want. Also contains some sanity checks like
5752 /// data type. Generally should be the same struct
5753 /// returned by ::HAPI_GetAttributeInfo().
5754 ///
5755 /// @param[in] stride
5756 /// Specifies how many items to skip over for each element.
5757 /// With a stride of -1, the stride will be set to
5758 /// @c attr_info->tuple_size. Otherwise, the stride will be
5759 /// set to the maximum of @c attr_info->tuple_size and
5760 /// @c stride.
5761 ///
5762 /// @param[out] data_array
5763 /// An 64-bit float array at least the size of
5764 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5765 ///
5766 /// @param[in] start
5767 /// First index of range. Must be at least 0 and at
5768 /// most ::HAPI_AttributeInfo::count - 1.
5769 /// <!-- default 0 -->
5770 ///
5771 /// @param[in] length
5772 /// Must be at least 0 and at most
5773 /// ::HAPI_AttributeInfo::count - @p start.
5774 /// Note, if 0 is passed for length, the function will just
5775 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5776 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5777 ///
5779  HAPI_NodeId node_id,
5780  HAPI_PartId part_id,
5781  const char * name,
5782  HAPI_AttributeInfo * attr_info,
5783  int stride,
5784  double * data_array,
5785  int start, int length );
5786 
5787 /// @brief Get array attribute 64-bit float data.
5788 /// Each entry in an array attribute can have varying array lengths.
5789 /// Therefore the array values are returned as a flat array, with
5790 /// another sizes array containing the lengths of each array entry.
5791 ///
5792 /// @ingroup GeometryGetters Attributes
5793 ///
5794 /// @param[in] session
5795 /// The session of Houdini you are interacting with.
5796 /// See @ref HAPI_Sessions for more on sessions.
5797 /// Pass NULL to just use the default in-process session.
5798 /// <!-- default NULL -->
5799 ///
5800 /// @param[in] node_id
5801 /// The node id.
5802 ///
5803 /// @param[in] part_id
5804 /// The part id.
5805 ///
5806 /// @param[in] name
5807 /// Attribute name.
5808 ///
5809 /// @param[in] attr_info
5810 /// ::HAPI_AttributeInfo used as input for the.
5811 /// totalArrayElements. Also contains some sanity checks like
5812 /// data type. Generally should be the same struct
5813 /// returned by ::HAPI_GetAttributeInfo().
5814 ///
5815 /// @param[out] data_fixed_array
5816 /// An 64-bit float array at least the size of
5817 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5818 ///
5819 /// @param[in] data_fixed_length
5820 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5821 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5822 ///
5823 /// @param[out] sizes_fixed_array
5824 /// An integer array at least the size of
5825 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5826 ///
5827 /// @param[in] start
5828 /// First index of range. Must be at least 0 and at
5829 /// most ::HAPI_AttributeInfo::count - 1.
5830 /// <!-- default 0 -->
5831 ///
5832 /// @param[in] sizes_fixed_length
5833 /// Must be at least 0 and at most
5834 /// ::HAPI_AttributeInfo::count - @p start.
5835 /// Note, if 0 is passed for length, the function will just
5836 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5837 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5838 ///
5840  HAPI_NodeId node_id,
5841  HAPI_PartId part_id,
5842  const char * name,
5843  HAPI_AttributeInfo * attr_info,
5844  double * data_fixed_array,
5845  int data_fixed_length,
5846  int * sizes_fixed_array,
5847  int start, int sizes_fixed_length );
5848 
5849 /// @brief Get attribute string data. Note that the string handles
5850 /// returned are only valid until the next time this function
5851 /// is called.
5852 ///
5853 /// @ingroup GeometryGetters Attributes
5854 ///
5855 /// @param[in] session
5856 /// The session of Houdini you are interacting with.
5857 /// See @ref HAPI_Sessions for more on sessions.
5858 /// Pass NULL to just use the default in-process session.
5859 /// <!-- default NULL -->
5860 ///
5861 /// @param[in] node_id
5862 /// The node id.
5863 ///
5864 /// @param[in] part_id
5865 /// The part id.
5866 ///
5867 /// @param[in] name
5868 /// Attribute name.
5869 ///
5870 /// @param[in] attr_info
5871 /// ::HAPI_AttributeInfo used as input for what tuple size.
5872 /// you want. Also contains some sanity checks like
5873 /// data type. Generally should be the same struct
5874 /// returned by ::HAPI_GetAttributeInfo().
5875 ///
5876 /// @param[out] data_array
5877 /// An ::HAPI_StringHandle array at least the size of
5878 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5879 ///
5880 /// @param[in] start
5881 /// First index of range. Must be at least 0 and at
5882 /// most ::HAPI_AttributeInfo::count - 1.
5883 /// <!-- default 0 -->
5884 ///
5885 /// @param[in] length
5886 /// Must be at least 0 and at most
5887 /// ::HAPI_AttributeInfo::count - @p start.
5888 /// Note, if 0 is passed for length, the function will just
5889 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5890 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5891 ///
5892 /// @warning The string handles should be used to retrieve the strings
5893 /// immediately and are invalidated when another call to get
5894 /// this attribute's data is made.
5895 ///
5897  HAPI_NodeId node_id,
5898  HAPI_PartId part_id,
5899  const char * name,
5900  HAPI_AttributeInfo * attr_info,
5901  HAPI_StringHandle * data_array,
5902  int start, int length );
5903 
5904 /// @brief Get array attribute string data.
5905 /// Each entry in an array attribute can have varying array lengths.
5906 /// Therefore the array values are returned as a flat array, with
5907 /// another sizes array containing the lengths of each array entry.
5908 /// Note that the string handles returned are only valid until
5909 /// the next time this function is called.
5910 ///
5911 /// @ingroup GeometryGetters Attributes
5912 ///
5913 /// @param[in] session
5914 /// The session of Houdini you are interacting with.
5915 /// See @ref HAPI_Sessions for more on sessions.
5916 /// Pass NULL to just use the default in-process session.
5917 /// <!-- default NULL -->
5918 ///
5919 /// @param[in] node_id
5920 /// The node id.
5921 ///
5922 /// @param[in] part_id
5923 /// The part id.
5924 ///
5925 /// @param[in] name
5926 /// Attribute name.
5927 ///
5928 /// @param[in] attr_info
5929 /// ::HAPI_AttributeInfo used as input for the.
5930 /// totalArrayElements. Also contains some sanity checks like
5931 /// data type. Generally should be the same struct
5932 /// returned by ::HAPI_GetAttributeInfo().
5933 ///
5934 /// @param[out] data_fixed_array
5935 /// An ::HAPI_StringHandle array at least the size of
5936 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5937 ///
5938 /// @param[in] data_fixed_length
5939 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5940 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5941 ///
5942 /// @param[out] sizes_fixed_array
5943 /// An integer array at least the size of
5944 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5945 ///
5946 /// @param[in] start
5947 /// First index of range. Must be at least 0 and at
5948 /// most ::HAPI_AttributeInfo::count - 1.
5949 /// <!-- default 0 -->
5950 ///
5951 /// @param[in] sizes_fixed_length
5952 /// Must be at least 0 and at most
5953 /// ::HAPI_AttributeInfo::count - @p start.
5954 /// Note, if 0 is passed for length, the function will just
5955 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5956 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5957 ///
5958 /// @warning The string handles should be used to retrieve the strings
5959 /// immediately and are invalidated when another call to get
5960 /// this attribute's data is made.
5961 ///
5963  HAPI_NodeId node_id,
5964  HAPI_PartId part_id,
5965  const char * name,
5966  HAPI_AttributeInfo * attr_info,
5967  HAPI_StringHandle * data_fixed_array,
5968  int data_fixed_length,
5969  int * sizes_fixed_array,
5970  int start, int sizes_fixed_length );
5971 
5972 /// @brief Get attribute dictionary data.
5973 ///
5974 /// Dictionary data is serialized as JSON-encoded strings.
5975 /// Note that the string handles returned are only valid until the next
5976 /// time this function is called.
5977 ///
5978 /// @ingroup GeometryGetters Attributes
5979 ///
5980 /// @param[in] session
5981 /// The session of Houdini you are interacting with.
5982 /// See @ref HAPI_Sessions for more on sessions.
5983 /// Pass NULL to just use the default in-process session.
5984 /// <!-- default NULL -->
5985 ///
5986 /// @param[in] node_id
5987 /// The node id.
5988 ///
5989 /// @param[in] part_id
5990 /// The part id.
5991 ///
5992 /// @param[in] name
5993 /// Attribute name.
5994 ///
5995 /// @param[in] attr_info
5996 /// ::HAPI_AttributeInfo used as input for what tuple size
5997 /// you want. Also contains some sanity checks like
5998 /// data type. Generally should be the same struct
5999 /// returned by ::HAPI_GetAttributeInfo().
6000 ///
6001 /// @param[out] data_array
6002 /// An ::HAPI_StringHandle array at least the size of
6003 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6004 ///
6005 /// @param[in] start
6006 /// First index of range. Must be at least 0 and at
6007 /// most ::HAPI_AttributeInfo::count - 1.
6008 /// <!-- default 0 -->
6009 ///
6010 /// @param[in] length
6011 /// Must be at least 0 and at most
6012 /// ::HAPI_AttributeInfo::count - @p start.
6013 /// Note, if 0 is passed for length, the function will just
6014 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6015 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6016 ///
6017 /// @warning The string handles should be used to retrieve the strings
6018 /// immediately and are invalidated when another call to get
6019 /// this attribute's data is made.
6020 ///
6022  HAPI_NodeId node_id,
6023  HAPI_PartId part_id,
6024  const char* name,
6025  HAPI_AttributeInfo* attr_info,
6026  HAPI_StringHandle* data_array,
6027  int start,
6028  int length );
6029 
6030 /// @brief Get array attribute dictionary data.
6031 /// Each entry in an array attribute can have varying array lengths.
6032 /// Therefore the array values are returned as a flat array, with
6033 /// another sizes array containing the lengths of each array entry.
6034 ///
6035 /// Dictionary data is serialized as JSON-encoded strings.
6036 /// Note that the string handles returned are only valid until
6037 /// the next time this function is called.
6038 ///
6039 /// @ingroup GeometryGetters Attributes
6040 ///
6041 /// @param[in] session
6042 /// The session of Houdini you are interacting with.
6043 /// See @ref HAPI_Sessions for more on sessions.
6044 /// Pass NULL to just use the default in-process session.
6045 /// <!-- default NULL -->
6046 ///
6047 /// @param[in] node_id
6048 /// The node id.
6049 ///
6050 /// @param[in] part_id
6051 /// The part id.
6052 ///
6053 /// @param[in] name
6054 /// Attribute name.
6055 ///
6056 /// @param[in] attr_info
6057 /// ::HAPI_AttributeInfo used as input for the.
6058 /// totalArrayElements. Also contains some sanity checks like
6059 /// data type. Generally should be the same struct
6060 /// returned by ::HAPI_GetAttributeInfo().
6061 ///
6062 /// @param[out] data_fixed_array
6063 /// An ::HAPI_StringHandle array at least the size of
6064 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6065 ///
6066 /// @param[in] data_fixed_length
6067 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6068 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6069 ///
6070 /// @param[out] sizes_fixed_array
6071 /// An integer array at least the size of
6072 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6073 ///
6074 /// @param[in] start
6075 /// First index of range. Must be at least 0 and at
6076 /// most ::HAPI_AttributeInfo::count - 1.
6077 /// <!-- default 0 -->
6078 ///
6079 /// @param[in] sizes_fixed_length
6080 /// Must be at least 0 and at most
6081 /// ::HAPI_AttributeInfo::count - @p start.
6082 /// Note, if 0 is passed for length, the function will just
6083 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6084 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6085 ///
6086 /// @warning The string handles should be used to retrieve the strings
6087 /// immediately and are invalidated when another call to get
6088 /// this attribute's data is made.
6089 ///
6091  HAPI_NodeId node_id,
6092  HAPI_PartId part_id,
6093  const char* name,
6094  HAPI_AttributeInfo* attr_info,
6095  HAPI_StringHandle* data_fixed_array,
6096  int data_fixed_length,
6097  int* sizes_fixed_array,
6098  int start,
6099  int sizes_fixed_length );
6100 
6101 
6102 /// @brief Get attribute integer data asynchronously.
6103 ///
6104 /// @ingroup GeometryGetters Attributes
6105 ///
6106 /// @param[in] session
6107 /// The session of Houdini you are interacting with.
6108 /// See @ref HAPI_Sessions for more on sessions.
6109 /// Pass NULL to just use the default in-process session.
6110 /// <!-- default NULL -->
6111 ///
6112 /// @param[in] node_id
6113 /// The node id.
6114 ///
6115 /// @param[in] part_id
6116 /// The part id.
6117 ///
6118 /// @param[in] name
6119 /// Attribute name.
6120 ///
6121 /// @param[in] attr_info
6122 /// ::HAPI_AttributeInfo used as input for what tuple size.
6123 /// you want. Also contains some sanity checks like
6124 /// data type. Generally should be the same struct
6125 /// returned by ::HAPI_GetAttributeInfo().
6126 ///
6127 /// @param[in] stride
6128 /// Specifies how many items to skip over for each element.
6129 /// With a stride of -1, the stride will be set to
6130 /// @c attr_info->tuple_size. Otherwise, the stride will be
6131 /// set to the maximum of @c attr_info->tuple_size and
6132 /// @c stride.
6133 ///
6134 /// @param[out] data_array
6135 /// An integer array at least the size of
6136 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6137 ///
6138 /// @param[in] start
6139 /// First index of range. Must be at least 0 and at
6140 /// most ::HAPI_AttributeInfo::count - 1.
6141 /// <!-- default 0 -->
6142 ///
6143 /// @param[in] length
6144 /// Must be at least 0 and at most
6145 /// ::HAPI_AttributeInfo::count - @p start.
6146 /// Note, if 0 is passed for length, the function will just
6147 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6148 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6149 ///
6150 /// @param[out] job_id
6151 /// The id assigned to the job.
6152 ///
6154  HAPI_NodeId node_id,
6155  HAPI_PartId part_id,
6156  const char * name,
6157  HAPI_AttributeInfo * attr_info,
6158  int stride,
6159  int * data_array,
6160  int start, int length,
6161  int * job_id );
6162 
6163 
6164 /// @brief Get attribute unsigned 8-bit integer data asynchronously.
6165 ///
6166 /// @ingroup GeometryGetters Attributes
6167 ///
6168 /// @param[in] session
6169 /// The session of Houdini you are interacting with.
6170 /// See @ref HAPI_Sessions for more on sessions.
6171 /// Pass NULL to just use the default in-process session.
6172 /// <!-- default NULL -->
6173 ///
6174 /// @param[in] node_id
6175 /// The node id.
6176 ///
6177 /// @param[in] part_id
6178 /// The part id.
6179 ///
6180 /// @param[in] name
6181 /// Attribute name.
6182 ///
6183 /// @param[in] attr_info
6184 /// ::HAPI_AttributeInfo used as input for what tuple size.
6185 /// you want. Also contains some sanity checks like
6186 /// data type. Generally should be the same struct
6187 /// returned by ::HAPI_GetAttributeInfo().
6188 ///
6189 /// @param[in] stride
6190 /// Specifies how many items to skip over for each element.
6191 /// With a stride of -1, the stride will be set to
6192 /// @c attr_info->tuple_size. Otherwise, the stride will be
6193 /// set to the maximum of @c attr_info->tuple_size and
6194 /// @c stride.
6195 ///
6196 /// @param[out] data_array
6197 /// An integer array at least the size of
6198 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6199 ///
6200 /// @param[in] start
6201 /// First index of range. Must be at least 0 and at
6202 /// most ::HAPI_AttributeInfo::count - 1.
6203 /// <!-- default 0 -->
6204 ///
6205 /// @param[in] length
6206 /// Must be at least 0 and at most
6207 /// ::HAPI_AttributeInfo::count - @p start.
6208 /// Note, if 0 is passed for length, the function will just
6209 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6210 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6211 ///
6212 /// @param[out] job_id
6213 /// The id assigned to the job.
6214 ///
6216  HAPI_NodeId node_id,
6217  HAPI_PartId part_id,
6218  const char * name,
6219  HAPI_AttributeInfo * attr_info,
6220  int stride,
6221  HAPI_UInt8 * data_array,
6222  int start, int length,
6223  int * job_id );
6224 
6225 
6226 /// @brief Get attribute 8-bit integer data asynchronously.
6227 ///
6228 /// @ingroup GeometryGetters Attributes
6229 ///
6230 /// @param[in] session
6231 /// The session of Houdini you are interacting with.
6232 /// See @ref HAPI_Sessions for more on sessions.
6233 /// Pass NULL to just use the default in-process session.
6234 /// <!-- default NULL -->
6235 ///
6236 /// @param[in] node_id
6237 /// The node id.
6238 ///
6239 /// @param[in] part_id
6240 /// The part id.
6241 ///
6242 /// @param[in] name
6243 /// Attribute name.
6244 ///
6245 /// @param[in] attr_info
6246 /// ::HAPI_AttributeInfo used as input for what tuple size.
6247 /// you want. Also contains some sanity checks like
6248 /// data type. Generally should be the same struct
6249 /// returned by ::HAPI_GetAttributeInfo().
6250 ///
6251 /// @param[in] stride
6252 /// Specifies how many items to skip over for each element.
6253 /// With a stride of -1, the stride will be set to
6254 /// @c attr_info->tuple_size. Otherwise, the stride will be
6255 /// set to the maximum of @c attr_info->tuple_size and
6256 /// @c stride.
6257 ///
6258 /// @param[out] data_array
6259 /// An integer array at least the size of
6260 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6261 ///
6262 /// @param[in] start
6263 /// First index of range. Must be at least 0 and at
6264 /// most ::HAPI_AttributeInfo::count - 1.
6265 /// <!-- default 0 -->
6266 ///
6267 /// @param[in] length
6268 /// Must be at least 0 and at most
6269 /// ::HAPI_AttributeInfo::count - @p start.
6270 /// Note, if 0 is passed for length, the function will just
6271 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6272 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6273 ///
6274 /// @param[out] job_id
6275 /// The id assigned to the job.
6276 ///
6278  HAPI_NodeId node_id,
6279  HAPI_PartId part_id,
6280  const char * name,
6281  HAPI_AttributeInfo * attr_info,
6282  int stride,
6283  HAPI_Int8 * data_array,
6284  int start, int length,
6285  int * job_id );
6286 
6287 /// @brief Get attribute 16-bit integer data asynchronously.
6288 ///
6289 /// @ingroup GeometryGetters Attributes
6290 ///
6291 /// @param[in] session
6292 /// The session of Houdini you are interacting with.
6293 /// See @ref HAPI_Sessions for more on sessions.
6294 /// Pass NULL to just use the default in-process session.
6295 /// <!-- default NULL -->
6296 ///
6297 /// @param[in] node_id
6298 /// The node id.
6299 ///
6300 /// @param[in] part_id
6301 /// The part id.
6302 ///
6303 /// @param[in] name
6304 /// Attribute name.
6305 ///
6306 /// @param[in] attr_info
6307 /// ::HAPI_AttributeInfo used as input for what tuple size.
6308 /// you want. Also contains some sanity checks like
6309 /// data type. Generally should be the same struct
6310 /// returned by ::HAPI_GetAttributeInfo().
6311 ///
6312 /// @param[in] stride
6313 /// Specifies how many items to skip over for each element.
6314 /// With a stride of -1, the stride will be set to
6315 /// @c attr_info->tuple_size. Otherwise, the stride will be
6316 /// set to the maximum of @c attr_info->tuple_size and
6317 /// @c stride.
6318 ///
6319 /// @param[out] data_array
6320 /// An integer array at least the size of
6321 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6322 ///
6323 /// @param[in] start
6324 /// First index of range. Must be at least 0 and at
6325 /// most ::HAPI_AttributeInfo::count - 1.
6326 /// <!-- default 0 -->
6327 ///
6328 /// @param[in] length
6329 /// Must be at least 0 and at most
6330 /// ::HAPI_AttributeInfo::count - @p start.
6331 /// Note, if 0 is passed for length, the function will just
6332 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6333 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6334 ///
6335 /// @param[out] job_id
6336 /// The id assigned to the job.
6337 ///
6339  HAPI_NodeId node_id,
6340  HAPI_PartId part_id,
6341  const char * name,
6342  HAPI_AttributeInfo * attr_info,
6343  int stride,
6344  HAPI_Int16 * data_array,
6345  int start, int length,
6346  int * job_id );
6347 
6348 /// @brief Get attribute 64-bit integer data asynchronously.
6349 ///
6350 /// @ingroup GeometryGetters Attributes
6351 ///
6352 /// @param[in] session
6353 /// The session of Houdini you are interacting with.
6354 /// See @ref HAPI_Sessions for more on sessions.
6355 /// Pass NULL to just use the default in-process session.
6356 /// <!-- default NULL -->
6357 ///
6358 /// @param[in] node_id
6359 /// The node id.
6360 ///
6361 /// @param[in] part_id
6362 /// The part id.
6363 ///
6364 /// @param[in] name
6365 /// Attribute name.
6366 ///
6367 /// @param[in] attr_info
6368 /// ::HAPI_AttributeInfo used as input for what tuple size.
6369 /// you want. Also contains some sanity checks like
6370 /// data type. Generally should be the same struct
6371 /// returned by ::HAPI_GetAttributeInfo().
6372 ///
6373 /// @param[in] stride
6374 /// Specifies how many items to skip over for each element.
6375 /// With a stride of -1, the stride will be set to
6376 /// @c attr_info->tuple_size. Otherwise, the stride will be
6377 /// set to the maximum of @c attr_info->tuple_size and
6378 /// @c stride.
6379 ///
6380 /// @param[out] data_array
6381 /// An integer array at least the size of
6382 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6383 ///
6384 /// @param[in] start
6385 /// First index of range. Must be at least 0 and at
6386 /// most ::HAPI_AttributeInfo::count - 1.
6387 /// <!-- default 0 -->
6388 ///
6389 /// @param[in] length
6390 /// Must be at least 0 and at most
6391 /// ::HAPI_AttributeInfo::count - @p start.
6392 /// Note, if 0 is passed for length, the function will just
6393 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6394 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6395 ///
6396 /// @param[out] job_id
6397 /// The id assigned to the job.
6398 ///
6400  HAPI_NodeId node_id,
6401  HAPI_PartId part_id,
6402  const char * name,
6403  HAPI_AttributeInfo * attr_info,
6404  int stride,
6405  HAPI_Int64 * data_array,
6406  int start, int length,
6407  int * job_id );
6408 
6409 
6410 /// @brief Get attribute float data asynchronously.
6411 ///
6412 /// @ingroup GeometryGetters Attributes
6413 ///
6414 /// @param[in] session
6415 /// The session of Houdini you are interacting with.
6416 /// See @ref HAPI_Sessions for more on sessions.
6417 /// Pass NULL to just use the default in-process session.
6418 /// <!-- default NULL -->
6419 ///
6420 /// @param[in] node_id
6421 /// The node id.
6422 ///
6423 /// @param[in] part_id
6424 /// The part id.
6425 ///
6426 /// @param[in] name
6427 /// Attribute name.
6428 ///
6429 /// @param[in] attr_info
6430 /// ::HAPI_AttributeInfo used as input for what tuple size.
6431 /// you want. Also contains some sanity checks like
6432 /// data type. Generally should be the same struct
6433 /// returned by ::HAPI_GetAttributeInfo().
6434 ///
6435 /// @param[in] stride
6436 /// Specifies how many items to skip over for each element.
6437 /// With a stride of -1, the stride will be set to
6438 /// @c attr_info->tuple_size. Otherwise, the stride will be
6439 /// set to the maximum of @c attr_info->tuple_size and
6440 /// @c stride.
6441 ///
6442 /// @param[out] data_array
6443 /// An integer array at least the size of
6444 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6445 ///
6446 /// @param[in] start
6447 /// First index of range. Must be at least 0 and at
6448 /// most ::HAPI_AttributeInfo::count - 1.
6449 /// <!-- default 0 -->
6450 ///
6451 /// @param[in] length
6452 /// Must be at least 0 and at most
6453 /// ::HAPI_AttributeInfo::count - @p start.
6454 /// Note, if 0 is passed for length, the function will just
6455 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6456 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6457 ///
6458 /// @param[out] job_id
6459 /// The id assigned to the job.
6460 ///
6462  HAPI_NodeId node_id,
6463  HAPI_PartId part_id,
6464  const char * name,
6465  HAPI_AttributeInfo * attr_info,
6466  int stride,
6467  float * data_array,
6468  int start, int length,
6469  int * job_id );
6470 
6471 /// @brief Get attribute 64-bit float data asynchronously.
6472 ///
6473 /// @ingroup GeometryGetters Attributes
6474 ///
6475 /// @param[in] session
6476 /// The session of Houdini you are interacting with.
6477 /// See @ref HAPI_Sessions for more on sessions.
6478 /// Pass NULL to just use the default in-process session.
6479 /// <!-- default NULL -->
6480 ///
6481 /// @param[in] node_id
6482 /// The node id.
6483 ///
6484 /// @param[in] part_id
6485 /// The part id.
6486 ///
6487 /// @param[in] name
6488 /// Attribute name.
6489 ///
6490 /// @param[in] attr_info
6491 /// ::HAPI_AttributeInfo used as input for what tuple size.
6492 /// you want. Also contains some sanity checks like
6493 /// data type. Generally should be the same struct
6494 /// returned by ::HAPI_GetAttributeInfo().
6495 ///
6496 /// @param[in] stride
6497 /// Specifies how many items to skip over for each element.
6498 /// With a stride of -1, the stride will be set to
6499 /// @c attr_info->tuple_size. Otherwise, the stride will be
6500 /// set to the maximum of @c attr_info->tuple_size and
6501 /// @c stride.
6502 ///
6503 /// @param[out] data_array
6504 /// An integer array at least the size of
6505 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6506 ///
6507 /// @param[in] start
6508 /// First index of range. Must be at least 0 and at
6509 /// most ::HAPI_AttributeInfo::count - 1.
6510 /// <!-- default 0 -->
6511 ///
6512 /// @param[in] length
6513 /// Must be at least 0 and at most
6514 /// ::HAPI_AttributeInfo::count - @p start.
6515 /// Note, if 0 is passed for length, the function will just
6516 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6517 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6518 ///
6519 /// @param[out] job_id
6520 /// The id assigned to the job.
6521 ///
6523  HAPI_NodeId node_id,
6524  HAPI_PartId part_id,
6525  const char * name,
6526  HAPI_AttributeInfo * attr_info,
6527  int stride,
6528  double * data_array,
6529  int start, int length,
6530  int * job_id );
6531 
6532 /// @brief Get attribute string data asynchronously.
6533 ///
6534 /// @ingroup GeometryGetters Attributes
6535 ///
6536 /// @param[in] session
6537 /// The session of Houdini you are interacting with.
6538 /// See @ref HAPI_Sessions for more on sessions.
6539 /// Pass NULL to just use the default in-process session.
6540 /// <!-- default NULL -->
6541 ///
6542 /// @param[in] node_id
6543 /// The node id.
6544 ///
6545 /// @param[in] part_id
6546 /// The part id.
6547 ///
6548 /// @param[in] name
6549 /// Attribute name.
6550 ///
6551 /// @param[in] attr_info
6552 /// ::HAPI_AttributeInfo used as input for what tuple size.
6553 /// you want. Also contains some sanity checks like
6554 /// data type. Generally should be the same struct
6555 /// returned by ::HAPI_GetAttributeInfo().
6556 ///
6557 /// @param[out] data_array
6558 /// An integer array at least the size of
6559 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6560 ///
6561 /// @param[in] start
6562 /// First index of range. Must be at least 0 and at
6563 /// most ::HAPI_AttributeInfo::count - 1.
6564 /// <!-- default 0 -->
6565 ///
6566 /// @param[in] length
6567 /// Must be at least 0 and at most
6568 /// ::HAPI_AttributeInfo::count - @p start.
6569 /// Note, if 0 is passed for length, the function will just
6570 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6571 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6572 ///
6573 /// @param[out] job_id
6574 /// The id assigned to the job.
6575 ///
6576 /// @warning The string handles should be used to retrieve the strings
6577 /// immediately and are invalidated when another call to get
6578 /// this attribute's data is made.
6579 ///
6581  HAPI_NodeId node_id,
6582  HAPI_PartId part_id,
6583  const char * name,
6584  HAPI_AttributeInfo * attr_info,
6585  HAPI_StringHandle * data_array,
6586  int start, int length,
6587  int * job_id );
6588 
6589 /// @brief Get attribute dictionary data asynchronously.
6590 ///
6591 /// @ingroup GeometryGetters Attributes
6592 ///
6593 /// @param[in] session
6594 /// The session of Houdini you are interacting with.
6595 /// See @ref HAPI_Sessions for more on sessions.
6596 /// Pass NULL to just use the default in-process session.
6597 /// <!-- default NULL -->
6598 ///
6599 /// @param[in] node_id
6600 /// The node id.
6601 ///
6602 /// @param[in] part_id
6603 /// The part id.
6604 ///
6605 /// @param[in] name
6606 /// Attribute name.
6607 ///
6608 /// @param[in] attr_info
6609 /// ::HAPI_AttributeInfo used as input for what tuple size.
6610 /// you want. Also contains some sanity checks like
6611 /// data type. Generally should be the same struct
6612 /// returned by ::HAPI_GetAttributeInfo().
6613 ///
6614 /// @param[out] data_array
6615 /// An integer array at least the size of
6616 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6617 ///
6618 /// @param[in] start
6619 /// First index of range. Must be at least 0 and at
6620 /// most ::HAPI_AttributeInfo::count - 1.
6621 /// <!-- default 0 -->
6622 ///
6623 /// @param[in] length
6624 /// Must be at least 0 and at most
6625 /// ::HAPI_AttributeInfo::count - @p start.
6626 /// Note, if 0 is passed for length, the function will just
6627 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6628 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6629 ///
6630 /// @param[out] job_id
6631 /// The id assigned to the job.
6632 ///
6633 /// @warning The string handles should be used to retrieve the strings
6634 /// immediately and are invalidated when another call to get
6635 /// this attribute's data is made.
6636 ///
6638  HAPI_NodeId node_id,
6639  HAPI_PartId part_id,
6640  const char * name,
6641  HAPI_AttributeInfo * attr_info,
6642  HAPI_StringHandle * data_array,
6643  int start, int length,
6644  int * job_id );
6645 
6646 /// @brief Get array attribute integer data asynchronously.
6647 /// Each entry in an array attribute can have varying array lengths.
6648 /// Therefore the array values are returned as a flat array, with
6649 /// another sizes array containing the lengths of each array entry.
6650 ///
6651 /// @ingroup GeometryGetters Attributes
6652 ///
6653 /// @param[in] session
6654 /// The session of Houdini you are interacting with.
6655 /// See @ref HAPI_Sessions for more on sessions.
6656 /// Pass NULL to just use the default in-process session.
6657 /// <!-- default NULL -->
6658 ///
6659 /// @param[in] node_id
6660 /// The node id.
6661 ///
6662 /// @param[in] part_id
6663 /// The part id.
6664 ///
6665 /// @param[in] attr_name
6666 /// Attribute name.
6667 ///
6668 /// @param[in] attr_info
6669 /// ::HAPI_AttributeInfo used as input for what tuple size.
6670 /// you want. Also contains some sanity checks like
6671 /// data type. Generally should be the same struct
6672 /// returned by ::HAPI_GetAttributeInfo().
6673 ///
6674 /// @param[out] data_fixed_array
6675 /// An integer array at least the size of
6676 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6677 ///
6678 /// @param[in] data_fixed_length
6679 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6680 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6681 ///
6682 /// @param[out] sizes_fixed_array
6683 /// An integer array at least the size of
6684 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6685 /// <!-- source ::HAPI_AttributeInfo::count -->
6686 ///
6687 /// @param[in] start
6688 /// First index of range. Must be at least 0 and at
6689 /// most ::HAPI_AttributeInfo::count - 1.
6690 /// <!-- default 0 -->
6691 ///
6692 /// @param[in] sizes_fixed_length
6693 /// Must be at least 0 and at most
6694 /// ::HAPI_AttributeInfo::count - @p start.
6695 /// Note, if 0 is passed for length, the function will just
6696 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6697 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6698 ///
6699 /// @param[out] job_id
6700 /// The id assigned to the job.
6701 ///
6703  HAPI_NodeId node_id,
6704  HAPI_PartId part_id,
6705  const char * attr_name,
6706  HAPI_AttributeInfo * attr_info,
6707  int * data_fixed_array,
6708  int data_fixed_length,
6709  int * sizes_fixed_array,
6710  int start, int sizes_fixed_length,
6711  int * job_id );
6712 
6713 /// @brief Get array attribute unsigned 8-bit integer data asynchronously.
6714 /// Each entry in an array attribute can have varying array lengths.
6715 /// Therefore the array values are returned as a flat array, with
6716 /// another sizes array containing the lengths of each array entry.
6717 ///
6718 /// @ingroup GeometryGetters Attributes
6719 ///
6720 /// @param[in] session
6721 /// The session of Houdini you are interacting with.
6722 /// See @ref HAPI_Sessions for more on sessions.
6723 /// Pass NULL to just use the default in-process session.
6724 /// <!-- default NULL -->
6725 ///
6726 /// @param[in] node_id
6727 /// The node id.
6728 ///
6729 /// @param[in] part_id
6730 /// The part id.
6731 ///
6732 /// @param[in] attr_name
6733 /// Attribute name.
6734 ///
6735 /// @param[in] attr_info
6736 /// ::HAPI_AttributeInfo used as input for what tuple size.
6737 /// you want. Also contains some sanity checks like
6738 /// data type. Generally should be the same struct
6739 /// returned by ::HAPI_GetAttributeInfo().
6740 ///
6741 /// @param[out] data_fixed_array
6742 /// An integer array at least the size of
6743 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6744 ///
6745 /// @param[in] data_fixed_length
6746 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6747 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6748 ///
6749 /// @param[out] sizes_fixed_array
6750 /// An integer array at least the size of
6751 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6752 /// <!-- source ::HAPI_AttributeInfo::count -->
6753 ///
6754 /// @param[in] start
6755 /// First index of range. Must be at least 0 and at
6756 /// most ::HAPI_AttributeInfo::count - 1.
6757 /// <!-- default 0 -->
6758 ///
6759 /// @param[in] sizes_fixed_length
6760 /// Must be at least 0 and at most
6761 /// ::HAPI_AttributeInfo::count - @p start.
6762 /// Note, if 0 is passed for length, the function will just
6763 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6764 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6765 ///
6766 /// @param[out] job_id
6767 /// The id assigned to the job.
6768 ///
6770  HAPI_NodeId node_id,
6771  HAPI_PartId part_id,
6772  const char * attr_name,
6773  HAPI_AttributeInfo * attr_info,
6774  HAPI_UInt8 * data_fixed_array,
6775  int data_fixed_length,
6776  int * sizes_fixed_array,
6777  int start, int sizes_fixed_length,
6778  int * job_id );
6779 
6780 /// @brief Get array attribute 8-bit integer data asynchronously.
6781 /// Each entry in an array attribute can have varying array lengths.
6782 /// Therefore the array values are returned as a flat array, with
6783 /// another sizes array containing the lengths of each array entry.
6784 ///
6785 /// @ingroup GeometryGetters Attributes
6786 ///
6787 /// @param[in] session
6788 /// The session of Houdini you are interacting with.
6789 /// See @ref HAPI_Sessions for more on sessions.
6790 /// Pass NULL to just use the default in-process session.
6791 /// <!-- default NULL -->
6792 ///
6793 /// @param[in] node_id
6794 /// The node id.
6795 ///
6796 /// @param[in] part_id
6797 /// The part id.
6798 ///
6799 /// @param[in] attr_name
6800 /// Attribute name.
6801 ///
6802 /// @param[in] attr_info
6803 /// ::HAPI_AttributeInfo used as input for what tuple size.
6804 /// you want. Also contains some sanity checks like
6805 /// data type. Generally should be the same struct
6806 /// returned by ::HAPI_GetAttributeInfo().
6807 ///
6808 /// @param[out] data_fixed_array
6809 /// An integer array at least the size of
6810 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6811 ///
6812 /// @param[in] data_fixed_length
6813 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6814 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6815 ///
6816 /// @param[out] sizes_fixed_array
6817 /// An integer array at least the size of
6818 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6819 /// <!-- source ::HAPI_AttributeInfo::count -->
6820 ///
6821 /// @param[in] start
6822 /// First index of range. Must be at least 0 and at
6823 /// most ::HAPI_AttributeInfo::count - 1.
6824 /// <!-- default 0 -->
6825 ///
6826 /// @param[in] sizes_fixed_length
6827 /// Must be at least 0 and at most
6828 /// ::HAPI_AttributeInfo::count - @p start.
6829 /// Note, if 0 is passed for length, the function will just
6830 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6831 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6832 ///
6833 /// @param[out] job_id
6834 /// The id assigned to the job.
6835 ///
6837  HAPI_NodeId node_id,
6838  HAPI_PartId part_id,
6839  const char * attr_name,
6840  HAPI_AttributeInfo * attr_info,
6841  HAPI_Int8 * data_fixed_array,
6842  int data_fixed_length,
6843  int * sizes_fixed_array,
6844  int start, int sizes_fixed_length,
6845  int * job_id );
6846 
6847 /// @brief Get array attribute 16-bit integer data asynchronously.
6848 /// Each entry in an array attribute can have varying array lengths.
6849 /// Therefore the array values are returned as a flat array, with
6850 /// another sizes array containing the lengths of each array entry.
6851 ///
6852 /// @ingroup GeometryGetters Attributes
6853 ///
6854 /// @param[in] session
6855 /// The session of Houdini you are interacting with.
6856 /// See @ref HAPI_Sessions for more on sessions.
6857 /// Pass NULL to just use the default in-process session.
6858 /// <!-- default NULL -->
6859 ///
6860 /// @param[in] node_id
6861 /// The node id.
6862 ///
6863 /// @param[in] part_id
6864 /// The part id.
6865 ///
6866 /// @param[in] attr_name
6867 /// Attribute name.
6868 ///
6869 /// @param[in] attr_info
6870 /// ::HAPI_AttributeInfo used as input for what tuple size.
6871 /// you want. Also contains some sanity checks like
6872 /// data type. Generally should be the same struct
6873 /// returned by ::HAPI_GetAttributeInfo().
6874 ///
6875 /// @param[out] data_fixed_array
6876 /// An integer array at least the size of
6877 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6878 ///
6879 /// @param[in] data_fixed_length
6880 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6881 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6882 ///
6883 /// @param[out] sizes_fixed_array
6884 /// An integer array at least the size of
6885 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6886 /// <!-- source ::HAPI_AttributeInfo::count -->
6887 ///
6888 /// @param[in] start
6889 /// First index of range. Must be at least 0 and at
6890 /// most ::HAPI_AttributeInfo::count - 1.
6891 /// <!-- default 0 -->
6892 ///
6893 /// @param[in] sizes_fixed_length
6894 /// Must be at least 0 and at most
6895 /// ::HAPI_AttributeInfo::count - @p start.
6896 /// Note, if 0 is passed for length, the function will just
6897 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6898 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6899 ///
6900 /// @param[out] job_id
6901 /// The id assigned to the job.
6902 ///
6904  HAPI_NodeId node_id,
6905  HAPI_PartId part_id,
6906  const char * attr_name,
6907  HAPI_AttributeInfo * attr_info,
6908  HAPI_Int16 * data_fixed_array,
6909  int data_fixed_length,
6910  int * sizes_fixed_array,
6911  int start, int sizes_fixed_length,
6912  int * job_id );
6913 
6914 /// @brief Get array attribute 64-bit integer data asynchronously.
6915 /// Each entry in an array attribute can have varying array lengths.
6916 /// Therefore the array values are returned as a flat array, with
6917 /// another sizes array containing the lengths of each array entry.
6918 ///
6919 /// @ingroup GeometryGetters Attributes
6920 ///
6921 /// @param[in] session
6922 /// The session of Houdini you are interacting with.
6923 /// See @ref HAPI_Sessions for more on sessions.
6924 /// Pass NULL to just use the default in-process session.
6925 /// <!-- default NULL -->
6926 ///
6927 /// @param[in] node_id
6928 /// The node id.
6929 ///
6930 /// @param[in] part_id
6931 /// The part id.
6932 ///
6933 /// @param[in] attr_name
6934 /// Attribute name.
6935 ///
6936 /// @param[in] attr_info
6937 /// ::HAPI_AttributeInfo used as input for what tuple size.
6938 /// you want. Also contains some sanity checks like
6939 /// data type. Generally should be the same struct
6940 /// returned by ::HAPI_GetAttributeInfo().
6941 ///
6942 /// @param[out] data_fixed_array
6943 /// An integer array at least the size of
6944 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6945 ///
6946 /// @param[in] data_fixed_length
6947 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
6948 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
6949 ///
6950 /// @param[out] sizes_fixed_array
6951 /// An integer array at least the size of
6952 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
6953 /// <!-- source ::HAPI_AttributeInfo::count -->
6954 ///
6955 /// @param[in] start
6956 /// First index of range. Must be at least 0 and at
6957 /// most ::HAPI_AttributeInfo::count - 1.
6958 /// <!-- default 0 -->
6959 ///
6960 /// @param[in] sizes_fixed_length
6961 /// Must be at least 0 and at most
6962 /// ::HAPI_AttributeInfo::count - @p start.
6963 /// Note, if 0 is passed for length, the function will just
6964 /// do nothing and return ::HAPI_RESULT_SUCCESS.
6965 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6966 ///
6967 /// @param[out] job_id
6968 /// The id assigned to the job.
6969 ///
6971  HAPI_NodeId node_id,
6972  HAPI_PartId part_id,
6973  const char * attr_name,
6974  HAPI_AttributeInfo * attr_info,
6975  HAPI_Int64 * data_fixed_array,
6976  int data_fixed_length,
6977  int * sizes_fixed_array,
6978  int start, int sizes_fixed_length,
6979  int * job_id );
6980 
6981 /// @brief Get array attribute float data asynchronously.
6982 /// Each entry in an array attribute can have varying array lengths.
6983 /// Therefore the array values are returned as a flat array, with
6984 /// another sizes array containing the lengths of each array entry.
6985 ///
6986 /// @ingroup GeometryGetters Attributes
6987 ///
6988 /// @param[in] session
6989 /// The session of Houdini you are interacting with.
6990 /// See @ref HAPI_Sessions for more on sessions.
6991 /// Pass NULL to just use the default in-process session.
6992 /// <!-- default NULL -->
6993 ///
6994 /// @param[in] node_id
6995 /// The node id.
6996 ///
6997 /// @param[in] part_id
6998 /// The part id.
6999 ///
7000 /// @param[in] attr_name
7001 /// Attribute name.
7002 ///
7003 /// @param[in] attr_info
7004 /// ::HAPI_AttributeInfo used as input for what tuple size.
7005 /// you want. Also contains some sanity checks like
7006 /// data type. Generally should be the same struct
7007 /// returned by ::HAPI_GetAttributeInfo().
7008 ///
7009 /// @param[out] data_fixed_array
7010 /// An integer array at least the size of
7011 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7012 ///
7013 /// @param[in] data_fixed_length
7014 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7015 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7016 ///
7017 /// @param[out] sizes_fixed_array
7018 /// An integer array at least the size of
7019 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7020 /// <!-- source ::HAPI_AttributeInfo::count -->
7021 ///
7022 /// @param[in] start
7023 /// First index of range. Must be at least 0 and at
7024 /// most ::HAPI_AttributeInfo::count - 1.
7025 /// <!-- default 0 -->
7026 ///
7027 /// @param[in] sizes_fixed_length
7028 /// Must be at least 0 and at most
7029 /// ::HAPI_AttributeInfo::count - @p start.
7030 /// Note, if 0 is passed for length, the function will just
7031 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7032 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7033 ///
7034 /// @param[out] job_id
7035 /// The id assigned to the job.
7036 ///
7038  HAPI_NodeId node_id,
7039  HAPI_PartId part_id,
7040  const char * attr_name,
7041  HAPI_AttributeInfo * attr_info,
7042  float * data_fixed_array,
7043  int data_fixed_length,
7044  int * sizes_fixed_array,
7045  int start, int sizes_fixed_length,
7046  int * job_id );
7047 
7048 /// @brief Get array attribute 64-bit float data asynchronously.
7049 /// Each entry in an array attribute can have varying array lengths.
7050 /// Therefore the array values are returned as a flat array, with
7051 /// another sizes array containing the lengths of each array entry.
7052 ///
7053 /// @ingroup GeometryGetters Attributes
7054 ///
7055 /// @param[in] session
7056 /// The session of Houdini you are interacting with.
7057 /// See @ref HAPI_Sessions for more on sessions.
7058 /// Pass NULL to just use the default in-process session.
7059 /// <!-- default NULL -->
7060 ///
7061 /// @param[in] node_id
7062 /// The node id.
7063 ///
7064 /// @param[in] part_id
7065 /// The part id.
7066 ///
7067 /// @param[in] attr_name
7068 /// Attribute name.
7069 ///
7070 /// @param[in] attr_info
7071 /// ::HAPI_AttributeInfo used as input for what tuple size.
7072 /// you want. Also contains some sanity checks like
7073 /// data type. Generally should be the same struct
7074 /// returned by ::HAPI_GetAttributeInfo().
7075 ///
7076 /// @param[out] data_fixed_array
7077 /// An integer array at least the size of
7078 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7079 ///
7080 /// @param[in] data_fixed_length
7081 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7082 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7083 ///
7084 /// @param[out] sizes_fixed_array
7085 /// An integer array at least the size of
7086 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7087 /// <!-- source ::HAPI_AttributeInfo::count -->
7088 ///
7089 /// @param[in] start
7090 /// First index of range. Must be at least 0 and at
7091 /// most ::HAPI_AttributeInfo::count - 1.
7092 /// <!-- default 0 -->
7093 ///
7094 /// @param[in] sizes_fixed_length
7095 /// Must be at least 0 and at most
7096 /// ::HAPI_AttributeInfo::count - @p start.
7097 /// Note, if 0 is passed for length, the function will just
7098 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7099 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7100 ///
7101 /// @param[out] job_id
7102 /// The id assigned to the job.
7103 ///
7105  HAPI_NodeId node_id,
7106  HAPI_PartId part_id,
7107  const char * attr_name,
7108  HAPI_AttributeInfo * attr_info,
7109  double * data_fixed_array,
7110  int data_fixed_length,
7111  int * sizes_fixed_array,
7112  int start, int sizes_fixed_length,
7113  int * job_id );
7114 
7115 /// @brief Get array attribute string data asynchronously.
7116 /// Each entry in an array attribute can have varying array lengths.
7117 /// Therefore the array values are returned as a flat array, with
7118 /// another sizes array containing the lengths of each array entry.
7119 ///
7120 /// @ingroup GeometryGetters Attributes
7121 ///
7122 /// @param[in] session
7123 /// The session of Houdini you are interacting with.
7124 /// See @ref HAPI_Sessions for more on sessions.
7125 /// Pass NULL to just use the default in-process session.
7126 /// <!-- default NULL -->
7127 ///
7128 /// @param[in] node_id
7129 /// The node id.
7130 ///
7131 /// @param[in] part_id
7132 /// The part id.
7133 ///
7134 /// @param[in] attr_name
7135 /// Attribute name.
7136 ///
7137 /// @param[in] attr_info
7138 /// ::HAPI_AttributeInfo used as input for what tuple size.
7139 /// you want. Also contains some sanity checks like
7140 /// data type. Generally should be the same struct
7141 /// returned by ::HAPI_GetAttributeInfo().
7142 ///
7143 /// @param[out] data_fixed_array
7144 /// An integer array at least the size of
7145 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7146 ///
7147 /// @param[in] data_fixed_length
7148 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7149 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7150 ///
7151 /// @param[out] sizes_fixed_array
7152 /// An integer array at least the size of
7153 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7154 /// <!-- source ::HAPI_AttributeInfo::count -->
7155 ///
7156 /// @param[in] start
7157 /// First index of range. Must be at least 0 and at
7158 /// most ::HAPI_AttributeInfo::count - 1.
7159 /// <!-- default 0 -->
7160 ///
7161 /// @param[in] sizes_fixed_length
7162 /// Must be at least 0 and at most
7163 /// ::HAPI_AttributeInfo::count - @p start.
7164 /// Note, if 0 is passed for length, the function will just
7165 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7166 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7167 ///
7168 /// @param[out] job_id
7169 /// The id assigned to the job.
7170 ///
7171 /// @warning The string handles should be used to retrieve the strings
7172 /// immediately and are invalidated when another call to get
7173 /// this attribute's data is made.
7174 ///
7176  HAPI_NodeId node_id,
7177  HAPI_PartId part_id,
7178  const char * attr_name,
7179  HAPI_AttributeInfo * attr_info,
7180  HAPI_StringHandle * data_fixed_array,
7181  int data_fixed_length,
7182  int * sizes_fixed_array,
7183  int start, int sizes_fixed_length,
7184  int * job_id );
7185 
7186 /// @brief Get array attribute dictionary data asynchronously.
7187 /// Each entry in an array attribute can have varying array lengths.
7188 /// Therefore the array values are returned as a flat array, with
7189 /// another sizes array containing the lengths of each array entry.
7190 ///
7191 /// @ingroup GeometryGetters Attributes
7192 ///
7193 /// @param[in] session
7194 /// The session of Houdini you are interacting with.
7195 /// See @ref HAPI_Sessions for more on sessions.
7196 /// Pass NULL to just use the default in-process session.
7197 /// <!-- default NULL -->
7198 ///
7199 /// @param[in] node_id
7200 /// The node id.
7201 ///
7202 /// @param[in] part_id
7203 /// The part id.
7204 ///
7205 /// @param[in] attr_name
7206 /// Attribute name.
7207 ///
7208 /// @param[in] attr_info
7209 /// ::HAPI_AttributeInfo used as input for what tuple size.
7210 /// you want. Also contains some sanity checks like
7211 /// data type. Generally should be the same struct
7212 /// returned by ::HAPI_GetAttributeInfo().
7213 ///
7214 /// @param[out] data_fixed_array
7215 /// An integer array at least the size of
7216 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7217 ///
7218 /// @param[in] data_fixed_length
7219 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
7220 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7221 ///
7222 /// @param[out] sizes_fixed_array
7223 /// An integer array at least the size of
7224 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
7225 /// <!-- source ::HAPI_AttributeInfo::count -->
7226 ///
7227 /// @param[in] start
7228 /// First index of range. Must be at least 0 and at
7229 /// most ::HAPI_AttributeInfo::count - 1.
7230 /// <!-- default 0 -->
7231 ///
7232 /// @param[in] sizes_fixed_length
7233 /// Must be at least 0 and at most
7234 /// ::HAPI_AttributeInfo::count - @p start.
7235 /// Note, if 0 is passed for length, the function will just
7236 /// do nothing and return ::HAPI_RESULT_SUCCESS.
7237 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7238 ///
7239 /// @param[out] job_id
7240 /// The id assigned to the job.
7241 ///
7242 /// @warning The string handles should be used to retrieve the strings
7243 /// immediately and are invalidated when another call to get
7244 /// this attribute's data is made.
7245 ///
7247  HAPI_NodeId node_id,
7248  HAPI_PartId part_id,
7249  const char * attr_name,
7250  HAPI_AttributeInfo * attr_info,
7251  HAPI_StringHandle * data_fixed_array,
7252  int data_fixed_length,
7253  int * sizes_fixed_array,
7254  int start, int sizes_fixed_length,
7255  int * job_id );
7256 
7257 /// @brief Get status of a job.
7258 ///
7259 /// @ingroup Status
7260 ///
7261 /// @param[in] session
7262 /// The session of Houdini you are interacting with.
7263 /// See @ref HAPI_Sessions for more on sessions.
7264 /// Pass NULL to just use the default in-process session.
7265 /// <!-- default NULL -->
7266 ///
7267 /// @param[in] job_id
7268 /// The id assigned to the job. It must equal to the index
7269 /// assigned through a previous call to an asynchronous HAPI
7270 /// method.
7271 ///
7272 /// @param[out] job_status
7273 /// The current status of the job. One of ::HAPI_JobStatus.
7274 ///
7275 HAPI_DECL HAPI_GetJobStatus( const HAPI_Session * session,
7276  int job_id,
7277  HAPI_JobStatus * job_status );
7278 
7279 /// @brief Get group names for an entire geo. Please note that this
7280 /// function is NOT per-part, but it is per-geo. The companion
7281 /// function ::HAPI_GetGroupMembership() IS per-part. Also keep
7282 /// in mind that the name string handles are only
7283 /// valid until the next time this function is called.
7284 ///
7285 /// @ingroup GeometryGetters
7286 ///
7287 /// @param[in] session
7288 /// The session of Houdini you are interacting with.
7289 /// See @ref HAPI_Sessions for more on sessions.
7290 /// Pass NULL to just use the default in-process session.
7291 /// <!-- default NULL -->
7292 ///
7293 /// @param[in] node_id
7294 /// The node id.
7295 ///
7296 /// @param[in] group_type
7297 /// The group type.
7298 ///
7299 /// @param[out] group_names_array
7300 /// The array of names to be filled. Should be the size
7301 /// given by ::HAPI_GeoInfo_GetGroupCountByType() with
7302 /// @p group_type and the ::HAPI_GeoInfo of @p geo_id.
7303 /// @note These string handles are only valid until the
7304 /// next call to ::HAPI_GetGroupNames().
7305 ///
7306 /// @param[in] group_count
7307 /// Sanity check. Should be less than or equal to the size
7308 /// of @p group_names.
7309 ///
7310 HAPI_DECL HAPI_GetGroupNames( const HAPI_Session * session,
7311  HAPI_NodeId node_id,
7312  HAPI_GroupType group_type,
7313  HAPI_StringHandle * group_names_array,
7314  int group_count );
7315 
7316 /// @brief Get group membership.
7317 ///
7318 /// @ingroup GeometryGetters
7319 ///
7320 /// @param[in] session
7321 /// The session of Houdini you are interacting with.
7322 /// See @ref HAPI_Sessions for more on sessions.
7323 /// Pass NULL to just use the default in-process session.
7324 /// <!-- default NULL -->
7325 ///
7326 /// @param[in] node_id
7327 /// The node id.
7328 ///
7329 /// @param[in] part_id
7330 /// The part id.
7331 ///
7332 /// @param[in] group_type
7333 /// The group type.
7334 ///
7335 /// @param[in] group_name
7336 /// The group name.
7337 ///
7338 /// @param[out] membership_array_all_equal
7339 /// (optional) Quick way to determine if all items are in
7340 /// the given group or all items our not in the group.
7341 /// If you do not need this information or you are getting edge
7342 /// group information, you can just pass NULL for this argument.
7343 ///
7344 /// @param[out] membership_array
7345 /// Array of ints that represent the membership of this
7346 /// group. When getting membership information for a point or
7347 /// primitive group, the size of the array should be the size
7348 /// given by ::HAPI_PartInfo_GetElementCountByGroupType() with
7349 /// @p group_type and the ::HAPI_PartInfo of @p part_id. When
7350 /// retrieving the edges belonging to an edge group, the
7351 /// membership array will be filled with point numbers that
7352 /// comprise the edges of the edge group. Each edge is specified
7353 /// by two points, which means that the size of the array should
7354 /// be the size given by ::HAPI_GetEdgeCountOfEdgeGroup() * 2.
7355 ///
7356 /// @param[in] start
7357 /// Start offset into the membership array. Must be
7358 /// less than ::HAPI_PartInfo_GetElementCountByGroupType() when
7359 /// it is a point or primitive group. When getting the
7360 /// membership information for an edge group, this argument must
7361 /// be less than the size returned by
7362 /// ::HAPI_GetEdgeCountOfEdgeGroup() * 2 - 1.
7363 /// <!-- default 0 -->
7364 ///
7365 /// @param[in] length
7366 /// Should be less than or equal to the size
7367 /// of @p membership_array.
7368 ///
7370  HAPI_NodeId node_id,
7371  HAPI_PartId part_id,
7372  HAPI_GroupType group_type,
7373  const char * group_name,
7374  HAPI_Bool * membership_array_all_equal,
7375  int * membership_array,
7376  int start, int length );
7377 
7378 /// @brief Get group counts for a specific packed instanced part.
7379 ///
7380 /// @ingroup GeometryGetters
7381 ///
7382 /// @param[in] session
7383 /// The session of Houdini you are interacting with.
7384 /// See @ref HAPI_Sessions for more on sessions.
7385 /// Pass NULL to just use the default in-process session.
7386 /// <!-- default NULL -->
7387 ///
7388 /// @param[in] node_id
7389 /// The node id.
7390 ///
7391 /// @param[in] part_id
7392 /// The part id. (should be a packed primitive)
7393 ///
7394 /// @param[out] pointGroupCount
7395 /// Number of point groups on the packed instance part.
7396 /// Will be set to -1 if the part is not a valid packed part.
7397 ///
7398 /// @param[out] primitiveGroupCount
7399 /// Number of primitive groups on the instanced part.
7400 /// Will be set to -1 if the part is not a valid instancer
7401 ///
7403  HAPI_NodeId node_id,
7404  HAPI_PartId part_id,
7405  int * pointGroupCount,
7406  int * primitiveGroupCount );
7407 
7408 /// @brief Get the group names for a packed instance part
7409 /// This functions allows you to get the group name for a specific
7410 /// packed primitive part.
7411 /// Keep in mind that the name string handles are only
7412 /// valid until the next time this function is called.
7413 ///
7414 /// @ingroup GeometryGetters
7415 ///
7416 /// @param[in] session
7417 /// The session of Houdini you are interacting with.
7418 /// See @ref HAPI_Sessions for more on sessions.
7419 /// Pass NULL to just use the default in-process session.
7420 /// <!-- default NULL -->
7421 ///
7422 /// @param[in] node_id
7423 /// The node id.
7424 ///
7425 /// @param[in] part_id
7426 /// The part id. (should be a packed primitive)
7427 ///
7428 /// @param[in] group_type
7429 /// The group type.
7430 ///
7431 /// @param[out] group_names_array
7432 /// The array of names to be filled. Should be the size
7433 /// given by ::HAPI_GetGroupCountOnPackedInstancePart() with
7434 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
7435 /// @note These string handles are only valid until the
7436 /// next call to ::HAPI_GetGroupNamesOnPackedInstancePart().
7437 ///
7438 /// @param[in] group_count
7439 /// Sanity check. Should be less than or equal to the size
7440 /// of @p group_names.
7441 ///
7443  HAPI_NodeId node_id,
7444  HAPI_PartId part_id,
7445  HAPI_GroupType group_type,
7446  HAPI_StringHandle * group_names_array,
7447  int group_count );
7448 
7449 /// @brief Get group membership for a packed instance part
7450 /// This functions allows you to get the group membership for a specific
7451 /// packed primitive part.
7452 ///
7453 /// @ingroup GeometryGetters
7454 ///
7455 /// @param[in] session
7456 /// The session of Houdini you are interacting with.
7457 /// See @ref HAPI_Sessions for more on sessions.
7458 /// Pass NULL to just use the default in-process session.
7459 /// <!-- default NULL -->
7460 ///
7461 /// @param[in] node_id
7462 /// The node id.
7463 ///
7464 /// @param[in] part_id
7465 /// The part id. (should be a packed primitive)
7466 ///
7467 /// @param[in] group_type
7468 /// The group type.
7469 ///
7470 /// @param[in] group_name
7471 /// The group name.
7472 ///
7473 /// @param[out] membership_array_all_equal
7474 /// (optional) Quick way to determine if all items are in
7475 /// the given group or all items our not in the group.
7476 /// You can just pass NULL here if not interested.
7477 ///
7478 /// @param[out] membership_array
7479 /// Array of ints that represent the membership of this
7480 /// group. Should be the size given by
7481 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
7482 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
7483 ///
7484 /// @param[in] start
7485 /// Start offset into the membership array. Must be
7486 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
7487 /// <!-- default 0 -->
7488 ///
7489 /// @param[in] length
7490 /// Should be less than or equal to the size
7491 /// of @p membership_array.
7492 /// <!-- source ::HAPI_PartInfo_GetElementCountByGroupType -->
7493 ///
7495  HAPI_NodeId node_id,
7496  HAPI_PartId part_id,
7497  HAPI_GroupType group_type,
7498  const char * group_name,
7499  HAPI_Bool * membership_array_all_equal,
7500  int * membership_array,
7501  int start, int length );
7502 
7503 /// @brief Get the part ids that this instancer part is instancing.
7504 ///
7505 /// @ingroup GeometryGetters
7506 ///
7507 /// @param[in] session
7508 /// The session of Houdini you are interacting with.
7509 /// See @ref HAPI_Sessions for more on sessions.
7510 /// Pass NULL to just use the default in-process session.
7511 /// <!-- default NULL -->
7512 ///
7513 /// @param[in] node_id
7514 /// The node id.
7515 ///
7516 /// @param[in] part_id
7517 /// The instancer part id.
7518 ///
7519 /// @param[out] instanced_parts_array
7520 /// Array of ::HAPI_PartId's to instance.
7521 ///
7522 /// @param[in] start
7523 /// Should be less than @p part_id's
7524 /// ::HAPI_PartInfo::instancedPartCount but more than or
7525 /// equal to 0.
7526 /// <!-- default 0 -->
7527 ///
7528 /// @param[in] length
7529 /// Should be less than @p part_id's
7530 /// ::HAPI_PartInfo::instancedPartCount - @p start.
7531 /// <!-- source ::HAPI_PartInfo::instancedPartCount - start -->
7532 ///
7534  HAPI_NodeId node_id,
7535  HAPI_PartId part_id,
7536  HAPI_PartId * instanced_parts_array,
7537  int start, int length );
7538 
7539 /// @brief Get the instancer part's list of transforms on which to
7540 /// instance the instanced parts you got from
7541 /// ::HAPI_GetInstancedPartIds().
7542 ///
7543 /// @ingroup GeometryGetters
7544 ///
7545 /// @param[in] session
7546 /// The session of Houdini you are interacting with.
7547 /// See @ref HAPI_Sessions for more on sessions.
7548 /// Pass NULL to just use the default in-process session.
7549 /// <!-- default NULL -->
7550 ///
7551 /// @param[in] node_id
7552 /// The node id.
7553 ///
7554 /// @param[in] part_id
7555 /// The instancer part id.
7556 ///
7557 /// @param[in] rst_order
7558 /// The order of application of translation, rotation and
7559 /// scale.
7560 ///
7561 /// @param[out] transforms_array
7562 /// Array of ::HAPI_PartId's to instance.
7563 ///
7564 /// @param[in] start
7565 /// Should be less than @p part_id's
7566 /// ::HAPI_PartInfo::instanceCount but more than or
7567 /// equal to 0.
7568 /// <!-- default 0 -->
7569 ///
7570 /// @param[in] length
7571 /// Should be less than @p part_id's
7572 /// ::HAPI_PartInfo::instanceCount - @p start.
7573 /// <!-- source ::HAPI_PartInfo::instanceCount - start -->
7574 ///
7576  HAPI_NodeId node_id,
7577  HAPI_PartId part_id,
7578  HAPI_RSTOrder rst_order,
7579  HAPI_Transform * transforms_array,
7580  int start, int length );
7581 
7582 /// @defgroup GeometrySetters Geometry Setters
7583 /// Functions for setting geometry (SOP) data
7584 
7585 /// @brief Set the main part info struct (::HAPI_PartInfo).
7586 ///
7587 /// @ingroup GeometrySetters
7588 ///
7589 /// @param[in] session
7590 /// The session of Houdini you are interacting with.
7591 /// See @ref HAPI_Sessions for more on sessions.
7592 /// Pass NULL to just use the default in-process session.
7593 /// <!-- default NULL -->
7594 ///
7595 /// @param[in] node_id
7596 /// The SOP node id.
7597 ///
7598 /// @param[in] part_id
7599 /// Currently not used. Just pass 0.
7600 /// <!-- default 0 -->
7601 ///
7602 /// @param[in] part_info
7603 /// ::HAPI_PartInfo value that describes the input
7604 /// geometry.
7605 ///
7606 HAPI_DECL HAPI_SetPartInfo( const HAPI_Session * session,
7607  HAPI_NodeId node_id,
7608  HAPI_PartId part_id,
7609  const HAPI_PartInfo * part_info );
7610 
7611 /// @brief Set the array of faces where the nth integer in the array is
7612 /// the number of vertices the nth face has.
7613 ///
7614 /// @ingroup GeometrySetters
7615 ///
7616 /// @param[in] session
7617 /// The session of Houdini you are interacting with.
7618 /// See @ref HAPI_Sessions for more on sessions.
7619 /// Pass NULL to just use the default in-process session.
7620 /// <!-- default NULL -->
7621 ///
7622 /// @param[in] node_id
7623 /// The SOP node id.
7624 ///
7625 /// @param[in] part_id
7626 /// Currently not used. Just pass 0.
7627 /// <!-- default 0 -->
7628 ///
7629 /// @param[in] face_counts_array
7630 /// An integer array at least the size of @p length.
7631 ///
7632 /// @param[in] start
7633 /// First index of range. Must be at least 0 and at
7634 /// most ::HAPI_PartInfo::faceCount - 1.
7635 /// <!-- default 0 -->
7636 ///
7637 /// @param[in] length
7638 /// Must be at least 0 and at most
7639 /// ::HAPI_PartInfo::faceCount - @p start.
7640 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
7641 ///
7642 HAPI_DECL HAPI_SetFaceCounts( const HAPI_Session * session,
7643  HAPI_NodeId node_id,
7644  HAPI_PartId part_id,
7645  const int * face_counts_array,
7646  int start, int length );
7647 
7648 /// @brief Set array containing the vertex-point associations where the
7649 /// ith element in the array is the point index the ith vertex
7650 /// associates with.
7651 ///
7652 /// @ingroup GeometrySetters
7653 ///
7654 /// @param[in] session
7655 /// The session of Houdini you are interacting with.
7656 /// See @ref HAPI_Sessions for more on sessions.
7657 /// Pass NULL to just use the default in-process session.
7658 /// <!-- default NULL -->
7659 ///
7660 /// @param[in] node_id
7661 /// The SOP node id.
7662 ///
7663 /// @param[in] part_id
7664 /// Currently not used. Just pass 0.
7665 ///
7666 /// @param[in] vertex_list_array
7667 /// An integer array at least the size of length.
7668 ///
7669 /// @param[in] start
7670 /// First index of range. Must be at least 0 and at
7671 /// most ::HAPI_PartInfo::vertexCount - 1.
7672 /// <!-- default 0 -->
7673 ///
7674 /// @param[in] length
7675 /// Must be at least 0 and at most
7676 /// ::HAPI_PartInfo::vertexCount - @p start.
7677 /// <!-- source ::HAPI_PartInfo::vertexCount - start -->
7678 ///
7679 HAPI_DECL HAPI_SetVertexList( const HAPI_Session * session,
7680  HAPI_NodeId node_id,
7681  HAPI_PartId part_id,
7682  const int * vertex_list_array,
7683  int start, int length );
7684 
7685 /// @brief Add an attribute.
7686 ///
7687 /// @ingroup GeometrySetters Attributes
7688 ///
7689 /// @param[in] session
7690 /// The session of Houdini you are interacting with.
7691 /// See @ref HAPI_Sessions for more on sessions.
7692 /// Pass NULL to just use the default in-process session.
7693 /// <!-- default NULL -->
7694 ///
7695 /// @param[in] node_id
7696 /// The SOP node id.
7697 ///
7698 /// @param[in] part_id
7699 /// Currently not used. Just pass 0.
7700 ///
7701 /// @param[in] name
7702 /// Attribute name.
7703 ///
7704 /// @param[in] attr_info
7705 /// ::HAPI_AttributeInfo stores attribute properties.
7706 ///
7707 HAPI_DECL HAPI_AddAttribute( const HAPI_Session * session,
7708  HAPI_NodeId node_id,
7709  HAPI_PartId part_id,
7710  const char * name,
7711  const HAPI_AttributeInfo * attr_info );
7712 
7713 /// @brief Delete an attribute from an input geo
7714 ///
7715 /// @ingroup GeometrySetters Attributes
7716 ///
7717 /// @param[in] session
7718 /// The session of Houdini you are interacting with.
7719 /// See @ref HAPI_Sessions for more on sessions.
7720 /// Pass NULL to just use the default in-process session.
7721 /// <!-- default NULL -->
7722 ///
7723 /// @param[in] node_id
7724 /// The SOP node id.
7725 ///
7726 /// @param[in] part_id
7727 /// Currently not used. Just pass 0.
7728 ///
7729 /// @param[in] name
7730 /// Attribute name.
7731 ///
7732 /// @param[in] attr_info
7733 /// ::HAPI_AttributeInfo stores attribute properties.
7734 ///
7736  HAPI_NodeId node_id,
7737  HAPI_PartId part_id,
7738  const char * name,
7739  const HAPI_AttributeInfo * attr_info );
7740 
7741 /// @brief Set attribute integer data.
7742 ///
7743 /// @ingroup GeometrySetters Attributes
7744 ///
7745 /// @param[in] session
7746 /// The session of Houdini you are interacting with.
7747 /// See @ref HAPI_Sessions for more on sessions.
7748 /// Pass NULL to just use the default in-process session.
7749 /// <!-- default NULL -->
7750 ///
7751 /// @param[in] node_id
7752 /// The SOP node id.
7753 ///
7754 /// @param[in] part_id
7755 /// Currently not used. Just pass 0.
7756 ///
7757 /// @param[in] name
7758 /// Attribute name.
7759 ///
7760 /// @param[in] attr_info
7761 /// ::HAPI_AttributeInfo used as input for what tuple size.
7762 /// you want. Also contains some sanity checks like
7763 /// data type. Generally should be the same struct
7764 /// returned by ::HAPI_GetAttributeInfo().
7765 ///
7766 /// @param[in] data_array
7767 /// An integer array at least the size of
7768 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7769 ///
7770 /// @param[in] start
7771 /// First index of range. Must be at least 0 and at
7772 /// most ::HAPI_AttributeInfo::count - 1.
7773 /// <!-- default 0 -->
7774 ///
7775 /// @param[in] length
7776 /// Must be at least 0 and at most
7777 /// ::HAPI_AttributeInfo::count - @p start.
7778 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7779 ///
7781  HAPI_NodeId node_id,
7782  HAPI_PartId part_id,
7783  const char * name,
7784  const HAPI_AttributeInfo * attr_info,
7785  const int * data_array,
7786  int start, int length );
7787 
7788 /// @brief Set unsigned 8-bit attribute integer data.
7789 ///
7790 /// @ingroup GeometrySetters Attributes
7791 ///
7792 /// @param[in] session
7793 /// The session of Houdini you are interacting with.
7794 /// See @ref HAPI_Sessions for more on sessions.
7795 /// Pass NULL to just use the default in-process session.
7796 /// <!-- default NULL -->
7797 ///
7798 /// @param[in] node_id
7799 /// The SOP node id.
7800 ///
7801 /// @param[in] part_id
7802 /// Currently not used. Just pass 0.
7803 ///
7804 /// @param[in] name
7805 /// Attribute name.
7806 ///
7807 /// @param[in] attr_info
7808 /// ::HAPI_AttributeInfo used as input for what tuple size.
7809 /// you want. Also contains some sanity checks like
7810 /// data type. Generally should be the same struct
7811 /// returned by ::HAPI_GetAttributeInfo().
7812 ///
7813 /// @param[in] data_array
7814 /// An unsigned 8-bit integer array at least the size of
7815 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7816 ///
7817 /// @param[in] start
7818 /// First index of range. Must be at least 0 and at
7819 /// most ::HAPI_AttributeInfo::count - 1.
7820 /// <!-- default 0 -->
7821 ///
7822 /// @param[in] length
7823 /// Must be at least 0 and at most
7824 /// ::HAPI_AttributeInfo::count - @p start.
7825 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7826 ///
7828  HAPI_NodeId node_id,
7829  HAPI_PartId part_id,
7830  const char * name,
7831  const HAPI_AttributeInfo * attr_info,
7832  const HAPI_UInt8 * data_array,
7833  int start, int length );
7834 
7835 /// @brief Set 8-bit attribute integer data.
7836 ///
7837 /// @ingroup GeometrySetters Attributes
7838 ///
7839 /// @param[in] session
7840 /// The session of Houdini you are interacting with.
7841 /// See @ref HAPI_Sessions for more on sessions.
7842 /// Pass NULL to just use the default in-process session.
7843 /// <!-- default NULL -->
7844 ///
7845 /// @param[in] node_id
7846 /// The SOP node id.
7847 ///
7848 /// @param[in] part_id
7849 /// Currently not used. Just pass 0.
7850 ///
7851 /// @param[in] name
7852 /// Attribute name.
7853 ///
7854 /// @param[in] attr_info
7855 /// ::HAPI_AttributeInfo used as input for what tuple size.
7856 /// you want. Also contains some sanity checks like
7857 /// data type. Generally should be the same struct
7858 /// returned by ::HAPI_GetAttributeInfo().
7859 ///
7860 /// @param[in] data_array
7861 /// An 8-bit integer array at least the size of
7862 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7863 ///
7864 /// @param[in] start
7865 /// First index of range. Must be at least 0 and at
7866 /// most ::HAPI_AttributeInfo::count - 1.
7867 /// <!-- default 0 -->
7868 ///
7869 /// @param[in] length
7870 /// Must be at least 0 and at most
7871 /// ::HAPI_AttributeInfo::count - @p start.
7872 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7873 ///
7875  HAPI_NodeId node_id,
7876  HAPI_PartId part_id,
7877  const char * name,
7878  const HAPI_AttributeInfo * attr_info,
7879  const HAPI_Int8 * data_array,
7880  int start, int length );
7881 
7882 /// @brief Set 16-bit attribute integer data.
7883 ///
7884 /// @ingroup GeometrySetters Attributes
7885 ///
7886 /// @param[in] session
7887 /// The session of Houdini you are interacting with.
7888 /// See @ref HAPI_Sessions for more on sessions.
7889 /// Pass NULL to just use the default in-process session.
7890 /// <!-- default NULL -->
7891 ///
7892 /// @param[in] node_id
7893 /// The SOP node id.
7894 ///
7895 /// @param[in] part_id
7896 /// Currently not used. Just pass 0.
7897 ///
7898 /// @param[in] name
7899 /// Attribute name.
7900 ///
7901 /// @param[in] attr_info
7902 /// ::HAPI_AttributeInfo used as input for what tuple size.
7903 /// you want. Also contains some sanity checks like
7904 /// data type. Generally should be the same struct
7905 /// returned by ::HAPI_GetAttributeInfo().
7906 ///
7907 /// @param[in] data_array
7908 /// An 16-bit integer array at least the size of
7909 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7910 ///
7911 /// @param[in] start
7912 /// First index of range. Must be at least 0 and at
7913 /// most ::HAPI_AttributeInfo::count - 1.
7914 /// <!-- default 0 -->
7915 ///
7916 /// @param[in] length
7917 /// Must be at least 0 and at most
7918 /// ::HAPI_AttributeInfo::count - @p start.
7919 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7920 ///
7922  HAPI_NodeId node_id,
7923  HAPI_PartId part_id,
7924  const char * name,
7925  const HAPI_AttributeInfo * attr_info,
7926  const HAPI_Int16 * data_array,
7927  int start, int length );
7928 
7929 /// @brief Set 64-bit attribute integer data.
7930 ///
7931 /// @ingroup GeometrySetters Attributes
7932 ///
7933 /// @param[in] session
7934 /// The session of Houdini you are interacting with.
7935 /// See @ref HAPI_Sessions for more on sessions.
7936 /// Pass NULL to just use the default in-process session.
7937 /// <!-- default NULL -->
7938 ///
7939 /// @param[in] node_id
7940 /// The SOP node id.
7941 ///
7942 /// @param[in] part_id
7943 /// Currently not used. Just pass 0.
7944 ///
7945 /// @param[in] name
7946 /// Attribute name.
7947 ///
7948 /// @param[in] attr_info
7949 /// ::HAPI_AttributeInfo used as input for what tuple size.
7950 /// you want. Also contains some sanity checks like
7951 /// data type. Generally should be the same struct
7952 /// returned by ::HAPI_GetAttributeInfo().
7953 ///
7954 /// @param[in] data_array
7955 /// An 64-bit integer array at least the size of
7956 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7957 ///
7958 /// @param[in] start
7959 /// First index of range. Must be at least 0 and at
7960 /// most ::HAPI_AttributeInfo::count - 1.
7961 /// <!-- default 0 -->
7962 ///
7963 /// @param[in] length
7964 /// Must be at least 0 and at most
7965 /// ::HAPI_AttributeInfo::count - @p start.
7966 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7967 ///
7969  HAPI_NodeId node_id,
7970  HAPI_PartId part_id,
7971  const char * name,
7972  const HAPI_AttributeInfo * attr_info,
7973  const HAPI_Int64 * data_array,
7974  int start, int length );
7975 
7976 /// @brief Set attribute float data.
7977 ///
7978 /// @ingroup GeometrySetters Attributes
7979 ///
7980 /// @param[in] session
7981 /// The session of Houdini you are interacting with.
7982 /// See @ref HAPI_Sessions for more on sessions.
7983 /// Pass NULL to just use the default in-process session.
7984 /// <!-- default NULL -->
7985 ///
7986 /// @param[in] node_id
7987 /// The SOP node id.
7988 ///
7989 /// @param[in] part_id
7990 /// Currently not used. Just pass 0.
7991 ///
7992 /// @param[in] name
7993 /// Attribute name.
7994 ///
7995 /// @param[in] attr_info
7996 /// ::HAPI_AttributeInfo used as input for what tuple size.
7997 /// you want. Also contains some sanity checks like
7998 /// data type. Generally should be the same struct
7999 /// returned by ::HAPI_GetAttributeInfo().
8000 ///
8001 /// @param[in] data_array
8002 /// An float array at least the size of
8003 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8004 ///
8005 /// @param[in] start
8006 /// First index of range. Must be at least 0 and at
8007 /// most ::HAPI_AttributeInfo::count - 1.
8008 /// <!-- default 0 -->
8009 ///
8010 /// @param[in] length
8011 /// Must be at least 0 and at most
8012 /// ::HAPI_AttributeInfo::count - @p start.
8013 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8014 ///
8016  HAPI_NodeId node_id,
8017  HAPI_PartId part_id,
8018  const char * name,
8019  const HAPI_AttributeInfo * attr_info,
8020  const float * data_array,
8021  int start, int length );
8022 
8023 /// @brief Set 64-bit attribute float data.
8024 ///
8025 /// @ingroup GeometrySetters Attributes
8026 ///
8027 /// @param[in] session
8028 /// The session of Houdini you are interacting with.
8029 /// See @ref HAPI_Sessions for more on sessions.
8030 /// Pass NULL to just use the default in-process session.
8031 /// <!-- default NULL -->
8032 ///
8033 /// @param[in] node_id
8034 /// The SOP node id.
8035 ///
8036 /// @param[in] part_id
8037 /// Currently not used. Just pass 0.
8038 ///
8039 /// @param[in] name
8040 /// Attribute name.
8041 ///
8042 /// @param[in] attr_info
8043 /// ::HAPI_AttributeInfo used as input for what tuple size.
8044 /// you want. Also contains some sanity checks like
8045 /// data type. Generally should be the same struct
8046 /// returned by ::HAPI_GetAttributeInfo().
8047 ///
8048 /// @param[in] data_array
8049 /// An 64-bit float array at least the size of
8050 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8051 ///
8052 /// @param[in] start
8053 /// First index of range. Must be at least 0 and at
8054 /// most ::HAPI_AttributeInfo::count - 1.
8055 /// <!-- default 0 -->
8056 ///
8057 /// @param[in] length
8058 /// Must be at least 0 and at most
8059 /// ::HAPI_AttributeInfo::count - @p start.
8060 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8061 ///
8063  HAPI_NodeId node_id,
8064  HAPI_PartId part_id,
8065  const char * name,
8066  const HAPI_AttributeInfo * attr_info,
8067  const double * data_array,
8068  int start, int length );
8069 
8070 /// @brief Set attribute string data.
8071 ///
8072 /// @ingroup GeometrySetters Attributes
8073 ///
8074 /// @param[in] session
8075 /// The session of Houdini you are interacting with.
8076 /// See @ref HAPI_Sessions for more on sessions.
8077 /// Pass NULL to just use the default in-process session.
8078 /// <!-- default NULL -->
8079 ///
8080 /// @param[in] node_id
8081 /// The SOP node id.
8082 ///
8083 /// @param[in] part_id
8084 /// Currently not used. Just pass 0.
8085 ///
8086 /// @param[in] name
8087 /// Attribute name.
8088 ///
8089 /// @param[in] attr_info
8090 /// ::HAPI_AttributeInfo used as input for what tuple size
8091 /// you want. Also contains some sanity checks like
8092 /// data type. Generally should be the same struct
8093 /// returned by ::HAPI_GetAttributeInfo().
8094 ///
8095 /// @param[in] data_array
8096 /// An ::HAPI_StringHandle array at least the size of
8097 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8098 ///
8099 /// @param[in] start
8100 /// First index of range. Must be at least 0 and at
8101 /// most ::HAPI_AttributeInfo::count - 1.
8102 /// <!-- default 0 -->
8103 ///
8104 /// @param[in] length
8105 /// Must be at least 0 and at most
8106 /// ::HAPI_AttributeInfo::count - @p start.
8107 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8108 ///
8110  HAPI_NodeId node_id,
8111  HAPI_PartId part_id,
8112  const char * name,
8113  const HAPI_AttributeInfo * attr_info,
8114  const char ** data_array,
8115  int start, int length );
8116 
8117 /// @brief Set attribute string data by index.
8118 ///
8119 /// @ingroup GeometrySetters Attributes
8120 ///
8121 /// @param[in] session
8122 /// The session of Houdini you are interacting with.
8123 /// See @ref HAPI_Sessions for more on sessions.
8124 /// Pass NULL to just use the default in-process session.
8125 /// <!-- default NULL -->
8126 ///
8127 /// @param[in] node_id
8128 /// The SOP node id.
8129 ///
8130 /// @param[in] part_id
8131 /// Currently not used. Just pass 0.
8132 ///
8133 /// @param[in] name
8134 /// Attribute name.
8135 ///
8136 /// @param[in] attr_info
8137 /// ::HAPI_AttributeInfo used as input for what tuple size.
8138 /// you want. Also contains some sanity checks like
8139 /// data type. Generally should be the same struct
8140 /// returned by ::HAPI_GetAttributeInfo().
8141 ///
8142 /// @param[in] string_array
8143 /// An array of strings at least the size of
8144 /// <tt>string_count/tt>.
8145 ///
8146 /// @param[in] string_count
8147 /// Number of strings that are indexed.
8148 ///
8149 /// @param[in] indices_array
8150 /// integer array at least the size of
8151 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>. Each
8152 /// entry indexes string_array.
8153 ///
8154 /// @param[in] indices_start
8155 /// First index of range. Must be at least 0 and at
8156 /// most ::HAPI_AttributeInfo::count - 1.
8157 /// <!-- default 0 -->
8158 ///
8159 /// @param[in] indices_length
8160 /// Must be at least 0 and at most
8161 /// ::HAPI_AttributeInfo::count - @p start.
8162 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8163 ///
8165  HAPI_NodeId node_id,
8166  HAPI_PartId part_id,
8167  const char* name,
8168  const HAPI_AttributeInfo* attr_info,
8169  const char** string_array,
8170  int string_count,
8171  const int* indices_array,
8172  int indices_start,
8173  int indices_length);
8174 
8175 /// @brief Set multiple attribute string data to the same unique value.
8176 ///
8177 /// @ingroup GeometrySetters Attributes
8178 ///
8179 /// @param[in] session
8180 /// The session of Houdini you are interacting with.
8181 /// See @ref HAPI_Sessions for more on sessions.
8182 /// Pass NULL to just use the default in-process session.
8183 /// <!-- default NULL -->
8184 ///
8185 /// @param[in] node_id
8186 /// The SOP node id.
8187 ///
8188 /// @param[in] part_id
8189 /// Currently not used. Just pass 0.
8190 ///
8191 /// @param[in] name
8192 /// Attribute name.
8193 ///
8194 /// @param[in] attr_info
8195 /// ::HAPI_AttributeInfo used as input for what tuple size.
8196 /// you want. Also contains some sanity checks like
8197 /// data type. Generally should be the same struct
8198 /// returned by ::HAPI_GetAttributeInfo().
8199 ///
8200 /// @param[in] data_array
8201 /// A string
8202 ///
8203 /// @param[in] data_length
8204 /// Must be the length of string data.
8205 ///
8206 /// @param[in] start_index
8207 /// Must be at least 0 and at most
8208 /// ::HAPI_AttributeInfo::count - @p start.
8209 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8210 ///
8211 /// @param[in] num_indices
8212 /// Must be at least 0 and at most
8213 /// ::HAPI_AttributeInfo::count - @p start.
8214 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8215 ///
8217  const HAPI_Session* session,
8218  HAPI_NodeId node_id,
8219  HAPI_PartId part_id,
8220  const char* name,
8221  const HAPI_AttributeInfo* attr_info,
8222  const char* data_array,
8223  int data_length,
8224  int start_index,
8225  int num_indices);
8226 
8227 /// @brief Set multiple attribute int data to the same unique value.
8228 ///
8229 /// @ingroup GeometrySetters Attributes
8230 ///
8231 /// @param[in] session
8232 /// The session of Houdini you are interacting with.
8233 /// See @ref HAPI_Sessions for more on sessions.
8234 /// Pass NULL to just use the default in-process session.
8235 /// <!-- default NULL -->
8236 ///
8237 /// @param[in] node_id
8238 /// The SOP node id.
8239 ///
8240 /// @param[in] part_id
8241 /// Currently not used. Just pass 0.
8242 ///
8243 /// @param[in] name
8244 /// Attribute name.
8245 ///
8246 /// @param[in] attr_info
8247 /// ::HAPI_AttributeInfo used as input for what tuple size.
8248 /// you want. Also contains some sanity checks like
8249 /// data type. Generally should be the same struct
8250 /// returned by ::HAPI_GetAttributeInfo().
8251 ///
8252 /// @param[in] data_array
8253 /// A integer array at least the size of
8254 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8255 ///
8256 /// @param[in] data_length
8257 /// An integer of at least the size of
8258 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8259 ///
8260 /// @param[in] start_index
8261 /// First index of range. Must be at least 0 and at
8262 /// most ::HAPI_AttributeInfo::count - 1.
8263 /// <!-- default 0 -->
8264 ///
8265 /// @param[in] num_indices
8266 /// Must be at least 0 and at most
8267 /// ::HAPI_AttributeInfo::count - @p start_index.
8268 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8269 ///
8271  const HAPI_Session* session,
8272  HAPI_NodeId node_id,
8273  HAPI_PartId part_id,
8274  const char* name,
8275  const HAPI_AttributeInfo* attr_info,
8276  const int* data_array,
8277  int data_length,
8278  int start_index,
8279  int num_indices);
8280 
8281 /// @brief Set multiple attribute unsigned 8-bit int data to the same unique value.
8282 ///
8283 /// @ingroup GeometrySetters Attributes
8284 ///
8285 /// @param[in] session
8286 /// The session of Houdini you are interacting with.
8287 /// See @ref HAPI_Sessions for more on sessions.
8288 /// Pass NULL to just use the default in-process session.
8289 /// <!-- default NULL -->
8290 ///
8291 /// @param[in] node_id
8292 /// The SOP node id.
8293 ///
8294 /// @param[in] part_id
8295 /// Currently not used. Just pass 0.
8296 ///
8297 /// @param[in] name
8298 /// Attribute name.
8299 ///
8300 /// @param[in] attr_info
8301 /// ::HAPI_AttributeInfo used as input for what tuple size.
8302 /// you want. Also contains some sanity checks like
8303 /// data type. Generally should be the same struct
8304 /// returned by ::HAPI_GetAttributeInfo().
8305 ///
8306 /// @param[in] data_array
8307 /// A integer array at least the size of
8308 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8309 ///
8310 /// @param[in] data_length
8311 /// An integer of at least the size of
8312 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8313 ///
8314 /// @param[in] start_index
8315 /// First index of range. Must be at least 0 and at
8316 /// most ::HAPI_AttributeInfo::count - 1.
8317 /// <!-- default 0 -->
8318 ///
8319 /// @param[in] num_indices
8320 /// Must be at least 0 and at most
8321 /// ::HAPI_AttributeInfo::count - @p start_index.
8322 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8323 ///
8325  const HAPI_Session* session,
8326  HAPI_NodeId node_id,
8327  HAPI_PartId part_id,
8328  const char* name,
8329  const HAPI_AttributeInfo* attr_info,
8330  const HAPI_UInt8* data_array,
8331  int data_length,
8332  int start_index,
8333  int num_indices);
8334 
8335 /// @brief Set multiple attribute 8-bit int data to the same unique value.
8336 ///
8337 ///
8338 /// @ingroup GeometrySetters Attributes
8339 ///
8340 /// @param[in] session
8341 /// The session of Houdini you are interacting with.
8342 /// See @ref HAPI_Sessions for more on sessions.
8343 /// Pass NULL to just use the default in-process session.
8344 /// <!-- default NULL -->
8345 ///
8346 /// @param[in] node_id
8347 /// The SOP node id.
8348 ///
8349 /// @param[in] part_id
8350 /// Currently not used. Just pass 0.
8351 ///
8352 /// @param[in] name
8353 /// Attribute name.
8354 ///
8355 /// @param[in] attr_info
8356 /// ::HAPI_AttributeInfo used as input for what tuple size.
8357 /// you want. Also contains some sanity checks like
8358 /// data type. Generally should be the same struct
8359 /// returned by ::HAPI_GetAttributeInfo().
8360 ///
8361 /// @param[in] data_array
8362 /// A integer array at least the size of
8363 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8364 ///
8365 /// @param[in] data_length
8366 /// An integer of at least the size of
8367 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8368 ///
8369 /// @param[in] start_index
8370 /// First index of range. Must be at least 0 and at
8371 /// most ::HAPI_AttributeInfo::count - 1.
8372 /// <!-- default 0 -->
8373 ///
8374 /// @param[in] num_indices
8375 /// Must be at least 0 and at most
8376 /// ::HAPI_AttributeInfo::count - @p start_index.
8377 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8378 ///
8380  const HAPI_Session* session,
8381  HAPI_NodeId node_id,
8382  HAPI_PartId part_id,
8383  const char* name,
8384  const HAPI_AttributeInfo* attr_info,
8385  const HAPI_Int8* data_array,
8386  int data_length,
8387  int start_index,
8388  int num_indices);
8389 
8390 /// @brief Set multiple attribute 16-bit int data to the same unique value.
8391 ///
8392 /// @ingroup GeometrySetters Attributes
8393 ///
8394 /// @param[in] session
8395 /// The session of Houdini you are interacting with.
8396 /// See @ref HAPI_Sessions for more on sessions.
8397 /// Pass NULL to just use the default in-process session.
8398 /// <!-- default NULL -->
8399 ///
8400 /// @param[in] node_id
8401 /// The SOP node id.
8402 ///
8403 /// @param[in] part_id
8404 /// Currently not used. Just pass 0.
8405 ///
8406 /// @param[in] name
8407 /// Attribute name.
8408 ///
8409 /// @param[in] attr_info
8410 /// ::HAPI_AttributeInfo used as input for what tuple size.
8411 /// you want. Also contains some sanity checks like
8412 /// data type. Generally should be the same struct
8413 /// returned by ::HAPI_GetAttributeInfo().
8414 ///
8415 /// @param[in] data_array
8416 /// A integer array at least the size of
8417 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8418 ///
8419 /// @param[in] data_length
8420 /// An integer of at least the size of
8421 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8422 ///
8423 /// @param[in] start_index
8424 /// First index of range. Must be at least 0 and at
8425 /// most ::HAPI_AttributeInfo::count - 1.
8426 /// <!-- default 0 -->
8427 ///
8428 /// @param[in] num_indices
8429 /// Must be at least 0 and at most
8430 /// ::HAPI_AttributeInfo::count - @p start_index.
8431 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8432 ///
8434  const HAPI_Session* session,
8435  HAPI_NodeId node_id,
8436  HAPI_PartId part_id,
8437  const char* name,
8438  const HAPI_AttributeInfo* attr_info,
8439  const HAPI_Int16* data_array,
8440  int data_length,
8441  int start_index,
8442  int num_indices);
8443 
8444 /// @brief Set multiple attribute 64-bit int data to the same unique value.
8445 ///
8446 /// @ingroup GeometrySetters Attributes
8447 ///
8448 /// @param[in] session
8449 /// The session of Houdini you are interacting with.
8450 /// See @ref HAPI_Sessions for more on sessions.
8451 /// Pass NULL to just use the default in-process session.
8452 /// <!-- default NULL -->
8453 ///
8454 /// @param[in] node_id
8455 /// The SOP node id.
8456 ///
8457 /// @param[in] part_id
8458 /// Currently not used. Just pass 0.
8459 ///
8460 /// @param[in] name
8461 /// Attribute name.
8462 ///
8463 /// @param[in] attr_info
8464 /// ::HAPI_AttributeInfo used as input for what tuple size.
8465 /// you want. Also contains some sanity checks like
8466 /// data type. Generally should be the same struct
8467 /// returned by ::HAPI_GetAttributeInfo().
8468 ///
8469 /// @param[in] data_array
8470 /// A integer array at least the size of
8471 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8472 ///
8473 /// @param[in] data_length
8474 /// An integer of at least the size of
8475 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8476 ///
8477 /// @param[in] start_index
8478 /// First index of range. Must be at least 0 and at
8479 /// most ::HAPI_AttributeInfo::count - 1.
8480 /// <!-- default 0 -->
8481 ///
8482 /// @param[in] num_indices
8483 /// Must be at least 0 and at most
8484 /// ::HAPI_AttributeInfo::count - @p start_index.
8485 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8486 ///
8488  const HAPI_Session* session,
8489  HAPI_NodeId node_id,
8490  HAPI_PartId part_id,
8491  const char* name,
8492  const HAPI_AttributeInfo* attr_info,
8493  const HAPI_Int64* data_array,
8494  int data_length,
8495  int start_index,
8496  int num_indices);
8497 
8498 /// @brief Set multiple attribute float data to the same unique value.
8499 ///
8500 /// @ingroup GeometrySetters Attributes
8501 ///
8502 /// @param[in] session
8503 /// The session of Houdini you are interacting with.
8504 /// See @ref HAPI_Sessions for more on sessions.
8505 /// Pass NULL to just use the default in-process session.
8506 /// <!-- default NULL -->
8507 ///
8508 /// @param[in] node_id
8509 /// The SOP node id.
8510 ///
8511 /// @param[in] part_id
8512 /// Currently not used. Just pass 0.
8513 ///
8514 /// @param[in] name
8515 /// Attribute name.
8516 ///
8517 /// @param[in] attr_info
8518 /// ::HAPI_AttributeInfo used as input for what tuple size.
8519 /// you want. Also contains some sanity checks like
8520 /// data type. Generally should be the same struct
8521 /// returned by ::HAPI_GetAttributeInfo().
8522 ///
8523 /// @param[in] data_array
8524 /// A floating point array at least the size of
8525 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8526 ///
8527 /// @param[in] data_length
8528 /// An integer of at least the size of
8529 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8530 ///
8531 /// @param[in] start_index
8532 /// First index of range. Must be at least 0 and at
8533 /// most ::HAPI_AttributeInfo::count - 1.
8534 /// <!-- default 0 -->
8535 ///
8536 /// @param[in] num_indices
8537 /// Must be at least 0 and at most
8538 /// ::HAPI_AttributeInfo::count - @p start_index.
8539 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8540 ///
8542  const HAPI_Session* session,
8543  HAPI_NodeId node_id,
8544  HAPI_PartId part_id,
8545  const char* name,
8546  const HAPI_AttributeInfo* attr_info,
8547  const float* data_array,
8548  int data_length,
8549  int start_index,
8550  int num_indices);
8551 
8552 /// @brief Set multiple attribute 64-bit float data to the same unique value.
8553 ///
8554 /// @ingroup GeometrySetters Attributes
8555 ///
8556 /// @param[in] session
8557 /// The session of Houdini you are interacting with.
8558 /// See @ref HAPI_Sessions for more on sessions.
8559 /// Pass NULL to just use the default in-process session.
8560 /// <!-- default NULL -->
8561 ///
8562 /// @param[in] node_id
8563 /// The SOP node id.
8564 ///
8565 /// @param[in] part_id
8566 /// Currently not used. Just pass 0.
8567 ///
8568 /// @param[in] name
8569 /// Attribute name.
8570 ///
8571 /// @param[in] attr_info
8572 /// ::HAPI_AttributeInfo used as input for what tuple size.
8573 /// you want. Also contains some sanity checks like
8574 /// data type. Generally should be the same struct
8575 /// returned by ::HAPI_GetAttributeInfo().
8576 ///
8577 /// @param[in] data_array
8578 /// A floating point array at least the size of
8579 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8580 ///
8581 /// @param[in] data_length
8582 /// An integer of at least the size of
8583 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
8584 ///
8585 /// @param[in] start_index
8586 /// First index of range. Must be at least 0 and at
8587 /// most ::HAPI_AttributeInfo::count - 1.
8588 /// <!-- default 0 -->
8589 ///
8590 /// @param[in] num_indices
8591 /// Must be at least 0 and at most
8592 /// ::HAPI_AttributeInfo::count - @p start_index.
8593 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8594 ///
8596  const HAPI_Session* session,
8597  HAPI_NodeId node_id,
8598  HAPI_PartId part_id,
8599  const char* name,
8600  const HAPI_AttributeInfo* attr_info,
8601  const double* data_array,
8602  int data_length,
8603  int start_index,
8604  int num_indices);
8605 
8606 /// @brief Set attribute dictionary data. The dictionary data should
8607 /// be provided as JSON-encoded strings.
8608 ///
8609 /// @ingroup GeometrySetters Attributes
8610 ///
8611 /// @param[in] session
8612 /// The session of Houdini you are interacting with.
8613 /// See @ref HAPI_Sessions for more on sessions.
8614 /// Pass NULL to just use the default in-process session.
8615 /// <!-- default NULL -->
8616 ///
8617 /// @param[in] node_id
8618 /// The SOP node id.
8619 ///
8620 /// @param[in] part_id
8621 /// Currently not used. Just pass 0.
8622 ///
8623 /// @param[in] name
8624 /// Attribute name.
8625 ///
8626 /// @param[in] attr_info
8627 /// ::HAPI_AttributeInfo used as input for what tuple size
8628 /// you want. Also contains some sanity checks like
8629 /// data type. Generally should be the same struct
8630 /// returned by ::HAPI_GetAttributeInfo().
8631 ///
8632 /// @param[in] data_array
8633 /// An ::HAPI_StringHandle array at least the size of
8634 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
8635 ///
8636 /// @param[in] start
8637 /// First index of range. Must be at least 0 and at
8638 /// most ::HAPI_AttributeInfo::count - 1.
8639 /// <!-- default 0 -->
8640 ///
8641 /// @param[in] length
8642 /// Must be at least 0 and at most
8643 /// ::HAPI_AttributeInfo::count - @p start.
8644 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8645 ///
8647  HAPI_NodeId node_id,
8648  HAPI_PartId part_id,
8649  const char* name,
8650  const HAPI_AttributeInfo* attr_info,
8651  const char** data_array,
8652  int start, int length );
8653 
8654 /// @brief Set integer array attribute data.
8655 ///
8656 /// @ingroup GeometrySetters Attributes
8657 ///
8658 /// @param[in] session
8659 /// The session of Houdini you are interacting with.
8660 /// See @ref HAPI_Sessions for more on sessions.
8661 /// Pass NULL to just use the default in-process session.
8662 /// <!-- default NULL -->
8663 ///
8664 /// @param[in] node_id
8665 /// The SOP node id.
8666 ///
8667 /// @param[in] part_id
8668 /// Currently not used. Just pass 0.
8669 ///
8670 /// @param[in] name
8671 /// Attribute name.
8672 ///
8673 /// @param[in] attr_info
8674 /// ::HAPI_AttributeInfo that contains the description for the
8675 /// attribute that is being set.
8676 ///
8677 /// @param[in] data_fixed_array
8678 /// An array containing the int values of the attribute.
8679 ///
8680 /// @param[in] data_fixed_length
8681 /// The total size of the data array. The size can be no greater
8682 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8683 /// of the attribute.
8684 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8685 ///
8686 /// @param[in] sizes_fixed_array
8687 /// An array of integers that contains the sizes of each
8688 /// attribute array. This is required because the attribute
8689 /// array for each geometry component can be of variable size.
8690 ///
8691 /// @param[in] start
8692 /// First index of range. Must be at least 0 and at most
8693 /// ::HAPI_AttributeInfo::count - 1.
8694 /// <!-- default 0 -->
8695 ///
8696 /// @param[in] sizes_fixed_length
8697 /// Must be at least 0 and at most
8698 /// ::HAPI_AttributeInfo::count - @p start.
8699 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8701  HAPI_NodeId node_id,
8702  HAPI_PartId part_id,
8703  const char * name,
8704  const HAPI_AttributeInfo * attr_info,
8705  const int * data_fixed_array,
8706  int data_fixed_length,
8707  const int * sizes_fixed_array,
8708  int start,
8709  int sizes_fixed_length );
8710 
8711 /// @brief Set unsigned 8-bit integer array attribute data.
8712 ///
8713 /// @ingroup GeometrySetters Attributes
8714 ///
8715 /// @param[in] session
8716 /// The session of Houdini you are interacting with.
8717 /// See @ref HAPI_Sessions for more on sessions.
8718 /// Pass NULL to just use the default in-process session.
8719 /// <!-- default NULL -->
8720 ///
8721 /// @param[in] node_id
8722 /// The SOP node id.
8723 ///
8724 /// @param[in] part_id
8725 /// Currently not used. Just pass 0.
8726 ///
8727 /// @param[in] name
8728 /// Attribute name.
8729 ///
8730 /// @param[in] attr_info
8731 /// ::HAPI_AttributeInfo that contains the description for the
8732 /// attribute that is being set.
8733 ///
8734 /// @param[in] data_fixed_array
8735 /// An array containing the HAPI_UInt8 values of the attribute.
8736 ///
8737 /// @param[in] data_fixed_length
8738 /// The total size of the data array. The size can be no greater
8739 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8740 /// of the attribute.
8741 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8742 ///
8743 /// @param[in] sizes_fixed_array
8744 /// An array of integers that contains the sizes of each
8745 /// attribute array. This is required because the attribute
8746 /// array for each geometry component can be of variable size.
8747 ///
8748 /// @param[in] start
8749 /// First index of range. Must be at least 0 and at most
8750 /// ::HAPI_AttributeInfo::count - 1.
8751 /// <!-- default 0 -->
8752 ///
8753 /// @param[in] sizes_fixed_length
8754 /// Must be at least 0 and at most
8755 /// ::HAPI_AttributeInfo::count - @p start.
8756 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8758  HAPI_NodeId node_id,
8759  HAPI_PartId part_id,
8760  const char * name,
8761  const HAPI_AttributeInfo * attr_info,
8762  const HAPI_UInt8 * data_fixed_array,
8763  int data_fixed_length,
8764  const int * sizes_fixed_array,
8765  int start,
8766  int sizes_fixed_length );
8767 
8768 /// @brief Set 8-bit integer array attribute data.
8769 ///
8770 /// @ingroup GeometrySetters Attributes
8771 ///
8772 /// @param[in] session
8773 /// The session of Houdini you are interacting with.
8774 /// See @ref HAPI_Sessions for more on sessions.
8775 /// Pass NULL to just use the default in-process session.
8776 /// <!-- default NULL -->
8777 ///
8778 /// @param[in] node_id
8779 /// The SOP node id.
8780 ///
8781 /// @param[in] part_id
8782 /// Currently not used. Just pass 0.
8783 ///
8784 /// @param[in] name
8785 /// Attribute name.
8786 ///
8787 /// @param[in] attr_info
8788 /// ::HAPI_AttributeInfo that contains the description for the
8789 /// attribute that is being set.
8790 ///
8791 /// @param[in] data_fixed_array
8792 /// An array containing the HAPI_Int8 values of the attribute.
8793 ///
8794 /// @param[in] data_fixed_length
8795 /// The total size of the data array. The size can be no greater
8796 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8797 /// of the attribute.
8798 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8799 ///
8800 /// @param[in] sizes_fixed_array
8801 /// An array of integers that contains the sizes of each
8802 /// attribute array. This is required because the attribute
8803 /// array for each geometry component can be of variable size.
8804 ///
8805 /// @param[in] start
8806 /// First index of range. Must be at least 0 and at most
8807 /// ::HAPI_AttributeInfo::count - 1.
8808 /// <!-- default 0 -->
8809 ///
8810 /// @param[in] sizes_fixed_length
8811 /// Must be at least 0 and at most
8812 /// ::HAPI_AttributeInfo::count - @p start.
8813 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8815  HAPI_NodeId node_id,
8816  HAPI_PartId part_id,
8817  const char * name,
8818  const HAPI_AttributeInfo * attr_info,
8819  const HAPI_Int8 * data_fixed_array,
8820  int data_fixed_length,
8821  const int * sizes_fixed_array,
8822  int start,
8823  int sizes_fixed_length);
8824 
8825 /// @brief Set 16-bit integer array attribute data.
8826 ///
8827 /// @ingroup GeometrySetters Attributes
8828 ///
8829 /// @param[in] session
8830 /// The session of Houdini you are interacting with.
8831 /// See @ref HAPI_Sessions for more on sessions.
8832 /// Pass NULL to just use the default in-process session.
8833 /// <!-- default NULL -->
8834 ///
8835 /// @param[in] node_id
8836 /// The SOP node id.
8837 ///
8838 /// @param[in] part_id
8839 /// Currently not used. Just pass 0.
8840 ///
8841 /// @param[in] name
8842 /// Attribute name.
8843 ///
8844 /// @param[in] attr_info
8845 /// ::HAPI_AttributeInfo that contains the description for the
8846 /// attribute that is being set.
8847 ///
8848 /// @param[in] data_fixed_array
8849 /// An array containing the HAPI_Int16 values of the attribute.
8850 ///
8851 /// @param[in] data_fixed_length
8852 /// The total size of the data array. The size can be no greater
8853 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8854 /// of the attribute.
8855 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8856 ///
8857 /// @param[in] sizes_fixed_array
8858 /// An array of integers that contains the sizes of each
8859 /// attribute array. This is required because the attribute
8860 /// array for each geometry component can be of variable size.
8861 ///
8862 /// @param[in] start
8863 /// First index of range. Must be at least 0 and at most
8864 /// ::HAPI_AttributeInfo::count - 1.
8865 /// <!-- default 0 -->
8866 ///
8867 /// @param[in] sizes_fixed_length
8868 /// Must be at least 0 and at most
8869 /// ::HAPI_AttributeInfo::count - @p start.
8870 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8872  HAPI_NodeId node_id,
8873  HAPI_PartId part_id,
8874  const char * name,
8875  const HAPI_AttributeInfo * attr_info,
8876  const HAPI_Int16 * data_fixed_array,
8877  int data_fixed_length,
8878  const int * sizes_fixed_array,
8879  int start,
8880  int sizes_fixed_length );
8881 
8882 /// @brief Set 64-bit integer array attribute data.
8883 ///
8884 /// @ingroup GeometrySetters Attributes
8885 ///
8886 /// @param[in] session
8887 /// The session of Houdini you are interacting with.
8888 /// See @ref HAPI_Sessions for more on sessions.
8889 /// Pass NULL to just use the default in-process session.
8890 /// <!-- default NULL -->
8891 ///
8892 /// @param[in] node_id
8893 /// The SOP node id.
8894 ///
8895 /// @param[in] part_id
8896 /// Currently not used. Just pass 0.
8897 ///
8898 /// @param[in] name
8899 /// Attribute name.
8900 ///
8901 /// @param[in] attr_info
8902 /// ::HAPI_AttributeInfo that contains the description for the
8903 /// attribute that is being set.
8904 ///
8905 /// @param[in] data_fixed_array
8906 /// An array containing the HAPI_Int64 values of the attribute.
8907 ///
8908 /// @param[in] data_fixed_length
8909 /// The total size of the data array. The size can be no greater
8910 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8911 /// of the attribute.
8912 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8913 ///
8914 /// @param[in] sizes_fixed_array
8915 /// An array of integers that contains the sizes of each
8916 /// attribute array. This is required because the attribute
8917 /// array for each geometry component can be of variable size.
8918 ///
8919 /// @param[in] start
8920 /// First index of range. Must be at least 0 and at most
8921 /// ::HAPI_AttributeInfo::count - 1.
8922 /// <!-- default 0 -->
8923 ///
8924 /// @param[in] sizes_fixed_length
8925 /// Must be at least 0 and at most
8926 /// ::HAPI_AttributeInfo::count - @p start.
8927 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8929  HAPI_NodeId node_id,
8930  HAPI_PartId part_id,
8931  const char * name,
8932  const HAPI_AttributeInfo * attr_info,
8933  const HAPI_Int64 * data_fixed_array,
8934  int data_fixed_length,
8935  const int * sizes_fixed_array,
8936  int start,
8937  int sizes_fixed_length );
8938 
8939 /// @brief Set float array attribute data.
8940 ///
8941 /// @ingroup GeometrySetters Attributes
8942 ///
8943 /// @param[in] session
8944 /// The session of Houdini you are interacting with.
8945 /// See @ref HAPI_Sessions for more on sessions.
8946 /// Pass NULL to just use the default in-process session.
8947 /// <!-- default NULL -->
8948 ///
8949 /// @param[in] node_id
8950 /// The SOP node id.
8951 ///
8952 /// @param[in] part_id
8953 /// Currently not used. Just pass 0.
8954 ///
8955 /// @param[in] name
8956 /// Attribute name.
8957 ///
8958 /// @param[in] attr_info
8959 /// ::HAPI_AttributeInfo that contains the description for the
8960 /// attribute that is being set.
8961 ///
8962 /// @param[in] data_fixed_array
8963 /// An array containing the float values of the attribute.
8964 ///
8965 /// @param[in] data_fixed_length
8966 /// The total size of the data array. The size can be no greater
8967 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
8968 /// of the attribute.
8969 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
8970 ///
8971 /// @param[in] sizes_fixed_array
8972 /// An array of integers that contains the sizes of each
8973 /// attribute array. This is required because the attribute
8974 /// array for each geometry component can be of variable size.
8975 ///
8976 /// @param[in] start
8977 /// First index of range. Must be at least 0 and at most
8978 /// ::HAPI_AttributeInfo::count - 1.
8979 /// <!-- default 0 -->
8980 ///
8981 /// @param[in] sizes_fixed_length
8982 /// Must be at least 0 and at most
8983 /// ::HAPI_AttributeInfo::count - @p start.
8984 /// <!-- source ::HAPI_AttributeInfo::count - start -->
8986  HAPI_NodeId node_id,
8987  HAPI_PartId part_id,
8988  const char * name,
8989  const HAPI_AttributeInfo * attr_info,
8990  const float * data_fixed_array,
8991  int data_fixed_length,
8992  const int * sizes_fixed_array,
8993  int start,
8994  int sizes_fixed_length );
8995 
8996 /// @brief Set 64-bit float array attribute data.
8997 ///
8998 /// @ingroup GeometrySetters Attributes
8999 ///
9000 /// @param[in] session
9001 /// The session of Houdini you are interacting with.
9002 /// See @ref HAPI_Sessions for more on sessions.
9003 /// Pass NULL to just use the default in-process session.
9004 /// <!-- default NULL -->
9005 ///
9006 /// @param[in] node_id
9007 /// The SOP node id.
9008 ///
9009 /// @param[in] part_id
9010 /// Currently not used. Just pass 0.
9011 ///
9012 /// @param[in] name
9013 /// Attribute name.
9014 ///
9015 /// @param[in] attr_info
9016 /// ::HAPI_AttributeInfo that contains the description for the
9017 /// attribute that is being set.
9018 ///
9019 /// @param[in] data_fixed_array
9020 /// An array containing the double values of the attribute.
9021 ///
9022 /// @param[in] data_fixed_length
9023 /// The total size of the data array. The size can be no greater
9024 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
9025 /// of the attribute.
9026 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
9027 ///
9028 /// @param[in] sizes_fixed_array
9029 /// An array of integers that contains the sizes of each
9030 /// attribute array. This is required because the attribute
9031 /// array for each geometry component can be of variable size.
9032 ///
9033 /// @param[in] start
9034 /// First index of range. Must be at least 0 and at most
9035 /// ::HAPI_AttributeInfo::count - 1.
9036 /// <!-- default 0 -->
9037 ///
9038 /// @param[in] sizes_fixed_length
9039 /// Must be at least 0 and at most
9040 /// ::HAPI_AttributeInfo::count - @p start.
9041 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9043  HAPI_NodeId node_id,
9044  HAPI_PartId part_id,
9045  const char * name,
9046  const HAPI_AttributeInfo * attr_info,
9047  const double * data_fixed_array,
9048  int data_fixed_length,
9049  const int * sizes_fixed_array,
9050  int start,
9051  int sizes_fixed_length );
9052 
9053 /// @brief Set string array attribute data.
9054 ///
9055 /// @ingroup GeometrySetters Attributes
9056 ///
9057 /// @param[in] session
9058 /// The session of Houdini you are interacting with.
9059 /// See @ref HAPI_Sessions for more on sessions.
9060 /// Pass NULL to just use the default in-process session.
9061 /// <!-- default NULL -->
9062 ///
9063 /// @param[in] node_id
9064 /// The SOP node id.
9065 ///
9066 /// @param[in] part_id
9067 /// Currently not used. Just pass 0.
9068 ///
9069 /// @param[in] name
9070 /// Attribute name.
9071 ///
9072 /// @param[in] attr_info
9073 /// ::HAPI_AttributeInfo that contains the description for the
9074 /// attribute that is being set.
9075 ///
9076 /// @param[in] data_fixed_array
9077 /// An array containing the string values of the attribute.
9078 ///
9079 /// @param[in] data_fixed_length
9080 /// The total size of the data array. The size can be no greater
9081 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
9082 /// of the attribute.
9083 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
9084 ///
9085 /// @param[in] sizes_fixed_array
9086 /// An array of integers that contains the sizes of each
9087 /// attribute array. This is required because the attribute
9088 /// array for each geometry component can be of variable size.
9089 ///
9090 /// @param[in] start
9091 /// First index of range. Must be at least 0 and at most
9092 /// ::HAPI_AttributeInfo::count - 1.
9093 /// <!-- default 0 -->
9094 ///
9095 /// @param[in] sizes_fixed_length
9096 /// Must be at least 0 and at most
9097 /// ::HAPI_AttributeInfo::count - @p start.
9098 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9100  HAPI_NodeId node_id,
9101  HAPI_PartId part_id,
9102  const char * name,
9103  const HAPI_AttributeInfo * attr_info,
9104  const char ** data_fixed_array,
9105  int data_fixed_length,
9106  const int * sizes_fixed_array,
9107  int start,
9108  int sizes_fixed_length );
9109 
9110 /// @brief Set attribute dictionary array data. The dictionary data should
9111 /// be provided as JSON-encoded strings.
9112 ///
9113 /// @ingroup GeometrySetters Attributes
9114 ///
9115 /// @param[in] session
9116 /// The session of Houdini you are interacting with.
9117 /// See @ref HAPI_Sessions for more on sessions.
9118 /// Pass NULL to just use the default in-process session.
9119 /// <!-- default NULL -->
9120 ///
9121 /// @param[in] node_id
9122 /// The SOP node id.
9123 ///
9124 /// @param[in] part_id
9125 /// Currently not used. Just pass 0.
9126 ///
9127 /// @param[in] name
9128 /// Attribute name.
9129 ///
9130 /// @param[in] attr_info
9131 /// ::HAPI_AttributeInfo that contains the description for the
9132 /// attribute that is being set.
9133 ///
9134 /// @param[in] data_fixed_array
9135 /// An array containing the dictionary values of the attribute.
9136 ///
9137 /// @param[in] data_fixed_length
9138 /// The total size of the data array. The size can be no greater
9139 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
9140 /// of the attribute.
9141 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
9142 ///
9143 /// @param[in] sizes_fixed_array
9144 /// An array of integers that contains the sizes of each
9145 /// attribute array. This is required because the attribute
9146 /// array for each geometry component can be of variable size.
9147 ///
9148 /// @param[in] start
9149 /// First index of range. Must be at least 0 and at most
9150 /// ::HAPI_AttributeInfo::count - 1.
9151 /// <!-- default 0 -->
9152 ///
9153 /// @param[in] sizes_fixed_length
9154 /// Must be at least 0 and at most
9155 /// ::HAPI_AttributeInfo::count - @p start.
9156 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9158  HAPI_NodeId node_id,
9159  HAPI_PartId part_id,
9160  const char* name,
9161  const HAPI_AttributeInfo* attr_info,
9162  const char** data_fixed_array,
9163  int data_fixed_length,
9164  const int* sizes_fixed_array,
9165  int start,
9166  int sizes_fixed_length);
9167 
9168 /// @brief Set attribute integer data asynchronously.
9169 ///
9170 /// @ingroup GeometrySetters Attributes
9171 ///
9172 /// @param[in] session
9173 /// The session of Houdini you are interacting with.
9174 /// See @ref HAPI_Sessions for more on sessions.
9175 /// Pass NULL to just use the default in-process session.
9176 /// <!-- default NULL -->
9177 ///
9178 /// @param[in] node_id
9179 /// The SOP node id.
9180 ///
9181 /// @param[in] part_id
9182 /// Currently not used. Just pass 0.
9183 ///
9184 /// @param[in] name
9185 /// Attribute name.
9186 ///
9187 /// @param[in] attr_info
9188 /// ::HAPI_AttributeInfo used as input for what tuple size.
9189 /// you want. Also contains some sanity checks like
9190 /// data type. Generally should be the same struct
9191 /// returned by ::HAPI_GetAttributeInfo().
9192 ///
9193 /// @param[in] data_array
9194 /// An integer array at least the size of
9195 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9196 ///
9197 /// @param[in] start
9198 /// First index of range. Must be at least 0 and at
9199 /// most ::HAPI_AttributeInfo::count - 1.
9200 /// <!-- default 0 -->
9201 ///
9202 /// @param[in] length
9203 /// Must be at least 0 and at most
9204 /// ::HAPI_AttributeInfo::count - @p start.
9205 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9206 ///
9207 /// @param[out] job_id
9208 /// The id assigned to the job.
9209 ///
9211  HAPI_NodeId node_id,
9212  HAPI_PartId part_id,
9213  const char * name,
9214  const HAPI_AttributeInfo * attr_info,
9215  const int * data_array,
9216  int start, int length,
9217  int * job_id );
9218 
9219 /// @brief Set unsigned 8-bit attribute integer data asynchronously.
9220 ///
9221 /// @ingroup GeometrySetters Attributes
9222 ///
9223 /// @param[in] session
9224 /// The session of Houdini you are interacting with.
9225 /// See @ref HAPI_Sessions for more on sessions.
9226 /// Pass NULL to just use the default in-process session.
9227 /// <!-- default NULL -->
9228 ///
9229 /// @param[in] node_id
9230 /// The SOP node id.
9231 ///
9232 /// @param[in] part_id
9233 /// Currently not used. Just pass 0.
9234 ///
9235 /// @param[in] name
9236 /// Attribute name.
9237 ///
9238 /// @param[in] attr_info
9239 /// ::HAPI_AttributeInfo used as input for what tuple size.
9240 /// you want. Also contains some sanity checks like
9241 /// data type. Generally should be the same struct
9242 /// returned by ::HAPI_GetAttributeInfo().
9243 ///
9244 /// @param[in] data_array
9245 /// An unsigned 8-bit integer array at least the size of
9246 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9247 ///
9248 /// @param[in] start
9249 /// First index of range. Must be at least 0 and at
9250 /// most ::HAPI_AttributeInfo::count - 1.
9251 /// <!-- default 0 -->
9252 ///
9253 /// @param[in] length
9254 /// Must be at least 0 and at most
9255 /// ::HAPI_AttributeInfo::count - @p start.
9256 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9257 ///
9258 /// @param[out] job_id
9259 /// The id assigned to the job.
9260 ///
9262  HAPI_NodeId node_id,
9263  HAPI_PartId part_id,
9264  const char * name,
9265  const HAPI_AttributeInfo * attr_info,
9266  const HAPI_UInt8 * data_array,
9267  int start, int length,
9268  int * job_id );
9269 
9270 /// @brief Set 8-bit attribute integer data asynchronously.
9271 ///
9272 /// @ingroup GeometrySetters Attributes
9273 ///
9274 /// @param[in] session
9275 /// The session of Houdini you are interacting with.
9276 /// See @ref HAPI_Sessions for more on sessions.
9277 /// Pass NULL to just use the default in-process session.
9278 /// <!-- default NULL -->
9279 ///
9280 /// @param[in] node_id
9281 /// The SOP node id.
9282 ///
9283 /// @param[in] part_id
9284 /// Currently not used. Just pass 0.
9285 ///
9286 /// @param[in] name
9287 /// Attribute name.
9288 ///
9289 /// @param[in] attr_info
9290 /// ::HAPI_AttributeInfo used as input for what tuple size.
9291 /// you want. Also contains some sanity checks like
9292 /// data type. Generally should be the same struct
9293 /// returned by ::HAPI_GetAttributeInfo().
9294 ///
9295 /// @param[in] data_array
9296 /// An 8-bit integer array at least the size of
9297 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9298 ///
9299 /// @param[in] start
9300 /// First index of range. Must be at least 0 and at
9301 /// most ::HAPI_AttributeInfo::count - 1.
9302 /// <!-- default 0 -->
9303 ///
9304 /// @param[in] length
9305 /// Must be at least 0 and at most
9306 /// ::HAPI_AttributeInfo::count - @p start.
9307 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9308 ///
9309 /// @param[out] job_id
9310 /// The id assigned to the job.
9311 ///
9313  HAPI_NodeId node_id,
9314  HAPI_PartId part_id,
9315  const char * name,
9316  const HAPI_AttributeInfo * attr_info,
9317  const HAPI_Int8 * data_array,
9318  int start, int length,
9319  int * job_id );
9320 
9321 /// @brief Set 16-bit attribute integer data asynchronously.
9322 ///
9323 /// @ingroup GeometrySetters Attributes
9324 ///
9325 /// @param[in] session
9326 /// The session of Houdini you are interacting with.
9327 /// See @ref HAPI_Sessions for more on sessions.
9328 /// Pass NULL to just use the default in-process session.
9329 /// <!-- default NULL -->
9330 ///
9331 /// @param[in] node_id
9332 /// The SOP node id.
9333 ///
9334 /// @param[in] part_id
9335 /// Currently not used. Just pass 0.
9336 ///
9337 /// @param[in] name
9338 /// Attribute name.
9339 ///
9340 /// @param[in] attr_info
9341 /// ::HAPI_AttributeInfo used as input for what tuple size.
9342 /// you want. Also contains some sanity checks like
9343 /// data type. Generally should be the same struct
9344 /// returned by ::HAPI_GetAttributeInfo().
9345 ///
9346 /// @param[in] data_array
9347 /// An 16-bit integer array at least the size of
9348 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9349 ///
9350 /// @param[in] start
9351 /// First index of range. Must be at least 0 and at
9352 /// most ::HAPI_AttributeInfo::count - 1.
9353 /// <!-- default 0 -->
9354 ///
9355 /// @param[in] length
9356 /// Must be at least 0 and at most
9357 /// ::HAPI_AttributeInfo::count - @p start.
9358 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9359 ///
9360 /// @param[out] job_id
9361 /// The id assigned to the job.
9362 ///
9364  HAPI_NodeId node_id,
9365  HAPI_PartId part_id,
9366  const char * name,
9367  const HAPI_AttributeInfo * attr_info,
9368  const HAPI_Int16 * data_array,
9369  int start, int length,
9370  int * job_id );
9371 
9372 /// @brief Set 64-bit attribute integer data asynchronously.
9373 ///
9374 /// @ingroup GeometrySetters Attributes
9375 ///
9376 /// @param[in] session
9377 /// The session of Houdini you are interacting with.
9378 /// See @ref HAPI_Sessions for more on sessions.
9379 /// Pass NULL to just use the default in-process session.
9380 /// <!-- default NULL -->
9381 ///
9382 /// @param[in] node_id
9383 /// The SOP node id.
9384 ///
9385 /// @param[in] part_id
9386 /// Currently not used. Just pass 0.
9387 ///
9388 /// @param[in] name
9389 /// Attribute name.
9390 ///
9391 /// @param[in] attr_info
9392 /// ::HAPI_AttributeInfo used as input for what tuple size.
9393 /// you want. Also contains some sanity checks like
9394 /// data type. Generally should be the same struct
9395 /// returned by ::HAPI_GetAttributeInfo().
9396 ///
9397 /// @param[in] data_array
9398 /// An 64-bit integer array at least the size of
9399 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9400 ///
9401 /// @param[in] start
9402 /// First index of range. Must be at least 0 and at
9403 /// most ::HAPI_AttributeInfo::count - 1.
9404 /// <!-- default 0 -->
9405 ///
9406 /// @param[in] length
9407 /// Must be at least 0 and at most
9408 /// ::HAPI_AttributeInfo::count - @p start.
9409 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9410 ///
9411 /// @param[out] job_id
9412 /// The id assigned to the job.
9413 ///
9415  HAPI_NodeId node_id,
9416  HAPI_PartId part_id,
9417  const char * name,
9418  const HAPI_AttributeInfo * attr_info,
9419  const HAPI_Int64 * data_array,
9420  int start, int length,
9421  int * job_id );
9422 
9423 /// @brief Set attribute float data asynchronously.
9424 ///
9425 /// @ingroup GeometrySetters Attributes
9426 ///
9427 /// @param[in] session
9428 /// The session of Houdini you are interacting with.
9429 /// See @ref HAPI_Sessions for more on sessions.
9430 /// Pass NULL to just use the default in-process session.
9431 /// <!-- default NULL -->
9432 ///
9433 /// @param[in] node_id
9434 /// The SOP node id.
9435 ///
9436 /// @param[in] part_id
9437 /// Currently not used. Just pass 0.
9438 ///
9439 /// @param[in] name
9440 /// Attribute name.
9441 ///
9442 /// @param[in] attr_info
9443 /// ::HAPI_AttributeInfo used as input for what tuple size.
9444 /// you want. Also contains some sanity checks like
9445 /// data type. Generally should be the same struct
9446 /// returned by ::HAPI_GetAttributeInfo().
9447 ///
9448 /// @param[in] data_array
9449 /// An float array at least the size of
9450 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9451 ///
9452 /// @param[in] start
9453 /// First index of range. Must be at least 0 and at
9454 /// most ::HAPI_AttributeInfo::count - 1.
9455 /// <!-- default 0 -->
9456 ///
9457 /// @param[in] length
9458 /// Must be at least 0 and at most
9459 /// ::HAPI_AttributeInfo::count - @p start.
9460 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9461 ///
9462 /// @param[out] job_id
9463 /// The id assigned to the job.
9464 ///
9466  HAPI_NodeId node_id,
9467  HAPI_PartId part_id,
9468  const char * name,
9469  const HAPI_AttributeInfo * attr_info,
9470  const float * data_array,
9471  int start, int length,
9472  int * job_id );
9473 
9474 /// @brief Set 64-bit attribute float data asynchronously.
9475 ///
9476 /// @ingroup GeometrySetters Attributes
9477 ///
9478 /// @param[in] session
9479 /// The session of Houdini you are interacting with.
9480 /// See @ref HAPI_Sessions for more on sessions.
9481 /// Pass NULL to just use the default in-process session.
9482 /// <!-- default NULL -->
9483 ///
9484 /// @param[in] node_id
9485 /// The SOP node id.
9486 ///
9487 /// @param[in] part_id
9488 /// Currently not used. Just pass 0.
9489 ///
9490 /// @param[in] name
9491 /// Attribute name.
9492 ///
9493 /// @param[in] attr_info
9494 /// ::HAPI_AttributeInfo used as input for what tuple size.
9495 /// you want. Also contains some sanity checks like
9496 /// data type. Generally should be the same struct
9497 /// returned by ::HAPI_GetAttributeInfo().
9498 ///
9499 /// @param[in] data_array
9500 /// An 64-bit float array at least the size of
9501 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9502 ///
9503 /// @param[in] start
9504 /// First index of range. Must be at least 0 and at
9505 /// most ::HAPI_AttributeInfo::count - 1.
9506 /// <!-- default 0 -->
9507 ///
9508 /// @param[in] length
9509 /// Must be at least 0 and at most
9510 /// ::HAPI_AttributeInfo::count - @p start.
9511 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9512 ///
9513 /// @param[out] job_id
9514 /// The id assigned to the job.
9515 ///
9517  const HAPI_Session * session,
9518  HAPI_NodeId node_id,
9519  HAPI_PartId part_id,
9520  const char * name,
9521  const HAPI_AttributeInfo * attr_info,
9522  const double * data_array,
9523  int start, int length,
9524  int * job_id );
9525 
9526 /// @brief Set attribute string data asynchronously.
9527 ///
9528 /// @ingroup GeometrySetters Attributes
9529 ///
9530 /// @param[in] session
9531 /// The session of Houdini you are interacting with.
9532 /// See @ref HAPI_Sessions for more on sessions.
9533 /// Pass NULL to just use the default in-process session.
9534 /// <!-- default NULL -->
9535 ///
9536 /// @param[in] node_id
9537 /// The SOP node id.
9538 ///
9539 /// @param[in] part_id
9540 /// Currently not used. Just pass 0.
9541 ///
9542 /// @param[in] name
9543 /// Attribute name.
9544 ///
9545 /// @param[in] attr_info
9546 /// ::HAPI_AttributeInfo used as input for what tuple size
9547 /// you want. Also contains some sanity checks like
9548 /// data type. Generally should be the same struct
9549 /// returned by ::HAPI_GetAttributeInfo().
9550 ///
9551 /// @param[in] data_array
9552 /// An ::HAPI_StringHandle array at least the size of
9553 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
9554 ///
9555 /// @param[in] start
9556 /// First index of range. Must be at least 0 and at
9557 /// most ::HAPI_AttributeInfo::count - 1.
9558 /// <!-- default 0 -->
9559 ///
9560 /// @param[in] length
9561 /// Must be at least 0 and at most
9562 /// ::HAPI_AttributeInfo::count - @p start.
9563 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9564 ///
9565 /// @param[out] job_id
9566 /// The id assigned to the job.
9567 ///
9569  const HAPI_Session * session,
9570  HAPI_NodeId node_id,
9571  HAPI_PartId part_id,
9572  const char * name,
9573  const HAPI_AttributeInfo * attr_info,
9574  const char ** data_array,
9575  int start, int length,
9576  int * job_id );
9577 
9578 /// @brief Set attribute string data by index asynchronously.
9579 ///
9580 /// @ingroup GeometrySetters Attributes
9581 ///
9582 /// @param[in] session
9583 /// The session of Houdini you are interacting with.
9584 /// See @ref HAPI_Sessions for more on sessions.
9585 /// Pass NULL to just use the default in-process session.
9586 /// <!-- default NULL -->
9587 ///
9588 /// @param[in] node_id
9589 /// The SOP node id.
9590 ///
9591 /// @param[in] part_id
9592 /// Currently not used. Just pass 0.
9593 ///
9594 /// @param[in] name
9595 /// Attribute name.
9596 ///
9597 /// @param[in] attr_info
9598 /// ::HAPI_AttributeInfo used as input for what tuple size.
9599 /// you want. Also contains some sanity checks like
9600 /// data type. Generally should be the same struct
9601 /// returned by ::HAPI_GetAttributeInfo().
9602 ///
9603 /// @param[in] string_array
9604 /// An array of strings at least the size of
9605 /// <tt>string_count/tt>.
9606 ///
9607 /// @param[in] string_count
9608 /// Number of strings that are indexed.
9609 ///
9610 /// @param[in] indices_array
9611 /// integer array at least the size of
9612 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>. Each
9613 /// entry indexes string_array.
9614 ///
9615 /// @param[in] indices_start
9616 /// First index of range. Must be at least 0 and at
9617 /// most ::HAPI_AttributeInfo::count - 1.
9618 /// <!-- default 0 -->
9619 ///
9620 /// @param[in] indices_length
9621 /// Must be at least 0 and at most
9622 /// ::HAPI_AttributeInfo::count - @p start.
9623 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9624 ///
9625 /// @param[out] job_id
9626 /// The id assigned to the job.
9627 ///
9629  const HAPI_Session * session,
9630  HAPI_NodeId node_id,
9631  HAPI_PartId part_id,
9632  const char * name,
9633  const HAPI_AttributeInfo * attr_info,
9634  const char ** string_array,
9635  int string_count,
9636  const int * indices_array,
9637  int indices_start,
9638  int indices_length,
9639  int * job_id );
9640 
9641 /// @brief Set multiple attribute string data to the same unique value
9642 /// asynchronously.
9643 ///
9644 /// @ingroup GeometrySetters Attributes
9645 ///
9646 /// @param[in] session
9647 /// The session of Houdini you are interacting with.
9648 /// See @ref HAPI_Sessions for more on sessions.
9649 /// Pass NULL to just use the default in-process session.
9650 /// <!-- default NULL -->
9651 ///
9652 /// @param[in] node_id
9653 /// The SOP node id.
9654 ///
9655 /// @param[in] part_id
9656 /// Currently not used. Just pass 0.
9657 ///
9658 /// @param[in] name
9659 /// Attribute name.
9660 ///
9661 /// @param[in] attr_info
9662 /// ::HAPI_AttributeInfo used as input for what tuple size.
9663 /// you want. Also contains some sanity checks like
9664 /// data type. Generally should be the same struct
9665 /// returned by ::HAPI_GetAttributeInfo().
9666 ///
9667 /// @param[in] data_array
9668 /// A string
9669 ///
9670 /// @param[in] data_length
9671 /// Must be the length of string data.
9672 ///
9673 /// @param[in] start_index
9674 /// Must be at least 0 and at most
9675 /// ::HAPI_AttributeInfo::count - @p start.
9676 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9677 ///
9678 /// @param[in] num_indices
9679 /// Must be at least 0 and at most
9680 /// ::HAPI_AttributeInfo::count - @p start.
9681 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9682 ///
9683 /// @param[out] job_id
9684 /// The id assigned to the job.
9685 ///
9687  const HAPI_Session * session,
9688  HAPI_NodeId node_id,
9689  HAPI_PartId part_id,
9690  const char * name,
9691  const HAPI_AttributeInfo * attr_info,
9692  const char * data_array,
9693  int data_length,
9694  int start_index,
9695  int num_indices,
9696  int * job_id );
9697 
9698 /// @brief Set multiple attribute int data to the same unique value
9699 /// asynchronously.
9700 ///
9701 /// @ingroup GeometrySetters Attributes
9702 ///
9703 /// @param[in] session
9704 /// The session of Houdini you are interacting with.
9705 /// See @ref HAPI_Sessions for more on sessions.
9706 /// Pass NULL to just use the default in-process session.
9707 /// <!-- default NULL -->
9708 ///
9709 /// @param[in] node_id
9710 /// The SOP node id.
9711 ///
9712 /// @param[in] part_id
9713 /// Currently not used. Just pass 0.
9714 ///
9715 /// @param[in] name
9716 /// Attribute name.
9717 ///
9718 /// @param[in] attr_info
9719 /// ::HAPI_AttributeInfo used as input for what tuple size.
9720 /// you want. Also contains some sanity checks like
9721 /// data type. Generally should be the same struct
9722 /// returned by ::HAPI_GetAttributeInfo().
9723 ///
9724 /// @param[in] data_array
9725 /// A integer array at least the size of
9726 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9727 ///
9728 /// @param[in] data_length
9729 /// An integer of at least the size of
9730 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9731 ///
9732 /// @param[in] start_index
9733 /// First index of range. Must be at least 0 and at
9734 /// most ::HAPI_AttributeInfo::count - 1.
9735 /// <!-- default 0 -->
9736 ///
9737 /// @param[in] num_indices
9738 /// Must be at least 0 and at most
9739 /// ::HAPI_AttributeInfo::count - @p start_index.
9740 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9741 ///
9742 /// @param[out] job_id
9743 /// The id assigned to the job.
9744 ///
9746  const HAPI_Session * session,
9747  HAPI_NodeId node_id,
9748  HAPI_PartId part_id,
9749  const char * name,
9750  const HAPI_AttributeInfo * attr_info,
9751  const int * data_array,
9752  int data_length,
9753  int start_index,
9754  int num_indices,
9755  int * job_id );
9756 
9757 /// @brief Set multiple attribute unsigned 8-bit int data to the same unique
9758 /// value asynchronously.
9759 ///
9760 /// @ingroup GeometrySetters Attributes
9761 ///
9762 /// @param[in] session
9763 /// The session of Houdini you are interacting with.
9764 /// See @ref HAPI_Sessions for more on sessions.
9765 /// Pass NULL to just use the default in-process session.
9766 /// <!-- default NULL -->
9767 ///
9768 /// @param[in] node_id
9769 /// The SOP node id.
9770 ///
9771 /// @param[in] part_id
9772 /// Currently not used. Just pass 0.
9773 ///
9774 /// @param[in] name
9775 /// Attribute name.
9776 ///
9777 /// @param[in] attr_info
9778 /// ::HAPI_AttributeInfo used as input for what tuple size.
9779 /// you want. Also contains some sanity checks like
9780 /// data type. Generally should be the same struct
9781 /// returned by ::HAPI_GetAttributeInfo().
9782 ///
9783 /// @param[in] data_array
9784 /// A integer array at least the size of
9785 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9786 ///
9787 /// @param[in] data_length
9788 /// An integer of at least the size of
9789 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9790 ///
9791 /// @param[in] start_index
9792 /// First index of range. Must be at least 0 and at
9793 /// most ::HAPI_AttributeInfo::count - 1.
9794 /// <!-- default 0 -->
9795 ///
9796 /// @param[in] num_indices
9797 /// Must be at least 0 and at most
9798 /// ::HAPI_AttributeInfo::count - @p start_index.
9799 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9800 ///
9801 /// @param[out] job_id
9802 /// The id assigned to the job.
9803 ///
9805  const HAPI_Session * session,
9806  HAPI_NodeId node_id,
9807  HAPI_PartId part_id,
9808  const char * name,
9809  const HAPI_AttributeInfo * attr_info,
9810  const HAPI_UInt8 * data_array,
9811  int data_length,
9812  int start_index,
9813  int num_indices,
9814  int * job_id );
9815 
9816 /// @brief Set multiple attribute 8-bit int data to the same unique value
9817 /// asynchronously.
9818 ///
9819 /// @ingroup GeometrySetters Attributes
9820 ///
9821 /// @param[in] session
9822 /// The session of Houdini you are interacting with.
9823 /// See @ref HAPI_Sessions for more on sessions.
9824 /// Pass NULL to just use the default in-process session.
9825 /// <!-- default NULL -->
9826 ///
9827 /// @param[in] node_id
9828 /// The SOP node id.
9829 ///
9830 /// @param[in] part_id
9831 /// Currently not used. Just pass 0.
9832 ///
9833 /// @param[in] name
9834 /// Attribute name.
9835 ///
9836 /// @param[in] attr_info
9837 /// ::HAPI_AttributeInfo used as input for what tuple size.
9838 /// you want. Also contains some sanity checks like
9839 /// data type. Generally should be the same struct
9840 /// returned by ::HAPI_GetAttributeInfo().
9841 ///
9842 /// @param[in] data_array
9843 /// A integer array at least the size of
9844 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9845 ///
9846 /// @param[in] data_length
9847 /// An integer of at least the size of
9848 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9849 ///
9850 /// @param[in] start_index
9851 /// First index of range. Must be at least 0 and at
9852 /// most ::HAPI_AttributeInfo::count - 1.
9853 /// <!-- default 0 -->
9854 ///
9855 /// @param[in] num_indices
9856 /// Must be at least 0 and at most
9857 /// ::HAPI_AttributeInfo::count - @p start_index.
9858 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9859 ///
9860 /// @param[out] job_id
9861 /// The id assigned to the job.
9862 ///
9864  const HAPI_Session * session,
9865  HAPI_NodeId node_id,
9866  HAPI_PartId part_id,
9867  const char * name,
9868  const HAPI_AttributeInfo * attr_info,
9869  const HAPI_Int8* data_array,
9870  int data_length,
9871  int start_index,
9872  int num_indices,
9873  int * job_id );
9874 
9875 /// @brief Set multiple attribute 16-bit int data to the same unique value
9876 /// asynchronously.
9877 ///
9878 /// @ingroup GeometrySetters Attributes
9879 ///
9880 /// @param[in] session
9881 /// The session of Houdini you are interacting with.
9882 /// See @ref HAPI_Sessions for more on sessions.
9883 /// Pass NULL to just use the default in-process session.
9884 /// <!-- default NULL -->
9885 ///
9886 /// @param[in] node_id
9887 /// The SOP node id.
9888 ///
9889 /// @param[in] part_id
9890 /// Currently not used. Just pass 0.
9891 ///
9892 /// @param[in] name
9893 /// Attribute name.
9894 ///
9895 /// @param[in] attr_info
9896 /// ::HAPI_AttributeInfo used as input for what tuple size.
9897 /// you want. Also contains some sanity checks like
9898 /// data type. Generally should be the same struct
9899 /// returned by ::HAPI_GetAttributeInfo().
9900 ///
9901 /// @param[in] data_array
9902 /// A integer array at least the size of
9903 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9904 ///
9905 /// @param[in] data_length
9906 /// An integer of at least the size of
9907 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9908 ///
9909 /// @param[in] start_index
9910 /// First index of range. Must be at least 0 and at
9911 /// most ::HAPI_AttributeInfo::count - 1.
9912 /// <!-- default 0 -->
9913 ///
9914 /// @param[in] num_indices
9915 /// Must be at least 0 and at most
9916 /// ::HAPI_AttributeInfo::count - @p start_index.
9917 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9918 ///
9919 /// @param[out] job_id
9920 /// The id assigned to the job.
9921 ///
9923  const HAPI_Session* session,
9924  HAPI_NodeId node_id,
9925  HAPI_PartId part_id,
9926  const char* name,
9927  const HAPI_AttributeInfo* attr_info,
9928  const HAPI_Int16* data_array,
9929  int data_length,
9930  int start_index,
9931  int num_indices,
9932  int * job_id );
9933 
9934 /// @brief Set multiple attribute 64-bit int data to the same unique value
9935 /// asynchronously.
9936 ///
9937 /// @ingroup GeometrySetters Attributes
9938 ///
9939 /// @param[in] session
9940 /// The session of Houdini you are interacting with.
9941 /// See @ref HAPI_Sessions for more on sessions.
9942 /// Pass NULL to just use the default in-process session.
9943 /// <!-- default NULL -->
9944 ///
9945 /// @param[in] node_id
9946 /// The SOP node id.
9947 ///
9948 /// @param[in] part_id
9949 /// Currently not used. Just pass 0.
9950 ///
9951 /// @param[in] name
9952 /// Attribute name.
9953 ///
9954 /// @param[in] attr_info
9955 /// ::HAPI_AttributeInfo used as input for what tuple size.
9956 /// you want. Also contains some sanity checks like
9957 /// data type. Generally should be the same struct
9958 /// returned by ::HAPI_GetAttributeInfo().
9959 ///
9960 /// @param[in] data_array
9961 /// A integer array at least the size of
9962 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9963 ///
9964 /// @param[in] data_length
9965 /// An integer of at least the size of
9966 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
9967 ///
9968 /// @param[in] start_index
9969 /// First index of range. Must be at least 0 and at
9970 /// most ::HAPI_AttributeInfo::count - 1.
9971 /// <!-- default 0 -->
9972 ///
9973 /// @param[in] num_indices
9974 /// Must be at least 0 and at most
9975 /// ::HAPI_AttributeInfo::count - @p start_index.
9976 /// <!-- source ::HAPI_AttributeInfo::count - start -->
9977 ///
9978 /// @param[out] job_id
9979 /// The id assigned to the job.
9980 ///
9982  const HAPI_Session* session,
9983  HAPI_NodeId node_id,
9984  HAPI_PartId part_id,
9985  const char* name,
9986  const HAPI_AttributeInfo* attr_info,
9987  const HAPI_Int64* data_array,
9988  int data_length,
9989  int start_index,
9990  int num_indices,
9991  int * job_id );
9992 
9993 /// @brief Set multiple attribute float data to the same unique value
9994 /// asynchronously.
9995 ///
9996 /// @ingroup GeometrySetters Attributes
9997 ///
9998 /// @param[in] session
9999 /// The session of Houdini you are interacting with.
10000 /// See @ref HAPI_Sessions for more on sessions.
10001 /// Pass NULL to just use the default in-process session.
10002 /// <!-- default NULL -->
10003 ///
10004 /// @param[in] node_id
10005 /// The SOP node id.
10006 ///
10007 /// @param[in] part_id
10008 /// Currently not used. Just pass 0.
10009 ///
10010 /// @param[in] name
10011 /// Attribute name.
10012 ///
10013 /// @param[in] attr_info
10014 /// ::HAPI_AttributeInfo used as input for what tuple size.
10015 /// you want. Also contains some sanity checks like
10016 /// data type. Generally should be the same struct
10017 /// returned by ::HAPI_GetAttributeInfo().
10018 ///
10019 /// @param[in] data_array
10020 /// A floating point array at least the size of
10021 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10022 ///
10023 /// @param[in] data_length
10024 /// An integer of at least the size of
10025 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10026 ///
10027 /// @param[in] start_index
10028 /// First index of range. Must be at least 0 and at
10029 /// most ::HAPI_AttributeInfo::count - 1.
10030 /// <!-- default 0 -->
10031 ///
10032 /// @param[in] num_indices
10033 /// Must be at least 0 and at most
10034 /// ::HAPI_AttributeInfo::count - @p start_index.
10035 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10036 ///
10037 /// @param[out] job_id
10038 /// The id assigned to the job.
10039 ///
10041  const HAPI_Session* session,
10042  HAPI_NodeId node_id,
10043  HAPI_PartId part_id,
10044  const char* name,
10045  const HAPI_AttributeInfo* attr_info,
10046  const float* data_array,
10047  int data_length,
10048  int start_index,
10049  int num_indices,
10050  int * job_id );
10051 
10052 /// @brief Set multiple attribute 64-bit float data to the same unique
10053 /// asynchronously.
10054 ///
10055 /// @ingroup GeometrySetters Attributes
10056 ///
10057 /// @param[in] session
10058 /// The session of Houdini you are interacting with.
10059 /// See @ref HAPI_Sessions for more on sessions.
10060 /// Pass NULL to just use the default in-process session.
10061 /// <!-- default NULL -->
10062 ///
10063 /// @param[in] node_id
10064 /// The SOP node id.
10065 ///
10066 /// @param[in] part_id
10067 /// Currently not used. Just pass 0.
10068 ///
10069 /// @param[in] name
10070 /// Attribute name.
10071 ///
10072 /// @param[in] attr_info
10073 /// ::HAPI_AttributeInfo used as input for what tuple size.
10074 /// you want. Also contains some sanity checks like
10075 /// data type. Generally should be the same struct
10076 /// returned by ::HAPI_GetAttributeInfo().
10077 ///
10078 /// @param[in] data_array
10079 /// A floating point array at least the size of
10080 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10081 ///
10082 /// @param[in] data_length
10083 /// An integer of at least the size of
10084 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
10085 ///
10086 /// @param[in] start_index
10087 /// First index of range. Must be at least 0 and at
10088 /// most ::HAPI_AttributeInfo::count - 1.
10089 /// <!-- default 0 -->
10090 ///
10091 /// @param[in] num_indices
10092 /// Must be at least 0 and at most
10093 /// ::HAPI_AttributeInfo::count - @p start_index.
10094 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10095 ///
10096 /// @param[out] job_id
10097 /// The id assigned to the job.
10098 ///
10100  const HAPI_Session* session,
10101  HAPI_NodeId node_id,
10102  HAPI_PartId part_id,
10103  const char* name,
10104  const HAPI_AttributeInfo* attr_info,
10105  const double* data_array,
10106  int data_length,
10107  int start_index,
10108  int num_indices,
10109  int * job_id );
10110 
10111 /// @brief Set attribute dictionary data asynchronously. The dictionary data
10112 /// should be provided as JSON-encoded strings.
10113 ///
10114 /// @ingroup GeometrySetters Attributes
10115 ///
10116 /// @param[in] session
10117 /// The session of Houdini you are interacting with.
10118 /// See @ref HAPI_Sessions for more on sessions.
10119 /// Pass NULL to just use the default in-process session.
10120 /// <!-- default NULL -->
10121 ///
10122 /// @param[in] node_id
10123 /// The SOP node id.
10124 ///
10125 /// @param[in] part_id
10126 /// Currently not used. Just pass 0.
10127 ///
10128 /// @param[in] name
10129 /// Attribute name.
10130 ///
10131 /// @param[in] attr_info
10132 /// ::HAPI_AttributeInfo used as input for what tuple size
10133 /// you want. Also contains some sanity checks like
10134 /// data type. Generally should be the same struct
10135 /// returned by ::HAPI_GetAttributeInfo().
10136 ///
10137 /// @param[in] data_array
10138 /// An ::HAPI_StringHandle array at least the size of
10139 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
10140 ///
10141 /// @param[in] start
10142 /// First index of range. Must be at least 0 and at
10143 /// most ::HAPI_AttributeInfo::count - 1.
10144 /// <!-- default 0 -->
10145 ///
10146 /// @param[in] length
10147 /// Must be at least 0 and at most
10148 /// ::HAPI_AttributeInfo::count - @p start.
10149 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10150 ///
10151 /// @param[out] job_id
10152 /// The id assigned to the job.
10153 ///
10155  const HAPI_Session* session,
10156  HAPI_NodeId node_id,
10157  HAPI_PartId part_id,
10158  const char* name,
10159  const HAPI_AttributeInfo* attr_info,
10160  const char** data_array,
10161  int start, int length,
10162  int * job_id );
10163 
10164 /// @brief Set integer array attribute data asynchronously.
10165 ///
10166 /// @ingroup GeometrySetters Attributes
10167 ///
10168 /// @param[in] session
10169 /// The session of Houdini you are interacting with.
10170 /// See @ref HAPI_Sessions for more on sessions.
10171 /// Pass NULL to just use the default in-process session.
10172 /// <!-- default NULL -->
10173 ///
10174 /// @param[in] node_id
10175 /// The SOP node id.
10176 ///
10177 /// @param[in] part_id
10178 /// Currently not used. Just pass 0.
10179 ///
10180 /// @param[in] name
10181 /// Attribute name.
10182 ///
10183 /// @param[in] attr_info
10184 /// ::HAPI_AttributeInfo that contains the description for the
10185 /// attribute that is being set.
10186 ///
10187 /// @param[in] data_fixed_array
10188 /// An array containing the int values of the attribute.
10189 ///
10190 /// @param[in] data_fixed_length
10191 /// The total size of the data array. The size can be no greater
10192 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10193 /// of the attribute.
10194 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10195 ///
10196 /// @param[in] sizes_fixed_array
10197 /// An array of integers that contains the sizes of each
10198 /// attribute array. This is required because the attribute
10199 /// array for each geometry component can be of variable size.
10200 ///
10201 /// @param[in] start
10202 /// First index of range. Must be at least 0 and at most
10203 /// ::HAPI_AttributeInfo::count - 1.
10204 /// <!-- default 0 -->
10205 ///
10206 /// @param[in] sizes_fixed_length
10207 /// Must be at least 0 and at most
10208 /// ::HAPI_AttributeInfo::count - @p start.
10209 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10210 ///
10211 /// @param[out] job_id
10212 /// The id assigned to the job.
10213 ///
10215  const HAPI_Session * session,
10216  HAPI_NodeId node_id,
10217  HAPI_PartId part_id,
10218  const char * name,
10219  const HAPI_AttributeInfo * attr_info,
10220  const int * data_fixed_array,
10221  int data_fixed_length,
10222  const int * sizes_fixed_array,
10223  int start,
10224  int sizes_fixed_length,
10225  int * job_id );
10226 
10227 /// @brief Set unsigned 8-bit integer array attribute data asynchronously.
10228 ///
10229 /// @ingroup GeometrySetters Attributes
10230 ///
10231 /// @param[in] session
10232 /// The session of Houdini you are interacting with.
10233 /// See @ref HAPI_Sessions for more on sessions.
10234 /// Pass NULL to just use the default in-process session.
10235 /// <!-- default NULL -->
10236 ///
10237 /// @param[in] node_id
10238 /// The SOP node id.
10239 ///
10240 /// @param[in] part_id
10241 /// Currently not used. Just pass 0.
10242 ///
10243 /// @param[in] name
10244 /// Attribute name.
10245 ///
10246 /// @param[in] attr_info
10247 /// ::HAPI_AttributeInfo that contains the description for the
10248 /// attribute that is being set.
10249 ///
10250 /// @param[in] data_fixed_array
10251 /// An array containing the HAPI_UInt8 values of the attribute.
10252 ///
10253 /// @param[in] data_fixed_length
10254 /// The total size of the data array. The size can be no greater
10255 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10256 /// of the attribute.
10257 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10258 ///
10259 /// @param[in] sizes_fixed_array
10260 /// An array of integers that contains the sizes of each
10261 /// attribute array. This is required because the attribute
10262 /// array for each geometry component can be of variable size.
10263 ///
10264 /// @param[in] start
10265 /// First index of range. Must be at least 0 and at most
10266 /// ::HAPI_AttributeInfo::count - 1.
10267 /// <!-- default 0 -->
10268 ///
10269 /// @param[in] sizes_fixed_length
10270 /// Must be at least 0 and at most
10271 /// ::HAPI_AttributeInfo::count - @p start.
10272 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10273 ///
10274 /// @param[out] job_id
10275 /// The id assigned to the job.
10276 ///
10278  const HAPI_Session * session,
10279  HAPI_NodeId node_id,
10280  HAPI_PartId part_id,
10281  const char * name,
10282  const HAPI_AttributeInfo * attr_info,
10283  const HAPI_UInt8 * data_fixed_array,
10284  int data_fixed_length,
10285  const int * sizes_fixed_array,
10286  int start,
10287  int sizes_fixed_length,
10288  int * job_id );
10289 
10290 /// @brief Set 8-bit integer array attribute data asynchronously.
10291 ///
10292 /// @ingroup GeometrySetters Attributes
10293 ///
10294 /// @param[in] session
10295 /// The session of Houdini you are interacting with.
10296 /// See @ref HAPI_Sessions for more on sessions.
10297 /// Pass NULL to just use the default in-process session.
10298 /// <!-- default NULL -->
10299 ///
10300 /// @param[in] node_id
10301 /// The SOP node id.
10302 ///
10303 /// @param[in] part_id
10304 /// Currently not used. Just pass 0.
10305 ///
10306 /// @param[in] name
10307 /// Attribute name.
10308 ///
10309 /// @param[in] attr_info
10310 /// ::HAPI_AttributeInfo that contains the description for the
10311 /// attribute that is being set.
10312 ///
10313 /// @param[in] data_fixed_array
10314 /// An array containing the HAPI_Int8 values of the attribute.
10315 ///
10316 /// @param[in] data_fixed_length
10317 /// The total size of the data array. The size can be no greater
10318 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10319 /// of the attribute.
10320 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10321 ///
10322 /// @param[in] sizes_fixed_array
10323 /// An array of integers that contains the sizes of each
10324 /// attribute array. This is required because the attribute
10325 /// array for each geometry component can be of variable size.
10326 ///
10327 /// @param[in] start
10328 /// First index of range. Must be at least 0 and at most
10329 /// ::HAPI_AttributeInfo::count - 1.
10330 /// <!-- default 0 -->
10331 ///
10332 /// @param[in] sizes_fixed_length
10333 /// Must be at least 0 and at most
10334 /// ::HAPI_AttributeInfo::count - @p start.
10335 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10336 ///
10337 /// @param[out] job_id
10338 /// The id assigned to the job.
10339 ///
10341  const HAPI_Session * session,
10342  HAPI_NodeId node_id,
10343  HAPI_PartId part_id,
10344  const char * name,
10345  const HAPI_AttributeInfo * attr_info,
10346  const HAPI_Int8 * data_fixed_array,
10347  int data_fixed_length,
10348  const int * sizes_fixed_array,
10349  int start,
10350  int sizes_fixed_length,
10351  int * job_id );
10352 
10353 /// @brief Set 16-bit integer array attribute data asynchronously.
10354 ///
10355 /// @ingroup GeometrySetters Attributes
10356 ///
10357 /// @param[in] session
10358 /// The session of Houdini you are interacting with.
10359 /// See @ref HAPI_Sessions for more on sessions.
10360 /// Pass NULL to just use the default in-process session.
10361 /// <!-- default NULL -->
10362 ///
10363 /// @param[in] node_id
10364 /// The SOP node id.
10365 ///
10366 /// @param[in] part_id
10367 /// Currently not used. Just pass 0.
10368 ///
10369 /// @param[in] name
10370 /// Attribute name.
10371 ///
10372 /// @param[in] attr_info
10373 /// ::HAPI_AttributeInfo that contains the description for the
10374 /// attribute that is being set.
10375 ///
10376 /// @param[in] data_fixed_array
10377 /// An array containing the HAPI_Int16 values of the attribute.
10378 ///
10379 /// @param[in] data_fixed_length
10380 /// The total size of the data array. The size can be no greater
10381 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10382 /// of the attribute.
10383 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10384 ///
10385 /// @param[in] sizes_fixed_array
10386 /// An array of integers that contains the sizes of each
10387 /// attribute array. This is required because the attribute
10388 /// array for each geometry component can be of variable size.
10389 ///
10390 /// @param[in] start
10391 /// First index of range. Must be at least 0 and at most
10392 /// ::HAPI_AttributeInfo::count - 1.
10393 /// <!-- default 0 -->
10394 ///
10395 /// @param[in] sizes_fixed_length
10396 /// Must be at least 0 and at most
10397 /// ::HAPI_AttributeInfo::count - @p start.
10398 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10399 ///
10400 /// @param[out] job_id
10401 /// The id assigned to the job.
10402 ///
10404  const HAPI_Session * session,
10405  HAPI_NodeId node_id,
10406  HAPI_PartId part_id,
10407  const char * name,
10408  const HAPI_AttributeInfo * attr_info,
10409  const HAPI_Int16 * data_fixed_array,
10410  int data_fixed_length,
10411  const int * sizes_fixed_array,
10412  int start,
10413  int sizes_fixed_length,
10414  int * job_id );
10415 
10416 /// @brief Set 64-bit integer array attribute data asynchronously.
10417 ///
10418 /// @ingroup GeometrySetters Attributes
10419 ///
10420 /// @param[in] session
10421 /// The session of Houdini you are interacting with.
10422 /// See @ref HAPI_Sessions for more on sessions.
10423 /// Pass NULL to just use the default in-process session.
10424 /// <!-- default NULL -->
10425 ///
10426 /// @param[in] node_id
10427 /// The SOP node id.
10428 ///
10429 /// @param[in] part_id
10430 /// Currently not used. Just pass 0.
10431 ///
10432 /// @param[in] name
10433 /// Attribute name.
10434 ///
10435 /// @param[in] attr_info
10436 /// ::HAPI_AttributeInfo that contains the description for the
10437 /// attribute that is being set.
10438 ///
10439 /// @param[in] data_fixed_array
10440 /// An array containing the HAPI_Int64 values of the attribute.
10441 ///
10442 /// @param[in] data_fixed_length
10443 /// The total size of the data array. The size can be no greater
10444 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10445 /// of the attribute.
10446 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10447 ///
10448 /// @param[in] sizes_fixed_array
10449 /// An array of integers that contains the sizes of each
10450 /// attribute array. This is required because the attribute
10451 /// array for each geometry component can be of variable size.
10452 ///
10453 /// @param[in] start
10454 /// First index of range. Must be at least 0 and at most
10455 /// ::HAPI_AttributeInfo::count - 1.
10456 /// <!-- default 0 -->
10457 ///
10458 /// @param[in] sizes_fixed_length
10459 /// Must be at least 0 and at most
10460 /// ::HAPI_AttributeInfo::count - @p start.
10461 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10462 ///
10463 /// @param[out] job_id
10464 /// The id assigned to the job.
10465 ///
10467  const HAPI_Session * session,
10468  HAPI_NodeId node_id,
10469  HAPI_PartId part_id,
10470  const char * name,
10471  const HAPI_AttributeInfo * attr_info,
10472  const HAPI_Int64 * data_fixed_array,
10473  int data_fixed_length,
10474  const int * sizes_fixed_array,
10475  int start,
10476  int sizes_fixed_length,
10477  int * job_id );
10478 
10479 /// @brief Set float array attribute data asynchronously.
10480 ///
10481 /// @ingroup GeometrySetters Attributes
10482 ///
10483 /// @param[in] session
10484 /// The session of Houdini you are interacting with.
10485 /// See @ref HAPI_Sessions for more on sessions.
10486 /// Pass NULL to just use the default in-process session.
10487 /// <!-- default NULL -->
10488 ///
10489 /// @param[in] node_id
10490 /// The SOP node id.
10491 ///
10492 /// @param[in] part_id
10493 /// Currently not used. Just pass 0.
10494 ///
10495 /// @param[in] name
10496 /// Attribute name.
10497 ///
10498 /// @param[in] attr_info
10499 /// ::HAPI_AttributeInfo that contains the description for the
10500 /// attribute that is being set.
10501 ///
10502 /// @param[in] data_fixed_array
10503 /// An array containing the float values of the attribute.
10504 ///
10505 /// @param[in] data_fixed_length
10506 /// The total size of the data array. The size can be no greater
10507 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10508 /// of the attribute.
10509 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10510 ///
10511 /// @param[in] sizes_fixed_array
10512 /// An array of integers that contains the sizes of each
10513 /// attribute array. This is required because the attribute
10514 /// array for each geometry component can be of variable size.
10515 ///
10516 /// @param[in] start
10517 /// First index of range. Must be at least 0 and at most
10518 /// ::HAPI_AttributeInfo::count - 1.
10519 /// <!-- default 0 -->
10520 ///
10521 /// @param[in] sizes_fixed_length
10522 /// Must be at least 0 and at most
10523 /// ::HAPI_AttributeInfo::count - @p start.
10524 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10525 ///
10526 /// @param[out] job_id
10527 /// The id assigned to the job.
10528 ///
10530  const HAPI_Session * session,
10531  HAPI_NodeId node_id,
10532  HAPI_PartId part_id,
10533  const char * name,
10534  const HAPI_AttributeInfo * attr_info,
10535  const float * data_fixed_array,
10536  int data_fixed_length,
10537  const int * sizes_fixed_array,
10538  int start,
10539  int sizes_fixed_length,
10540  int * job_id );
10541 
10542 /// @brief Set 64-bit float array attribute data asynchronously.
10543 ///
10544 /// @ingroup GeometrySetters Attributes
10545 ///
10546 /// @param[in] session
10547 /// The session of Houdini you are interacting with.
10548 /// See @ref HAPI_Sessions for more on sessions.
10549 /// Pass NULL to just use the default in-process session.
10550 /// <!-- default NULL -->
10551 ///
10552 /// @param[in] node_id
10553 /// The SOP node id.
10554 ///
10555 /// @param[in] part_id
10556 /// Currently not used. Just pass 0.
10557 ///
10558 /// @param[in] name
10559 /// Attribute name.
10560 ///
10561 /// @param[in] attr_info
10562 /// ::HAPI_AttributeInfo that contains the description for the
10563 /// attribute that is being set.
10564 ///
10565 /// @param[in] data_fixed_array
10566 /// An array containing the double values of the attribute.
10567 ///
10568 /// @param[in] data_fixed_length
10569 /// The total size of the data array. The size can be no greater
10570 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10571 /// of the attribute.
10572 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10573 ///
10574 /// @param[in] sizes_fixed_array
10575 /// An array of integers that contains the sizes of each
10576 /// attribute array. This is required because the attribute
10577 /// array for each geometry component can be of variable size.
10578 ///
10579 /// @param[in] start
10580 /// First index of range. Must be at least 0 and at most
10581 /// ::HAPI_AttributeInfo::count - 1.
10582 /// <!-- default 0 -->
10583 ///
10584 /// @param[in] sizes_fixed_length
10585 /// Must be at least 0 and at most
10586 /// ::HAPI_AttributeInfo::count - @p start.
10587 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10588 ///
10589 /// @param[out] job_id
10590 /// The id assigned to the job.
10591 ///
10593  const HAPI_Session * session,
10594  HAPI_NodeId node_id,
10595  HAPI_PartId part_id,
10596  const char * name,
10597  const HAPI_AttributeInfo * attr_info,
10598  const double * data_fixed_array,
10599  int data_fixed_length,
10600  const int * sizes_fixed_array,
10601  int start,
10602  int sizes_fixed_length,
10603  int * job_id );
10604 
10605 /// @brief Set string array attribute data asynchronously.
10606 ///
10607 /// @ingroup GeometrySetters Attributes
10608 ///
10609 /// @param[in] session
10610 /// The session of Houdini you are interacting with.
10611 /// See @ref HAPI_Sessions for more on sessions.
10612 /// Pass NULL to just use the default in-process session.
10613 /// <!-- default NULL -->
10614 ///
10615 /// @param[in] node_id
10616 /// The SOP node id.
10617 ///
10618 /// @param[in] part_id
10619 /// Currently not used. Just pass 0.
10620 ///
10621 /// @param[in] name
10622 /// Attribute name.
10623 ///
10624 /// @param[in] attr_info
10625 /// ::HAPI_AttributeInfo that contains the description for the
10626 /// attribute that is being set.
10627 ///
10628 /// @param[in] data_fixed_array
10629 /// An array containing the string values of the attribute.
10630 ///
10631 /// @param[in] data_fixed_length
10632 /// The total size of the data array. The size can be no greater
10633 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10634 /// of the attribute.
10635 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10636 ///
10637 /// @param[in] sizes_fixed_array
10638 /// An array of integers that contains the sizes of each
10639 /// attribute array. This is required because the attribute
10640 /// array for each geometry component can be of variable size.
10641 ///
10642 /// @param[in] start
10643 /// First index of range. Must be at least 0 and at most
10644 /// ::HAPI_AttributeInfo::count - 1.
10645 /// <!-- default 0 -->
10646 ///
10647 /// @param[in] sizes_fixed_length
10648 /// Must be at least 0 and at most
10649 /// ::HAPI_AttributeInfo::count - @p start.
10650 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10651 ///
10652 /// @param[out] job_id
10653 /// The id assigned to the job.
10654 ///
10656  const HAPI_Session * session,
10657  HAPI_NodeId node_id,
10658  HAPI_PartId part_id,
10659  const char * name,
10660  const HAPI_AttributeInfo * attr_info,
10661  const char ** data_fixed_array,
10662  int data_fixed_length,
10663  const int * sizes_fixed_array,
10664  int start,
10665  int sizes_fixed_length,
10666  int * job_id );
10667 
10668 /// @brief Set attribute dictionary array data asynchronously. The dictionary
10669 /// should be provided as JSON-encoded strings.
10670 ///
10671 /// @ingroup GeometrySetters Attributes
10672 ///
10673 /// @param[in] session
10674 /// The session of Houdini you are interacting with.
10675 /// See @ref HAPI_Sessions for more on sessions.
10676 /// Pass NULL to just use the default in-process session.
10677 /// <!-- default NULL -->
10678 ///
10679 /// @param[in] node_id
10680 /// The SOP node id.
10681 ///
10682 /// @param[in] part_id
10683 /// Currently not used. Just pass 0.
10684 ///
10685 /// @param[in] name
10686 /// Attribute name.
10687 ///
10688 /// @param[in] attr_info
10689 /// ::HAPI_AttributeInfo that contains the description for the
10690 /// attribute that is being set.
10691 ///
10692 /// @param[in] data_fixed_array
10693 /// An array containing the dictionary values of the attribute.
10694 ///
10695 /// @param[in] data_fixed_length
10696 /// The total size of the data array. The size can be no greater
10697 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
10698 /// of the attribute.
10699 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
10700 ///
10701 /// @param[in] sizes_fixed_array
10702 /// An array of integers that contains the sizes of each
10703 /// attribute array. This is required because the attribute
10704 /// array for each geometry component can be of variable size.
10705 ///
10706 /// @param[in] start
10707 /// First index of range. Must be at least 0 and at most
10708 /// ::HAPI_AttributeInfo::count - 1.
10709 /// <!-- default 0 -->
10710 ///
10711 /// @param[in] sizes_fixed_length
10712 /// Must be at least 0 and at most
10713 /// ::HAPI_AttributeInfo::count - @p start.
10714 /// <!-- source ::HAPI_AttributeInfo::count - start -->
10715 ///
10716 /// @param[out] job_id
10717 /// The id assigned to the job.
10718 ///
10720  const HAPI_Session * session,
10721  HAPI_NodeId node_id,
10722  HAPI_PartId part_id,
10723  const char * name,
10724  const HAPI_AttributeInfo * attr_info,
10725  const char ** data_fixed_array,
10726  int data_fixed_length,
10727  const int * sizes_fixed_array,
10728  int start,
10729  int sizes_fixed_length,
10730  int * job_id );
10731 
10732 /// @brief Add a group to the input geo with the given type and name.
10733 ///
10734 /// @ingroup GeometrySetters
10735 ///
10736 /// @param[in] session
10737 /// The session of Houdini you are interacting with.
10738 /// See @ref HAPI_Sessions for more on sessions.
10739 /// Pass NULL to just use the default in-process session.
10740 /// <!-- default NULL -->
10741 ///
10742 /// @param[in] node_id
10743 /// The SOP node id.
10744 ///
10745 /// @param[in] part_id
10746 /// Currently not used. Just pass 0.
10747 ///
10748 /// @param[in] group_type
10749 /// The group type.
10750 ///
10751 /// @param[in] group_name
10752 /// Name of new group to be added.
10753 ///
10754 HAPI_DECL HAPI_AddGroup( const HAPI_Session * session,
10755  HAPI_NodeId node_id,
10756  HAPI_PartId part_id,
10757  HAPI_GroupType group_type,
10758  const char * group_name );
10759 
10760 /// @brief Remove a group from the input geo with the given type and name.
10761 ///
10762 /// @ingroup GeometrySetters
10763 ///
10764 /// @param[in] session
10765 /// The session of Houdini you are interacting with.
10766 /// See @ref HAPI_Sessions for more on sessions.
10767 /// Pass NULL to just use the default in-process session.
10768 /// <!-- default NULL -->
10769 ///
10770 /// @param[in] node_id
10771 /// The SOP node id.
10772 ///
10773 /// @param[in] part_id
10774 /// Currently not used. Just pass 0.
10775 ///
10776 /// @param[in] group_type
10777 /// The group type.
10778 ///
10779 /// @param[in] group_name
10780 /// Name of the group to be removed
10781 ///
10782 HAPI_DECL HAPI_DeleteGroup( const HAPI_Session * session,
10783  HAPI_NodeId node_id,
10784  HAPI_PartId part_id,
10785  HAPI_GroupType group_type,
10786  const char * group_name );
10787 
10788 /// @brief Set group membership.
10789 ///
10790 /// @ingroup GeometrySetters
10791 ///
10792 /// @param[in] session
10793 /// The session of Houdini you are interacting with.
10794 /// See @ref HAPI_Sessions for more on sessions.
10795 /// Pass NULL to just use the default in-process session.
10796 /// <!-- default NULL -->
10797 ///
10798 /// @param[in] node_id
10799 /// The SOP node id.
10800 ///
10801 /// @param[in] part_id
10802 /// Currently not used. Just pass 0.
10803 /// <!-- default 0 -->
10804 ///
10805 /// @param[in] group_type
10806 /// The group type.
10807 ///
10808 /// @param[in] group_name
10809 /// The group name.
10810 ///
10811 /// @param[in] membership_array
10812 /// Array of ints that represent the membership of this
10813 /// group. Should be the size given by
10814 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
10815 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
10816 ///
10817 /// @param[in] start
10818 /// Start offset into the membership array. Must be
10819 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
10820 /// <!-- default 0 -->
10821 ///
10822 /// @param[in] length
10823 /// Should be less than or equal to the size
10824 /// of @p membership_array. When setting edge group membership,
10825 /// this parameter should be set to the number of points (which
10826 /// are used to implictly define the edges), not to the number
10827 /// edges in the group.
10828 /// <!-- source ::HAPI_PartInfo_GetElementCountByGroupType -->
10829 ///
10831  HAPI_NodeId node_id,
10832  HAPI_PartId part_id,
10833  HAPI_GroupType group_type,
10834  const char * group_name,
10835  const int * membership_array,
10836  int start, int length );
10837 
10838 /// @brief Commit the current input geometry to the cook engine. Nodes
10839 /// that use this geometry node will re-cook using the input
10840 /// geometry given through the geometry setter API calls.
10841 ///
10842 /// @ingroup GeometrySetters
10843 ///
10844 /// @param[in] session
10845 /// The session of Houdini you are interacting with.
10846 /// See @ref HAPI_Sessions for more on sessions.
10847 /// Pass NULL to just use the default in-process session.
10848 /// <!-- default NULL -->
10849 ///
10850 /// @param[in] node_id
10851 /// The SOP node id.
10852 ///
10853 HAPI_DECL HAPI_CommitGeo( const HAPI_Session * session,
10854  HAPI_NodeId node_id );
10855 
10856 /// @brief Remove all changes that have been committed to this
10857 /// geometry. If this is an intermediate result node (Edit SOP), all
10858 /// deltas will be removed. If it's any other type of node, the node
10859 /// will be unlocked if it is locked.
10860 ///
10861 /// @ingroup GeometrySetters
10862 ///
10863 /// @param[in] session
10864 /// The session of Houdini you are interacting with.
10865 /// See @ref HAPI_Sessions for more on sessions.
10866 /// Pass NULL to just use the default in-process session.
10867 /// <!-- default NULL -->
10868 ///
10869 /// @param[in] node_id
10870 /// The SOP node id.
10871 ///
10872 HAPI_DECL HAPI_RevertGeo( const HAPI_Session * session,
10873  HAPI_NodeId node_id );
10874 
10875 /// @defgroup Materials
10876 /// Functions for working with materials
10877 
10878 /// @brief Get material ids by face/primitive. The material ids returned
10879 /// will be valid as long as the asset is alive. You should query
10880 /// this list after every cook to see if the material assignments
10881 /// have changed. You should also query each material individually
10882 /// using ::HAPI_GetMaterialInfo() to see if it is dirty and needs
10883 /// to be re-imported.
10884 ///
10885 /// @ingroup Materials
10886 ///
10887 /// @param[in] session
10888 /// The session of Houdini you are interacting with.
10889 /// See @ref HAPI_Sessions for more on sessions.
10890 /// Pass NULL to just use the default in-process session.
10891 /// <!-- default NULL -->
10892 ///
10893 /// @param[in] geometry_node_id
10894 /// The geometry node id.
10895 ///
10896 /// @param[in] part_id
10897 /// The part id.
10898 ///
10899 /// @param[out] are_all_the_same
10900 /// (optional) If true, all faces on this part have the
10901 /// same material assignment. You can pass NULL here.
10902 ///
10903 /// @param[out] material_ids_array
10904 /// An array of ::HAPI_NodeId at least the size of
10905 /// @p length and at most the size of
10906 /// ::HAPI_PartInfo::faceCount.
10907 ///
10908 /// @param[in] start
10909 /// The starting index into the list of faces from which
10910 /// you wish to get the material ids from. Note that
10911 /// this should be less than ::HAPI_PartInfo::faceCount.
10912 /// <!-- default 0 -->
10913 ///
10914 /// @param[in] length
10915 /// The number of material ids you wish to get. Note that
10916 /// this should be at most:
10917 /// ::HAPI_PartInfo::faceCount - @p start.
10918 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
10919 ///
10921  HAPI_NodeId geometry_node_id,
10922  HAPI_PartId part_id,
10923  HAPI_Bool * are_all_the_same,
10924  HAPI_NodeId * material_ids_array,
10925  int start, int length );
10926 
10927 /// @brief Get the material info.
10928 ///
10929 /// @ingroup Materials
10930 ///
10931 /// @param[in] session
10932 /// The session of Houdini you are interacting with.
10933 /// See @ref HAPI_Sessions for more on sessions.
10934 /// Pass NULL to just use the default in-process session.
10935 /// <!-- default NULL -->
10936 ///
10937 /// @param[in] material_node_id
10938 /// The material node id.
10939 ///
10940 /// @param[out] material_info
10941 /// The returned material info.
10942 ///
10944  HAPI_NodeId material_node_id,
10945  HAPI_MaterialInfo * material_info );
10946 
10947 /// @brief Render a single texture from a COP to an image for
10948 /// later extraction.
10949 ///
10950 /// @ingroup Materials
10951 ///
10952 /// Note that you must call this method,
10953 /// ::HAPI_RenderCOPOutputToImage(), or ::HAPI_RenderTextureToImage()
10954 /// before any of the other material APIs.
10955 ///
10956 /// @param[in] session
10957 /// The session of Houdini you are interacting with.
10958 /// See @ref HAPI_Sessions for more on sessions.
10959 /// Pass NULL to just use the default in-process session.
10960 /// <!-- default NULL -->
10961 ///
10962 /// @param[in] cop_node_id
10963 /// The COP node id.
10964 ///
10966  HAPI_NodeId cop_node_id );
10967 
10968 /// @brief Render a single texture from a COP to an image for
10969 /// later extraction. COPs may have multiple outputs,
10970 /// so this method lets you select which output to use.
10971 ///
10972 /// @ingroup Materials
10973 ///
10974 /// Note that you must call this method,
10975 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderTextureToImage()
10976 /// before any of the other material APIs.
10977 ///
10978 /// @param[in] session
10979 /// The session of Houdini you are interacting with.
10980 /// See @ref HAPI_Sessions for more on sessions.
10981 /// Pass NULL to just use the default in-process session.
10982 /// <!-- default NULL -->
10983 ///
10984 /// @param[in] cop_node_id
10985 /// The COP node id.
10986 ///
10987 /// @param[in] cop_output_name
10988 /// The name of the output to extract. Passing in
10989 /// an empty string will default to the COP's first output.
10990 ///
10992  HAPI_NodeId cop_node_id,
10993  const char * cop_output_name );
10994 
10995 /// @brief Render only a single texture to an image for later extraction.
10996 /// An example use of this method might be to render the diffuse,
10997 /// normal, and bump texture maps of a material to individual
10998 /// texture files for use within the client application.
10999 ///
11000 /// Note that you must call this method,
11001 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11002 /// before any of the other material APIs.
11003 ///
11004 /// @ingroup Materials
11005 ///
11006 /// @param[in] session
11007 /// The session of Houdini you are interacting with.
11008 /// See @ref HAPI_Sessions for more on sessions.
11009 /// Pass NULL to just use the default in-process session.
11010 /// <!-- default NULL -->
11011 ///
11012 /// @param[in] material_node_id
11013 /// The material node id.
11014 ///
11015 /// @param[in] parm_id
11016 /// This is the index in the parameter list of the
11017 /// material_id's node of the parameter containing the
11018 /// texture map file path.
11019 ///
11021  HAPI_NodeId material_node_id,
11022  HAPI_ParmId parm_id );
11023 
11024 /// @brief Get information about the image that was just rendered, like
11025 /// resolution and default file format. This information will be
11026 /// used when extracting planes to an image.
11027 ///
11028 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11029 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11030 /// first for this method call to make sense.
11031 ///
11032 /// @ingroup Materials
11033 ///
11034 /// @param[in] session
11035 /// The session of Houdini you are interacting with.
11036 /// See @ref HAPI_Sessions for more on sessions.
11037 /// Pass NULL to just use the default in-process session.
11038 /// <!-- default NULL -->
11039 ///
11040 /// @param[in] material_node_id
11041 /// The material node id.
11042 ///
11043 /// @param[out] image_info
11044 /// The struct containing the image information.
11045 ///
11046 HAPI_DECL HAPI_GetImageInfo( const HAPI_Session * session,
11047  HAPI_NodeId material_node_id,
11048  HAPI_ImageInfo * image_info );
11049 
11050 /// @brief Set image information like resolution and file format.
11051 /// This information will be used when extracting planes to
11052 /// an image.
11053 ///
11054 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11055 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11056 /// first for this method call to make sense.
11057 ///
11058 /// You should also first call ::HAPI_GetImageInfo() to get the
11059 /// current Image Info and change only the properties
11060 /// you don't like.
11061 ///
11062 /// @ingroup Materials
11063 ///
11064 /// @param[in] session
11065 /// The session of Houdini you are interacting with.
11066 /// See @ref HAPI_Sessions for more on sessions.
11067 /// Pass NULL to just use the default in-process session.
11068 /// <!-- default NULL -->
11069 ///
11070 /// @param[in] material_node_id
11071 /// The material node id.
11072 ///
11073 /// @param[in] image_info
11074 /// The struct containing the new image information.
11075 ///
11076 HAPI_DECL HAPI_SetImageInfo( const HAPI_Session * session,
11077  HAPI_NodeId material_node_id,
11078  const HAPI_ImageInfo * image_info );
11079 
11080 /// @brief Get the number of image planes for the just rendered image.
11081 ///
11082 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11083 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11084 /// first for this method call to make sense.
11085 ///
11086 /// @ingroup Materials
11087 ///
11088 /// @param[in] session
11089 /// The session of Houdini you are interacting with.
11090 /// See @ref HAPI_Sessions for more on sessions.
11091 /// Pass NULL to just use the default in-process session.
11092 /// <!-- default NULL -->
11093 ///
11094 /// @param[in] material_node_id
11095 /// The material node id.
11096 ///
11097 /// @param[out] image_plane_count
11098 /// The number of image planes.
11099 ///
11101  HAPI_NodeId material_node_id,
11102  int * image_plane_count );
11103 
11104 /// @brief Get the names of the image planes of the just rendered image.
11105 ///
11106 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11107 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11108 /// first for this method call to make sense.
11109 ///
11110 /// You should also call ::HAPI_GetImagePlaneCount() first to get
11111 /// the total number of image planes so you know how large the
11112 /// image_planes string handle array should be.
11113 ///
11114 /// @ingroup Materials
11115 ///
11116 /// @param[in] session
11117 /// The session of Houdini you are interacting with.
11118 /// See @ref HAPI_Sessions for more on sessions.
11119 /// Pass NULL to just use the default in-process session.
11120 /// <!-- default NULL -->
11121 ///
11122 /// @param[in] material_node_id
11123 /// The material node id.
11124 ///
11125 /// @param[out] image_planes_array
11126 /// The image plane names.
11127 ///
11128 /// @param[in] image_plane_count
11129 /// The number of image planes to get names for. This
11130 /// must be less than or equal to the count returned
11131 /// by ::HAPI_GetImagePlaneCount().
11132 /// <!-- source ::HAPI_GetImagePlaneCount -->
11133 ///
11134 HAPI_DECL HAPI_GetImagePlanes( const HAPI_Session * session,
11135  HAPI_NodeId material_node_id,
11136  HAPI_StringHandle * image_planes_array,
11137  int image_plane_count );
11138 
11139 /// @brief Extract a rendered image to a file.
11140 ///
11141 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11142 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11143 /// first for this method call to make sense.
11144 ///
11145 /// @ingroup Materials
11146 ///
11147 /// @param[in] session
11148 /// The session of Houdini you are interacting with.
11149 /// See @ref HAPI_Sessions for more on sessions.
11150 /// Pass NULL to just use the default in-process session.
11151 /// <!-- default NULL -->
11152 ///
11153 /// @param[in] material_node_id
11154 /// The material node id.
11155 ///
11156 /// @param[in] image_file_format_name
11157 /// The image file format name you wish the image to be
11158 /// extracted as. You can leave this parameter NULL to
11159 /// get the image in the original format if it comes from
11160 /// another texture file or in the default HAPI format,
11161 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
11162 /// is generated.
11163 ///
11164 /// You can get some of the very common standard image
11165 /// file format names from HAPI_Common.h under the
11166 /// "Defines" section.
11167 ///
11168 /// You can also get a list of all supported file formats
11169 /// (and the exact names this parameter expects)
11170 /// by using ::HAPI_GetSupportedImageFileFormats(). This
11171 /// list will include custom file formats you created via
11172 /// custom DSOs (see HDK docs about IMG_Format). You will
11173 /// get back a list of ::HAPI_ImageFileFormat. This
11174 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
11175 /// of a given image file format.
11176 ///
11177 /// @param[in] image_planes
11178 /// The image planes you wish to extract into the file.
11179 /// Multiple image planes should be separated by spaces.
11180 ///
11181 /// @param[in] destination_folder_path
11182 /// The folder where the image file should be created.
11183 ///
11184 /// @param[in] destination_file_name
11185 /// Optional parameter to overwrite the name of the
11186 /// extracted texture file. This should NOT include
11187 /// the extension as the file type will be decided
11188 /// by the ::HAPI_ImageInfo you can set using
11189 /// ::HAPI_SetImageInfo(). You still have to use
11190 /// destination_file_path to get the final file path.
11191 ///
11192 /// Pass in NULL to have the file name be automatically
11193 /// generated from the name of the material SHOP node,
11194 /// the name of the texture map parameter if the
11195 /// image was rendered from a texture, and the image
11196 /// plane names specified.
11197 ///
11198 /// @param[out] destination_file_path
11199 /// The full path string handle, including the
11200 /// destination_folder_path and the texture file name,
11201 /// to the extracted file. Note that this string handle
11202 /// will only be valid until the next call to
11203 /// this function.
11204 ///
11206  HAPI_NodeId material_node_id,
11207  const char * image_file_format_name,
11208  const char * image_planes,
11209  const char * destination_folder_path,
11210  const char * destination_file_name,
11211  int * destination_file_path );
11212 /// @brief Get the file name that this image would be saved to
11213 ///
11214 /// Check to see what file path HAPI_ExtractImageToFile would have
11215 /// saved to given the same parms. Perhaps you might wish to see
11216 /// if it already exists before extracting.
11217 ///
11218 /// @ingroup Materials
11219 ///
11220 /// @param[in] session
11221 /// The session of Houdini you are interacting with.
11222 /// See @ref HAPI_Sessions for more on sessions.
11223 /// Pass NULL to just use the default in-process session.
11224 /// <!-- default NULL -->
11225 ///
11226 /// @param[in] material_node_id
11227 /// The material node id.
11228 ///
11229 /// @param[in] image_file_format_name
11230 /// The image file format name you wish the image to be
11231 /// extracted as. See HAPI_ExtractImageToFile for more information.
11232 ///
11233 /// @param[in] image_planes
11234 /// The image planes you wish to extract into the file.
11235 /// Multiple image planes should be separated by spaces.
11236 ///
11237 /// @param[in] destination_folder_path
11238 /// The folder where the image file sould be created.
11239 ///
11240 /// @param[in] destination_file_name
11241 /// Optional parameter to overwrite the name of the
11242 /// extracted texture file. See HAPI_ExtractImageToFile for more information.
11243 ///
11244 /// @param[in] texture_parm_id
11245 /// The index in the parameter list of the material node.
11246 /// of the parameter containing the texture map file path
11247 ///
11248 /// @param[out] destination_file_path
11249 /// The full path string handle, including the
11250 /// destination_folder_path and the texture file name,
11251 /// to the extracted file. Note that this string handle
11252 /// will only be valid until the next call to
11253 /// this function.
11254 ///
11256  HAPI_NodeId material_node_id,
11257  const char * image_file_format_name,
11258  const char * image_planes,
11259  const char * destination_folder_path,
11260  const char * destination_file_name,
11261  HAPI_ParmId texture_parm_id,
11262  int * destination_file_path );
11263 
11264 /// @brief Extract a rendered image to memory.
11265 ///
11266 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11267 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11268 /// first for this method call to make sense.
11269 ///
11270 /// Also note that this function will do all the work of
11271 /// extracting and compositing the image into a memory buffer
11272 /// but will not return to you that buffer, only its size. Use
11273 /// the returned size to allocated a sufficiently large buffer
11274 /// and call ::HAPI_GetImageMemoryBuffer() to fill your buffer
11275 /// with the just extracted image.
11276 ///
11277 /// @ingroup Materials
11278 ///
11279 /// @param[in] session
11280 /// The session of Houdini you are interacting with.
11281 /// See @ref HAPI_Sessions for more on sessions.
11282 /// Pass NULL to just use the default in-process session.
11283 /// <!-- default NULL -->
11284 ///
11285 /// @param[in] material_node_id
11286 /// The material node id.
11287 ///
11288 /// @param[in] image_file_format_name
11289 /// The image file format name you wish the image to be
11290 /// extracted as. You can leave this parameter NULL to
11291 /// get the image in the original format if it comes from
11292 /// another texture file or in the default HAPI format,
11293 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
11294 /// is generated.
11295 ///
11296 /// You can get some of the very common standard image
11297 /// file format names from HAPI_Common.h under the
11298 /// "Defines" section.
11299 ///
11300 /// You can also get a list of all supported file formats
11301 /// (and the exact names this parameter expects)
11302 /// by using ::HAPI_GetSupportedImageFileFormats(). This
11303 /// list will include custom file formats you created via
11304 /// custom DSOs (see HDK docs about IMG_Format). You will
11305 /// get back a list of ::HAPI_ImageFileFormat. This
11306 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
11307 /// of a given image file format.
11308 ///
11309 /// @param[in] image_planes
11310 /// The image planes you wish to extract into the file.
11311 /// Multiple image planes should be separated by spaces.
11312 ///
11313 /// @param[out] buffer_size
11314 /// The extraction will be done to an internal buffer
11315 /// who's size you get via this parameter. Use the
11316 /// returned buffer_size when calling
11317 /// ::HAPI_GetImageMemoryBuffer() to get the image
11318 /// buffer you just extracted.
11319 ///
11321  HAPI_NodeId material_node_id,
11322  const char * image_file_format_name,
11323  const char * image_planes,
11324  int * buffer_size );
11325 
11326 /// @brief Fill your allocated buffer with the just extracted
11327 /// image buffer.
11328 ///
11329 /// Note that you must call one of ::HAPI_RenderTextureToImage(),
11330 /// ::HAPI_RenderCOPToImage(), or ::HAPI_RenderCOPOutputToImage()
11331 /// first for this method call to make sense.
11332 ///
11333 /// Also note that you must call ::HAPI_ExtractImageToMemory()
11334 /// first in order to perform the extraction and get the
11335 /// extracted image buffer size that you need to know how much
11336 /// memory to allocated to fit your extracted image.
11337 ///
11338 /// @ingroup Materials
11339 ///
11340 /// @param[in] session
11341 /// The session of Houdini you are interacting with.
11342 /// See @ref HAPI_Sessions for more on sessions.
11343 /// Pass NULL to just use the default in-process session.
11344 /// <!-- default NULL -->
11345 ///
11346 /// @param[in] material_node_id
11347 /// The material node id.
11348 ///
11349 /// @param[out] buffer
11350 /// The buffer passed in here will be filled with the
11351 /// image buffer created during the call to
11352 /// ::HAPI_ExtractImageToMemory().
11353 ///
11354 /// @param[in] length
11355 /// Sanity check. This size should be the same as the
11356 /// size allocated for the buffer passed in and should
11357 /// be at least as large as the buffer_size returned by
11358 /// the call to ::HAPI_ExtractImageToMemory().
11359 /// <!-- source ::HAPI_ExtractImageToMemory -->
11360 ///
11362  HAPI_NodeId material_node_id,
11363  char * buffer, int length );
11364 
11365 /// @brief Get the number of supported texture file formats.
11366 ///
11367 /// @ingroup Materials
11368 ///
11369 /// @param[in] session
11370 /// The session of Houdini you are interacting with.
11371 /// See @ref HAPI_Sessions for more on sessions.
11372 /// Pass NULL to just use the default in-process session.
11373 /// <!-- default NULL -->
11374 ///
11375 /// @param[out] file_format_count
11376 /// The number of supported texture file formats.
11377 ///
11379  int * file_format_count );
11380 
11381 /// @brief Get a list of support image file formats - their names,
11382 /// descriptions and a list of recognized extensions.
11383 ///
11384 /// Note that you MUST call
11385 /// ::HAPI_GetSupportedImageFileFormatCount()
11386 /// before calling this function for the first time.
11387 ///
11388 /// @ingroup Materials
11389 ///
11390 /// @param[in] session
11391 /// The session of Houdini you are interacting with.
11392 /// See @ref HAPI_Sessions for more on sessions.
11393 /// Pass NULL to just use the default in-process session.
11394 /// <!-- default NULL -->
11395 ///
11396 /// @param[out] formats_array
11397 /// The list of ::HAPI_ImageFileFormat structs to
11398 /// be filled.
11399 ///
11400 /// @param[in] file_format_count
11401 /// The number of supported texture file formats. This
11402 /// should be at least as large as the count returned
11403 /// by ::HAPI_GetSupportedImageFileFormatCount().
11404 /// <!-- source ::HAPI_GetSupportedImageFileFormatCount -->
11405 ///
11407  const HAPI_Session * session,
11408  HAPI_ImageFileFormat * formats_array,
11409  int file_format_count );
11410 
11411 /// @brief Loads some raw image data into a COP node.
11412 ///
11413 /// This method expects the image data to be in linear color space.
11414 /// It will not do any color space conversions for you; the data
11415 /// must be converted beforehand.
11416 ///
11417 /// @ingroup Materials
11418 ///
11419 /// @param[in] session
11420 /// The session of Houdini you are interacting with.
11421 /// See @ref HAPI_Sessions for more on sessions.
11422 /// Pass NULL to just use the default in-process session.
11423 /// <!-- default NULL -->
11424 ///
11425 /// @param[in] parent_node_id
11426 /// The node that the copnet containing the texture will be
11427 /// created in, or -1 if the parent is the image manager.
11428 ///
11429 /// @param[in] width
11430 /// The width of the image in pixels. @p width * @p height *
11431 /// channel count (implied by @p packing) should equal the size
11432 /// of @p data_array.
11433 ///
11434 /// @param[in] height
11435 /// The height of the image in pixels. @p width * @p height *
11436 /// channel count (implied by @p packing) should equal the size
11437 /// of @p data_array.
11438 ///
11439 /// @param[in] packing
11440 /// How the image data is packed (single-channel, RBGA, etc).
11441 ///
11442 /// @param[in] flip_x
11443 /// Whether to flip the image horizontally.
11444 ///
11445 /// @param[in] flip_y
11446 /// Whether to flip the image vertically.
11447 ///
11448 /// @param[in] data_array
11449 /// A float array representing the image's pixel data. Values
11450 /// should be between 0.0 and 1.0. The data should be packed
11451 /// according to @p packing.
11452 ///
11453 /// @param[in] start
11454 /// The index of the first value of @p data_array to use.
11455 /// Must be at least 0 and at most (size of @p data_array - 1).
11456 /// <!-- min 0 -->
11457 /// <!-- default 0 -->
11458 ///
11459 /// @param[in] length
11460 /// How much of @p data_array to use. Must be at least 0
11461 /// and at most (size of @p data_array - start).
11462 /// <!-- min 0 -->
11463 ///
11464 HAPI_DECL HAPI_CreateCOPImage( const HAPI_Session * session,
11465  HAPI_NodeId parent_node_id,
11466  const int width,
11467  const int height,
11468  const HAPI_ImagePacking packing,
11469  HAPI_Bool flip_x,
11470  HAPI_Bool flip_y,
11471  const float * data_array,
11472  int start, int length );
11473 
11474 /// @defgroup Animation
11475 /// Functions for working with animation.
11476 
11477 /// @brief Set an animation curve on a parameter of an exposed node.
11478 ///
11479 /// @ingroup Animation
11480 ///
11481 /// @param[in] session
11482 /// The session of Houdini you are interacting with.
11483 /// See @ref HAPI_Sessions for more on sessions.
11484 /// Pass NULL to just use the default in-process session.
11485 /// <!-- default NULL -->
11486 ///
11487 /// @param[in] node_id
11488 /// The exposed node id.
11489 ///
11490 /// @param[in] parm_id
11491 /// The id of an exposed parameter within the node.
11492 /// @param[in] parm_index
11493 /// The index of the parameter, if it is for example
11494 /// a 3 tuple
11495 ///
11496 /// @param[in] curve_keyframes_array
11497 /// An array of ::HAPI_Keyframe structs that describes
11498 /// the keys on this curve.
11499 ///
11500 /// @param[in] keyframe_count
11501 /// The number of keys on the curve.
11502 ///
11503 HAPI_DECL HAPI_SetAnimCurve( const HAPI_Session * session,
11504  HAPI_NodeId node_id, HAPI_ParmId parm_id,
11505  int parm_index,
11506  const HAPI_Keyframe * curve_keyframes_array,
11507  int keyframe_count );
11508 
11509 /// @brief A specialized convenience function to set the T,R,S values
11510 /// on an exposed node.
11511 ///
11512 /// @ingroup Animation
11513 ///
11514 /// @param[in] session
11515 /// The session of Houdini you are interacting with.
11516 /// See @ref HAPI_Sessions for more on sessions.
11517 /// Pass NULL to just use the default in-process session.
11518 /// <!-- default NULL -->
11519 ///
11520 /// @param[in] node_id
11521 /// The exposed node id.
11522 ///
11523 /// @param[in] trans_comp
11524 /// A value of ::HAPI_TransformComponent that
11525 /// identifies the particular component of the
11526 /// transform to attach the curve to, for example
11527 /// ::HAPI_TRANSFORM_TX.
11528 ///
11529 /// @param[in] curve_keyframes_array
11530 /// An array of ::HAPI_Keyframe structs that describes
11531 /// the keys on this curve.
11532 ///
11533 /// @param[in] keyframe_count
11534 /// The number of keys on the curve.
11535 ///
11537  const HAPI_Session * session,
11538  HAPI_NodeId node_id,
11539  HAPI_TransformComponent trans_comp,
11540  const HAPI_Keyframe * curve_keyframes_array,
11541  int keyframe_count );
11542 
11543 /// @brief Resets the simulation cache of the asset. This is very useful
11544 /// for assets that use dynamics, to be called after some
11545 /// setup has changed for the asset - for example, asset inputs
11546 ///
11547 /// @ingroup Time
11548 ///
11549 /// @param[in] session
11550 /// The session of Houdini you are interacting with.
11551 /// See @ref HAPI_Sessions for more on sessions.
11552 /// Pass NULL to just use the default in-process session.
11553 /// <!-- default NULL -->
11554 ///
11555 /// @param[in] node_id
11556 /// The asset node id.
11557 ///
11559  HAPI_NodeId node_id );
11560 
11561 /// @defgroup Volumes
11562 /// Functions for working with Volume data
11563 
11564 /// @brief Retrieve any meta-data about the volume primitive, including
11565 /// its transform, location, scale, taper, resolution.
11566 ///
11567 /// @ingroup Volumes
11568 ///
11569 /// @param[in] session
11570 /// The session of Houdini you are interacting with.
11571 /// See @ref HAPI_Sessions for more on sessions.
11572 /// Pass NULL to just use the default in-process session.
11573 /// <!-- default NULL -->
11574 ///
11575 /// @param[in] node_id
11576 /// The node id.
11577 ///
11578 /// @param[in] part_id
11579 /// The part id.
11580 ///
11581 /// @param[out] volume_info
11582 /// The meta-data associated with the volume on the
11583 /// part specified by the previous parameters.
11584 ///
11585 HAPI_DECL HAPI_GetVolumeInfo( const HAPI_Session * session,
11586  HAPI_NodeId node_id,
11587  HAPI_PartId part_id,
11588  HAPI_VolumeInfo * volume_info );
11589 
11590 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
11591 /// Start iterating through the value of the volume at part_id.
11592 ///
11593 /// @ingroup Volumes
11594 ///
11595 /// @param[in] session
11596 /// The session of Houdini you are interacting with.
11597 /// See @ref HAPI_Sessions for more on sessions.
11598 /// Pass NULL to just use the default in-process session.
11599 /// <!-- default NULL -->
11600 ///
11601 /// @param[in] node_id
11602 /// The node id.
11603 ///
11604 /// @param[in] part_id
11605 /// The part id.
11606 ///
11607 /// @param[out] tile
11608 /// The tile info referring to the first tile in the
11609 /// volume at part_id.
11610 ///
11612  HAPI_NodeId node_id,
11613  HAPI_PartId part_id,
11614  HAPI_VolumeTileInfo * tile );
11615 
11616 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
11617 /// Continue iterating through the value of the volume at part_id.
11618 ///
11619 /// @ingroup Volumes
11620 ///
11621 /// @param[in] session
11622 /// The session of Houdini you are interacting with.
11623 /// See @ref HAPI_Sessions for more on sessions.
11624 /// Pass NULL to just use the default in-process session.
11625 /// <!-- default NULL -->
11626 ///
11627 /// @param[in] node_id
11628 /// The node id.
11629 ///
11630 /// @param[in] part_id
11631 /// The part id.
11632 ///
11633 /// @param[out] tile
11634 /// The tile info referring to the next tile in the
11635 /// set of tiles associated with the volume at this part.
11636 ///
11638  HAPI_NodeId node_id,
11639  HAPI_PartId part_id,
11640  HAPI_VolumeTileInfo * tile );
11641 
11642 /// @brief Retrieve floating point values of the voxel at a specific
11643 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
11644 /// to this call.
11645 ///
11646 /// @ingroup Volumes
11647 ///
11648 /// @param[in] session
11649 /// The session of Houdini you are interacting with.
11650 /// See @ref HAPI_Sessions for more on sessions.
11651 /// Pass NULL to just use the default in-process session.
11652 /// <!-- default NULL -->
11653 ///
11654 /// @param[in] node_id
11655 /// The node id.
11656 ///
11657 /// @param[in] part_id
11658 /// The part id.
11659 ///
11660 /// @param[in] x_index
11661 /// The x index/coordinate of the voxel.
11662 ///
11663 /// @param[in] y_index
11664 /// The y index/coordinate of the voxel.
11665 ///
11666 /// @param[in] z_index
11667 /// The z index/coordinate of the voxel.
11668 ///
11669 /// @param[out] values_array
11670 /// The values of the voxel.
11671 ///
11672 /// @param[in] value_count
11673 /// Should be equal to the volume's
11674 /// ::HAPI_VolumeInfo::tupleSize.
11675 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11676 ///
11678  HAPI_NodeId node_id,
11679  HAPI_PartId part_id,
11680  int x_index,
11681  int y_index,
11682  int z_index,
11683  float * values_array,
11684  int value_count );
11685 
11686 /// @brief Retrieve floating point values of the voxels pointed to
11687 /// by a tile. Note that a tile may extend beyond the limits
11688 /// of the volume so not all values in the given buffer will
11689 /// be written to. Voxels outside the volume will be initialized
11690 /// to the given fill value.
11691 ///
11692 /// @ingroup Volumes
11693 ///
11694 /// @param[in] session
11695 /// The session of Houdini you are interacting with.
11696 /// See @ref HAPI_Sessions for more on sessions.
11697 /// Pass NULL to just use the default in-process session.
11698 /// <!-- default NULL -->
11699 ///
11700 /// @param[in] node_id
11701 /// The node id.
11702 ///
11703 /// @param[in] part_id
11704 /// The part id.
11705 ///
11706 /// @param[in] fill_value
11707 /// Value that will be used to fill the @p values_array.
11708 /// This is useful so that you can see what values
11709 /// have actually been written to.
11710 ///
11711 /// @param[in] tile
11712 /// The tile to retrieve.
11713 ///
11714 /// @param[out] values_array
11715 /// The values of the tile.
11716 ///
11717 /// @param[in] length
11718 /// The length should be ( 8 ^ 3 ) * tupleSize.
11719 ///
11721  HAPI_NodeId node_id,
11722  HAPI_PartId part_id,
11723  float fill_value,
11724  const HAPI_VolumeTileInfo * tile,
11725  float * values_array,
11726  int length );
11727 
11728 /// @brief Retrieve integer point values of the voxel at a specific
11729 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
11730 /// to this call.
11731 ///
11732 /// @ingroup Volumes
11733 ///
11734 /// @param[in] session
11735 /// The session of Houdini you are interacting with.
11736 /// See @ref HAPI_Sessions for more on sessions.
11737 /// Pass NULL to just use the default in-process session.
11738 /// <!-- default NULL -->
11739 ///
11740 /// @param[in] node_id
11741 /// The node id.
11742 ///
11743 /// @param[in] part_id
11744 /// The part id.
11745 ///
11746 /// @param[in] x_index
11747 /// The x index/coordinate of the voxel.
11748 ///
11749 /// @param[in] y_index
11750 /// The y index/coordinate of the voxel.
11751 ///
11752 /// @param[in] z_index
11753 /// The z index/coordinate of the voxel.
11754 ///
11755 /// @param[out] values_array
11756 /// The values of the voxel.
11757 ///
11758 /// @param[in] value_count
11759 /// Should be equal to the volume's
11760 /// ::HAPI_VolumeInfo::tupleSize.
11761 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11762 ///
11764  HAPI_NodeId node_id,
11765  HAPI_PartId part_id,
11766  int x_index,
11767  int y_index,
11768  int z_index,
11769  int * values_array,
11770  int value_count );
11771 
11772 /// @brief Retrieve integer point values of the voxels pointed to
11773 /// by a tile. Note that a tile may extend beyond the limits
11774 /// of the volume so not all values in the given buffer will
11775 /// be written to. Voxels outside the volume will be initialized
11776 /// to the given fill value.
11777 ///
11778 /// @ingroup Volumes
11779 ///
11780 /// @param[in] session
11781 /// The session of Houdini you are interacting with.
11782 /// See @ref HAPI_Sessions for more on sessions.
11783 /// Pass NULL to just use the default in-process session.
11784 /// <!-- default NULL -->
11785 ///
11786 /// @param[in] node_id
11787 /// The node id.
11788 ///
11789 /// @param[in] part_id
11790 /// The part id.
11791 ///
11792 /// @param[in] fill_value
11793 /// Value that will be used to fill the @p values_array.
11794 /// This is useful so that you can see what values
11795 /// have actually been written to.
11796 ///
11797 /// @param[in] tile
11798 /// The tile to retrieve.
11799 ///
11800 /// @param[out] values_array
11801 /// The values of the tile.
11802 ///
11803 /// @param[in] length
11804 /// The length should be ( 8 ^ 3 ) * tupleSize.
11805 ///
11807  HAPI_NodeId node_id,
11808  HAPI_PartId part_id,
11809  int fill_value,
11810  const HAPI_VolumeTileInfo * tile,
11811  int * values_array,
11812  int length );
11813 
11814 /// @brief Get the height field data for a terrain volume as a flattened
11815 /// 2D array of float heights. Should call ::HAPI_GetVolumeInfo()
11816 /// first to make sure the volume info is initialized.
11817 ///
11818 /// @ingroup Volumes
11819 ///
11820 /// @param[in] session
11821 /// The session of Houdini you are interacting with.
11822 /// See @ref HAPI_Sessions for more on sessions.
11823 /// Pass NULL to just use the default in-process session.
11824 /// <!-- default NULL -->
11825 ///
11826 /// @param[in] node_id
11827 /// The node id.
11828 ///
11829 /// @param[in] part_id
11830 /// The part id.
11831 ///
11832 /// @param[out] values_array
11833 /// Heightfield flattened array. Should be at least the size of
11834 /// @p start + @p length.
11835 ///
11836 /// @param[in] start
11837 /// The start at least 0 and at most
11838 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength )
11839 /// - @p length.
11840 ///
11841 /// @param[in] length
11842 /// The length should be at least 1 or at most
11843 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength )
11844 /// - @p start.
11845 ///
11847  HAPI_NodeId node_id,
11848  HAPI_PartId part_id,
11849  float * values_array,
11850  int start, int length );
11851 
11852 /// @brief Set the volume info of a geo on a geo input.
11853 ///
11854 /// @ingroup Volumes
11855 ///
11856 /// @param[in] session
11857 /// The session of Houdini you are interacting with.
11858 /// See @ref HAPI_Sessions for more on sessions.
11859 /// Pass NULL to just use the default in-process session.
11860 /// <!-- default NULL -->
11861 ///
11862 /// @param[in] node_id
11863 /// The node id.
11864 ///
11865 /// @param[in] part_id
11866 /// The part id.
11867 ///
11868 /// @param[in] volume_info
11869 /// All volume information that can be specified per
11870 /// volume. This includes the position, orientation, scale,
11871 /// data format, tuple size, and taper. The tile size is
11872 /// always 8x8x8.
11873 ///
11874 HAPI_DECL HAPI_SetVolumeInfo( const HAPI_Session * session,
11875  HAPI_NodeId node_id,
11876  HAPI_PartId part_id,
11877  const HAPI_VolumeInfo * volume_info );
11878 
11879 /// @brief Set the values of a float tile: this is an 8x8x8 subsection of
11880 /// the volume.
11881 ///
11882 /// @ingroup Volumes
11883 ///
11884 /// @param[in] session
11885 /// The session of Houdini you are interacting with.
11886 /// See @ref HAPI_Sessions for more on sessions.
11887 /// Pass NULL to just use the default in-process session.
11888 /// <!-- default NULL -->
11889 ///
11890 /// @param[in] node_id
11891 /// The node id.
11892 ///
11893 /// @param[in] part_id
11894 /// The part id.
11895 ///
11896 /// @param[in] tile
11897 /// The tile that the volume will be input into.
11898 ///
11899 /// @param[in] values_array
11900 /// The values of the individual voxel tiles in the
11901 /// volume. The length of this array should
11902 /// be ( 8 ^ 3 ) * tupleSize.
11903 ///
11904 /// @param[in] length
11905 /// The length should be ( 8 ^ 3 ) * tupleSize.
11906 ///
11908  HAPI_NodeId node_id,
11909  HAPI_PartId part_id,
11910  const HAPI_VolumeTileInfo * tile,
11911  const float * values_array,
11912  int length );
11913 
11914 /// @brief Set the values of an int tile: this is an 8x8x8 subsection of
11915 /// the volume.
11916 ///
11917 /// @ingroup Volumes
11918 ///
11919 /// @param[in] session
11920 /// The session of Houdini you are interacting with.
11921 /// See @ref HAPI_Sessions for more on sessions.
11922 /// Pass NULL to just use the default in-process session.
11923 /// <!-- default NULL -->
11924 ///
11925 /// @param[in] node_id
11926 /// The node id.
11927 ///
11928 /// @param[in] part_id
11929 /// The part id.
11930 ///
11931 /// @param[in] tile
11932 /// The tile that the volume will be input into.
11933 ///
11934 /// @param[in] values_array
11935 /// The values of the individual voxel tiles in the
11936 /// volume. The length of this array should
11937 /// be ( 8 ^ 3 ) * tupleSize.
11938 ///
11939 /// @param[in] length
11940 /// The length should be ( 8 ^ 3 ) * tupleSize.
11941 ///
11943  HAPI_NodeId node_id,
11944  HAPI_PartId part_id,
11945  const HAPI_VolumeTileInfo * tile,
11946  const int * values_array,
11947  int length );
11948 
11949 /// @brief Set the values of a float voxel in the volume.
11950 ///
11951 /// @ingroup Volumes
11952 ///
11953 /// @param[in] session
11954 /// The session of Houdini you are interacting with.
11955 /// See @ref HAPI_Sessions for more on sessions.
11956 /// Pass NULL to just use the default in-process session.
11957 /// <!-- default NULL -->
11958 ///
11959 /// @param[in] node_id
11960 /// The node id.
11961 ///
11962 /// @param[in] part_id
11963 /// The part id.
11964 ///
11965 /// @param[in] x_index
11966 /// The x index/coordinate of the voxel.
11967 ///
11968 /// @param[in] y_index
11969 /// The y index/coordinate of the voxel.
11970 ///
11971 /// @param[in] z_index
11972 /// The z index/coordinate of the voxel.
11973 ///
11974 /// @param[in] values_array
11975 /// The values of the voxel.
11976 ///
11977 /// @param[in] value_count
11978 /// Should be equal to the volume's
11979 /// ::HAPI_VolumeInfo::tupleSize.
11980 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
11981 ///
11983  HAPI_NodeId node_id,
11984  HAPI_PartId part_id,
11985  int x_index,
11986  int y_index,
11987  int z_index,
11988  const float * values_array,
11989  int value_count );
11990 
11991 /// @brief Set the values of a integer voxel in the volume.
11992 ///
11993 /// @ingroup Volumes
11994 ///
11995 /// @param[in] session
11996 /// The session of Houdini you are interacting with.
11997 /// See @ref HAPI_Sessions for more on sessions.
11998 /// Pass NULL to just use the default in-process session.
11999 /// <!-- default NULL -->
12000 ///
12001 /// @param[in] node_id
12002 /// The node id.
12003 ///
12004 /// @param[in] part_id
12005 /// The part id.
12006 ///
12007 /// @param[in] x_index
12008 /// The x index/coordinate of the voxel.
12009 ///
12010 /// @param[in] y_index
12011 /// The y index/coordinate of the voxel.
12012 ///
12013 /// @param[in] z_index
12014 /// The z index/coordinate of the voxel.
12015 ///
12016 /// @param[in] values_array
12017 /// The values of the voxel.
12018 ///
12019 /// @param[in] value_count
12020 /// Should be equal to the volume's
12021 /// ::HAPI_VolumeInfo::tupleSize.
12022 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
12023 ///
12025  HAPI_NodeId node_id,
12026  HAPI_PartId part_id,
12027  int x_index,
12028  int y_index,
12029  int z_index,
12030  const int * values_array,
12031  int value_count );
12032 
12033 /// @brief Get the bounding values of a 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] x_min
12050 /// The minimum x value of the volume's bounding box.
12051 /// Can be null if you do not want this value.
12052 ///
12053 /// @param[out] y_min
12054 /// The minimum y value of the volume's bounding box.
12055 /// Can be null if you do not want this value.
12056 ///
12057 /// @param[out] z_min
12058 /// The minimum z value of the volume's bounding box.
12059 /// Can be null if you do not want this value.
12060 ///
12061 /// @param[out] x_max
12062 /// The maximum x value of the volume's bounding box.
12063 /// Can be null if you do not want this value.
12064 ///
12065 /// @param[out] y_max
12066 /// The maximum y value of the volume's bounding box.
12067 /// Can be null if you do not want this value.
12068 ///
12069 /// @param[out] z_max
12070 /// The maximum z value of the volume's bounding box.
12071 /// Can be null if you do not want this value.
12072 ///
12073 /// @param[out] x_center
12074 /// The x value of the volume's bounding box center.
12075 /// Can be null if you do not want this value.
12076 ///
12077 /// @param[out] y_center
12078 /// The y value of the volume's bounding box center.
12079 /// Can be null if you do not want this value.
12080 ///
12081 /// @param[out] z_center
12082 /// The z value of the volume's bounding box center.
12083 /// Can be null if you do not want this value.
12084 ///
12086  HAPI_NodeId node_id,
12087  HAPI_PartId part_id,
12088  float * x_min, float * y_min, float * z_min,
12089  float * x_max, float * y_max, float * z_max,
12090  float * x_center, float * y_center, float * z_center );
12091 
12092 /// @brief Set the height field data for a terrain volume with the values from
12093 /// a flattened 2D array of float.
12094 /// ::HAPI_SetVolumeInfo() should be called first to make sure that the
12095 /// volume and its info are initialized.
12096 ///
12097 /// @ingroup Volumes
12098 ///
12099 /// @param[in] session
12100 /// The session of Houdini you are interacting with.
12101 /// See @ref HAPI_Sessions for more on sessions.
12102 /// Pass NULL to just use the default in-process session.
12103 /// <!-- default NULL -->
12104 ///
12105 /// @param[in] node_id
12106 /// The node id.
12107 ///
12108 /// @param[in] part_id
12109 /// The part id.
12110 ///
12111 /// @param[in] values_array
12112 /// Heightfield flattened array. Should be at least the size of
12113 /// @p start + @p length.
12114 ///
12115 /// @param[in] start
12116 /// The start at least 0 and at most
12117 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength ) - @p length.
12118 ///
12119 /// @param[in] length
12120 /// The length should be at least 1 or at most
12121 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength ) - @p start.
12122 ///
12123 /// @param[in] name
12124 /// The name of the volume used for the heightfield.
12125 /// If set to "height" the values will be used for height information,
12126 /// if not, the data will used as a mask.
12127 ///
12129  HAPI_NodeId node_id,
12130  HAPI_PartId part_id,
12131  const char * name,
12132  const float * values_array,
12133  int start, int length );
12134 
12135 /// @brief Retrieve the visualization meta-data of the volume.
12136 ///
12137 /// @ingroup Volumes
12138 ///
12139 /// @param[in] session
12140 /// The session of Houdini you are interacting with.
12141 /// See @ref HAPI_Sessions for more on sessions.
12142 /// Pass NULL to just use the default in-process session.
12143 /// <!-- default NULL -->
12144 ///
12145 /// @param[in] node_id
12146 /// The node id.
12147 ///
12148 /// @param[in] part_id
12149 /// The part id.
12150 ///
12151 /// @param[out] visual_info
12152 /// The meta-data associated with the visualization
12153 /// settings of the part specified by the previous
12154 /// parameters.
12155 ///
12157  HAPI_NodeId node_id,
12158  HAPI_PartId part_id,
12159  HAPI_VolumeVisualInfo * visual_info );
12160 
12161 /// @defgroup Curves
12162 /// Functions for working with curves
12163 
12164 /// @brief Retrieve any meta-data about the curves, including the
12165 /// curve's type, order, and periodicity.
12166 ///
12167 /// @ingroup Curves
12168 ///
12169 /// @param[in] session
12170 /// The session of Houdini you are interacting with.
12171 /// See @ref HAPI_Sessions for more on sessions.
12172 /// Pass NULL to just use the default in-process session.
12173 /// <!-- default NULL -->
12174 ///
12175 /// @param[in] node_id
12176 /// The node id.
12177 ///
12178 /// @param[in] part_id
12179 /// The part id.
12180 ///
12181 /// @param[out] info
12182 /// The curve info represents the meta-data about
12183 /// the curves, including the type, order,
12184 /// and periodicity.
12185 ///
12186 HAPI_DECL HAPI_GetCurveInfo( const HAPI_Session * session,
12187  HAPI_NodeId node_id,
12188  HAPI_PartId part_id,
12189  HAPI_CurveInfo * info );
12190 
12191 /// @brief Retrieve the number of vertices for each curve in the part.
12192 ///
12193 /// @ingroup Curves
12194 ///
12195 /// @param[in] session
12196 /// The session of Houdini you are interacting with.
12197 /// See @ref HAPI_Sessions for more on sessions.
12198 /// Pass NULL to just use the default in-process session.
12199 /// <!-- default NULL -->
12200 ///
12201 /// @param[in] node_id
12202 /// The node id.
12203 ///
12204 /// @param[in] part_id
12205 /// The part id.
12206 ///
12207 /// @param[out] counts_array
12208 /// The number of cvs each curve contains
12209 ///
12210 /// @param[in] start
12211 /// The index of the first curve.
12212 /// <!-- default 0 -->
12213 ///
12214 /// @param[in] length
12215 /// The number of curves' counts to retrieve.
12216 ///
12217 HAPI_DECL HAPI_GetCurveCounts( const HAPI_Session * session,
12218  HAPI_NodeId node_id,
12219  HAPI_PartId part_id,
12220  int * counts_array,
12221  int start, int length );
12222 
12223 /// @brief Retrieve the orders for each curve in the part if the
12224 /// curve has varying order.
12225 ///
12226 /// @ingroup Curves
12227 ///
12228 /// @param[in] session
12229 /// The session of Houdini you are interacting with.
12230 /// See @ref HAPI_Sessions for more on sessions.
12231 /// Pass NULL to just use the default in-process session.
12232 /// <!-- default NULL -->
12233 ///
12234 /// @param[in] node_id
12235 /// The node id.
12236 ///
12237 /// @param[in] part_id
12238 /// The part id.
12239 ///
12240 /// @param[out] orders_array
12241 /// The order of each curve will be returned in this
12242 /// array.
12243 ///
12244 /// @param[in] start
12245 /// The index of the first curve.
12246 /// <!-- default 0 -->
12247 ///
12248 /// @param[in] length
12249 /// The number of curves' orders to retrieve.
12250 ///
12251 HAPI_DECL HAPI_GetCurveOrders( const HAPI_Session * session,
12252  HAPI_NodeId node_id,
12253  HAPI_PartId part_id,
12254  int * orders_array,
12255  int start, int length );
12256 
12257 /// @brief Retrieve the knots of the curves in this part.
12258 ///
12259 /// @ingroup Curves
12260 ///
12261 /// @param[in] session
12262 /// The session of Houdini you are interacting with.
12263 /// See @ref HAPI_Sessions for more on sessions.
12264 /// Pass NULL to just use the default in-process session.
12265 /// <!-- default NULL -->
12266 ///
12267 /// @param[in] node_id
12268 /// The node id.
12269 ///
12270 /// @param[in] part_id
12271 /// The part id.
12272 ///
12273 /// @param[out] knots_array
12274 /// The knots of each curve will be returned in this
12275 /// array.
12276 ///
12277 /// @param[in] start
12278 /// The index of the first curve.
12279 /// <!-- default 0 -->
12280 ///
12281 /// @param[in] length
12282 /// The number of curves' knots to retrieve. The
12283 /// length of all the knots on a single curve is
12284 /// the order of that curve plus the number of
12285 /// vertices (see ::HAPI_GetCurveOrders(),
12286 /// and ::HAPI_GetCurveCounts()).
12287 ///
12288 HAPI_DECL HAPI_GetCurveKnots( const HAPI_Session * session,
12289  HAPI_NodeId node_id,
12290  HAPI_PartId part_id,
12291  float * knots_array,
12292  int start, int length );
12293 
12294 /// @brief Set meta-data for the curve mesh, including the
12295 /// curve type, order, and periodicity.
12296 ///
12297 /// @ingroup Curves
12298 ///
12299 /// @param[in] session
12300 /// The session of Houdini you are interacting with.
12301 /// See @ref HAPI_Sessions for more on sessions.
12302 /// Pass NULL to just use the default in-process session.
12303 /// <!-- default NULL -->
12304 ///
12305 /// @param[in] node_id
12306 /// The node id.
12307 ///
12308 /// @param[in] part_id
12309 /// Currently unused. Input asset geos are assumed
12310 /// to have only one part.
12311 ///
12312 /// @param[in] info
12313 /// The curve info represents the meta-data about
12314 /// the curves, including the type, order,
12315 /// and periodicity.
12316 ///
12317 HAPI_DECL HAPI_SetCurveInfo( const HAPI_Session * session,
12318  HAPI_NodeId node_id,
12319  HAPI_PartId part_id,
12320  const HAPI_CurveInfo * info );
12321 
12322 /// @brief Set the number of vertices for each curve in the part.
12323 ///
12324 /// @ingroup Curves
12325 ///
12326 /// @param[in] session
12327 /// The session of Houdini you are interacting with.
12328 /// See @ref HAPI_Sessions for more on sessions.
12329 /// Pass NULL to just use the default in-process session.
12330 /// <!-- default NULL -->
12331 ///
12332 /// @param[in] node_id
12333 /// The node id.
12334 ///
12335 /// @param[in] part_id
12336 /// Currently unused. Input asset geos are assumed
12337 /// to have only one part.
12338 ///
12339 /// @param[in] counts_array
12340 /// The number of cvs each curve contains.
12341 ///
12342 /// @param[in] start
12343 /// The index of the first curve.
12344 /// <!-- default 0 -->
12345 ///
12346 /// @param[in] length
12347 /// The number of curves' counts to set.
12348 /// <!-- source arglength(counts_array) -->
12349 ///
12350 HAPI_DECL HAPI_SetCurveCounts( const HAPI_Session * session,
12351  HAPI_NodeId node_id,
12352  HAPI_PartId part_id,
12353  const int * counts_array,
12354  int start, int length );
12355 
12356 /// @brief Set the orders for each curve in the part if the
12357 /// curve has varying order.
12358 ///
12359 /// @ingroup Curves
12360 ///
12361 /// @param[in] session
12362 /// The session of Houdini you are interacting with.
12363 /// See @ref HAPI_Sessions for more on sessions.
12364 /// Pass NULL to just use the default in-process session.
12365 /// <!-- default NULL -->
12366 ///
12367 /// @param[in] node_id
12368 /// The node id.
12369 ///
12370 /// @param[in] part_id
12371 /// Currently unused. Input asset geos are assumed
12372 /// to have only one part.
12373 ///
12374 /// @param[in] orders_array
12375 /// The orders of each curve.
12376 ///
12377 /// @param[in] start
12378 /// The index of the first curve.
12379 /// <!-- default 0 -->
12380 ///
12381 /// @param[in] length
12382 /// The number of curves' orders to retrieve.
12383 /// <!-- source arglength(orders_array) -->
12384 ///
12385 HAPI_DECL HAPI_SetCurveOrders( const HAPI_Session * session,
12386  HAPI_NodeId node_id,
12387  HAPI_PartId part_id,
12388  const int * orders_array,
12389  int start, int length );
12390 
12391 /// @brief Set the knots of the curves in this part.
12392 ///
12393 /// @ingroup Curves
12394 ///
12395 /// @param[in] session
12396 /// The session of Houdini you are interacting with.
12397 /// See @ref HAPI_Sessions for more on sessions.
12398 /// Pass NULL to just use the default in-process session.
12399 /// <!-- default NULL -->
12400 ///
12401 /// @param[in] node_id
12402 /// The node id.
12403 ///
12404 /// @param[in] part_id
12405 /// Currently unused. Input asset geos are assumed
12406 /// to have only one part.
12407 ///
12408 /// @param[in] knots_array
12409 /// The knots of each curve.
12410 ///
12411 /// @param[in] start
12412 /// The index of the first curve.
12413 /// <!-- default 0 -->
12414 ///
12415 /// @param[in] length
12416 /// The number of curves' knots to set. The
12417 /// length of all the knots on a single curve is
12418 /// the order of that curve plus the number of
12419 /// vertices (see ::HAPI_SetCurveOrders(),
12420 /// and ::HAPI_SetCurveCounts()).
12421 ///
12422 HAPI_DECL HAPI_SetCurveKnots( const HAPI_Session * session,
12423  HAPI_NodeId node_id,
12424  HAPI_PartId part_id,
12425  const float * knots_array,
12426  int start, int length );
12427 
12428 // INPUT CURVE INFO ---------------------------------------------------------
12429 
12430 /// @defgroup InputCurves
12431 /// Functions for working with curves
12432 
12433 /// @brief Retrieve meta-data about the input curves, including the
12434 /// curve's type, order, and whether or not the curve is closed and reversed.
12435 ///
12436 /// @ingroup InputCurves
12437 ///
12438 /// @param[in] session
12439 /// The session of Houdini you are interacting with.
12440 /// See @ref HAPI_Sessions for more on sessions.
12441 /// Pass NULL to just use the default in-process session.
12442 /// <!-- default NULL -->
12443 ///
12444 /// @param[in] node_id
12445 /// The node id.
12446 ///
12447 /// @param[in] part_id
12448 /// The part id.
12449 ///
12450 /// @param[out] info
12451 /// The curve info represents the meta-data about
12452 /// the curves, including the type, order,
12453 /// and closed and reversed values.
12454 ///
12456  HAPI_NodeId node_id,
12457  HAPI_PartId part_id,
12458  HAPI_InputCurveInfo * info );
12459 
12460 /// @brief Set meta-data for the input curves, including the
12461 /// curve type, order, reverse and closed properties.
12462 ///
12463 /// @ingroup InputCurves
12464 ///
12465 /// @param[in] session
12466 /// The session of Houdini you are interacting with.
12467 /// See @ref HAPI_Sessions for more on sessions.
12468 /// Pass NULL to just use the default in-process session.
12469 /// <!-- default NULL -->
12470 ///
12471 /// @param[in] node_id
12472 /// The node id.
12473 ///
12474 /// @param[in] part_id
12475 /// Currently unused. Input asset geos are assumed
12476 /// to have only one part.
12477 ///
12478 /// @param[in] info
12479 /// The curve info represents the meta-data about
12480 /// the curves, including the type, order,
12481 /// and closed and reverse properties.
12482 ///
12484  HAPI_NodeId node_id,
12485  HAPI_PartId part_id,
12486  const HAPI_InputCurveInfo * info );
12487 
12488 /// @brief Sets the positions for input curves, doing checks for
12489 /// curve validity, and adjusting the curve settings accordingly.
12490 /// Will also cook the node.
12491 ///
12492 /// @ingroup InputCurves
12493 ///
12494 /// @param[in] session
12495 /// The session of Houdini you are interacting with.
12496 /// See @ref HAPI_Sessions for more on sessions.
12497 /// Pass NULL to just use the default in-process session.
12498 /// <!-- default NULL -->
12499 ///
12500 /// @param[in] node_id
12501 /// The node id.
12502 ///
12503 /// @param[in] part_id
12504 /// Currently unused. Input asset geos are assumed
12505 /// to have only one part.
12506 ///
12507 /// @param[in] positions_array
12508 /// A float array representing the positions attribute.
12509 /// It will read the array assuming a tuple size of 3.
12510 /// Note that this function does not do any coordinate axes
12511 /// conversion.
12512 ///
12513 /// @param[in] start
12514 /// The index of the first position in positions_array.
12515 /// <!-- default 0 -->
12516 ///
12517 /// @param[in] length
12518 /// The size of the positions array.
12519 /// <!-- source arglength(positions_array) -->
12520 ///
12522  const HAPI_Session* session,
12523  HAPI_NodeId node_id,
12524  HAPI_PartId part_id,
12525  const float* positions_array,
12526  int start,
12527  int length);
12528 
12529 /// @brief Sets the positions for input curves, doing checks for
12530 /// curve validity, and adjusting the curve settings accordingly.
12531 /// Will also cook the node. Additionally, adds rotation and scale
12532 /// attributes to the curve.
12533 ///
12534 /// @ingroup InputCurves
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] node_id
12543 /// The node id.
12544 ///
12545 /// @param[in] part_id
12546 /// Currently unused. Input asset geos are assumed
12547 /// to have only one part.
12548 ///
12549 /// @param[in] positions_array
12550 /// A float array representing the positions attribute.
12551 /// It will read the array assuming a tuple size of 3.
12552 /// Note that this function does not do any coordinate axes
12553 /// conversion.
12554 ///
12555 /// @param[in] positions_array
12556 /// A float array representing the positions attribute.
12557 /// It will read the array assuming a tuple size of 3.
12558 /// Note that this function does not do any coordinate axes
12559 /// conversion.
12560 ///
12561 /// @param[in] positions_start
12562 /// The index of the first position in positions_array.
12563 /// <!-- default 0 -->
12564 ///
12565 /// @param[in] positions_length
12566 /// The size of the positions array.
12567 /// <!-- source arglength(positions_array) -->
12568 ///
12569 /// @param[in] rotations_array
12570 /// A float array representing the rotation (rot) attribute.
12571 /// It will read the array assuming a tuple size of 4
12572 /// representing quaternion values
12573 ///
12574 /// @param[in] rotations_start
12575 /// The index of the first rotation in rotations_array.
12576 /// <!-- default 0 -->
12577 ///
12578 /// @param[in] rotations_length
12579 /// The size of the rotations array.
12580 /// <!-- source arglength(rotations_array) -->
12581 ///
12582 /// @param[in] scales_array
12583 /// A float array representing the scale attribute.
12584 /// It will read the array assuming a tuple size of 3
12585 ///
12586 /// @param[in] scales_start
12587 /// The index of the first scale in scales_array.
12588 /// <!-- default 0 -->
12589 ///
12590 /// @param[in] scales_length
12591 /// The size of the scales array.
12592 /// <!-- source arglength(scales_array) -->
12593 ///
12595  const HAPI_Session* session,
12596  HAPI_NodeId node_id,
12597  HAPI_PartId part_id,
12598  const float* positions_array,
12599  int positions_start,
12600  int positions_length,
12601  const float* rotations_array,
12602  int rotations_start,
12603  int rotations_length,
12604  const float * scales_array,
12605  int scales_start,
12606  int scales_length);
12607 
12608 // BASIC PRIMITIVES ---------------------------------------------------------
12609 
12610 /// @brief Get the box info on a geo part (if the part is a box).
12611 ///
12612 /// @ingroup Geometry
12613 ///
12614 /// @param[in] session
12615 /// The session of Houdini you are interacting with.
12616 /// See @ref HAPI_Sessions for more on sessions.
12617 /// Pass NULL to just use the default in-process session.
12618 /// <!-- default NULL -->
12619 ///
12620 /// @param[in] geo_node_id
12621 /// The geo node id.
12622 ///
12623 /// @param[in] part_id
12624 /// The part id of the
12625 ///
12626 /// @param[out] box_info
12627 /// The returned box info.
12628 ///
12629 HAPI_DECL HAPI_GetBoxInfo( const HAPI_Session * session,
12630  HAPI_NodeId geo_node_id,
12631  HAPI_PartId part_id,
12632  HAPI_BoxInfo * box_info );
12633 
12634 /// @brief Get the sphere info on a geo part (if the part is a sphere).
12635 ///
12636 /// @ingroup Geometry
12637 ///
12638 /// @param[in] session
12639 /// The session of Houdini you are interacting with.
12640 /// See @ref HAPI_Sessions for more on sessions.
12641 /// Pass NULL to just use the default in-process session.
12642 /// <!-- default NULL -->
12643 ///
12644 /// @param[in] geo_node_id
12645 /// The geo node id.
12646 ///
12647 /// @param[in] part_id
12648 /// The part id of the
12649 ///
12650 /// @param[out] sphere_info
12651 /// The returned sphere info.
12652 ///
12653 HAPI_DECL HAPI_GetSphereInfo( const HAPI_Session * session,
12654  HAPI_NodeId geo_node_id,
12655  HAPI_PartId part_id,
12656  HAPI_SphereInfo * sphere_info );
12657 
12658 /// @defgroup Caching
12659 /// Functions for working with memory and file caches
12660 
12661 /// @brief Get the number of currently active caches.
12662 ///
12663 /// @ingroup Caching
12664 ///
12665 /// @param[in] session
12666 /// The session of Houdini you are interacting with.
12667 /// See @ref HAPI_Sessions for more on sessions.
12668 /// Pass NULL to just use the default in-process session.
12669 /// <!-- default NULL -->
12670 ///
12671 /// @param[out] active_cache_count
12672 /// The number of currently active caches.
12673 ///
12675  int * active_cache_count );
12676 
12677 /// @brief Get the names of the currently active caches.
12678 ///
12679 /// Requires a valid active cache count which you get from:
12680 /// ::HAPI_GetActiveCacheCount().
12681 ///
12682 /// @ingroup Caching
12683 ///
12684 /// @param[in] session
12685 /// The session of Houdini you are interacting with.
12686 /// See @ref HAPI_Sessions for more on sessions.
12687 /// Pass NULL to just use the default in-process session.
12688 /// <!-- default NULL -->
12689 ///
12690 /// @param[out] cache_names_array
12691 /// String array with the returned cache names. Must be
12692 /// at least the size of @a active_cache_count.
12693 ///
12694 /// @param[in] active_cache_count
12695 /// The count returned by ::HAPI_GetActiveCacheCount().
12696 /// <!-- source ::HAPI_GetActiveCacheCount -->
12697 ///
12699  HAPI_StringHandle * cache_names_array,
12700  int active_cache_count );
12701 
12702 /// @brief Lets you inspect specific properties of the different memory
12703 /// caches in the current Houdini context.
12704 ///
12705 /// @ingroup Caching
12706 ///
12707 /// @param[in] session
12708 /// The session of Houdini you are interacting with.
12709 /// See @ref HAPI_Sessions for more on sessions.
12710 /// Pass NULL to just use the default in-process session.
12711 /// <!-- default NULL -->
12712 ///
12713 /// @param[in] cache_name
12714 /// Cache name from ::HAPI_GetActiveCacheNames().
12715 ///
12716 /// @param[in] cache_property
12717 /// The specific property of the cache to get the value for.
12718 ///
12719 /// @param[out] property_value
12720 /// Returned property value.
12721 ///
12723  const char * cache_name,
12724  HAPI_CacheProperty cache_property,
12725  int * property_value );
12726 
12727 /// @brief Lets you modify specific properties of the different memory
12728 /// caches in the current Houdini context. This includes clearing
12729 /// caches, reducing their memory use, or changing how memory limits
12730 /// are respected by a cache.
12731 ///
12732 /// @ingroup Caching
12733 ///
12734 /// @param[in] session
12735 /// The session of Houdini you are interacting with.
12736 /// See @ref HAPI_Sessions for more on sessions.
12737 /// Pass NULL to just use the default in-process session.
12738 /// <!-- default NULL -->
12739 ///
12740 /// @param[in] cache_name
12741 /// Cache name from ::HAPI_GetActiveCacheNames().
12742 ///
12743 /// @param[in] cache_property
12744 /// The specific property of the cache to modify.
12745 ///
12746 /// @param[in] property_value
12747 /// The new property value.
12748 ///
12750  const char * cache_name,
12751  HAPI_CacheProperty cache_property,
12752  int property_value );
12753 
12754 /// @brief Saves a geometry to file. The type of file to save is
12755 /// to be determined by the extension ie. .bgeo, .obj
12756 ///
12757 /// @ingroup Caching
12758 ///
12759 /// @param[in] session
12760 /// The session of Houdini you are interacting with.
12761 /// See @ref HAPI_Sessions for more on sessions.
12762 /// Pass NULL to just use the default in-process session.
12763 /// <!-- default NULL -->
12764 ///
12765 /// @param[in] node_id
12766 /// The node id.
12767 ///
12768 /// @param[in] file_name
12769 /// The name of the file to be saved. The extension
12770 /// of the file determines its type.
12771 ///
12772 HAPI_DECL HAPI_SaveGeoToFile( const HAPI_Session * session,
12773  HAPI_NodeId node_id,
12774  const char * file_name );
12775 
12776 /// @brief Loads a geometry file and put its contents onto a SOP
12777 /// node.
12778 ///
12779 /// @ingroup Caching
12780 ///
12781 /// @param[in] session
12782 /// The session of Houdini you are interacting with.
12783 /// See @ref HAPI_Sessions for more on sessions.
12784 /// Pass NULL to just use the default in-process session.
12785 /// <!-- default NULL -->
12786 ///
12787 /// @param[in] node_id
12788 /// The node id.
12789 ///
12790 /// @param[in] file_name
12791 /// The name of the file to be loaded
12792 ///
12794  HAPI_NodeId node_id,
12795  const char * file_name );
12796 
12797 /// @brief Saves the node and all its contents to file.
12798 /// The saved file can be loaded by calling ::HAPI_LoadNodeFromFile.
12799 ///
12800 /// @ingroup Caching
12801 ///
12802 /// @param[in] session
12803 /// The session of Houdini you are interacting with.
12804 /// See @ref HAPI_Sessions for more on sessions.
12805 /// Pass NULL to just use the default in-process session.
12806 /// <!-- default NULL -->
12807 ///
12808 /// @param[in] node_id
12809 /// The node id.
12810 ///
12811 /// @param[in] file_name
12812 /// The name of the file to be saved. The extension
12813 /// of the file determines its type.
12814 ///
12815 HAPI_DECL HAPI_SaveNodeToFile( const HAPI_Session * session,
12816  HAPI_NodeId node_id,
12817  const char * file_name );
12818 
12819 /// @brief Loads and creates a previously saved node and all
12820 /// its contents from given file.
12821 /// The saved file must have been created by calling
12822 /// ::HAPI_SaveNodeToFile.
12823 ///
12824 /// @ingroup Caching
12825 ///
12826 /// @param[in] session
12827 /// The session of Houdini you are interacting with.
12828 /// See @ref HAPI_Sessions for more on sessions.
12829 /// Pass NULL to just use the default in-process session.
12830 /// <!-- default NULL -->
12831 ///
12832 /// @param[in] file_name
12833 /// The name of the file to be loaded
12834 ///
12835 /// @param[in] parent_node_id
12836 /// The parent node id of the Geometry object.
12837 ///
12838 /// @param[in] node_label
12839 /// The name of the new Geometry object.
12840 ///
12841 /// @param[in] cook_on_load
12842 /// Set to true if you wish the nodes to cook as soon
12843 /// as they are created. Otherwise, you will have to
12844 /// call ::HAPI_CookNode() explicitly for each after you
12845 /// call this function.
12846 ///
12847 /// @param[out] new_node_id
12848 /// The newly created node id.
12849 ///
12851  const char * file_name,
12852  HAPI_NodeId parent_node_id,
12853  const char * node_label,
12854  HAPI_Bool cook_on_load,
12855  HAPI_NodeId * new_node_id );
12856 
12857 /// @brief Cache the current state of the geo to memory, given the
12858 /// format, and return the size. Use this size with your call
12859 /// to ::HAPI_SaveGeoToMemory() to copy the cached geo to your
12860 /// buffer. It is guaranteed that the size will not change between
12861 /// your call to ::HAPI_GetGeoSize() and ::HAPI_SaveGeoToMemory().
12862 ///
12863 /// @ingroup Caching
12864 ///
12865 /// @param[in] session
12866 /// The session of Houdini you are interacting with.
12867 /// See @ref HAPI_Sessions for more on sessions.
12868 /// Pass NULL to just use the default in-process session.
12869 /// <!-- default NULL -->
12870 ///
12871 /// @param[in] node_id
12872 /// The node id.
12873 ///
12874 /// @param[in] format
12875 /// The file format, ie. ".obj", ".bgeo.sc" etc.
12876 ///
12877 /// @param[out] size
12878 /// The size of the buffer required to hold the output.
12879 ///
12880 HAPI_DECL HAPI_GetGeoSize( const HAPI_Session * session,
12881  HAPI_NodeId node_id,
12882  const char * format,
12883  int * size );
12884 
12885 /// @brief Saves the cached geometry to your buffer in memory,
12886 /// whose format and required size is identified by the call to
12887 /// ::HAPI_GetGeoSize(). The call to ::HAPI_GetGeoSize() is
12888 /// required as ::HAPI_GetGeoSize() does the actual saving work.
12889 ///
12890 /// Also note that this call to ::HAPI_SaveGeoToMemory will delete
12891 /// the internal geo buffer that was cached in the previous call
12892 /// to ::HAPI_GetGeoSize(). This means that you will need to call
12893 /// ::HAPI_GetGeoSize() again before you can call this function.
12894 ///
12895 /// @ingroup Caching
12896 ///
12897 /// @param[in] session
12898 /// The session of Houdini you are interacting with.
12899 /// See @ref HAPI_Sessions for more on sessions.
12900 /// Pass NULL to just use the default in-process session.
12901 /// <!-- default NULL -->
12902 ///
12903 /// @param[in] node_id
12904 /// The node id.
12905 ///
12906 /// @param[out] buffer
12907 /// The buffer we will write into.
12908 ///
12909 /// @param[in] length
12910 /// The size of the buffer passed in.
12911 /// <!-- source ::HAPI_GetGeoSize -->
12912 ///
12914  HAPI_NodeId node_id,
12915  char * buffer,
12916  int length );
12917 
12918 /// @brief Loads a geometry from memory and put its
12919 /// contents onto a SOP node.
12920 ///
12921 /// @ingroup Caching
12922 ///
12923 /// @param[in] session
12924 /// The session of Houdini you are interacting with.
12925 /// See @ref HAPI_Sessions for more on sessions.
12926 /// Pass NULL to just use the default in-process session.
12927 /// <!-- default NULL -->
12928 ///
12929 /// @param[in] node_id
12930 /// The node id.
12931 ///
12932 /// @param[in] format
12933 /// The file format, ie. "obj", "bgeo" etc.
12934 ///
12935 /// @param[in] buffer
12936 /// The buffer we will read the geometry from.
12937 ///
12938 /// @param[in] length
12939 /// The size of the buffer passed in.
12940 /// <!-- source arglength(buffer) -->
12941 ///
12943  HAPI_NodeId node_id,
12944  const char * format,
12945  const char * buffer,
12946  int length );
12947 
12948 /// @brief Set the specified node's display flag.
12949 ///
12950 /// @ingroup Nodes
12951 ///
12952 /// @param[in] session
12953 /// The session of Houdini you are interacting with.
12954 /// See @ref HAPI_Sessions for more on sessions.
12955 /// Pass NULL to just use the default in-process session.
12956 /// <!-- default NULL -->
12957 ///
12958 /// @param[in] node_id
12959 /// The node id.
12960 ///
12961 /// @param[in] onOff
12962 /// Display flag.
12963 ///
12964 HAPI_DECL HAPI_SetNodeDisplay( const HAPI_Session * session,
12965  HAPI_NodeId node_id,
12966  int onOff );
12967 
12968 /// @brief Get the specified node's total cook count, including
12969 /// its children, if specified.
12970 ///
12971 /// @ingroup Nodes
12972 ///
12973 /// @param[in] session
12974 /// The session of Houdini you are interacting with.
12975 /// See @ref HAPI_Sessions for more on sessions.
12976 /// Pass NULL to just use the default in-process session.
12977 /// <!-- default NULL -->
12978 ///
12979 /// @param[in] node_id
12980 /// The node id.
12981 ///
12982 /// @param[in] node_type_filter
12983 /// The node type by which to filter the children.
12984 ///
12985 /// @param[in] node_flags_filter
12986 /// The node flags by which to filter the children.
12987 ///
12988 /// @param[in] recursive
12989 /// Whether or not to include the specified node's
12990 /// children cook count in the tally.
12991 ///
12992 /// @param[out] count
12993 /// The number of cooks in total for this session.
12994 ///
12996  HAPI_NodeId node_id,
12997  HAPI_NodeTypeBits node_type_filter,
12998  HAPI_NodeFlagsBits node_flags_filter,
12999  HAPI_Bool recursive,
13000  int * count );
13001 
13002 /// @defgroup SessionSync
13003 /// Functions for working with SessionSync
13004 
13005 /// @brief Enable or disable SessionSync mode.
13006 ///
13007 /// @ingroup SessionSync
13008 ///
13009 /// @param[in] session
13010 /// The session of Houdini you are interacting with.
13011 /// See @ref HAPI_Sessions for more on sessions.
13012 /// Pass NULL to just use the default in-process session.
13013 /// <!-- default NULL -->
13014 ///
13015 /// @param[in] enable
13016 /// Enable or disable SessionSync mode.
13017 ///
13018 HAPI_DECL HAPI_SetSessionSync( const HAPI_Session * session,
13019  HAPI_Bool enable );
13020 
13021 /// @brief Get the ::HAPI_Viewport info for synchronizing viewport in
13022 /// SessionSync. When SessionSync is running this will
13023 /// return Houdini's current viewport information.
13024 ///
13025 /// @ingroup SessionSync
13026 ///
13027 /// @param[in] session
13028 /// The session of Houdini you are interacting with.
13029 /// See @ref HAPI_Sessions for more on sessions.
13030 /// Pass NULL to just use the default in-process session.
13031 ///
13032 /// @param[out] viewport
13033 /// The output ::HAPI_Viewport.
13034 ///
13035 HAPI_DECL HAPI_GetViewport( const HAPI_Session * session,
13036  HAPI_Viewport * viewport );
13037 
13038 /// @brief Set the ::HAPI_Viewport info for synchronizing viewport in
13039 /// SessionSync. When SessionSync is running, this can be
13040 /// used to set the viewport information which Houdini
13041 /// will then synchronizse with for its viewport.
13042 ///
13043 /// @ingroup SessionSync
13044 ///
13045 /// @param[in] session
13046 /// The session of Houdini you are interacting with.
13047 /// See @ref HAPI_Sessions for more on sessions.
13048 /// Pass NULL to just use the default in-process session.
13049 ///
13050 /// @param[in] viewport
13051 /// A ::HAPI_Viewport that stores the viewport.
13052 ///
13053 HAPI_DECL HAPI_SetViewport( const HAPI_Session * session,
13054  const HAPI_Viewport * viewport );
13055 
13056 /// @brief Get the ::HAPI_SessionSyncInfo for synchronizing SessionSync
13057 /// state between Houdini and Houdini Engine integrations.
13058 ///
13059 /// @ingroup SessionSync
13060 ///
13061 /// @param[in] session
13062 /// The session of Houdini you are interacting with.
13063 /// See @ref HAPI_Sessions for more on sessions.
13064 /// Pass NULL to just use the default in-process session.
13065 ///
13066 /// @param[out] session_sync_info
13067 /// The output ::HAPI_SessionSyncInfo.
13068 ///
13070  const HAPI_Session * session,
13071  HAPI_SessionSyncInfo * session_sync_info );
13072 
13073 /// @brief Set the ::HAPI_SessionSyncInfo for synchronizing SessionSync
13074 /// state between Houdini and Houdini Engine integrations.
13075 ///
13076 /// @ingroup SessionSync
13077 ///
13078 /// @param[in] session
13079 /// The session of Houdini you are interacting with.
13080 /// See @ref HAPI_Sessions for more on sessions.
13081 /// Pass NULL to just use the default in-process session.
13082 ///
13083 /// @param[in] session_sync_info
13084 /// A ::HAPI_SessionSyncInfo that stores the state.
13085 ///
13087  const HAPI_Session * session,
13088  const HAPI_SessionSyncInfo * session_sync_info );
13089 
13090 /// @defgroup PDG PDG/TOPs
13091 /// Functions for working with PDG/TOPs
13092 
13093 /// @brief Return an array of PDG graph context names and ids, the first
13094 /// count names will be returned. These ids can be used
13095 /// with ::HAPI_GetPDGEvents and ::HAPI_GetPDGState. The values
13096 /// of the names can be retrieved with ::HAPI_GetString.
13097 ///
13098 /// @ingroup PDG
13099 ///
13100 /// @param[in] session
13101 /// The session of Houdini you are interacting with.
13102 /// See @ref HAPI_Sessions for more on sessions.
13103 /// Pass NULL to just use the default in-process session.
13104 /// <!-- default NULL -->
13105 ///
13106 /// @param[out] context_names_array
13107 /// Array of context names stored as ::HAPI_StringHandle
13108 /// at least the size of length. These can be used
13109 /// with ::HAPI_GetString() and are valid until the
13110 /// next call to this function.
13111 ///
13112 /// @param[out] context_id_array
13113 /// Array of graph context ids at least the size of length.
13114 ///
13115 /// @param[in] start
13116 /// First index of range. Must be at least @c 0 and at most
13117 /// @c context_count - 1 where @c context_count is the count
13118 /// returned by ::HAPI_GetPDGGraphContextsCount()
13119 /// <!-- min 0 -->
13120 /// <!-- max ::HAPI_GetPDGGraphContextsCount -->
13121 /// <!-- default 0 -->
13122 ///
13123 /// @param[in] length
13124 /// Given @c num_contexts returned by ::HAPI_GetPDGGraphContextsCount(),
13125 /// length should be at least @c 0 and at most <tt>num_contexts - start.</tt>
13126 /// <!-- default 0 -->
13128  HAPI_StringHandle * context_names_array,
13129  HAPI_PDG_GraphContextId * context_id_array,
13130  int start,
13131  int length );
13132 
13133 /// @brief Return the total number of PDG graph contexts found.
13134 ///
13135 /// @ingroup PDG
13136 ///
13137 /// @param[in] session
13138 /// The session of Houdini you are interacting with.
13139 /// See @ref HAPI_Sessions for more on sessions.
13140 /// Pass NULL to just use the default in-process session.
13141 /// <!-- default NULL -->
13142 ///
13143 /// @param[out] num_contexts
13144 /// Total PDG graph contexts count.
13145 ///
13147  const HAPI_Session* session,
13148  int* num_contexts );
13149 
13150 /// @brief Get the PDG graph context for the specified TOP node.
13151 ///
13152 /// @ingroup PDG
13153 ///
13154 /// @param[in] session
13155 /// The session of Houdini you are interacting with.
13156 /// See @ref HAPI_Sessions for more on sessions.
13157 /// Pass NULL to just use the default in-process session.
13158 /// <!-- default NULL -->
13159 ///
13160 /// @param[in] top_node_id
13161 /// The id of the TOP node to query its graph context.
13162 ///
13163 /// @param[out] context_id
13164 /// The PDG graph context id.
13165 ///
13167  HAPI_NodeId top_node_id,
13168  HAPI_PDG_GraphContextId * context_id );
13169 
13170 /// @brief Starts a PDG cooking operation. This can be asynchronous.
13171 /// Progress can be checked with ::HAPI_GetPDGState() and
13172 /// ::HAPI_GetPDGState(). Events generated during this cook can be
13173 /// collected with ::HAPI_GetPDGEvents(). Any uncollected events will be
13174 /// discarded at the start of the cook.
13175 ///
13176 /// If there are any $HIPFILE file dependencies on nodes involved in the cook
13177 /// a hip file will be automatically saved to $HOUDINI_TEMP_DIR directory so
13178 /// that it can be copied to the working directory by the scheduler. This means
13179 /// $HIP will be equal to $HOUDINI_TEMP_DIR.
13180 ///
13181 /// @ingroup PDG
13182 ///
13183 /// @param[in] session
13184 /// The session of Houdini you are interacting with.
13185 /// See @ref HAPI_Sessions for more on sessions.
13186 /// Pass NULL to just use the default in-process session.
13187 ///
13188 /// @param[in] cook_node_id
13189 /// The node id of a TOP node for the cook operation.
13190 ///
13191 /// @param[in] generate_only
13192 /// 1 means only static graph generation will done. 0 means
13193 /// a full graph cook. Generation is always blocking.
13194 ///
13195 /// @param[in] blocking
13196 /// 0 means return immediately and cooking will be done
13197 /// asynchronously. 1 means return when cooking completes.
13198 ///
13199 HAPI_DECL HAPI_CookPDG( const HAPI_Session * session,
13200  HAPI_NodeId cook_node_id,
13201  int generate_only,
13202  int blocking );
13203 
13204 /// @brief Starts a PDG cooking operation. This can be asynchronous.
13205 /// Progress can be checked with ::HAPI_GetPDGState() and
13206 /// ::HAPI_GetPDGState(). Events generated during this cook can be
13207 /// collected with ::HAPI_GetPDGEvents(). Any uncollected events will be
13208 /// discarded at the start of the cook.
13209 ///
13210 /// If there are any $HIPFILE file dependencies on nodes involved in the
13211 /// cook a hip file will be automatically saved to $HOUDINI_TEMP_DIR
13212 /// directory so that it can be copied to the working directory by the
13213 /// scheduler. This means $HIP will be equal to $HOUDINI_TEMP_DIR.
13214 ///
13215 /// If cook_node_id is a network / subnet, then if it has output nodes
13216 /// it cooks all of its output nodes and not just output 0. If it does
13217 /// not have output nodes it cooks the node with the output flag.
13218 ///
13219 /// @ingroup PDG
13220 ///
13221 /// @param[in] session
13222 /// The session of Houdini you are interacting with.
13223 /// See @ref HAPI_Sessions for more on sessions.
13224 /// Pass NULL to just use the default in-process session.
13225 ///
13226 /// @param[in] cook_node_id
13227 /// The node id of a TOP node for the cook operation.
13228 ///
13229 /// @param[in] generate_only
13230 /// 1 means only static graph generation will done. 0 means
13231 /// a full graph cook. Generation is always blocking.
13232 ///
13233 /// @param[in] blocking
13234 /// 0 means return immediately and cooking will be done
13235 /// asynchronously. 1 means return when cooking completes.
13236 ///
13238  const HAPI_Session* session,
13239  HAPI_NodeId cook_node_id,
13240  int generate_only,
13241  int blocking);
13242 
13243 /// @brief Returns PDG events that have been collected. Calling this function
13244 /// will remove those events from the queue. Events collection is restarted
13245 /// by calls to ::HAPI_CookPDG().
13246 ///
13247 /// @ingroup PDG
13248 ///
13249 ///
13250 /// @param[in] session
13251 /// The session of Houdini you are interacting with.
13252 /// See @ref HAPI_Sessions for more on sessions.
13253 /// Pass NULL to just use the default in-process session.
13254 /// <!-- default NULL -->
13255 ///
13256 /// @param[in] graph_context_id
13257 /// The id of the graph context
13258 ///
13259 /// @param[out] event_array
13260 /// buffer of ::HAPI_PDG_EventInfo of size at least length.
13261 ///
13262 /// @param[in] length
13263 /// The size of the buffer passed in.
13264 ///
13265 /// @param[out] event_count
13266 /// Number of events removed from queue and copied to buffer.
13267 ///
13268 /// @param[out] remaining_events
13269 /// Number of queued events remaining after this operation.
13270 ///
13271 HAPI_DECL HAPI_GetPDGEvents( const HAPI_Session * session,
13272  HAPI_PDG_GraphContextId graph_context_id,
13273  HAPI_PDG_EventInfo * event_array,
13274  int length,
13275  int * event_count,
13276  int * remaining_events );
13277 
13278 /// @brief Gets the state of a PDG graph
13279 ///
13280 /// @ingroup PDG
13281 ///
13282 ///
13283 /// @param[in] session
13284 /// The session of Houdini you are interacting with.
13285 /// See @ref HAPI_Sessions for more on sessions.
13286 /// Pass NULL to just use the default in-process session.
13287 /// <!-- default NULL -->
13288 ///
13289 /// @param[in] graph_context_id
13290 /// The graph context id
13291 ///
13292 /// @param[out] pdg_state
13293 /// One of ::HAPI_PDG_State.
13294 ///
13295 HAPI_DECL HAPI_GetPDGState( const HAPI_Session * session,
13296  HAPI_PDG_GraphContextId graph_context_id,
13297  int * pdg_state );
13298 
13299 /// @brief Creates a new pending workitem for the given node. The workitem
13300 /// will not be submitted to the graph until it is committed with
13301 /// ::HAPI_CommitWorkitems(). The node is expected to be a generator type.
13302 ///
13303 /// @ingroup PDG
13304 ///
13305 /// @param[in] session
13306 /// The session of Houdini you are interacting with.
13307 /// See @ref HAPI_Sessions for more on sessions.
13308 /// Pass NULL to just use the default in-process session.
13309 /// <!-- default NULL -->
13310 ///
13311 /// @param[in] node_id
13312 /// The node id.
13313 ///
13314 /// @param[out] workitem_id
13315 /// The id of the pending workitem.
13316 ///
13317 /// @param[in] name
13318 /// The null-terminated name of the workitem. The name will
13319 /// be automatically suffixed to make it unique.
13320 ///
13321 /// @param[in] index
13322 /// The index of the workitem. The semantics of the index
13323 /// are user defined.
13324 ///
13326 HAPI_CreateWorkitem( const HAPI_Session * session,
13327  HAPI_NodeId node_id,
13328  HAPI_PDG_WorkItemId * workitem_id,
13329  const char * name,
13330  int index );
13331 
13332 /// @brief Retrieves the info of a given workitem by id.
13333 ///
13334 /// @ingroup PDG
13335 ///
13336 /// @param[in] session
13337 /// The session of Houdini you are interacting with.
13338 /// See @ref HAPI_Sessions for more on sessions.
13339 /// Pass NULL to just use the default in-process session.
13340 /// <!-- default NULL -->
13341 ///
13342 /// @param[in] graph_context_id
13343 /// The graph context that the workitem is in.
13344 ///
13345 /// @param[in] workitem_id
13346 /// The id of the workitem.
13347 ///
13348 /// @param[out] workitem_info
13349 /// The returned ::HAPI_PDG_WorkItemInfo for the workitem. Note
13350 /// that the enclosed string handle is only valid until the next
13351 /// call to this function.
13352 ///
13354 HAPI_GetWorkitemInfo( const HAPI_Session * session,
13355  HAPI_PDG_GraphContextId graph_context_id,
13356  HAPI_PDG_WorkItemId workitem_id,
13357  HAPI_PDG_WorkItemInfo * workitem_info );
13358 
13359 /// @brief Adds integer data to a pending PDG workitem data member for the given node.
13360 ///
13361 /// @ingroup PDG
13362 ///
13363 /// @param[in] session
13364 /// The session of Houdini you are interacting with.
13365 /// See @ref HAPI_Sessions for more on sessions.
13366 /// Pass NULL to just use the default in-process session.
13367 /// <!-- default NULL -->
13368 ///
13369 /// @param[in] node_id
13370 /// The node id.
13371 ///
13372 /// @param[in] workitem_id
13373 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem()
13374 ///
13375 /// @param[in] data_name
13376 /// null-terminated name of the data member
13377 ///
13378 /// @param[in] values_array
13379 /// array of integer values
13380 ///
13381 /// @param[in] length
13382 /// number of values to copy from values_array to the parameter
13383 ///
13385 HAPI_SetWorkitemIntData( const HAPI_Session * session,
13386  HAPI_NodeId node_id,
13387  HAPI_PDG_WorkItemId workitem_id,
13388  const char * data_name,
13389  const int * values_array,
13390  int length );
13391 
13392 /// @brief Adds float data to a pending PDG workitem data member for the given node.
13393 ///
13394 /// @ingroup PDG
13395 ///
13396 /// @param[in] session
13397 /// The session of Houdini you are interacting with.
13398 /// See @ref HAPI_Sessions for more on sessions.
13399 /// Pass NULL to just use the default in-process session.
13400 /// <!-- default NULL -->
13401 ///
13402 /// @param[in] node_id
13403 /// The node id.
13404 ///
13405 /// @param[in] workitem_id
13406 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem()
13407 ///
13408 /// @param[in] data_name
13409 /// null-terminated name of the workitem data member
13410 ///
13411 /// @param[in] values_array
13412 /// array of float values
13413 ///
13414 /// @param[in] length
13415 /// number of values to copy from values_array to the parameter
13416 ///
13418 HAPI_SetWorkitemFloatData( const HAPI_Session * session,
13419  HAPI_NodeId node_id,
13420  HAPI_PDG_WorkItemId workitem_id,
13421  const char * data_name,
13422  const float * values_array,
13423  int length );
13424 
13425 /// @brief Adds integer data to a pending PDG workitem data member for the given node.
13426 ///
13427 /// @ingroup PDG
13428 ///
13429 /// @param[in] session
13430 /// The session of Houdini you are interacting with.
13431 /// See @ref HAPI_Sessions for more on sessions.
13432 /// Pass NULL to just use the default in-process session.
13433 /// <!-- default NULL -->
13434 ///
13435 /// @param[in] node_id
13436 /// The node id.
13437 ///
13438 /// @param[in] workitem_id
13439 /// The id of the created workitem returned by HAPI_CreateWorkitem()
13440 ///
13441 /// @param[in] data_name
13442 /// null-terminated name of the data member
13443 ///
13444 /// @param[in] data_index
13445 /// index of the string data member
13446 ///
13447 /// @param[in] value
13448 /// null-terminated string to copy to the workitem data member
13449 ///
13451 HAPI_SetWorkitemStringData( const HAPI_Session * session,
13452  HAPI_NodeId node_id,
13453  HAPI_PDG_WorkItemId workitem_id,
13454  const char * data_name,
13455  int data_index,
13456  const char * value );
13457 
13458 /// @brief Commits any pending workitems.
13459 ///
13460 /// @ingroup PDG
13461 ///
13462 /// @param[in] session
13463 /// The session of Houdini you are interacting with.
13464 /// See @ref HAPI_Sessions for more on sessions.
13465 /// Pass NULL to just use the default in-process session.
13466 /// <!-- default NULL -->
13467 ///
13468 /// @param[in] node_id
13469 /// The node id for which the pending workitems have been
13470 /// created but not yet injected.
13471 ///
13473 HAPI_CommitWorkitems( const HAPI_Session * session,
13474  HAPI_NodeId node_id );
13475 
13476 /// @brief Gets the number of workitems that are available on the given node.
13477 /// Should be used with ::HAPI_GetWorkitems.
13478 ///
13479 /// @ingroup PDG
13480 ///
13481 /// @param[in] session
13482 /// The session of Houdini you are interacting with.
13483 /// See @ref HAPI_Sessions for more on sessions.
13484 /// Pass NULL to just use the default in-process session.
13485 /// <!-- default NULL -->
13486 ///
13487 /// @param[in] node_id
13488 /// The node id.
13489 ///
13490 /// @param[out] num
13491 /// The number of workitems.
13492 ///
13494 HAPI_GetNumWorkitems( const HAPI_Session * session,
13495  HAPI_NodeId node_id,
13496  int * num );
13497 
13498 /// @brief Gets the list of work item ids for the given node
13499 ///
13500 /// @ingroup PDG
13501 ///
13502 /// @param[in] session
13503 /// The session of Houdini you are interacting with.
13504 /// See @ref HAPI_Sessions for more on sessions.
13505 /// Pass NULL to just use the default in-process session.
13506 /// <!-- default NULL -->
13507 ///
13508 /// @param[in] node_id
13509 /// The node id.
13510 ///
13511 /// @param[out] workitem_ids_array
13512 /// buffer for resulting array of ::HAPI_PDG_WorkItemId
13513 ///
13514 /// @param[in] length
13515 /// The length of the @p workitem_ids buffer
13516 ///
13518 HAPI_GetWorkitems( const HAPI_Session * session,
13519  HAPI_NodeId node_id,
13520  int * workitem_ids_array,
13521  int length );
13522 
13523 /// @brief Gets the length of the workitem data member.
13524 /// It is the length of the array of data.
13525 ///
13526 /// @ingroup PDG
13527 ///
13528 /// @param[in] session
13529 /// The session of Houdini you are interacting with.
13530 /// See @ref HAPI_Sessions for more on sessions.
13531 /// Pass NULL to just use the default in-process session.
13532 /// <!-- default NULL -->
13533 ///
13534 /// @param[in] node_id
13535 /// The node id.
13536 ///
13537 /// @param[in] workitem_id
13538 /// The id of the workitem
13539 ///
13540 /// @param[in] data_name
13541 /// null-terminated name of the data member
13542 ///
13543 /// @param[out] length
13544 /// The length of the data member array
13545 ///
13546 HAPI_DECL_DEPRECATED_REPLACE(5.0.0, 19.5.161, HAPI_GetWorkItemDataSize)
13547 HAPI_GetWorkitemDataLength( const HAPI_Session * session,
13548  HAPI_NodeId node_id,
13549  HAPI_PDG_WorkItemId workitem_id,
13550  const char * data_name,
13551  int * length );
13552 
13553 /// @brief Gets int data from a work item member.
13554 ///
13555 /// @ingroup PDG
13556 ///
13557 /// @param[in] session
13558 /// The session of Houdini you are interacting with.
13559 /// See @ref HAPI_Sessions for more on sessions.
13560 /// Pass NULL to just use the default in-process session.
13561 /// <!-- default NULL -->
13562 ///
13563 /// @param[in] node_id
13564 /// The node id.
13565 ///
13566 /// @param[in] workitem_id
13567 /// The id of the workitem
13568 ///
13569 /// @param[in] data_name
13570 /// null-terminated name of the data member
13571 ///
13572 /// @param[out] data_array
13573 /// buffer of at least size length to copy the data into. The required
13574 /// length should be determined by ::HAPI_GetWorkitemDataLength().
13575 ///
13576 /// @param[in] length
13577 /// The length of @p data_array
13578 ///
13580 HAPI_GetWorkitemIntData( const HAPI_Session * session,
13581  HAPI_NodeId node_id,
13582  HAPI_PDG_WorkItemId workitem_id,
13583  const char * data_name,
13584  int * data_array,
13585  int length );
13586 
13587 /// @brief Gets float data from a work item member.
13588 ///
13589 /// @ingroup PDG
13590 ///
13591 /// @param[in] session
13592 /// The session of Houdini you are interacting with.
13593 /// See @ref HAPI_Sessions for more on sessions.
13594 /// Pass NULL to just use the default in-process session.
13595 /// <!-- default NULL -->
13596 ///
13597 /// @param[in] node_id
13598 /// The node id.
13599 ///
13600 /// @param[in] workitem_id
13601 /// The id of the workitem
13602 ///
13603 /// @param[in] data_name
13604 /// null-terminated name of the data member
13605 ///
13606 /// @param[out] data_array
13607 /// buffer of at least size length to copy the data into. The required
13608 /// length should be determined by ::HAPI_GetWorkitemDataLength().
13609 ///
13610 /// @param[in] length
13611 /// The length of the @p data_array
13612 ///
13614 HAPI_GetWorkitemFloatData( const HAPI_Session * session,
13615  HAPI_NodeId node_id,
13616  HAPI_PDG_WorkItemId workitem_id,
13617  const char * data_name,
13618  float * data_array,
13619  int length );
13620 
13621 /// @brief Gets string ids from a work item member.
13622 ///
13623 /// @ingroup PDG
13624 ///
13625 /// @param[in] session
13626 /// The session of Houdini you are interacting with.
13627 /// See @ref HAPI_Sessions for more on sessions.
13628 /// Pass NULL to just use the default in-process session.
13629 /// <!-- default NULL -->
13630 ///
13631 /// @param[in] node_id
13632 /// The node id.
13633 ///
13634 /// @param[in] workitem_id
13635 /// The id of the workitem
13636 ///
13637 /// @param[in] data_name
13638 /// null-terminated name of the data member
13639 ///
13640 /// @param[out] data_array
13641 /// buffer of at least size length to copy the data into. The required
13642 /// length should be determined by ::HAPI_GetWorkitemDataLength().
13643 /// The data is an array of ::HAPI_StringHandle which can be used with
13644 /// ::HAPI_GetString(). The string handles are valid until the
13645 /// next call to this function.
13646 ///
13647 /// @param[in] length
13648 /// The length of @p data_array
13649 ///
13651 HAPI_GetWorkitemStringData( const HAPI_Session * session,
13652  HAPI_NodeId node_id,
13653  HAPI_PDG_WorkItemId workitem_id,
13654  const char * data_name,
13655  HAPI_StringHandle * data_array,
13656  int length );
13657 
13658 /// @brief Gets the info for workitem results.
13659 /// The number of workitem results is found on the ::HAPI_PDG_WorkItemInfo
13660 /// returned by ::HAPI_GetWorkitemInfo()
13661 ///
13662 /// @ingroup PDG
13663 ///
13664 /// @param[in] session
13665 /// The session of Houdini you are interacting with.
13666 /// See @ref HAPI_Sessions for more on sessions.
13667 /// Pass NULL to just use the default in-process session.
13668 /// <!-- default NULL -->
13669 ///
13670 /// @param[in] node_id
13671 /// The node id.
13672 ///
13673 /// @param[in] workitem_id
13674 /// The id of the workitem
13675 ///
13676 /// @param[out] resultinfo_array
13677 /// Buffer to fill with info structs. String handles are valid
13678 /// until the next call of this function.
13679 ///
13680 /// @param[in] resultinfo_count
13681 /// The length of @p resultinfo_array
13682 ///
13684 HAPI_GetWorkitemResultInfo( const HAPI_Session * session,
13685  HAPI_NodeId node_id,
13686  HAPI_PDG_WorkItemId workitem_id,
13687  HAPI_PDG_WorkItemOutputFile * resultinfo_array,
13688  int resultinfo_count );
13689 
13690 /// @brief Creates a new pending work item for the given node. The work item
13691 /// will not be submitted to the graph until it is committed with
13692 /// ::HAPI_CommitWorkItems(). The node is expected to be a generator type.
13693 ///
13694 /// @ingroup PDG
13695 ///
13696 /// @param[in] session
13697 /// The session of Houdini you are interacting with.
13698 /// See @ref HAPI_Sessions for more on sessions.
13699 /// Pass NULL to just use the default in-process session.
13700 /// <!-- default NULL -->
13701 ///
13702 /// @param[in] node_id
13703 /// The node id.
13704 ///
13705 /// @param[out] work_item_id
13706 /// The id of the pending workitem.
13707 ///
13708 /// @param[in] name
13709 /// The null-terminated name of the work item. The name will
13710 /// be automatically suffixed to make it unique.
13711 ///
13712 /// @param[in] index
13713 /// The index of the work item. The semantics of the index
13714 /// are user defined.
13715 ///
13716 HAPI_DECL HAPI_CreateWorkItem( const HAPI_Session * session,
13717  HAPI_NodeId node_id,
13718  HAPI_PDG_WorkItemId * work_item_id,
13719  const char * name,
13720  int index );
13721 
13722 /// @brief Retrieves the info of a given work item by id.
13723 ///
13724 /// @ingroup PDG
13725 ///
13726 /// @param[in] session
13727 /// The session of Houdini you are interacting with.
13728 /// See @ref HAPI_Sessions for more on sessions.
13729 /// Pass NULL to just use the default in-process session.
13730 /// <!-- default NULL -->
13731 ///
13732 /// @param[in] graph_context_id
13733 /// The graph context that the work item is in.
13734 ///
13735 /// @param[in] work_item_id
13736 /// The id of the work item.
13737 ///
13738 /// @param[out] work_item_info
13739 /// The returned ::HAPI_PDG_WorkItemInfo for the work item. Note
13740 /// that the enclosed string handle is only valid until the next
13741 /// call to this function.
13742 ///
13744  HAPI_PDG_GraphContextId graph_context_id,
13745  HAPI_PDG_WorkItemId work_item_id,
13746  HAPI_PDG_WorkItemInfo * work_item_info );
13747 
13748 /// @brief Adds integer data to a pending PDG work item attribute for the given node.
13749 ///
13750 /// @ingroup PDG
13751 ///
13752 /// @param[in] session
13753 /// The session of Houdini you are interacting with.
13754 /// See @ref HAPI_Sessions for more on sessions.
13755 /// Pass NULL to just use the default in-process session.
13756 /// <!-- default NULL -->
13757 ///
13758 /// @param[in] node_id
13759 /// The node id.
13760 ///
13761 /// @param[in] work_item_id
13762 /// The id of the pending work item returned by ::HAPI_CreateWorkItem()
13763 ///
13764 /// @param[in] attribute_name
13765 /// null-terminated name of the work item attribute
13766 ///
13767 /// @param[in] values_array
13768 /// array of integer values
13769 ///
13770 /// @param[in] length
13771 /// number of values to copy from values_array to the parameter
13772 ///
13774  HAPI_NodeId node_id,
13775  HAPI_PDG_WorkItemId work_item_id,
13776  const char * attribute_name,
13777  const int * values_array,
13778  int length );
13779 
13780 /// @brief Adds float data to a pending PDG work item attribute 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[in] work_item_id
13794 /// The id of the pending work item returned by ::HAPI_CreateWorkItem()
13795 ///
13796 /// @param[in] attribute_name
13797 /// null-terminated name of the work item attribute
13798 ///
13799 /// @param[in] values_array
13800 /// array of float values
13801 ///
13802 /// @param[in] length
13803 /// number of values to copy from values_array to the parameter
13804 ///
13806  HAPI_NodeId node_id,
13807  HAPI_PDG_WorkItemId work_item_id,
13808  const char * attribute_name,
13809  const float * values_array,
13810  int length );
13811 
13812 /// @brief Adds integer data to a pending PDG work item attribute for the given node.
13813 ///
13814 /// @ingroup PDG
13815 ///
13816 /// @param[in] session
13817 /// The session of Houdini you are interacting with.
13818 /// See @ref HAPI_Sessions for more on sessions.
13819 /// Pass NULL to just use the default in-process session.
13820 /// <!-- default NULL -->
13821 ///
13822 /// @param[in] node_id
13823 /// The node id.
13824 ///
13825 /// @param[in] work_item_id
13826 /// The id of the created work item returned by HAPI_CreateWorkItem()
13827 ///
13828 /// @param[in] attribute_name
13829 /// null-terminated name of the work item attribute
13830 ///
13831 /// @param[in] data_index
13832 /// index of the string data member
13833 ///
13834 /// @param[in] value
13835 /// null-terminated string to copy to the work item data member
13836 ///
13838  HAPI_NodeId node_id,
13839  HAPI_PDG_WorkItemId work_item_id,
13840  const char * attribute_name,
13841  int data_index,
13842  const char * value );
13843 
13844 /// @brief Commits any pending work items.
13845 ///
13846 /// @ingroup PDG
13847 ///
13848 /// @param[in] session
13849 /// The session of Houdini you are interacting with.
13850 /// See @ref HAPI_Sessions for more on sessions.
13851 /// Pass NULL to just use the default in-process session.
13852 /// <!-- default NULL -->
13853 ///
13854 /// @param[in] node_id
13855 /// The node id for which the pending work items have been
13856 /// created but not yet injected.
13857 ///
13859  HAPI_NodeId node_id );
13860 
13861 /// @brief Gets the number of work items that are available on the given node.
13862 /// Should be used with ::HAPI_GetWorkItems.
13863 ///
13864 /// @ingroup PDG
13865 ///
13866 /// @param[in] session
13867 /// The session of Houdini you are interacting with.
13868 /// See @ref HAPI_Sessions for more on sessions.
13869 /// Pass NULL to just use the default in-process session.
13870 /// <!-- default NULL -->
13871 ///
13872 /// @param[in] node_id
13873 /// The node id.
13874 ///
13875 /// @param[out] num
13876 /// The number of work items.
13877 ///
13879  HAPI_NodeId node_id,
13880  int * num );
13881 
13882 /// @brief Gets the list of work item ids for the given node
13883 ///
13884 /// @ingroup PDG
13885 ///
13886 /// @param[in] session
13887 /// The session of Houdini you are interacting with.
13888 /// See @ref HAPI_Sessions for more on sessions.
13889 /// Pass NULL to just use the default in-process session.
13890 /// <!-- default NULL -->
13891 ///
13892 /// @param[in] node_id
13893 /// The node id.
13894 ///
13895 /// @param[out] work_item_ids_array
13896 /// buffer for resulting array of ::HAPI_PDG_WorkItemId
13897 ///
13898 /// @param[in] length
13899 /// The length of the @p work_item_ids buffer
13900 ///
13901 HAPI_DECL HAPI_GetWorkItems( const HAPI_Session * session,
13902  HAPI_NodeId node_id,
13903  int * work_item_ids_array,
13904  int length );
13905 
13906 /// @brief Gets the size of the work item attribute.
13907 /// It is the length of the array of data.
13908 ///
13909 /// @ingroup PDG
13910 ///
13911 /// @param[in] session
13912 /// The session of Houdini you are interacting with.
13913 /// See @ref HAPI_Sessions for more on sessions.
13914 /// Pass NULL to just use the default in-process session.
13915 /// <!-- default NULL -->
13916 ///
13917 /// @param[in] node_id
13918 /// The node id.
13919 ///
13920 /// @param[in] work_item_id
13921 /// The id of the work item
13922 ///
13923 /// @param[in] attribute_name
13924 /// null-terminated name of the work item attribute
13925 ///
13926 /// @param[out] length
13927 /// The length of the data member array
13928 ///
13930  HAPI_NodeId node_id,
13931  HAPI_PDG_WorkItemId work_item_id,
13932  const char * attribute_name,
13933  int * length );
13934 
13935 /// @brief Gets int data from a work item attribute.
13936 ///
13937 /// @ingroup PDG
13938 ///
13939 /// @param[in] session
13940 /// The session of Houdini you are interacting with.
13941 /// See @ref HAPI_Sessions for more on sessions.
13942 /// Pass NULL to just use the default in-process session.
13943 /// <!-- default NULL -->
13944 ///
13945 /// @param[in] node_id
13946 /// The node id.
13947 ///
13948 /// @param[in] work_item_id
13949 /// The id of the work_item
13950 ///
13951 /// @param[in] attribute_name
13952 /// null-terminated name of the work item attribute
13953 ///
13954 /// @param[out] data_array
13955 /// buffer of at least size length to copy the data into. The required
13956 /// length should be determined by ::HAPI_GetWorkItemDataLength().
13957 ///
13958 /// @param[in] length
13959 /// The length of @p data_array
13960 ///
13962  HAPI_NodeId node_id,
13963  HAPI_PDG_WorkItemId work_item_id,
13964  const char * attribute_name,
13965  int * data_array,
13966  int length );
13967 
13968 /// @brief Gets float data from a work item attribute.
13969 ///
13970 /// @ingroup PDG
13971 ///
13972 /// @param[in] session
13973 /// The session of Houdini you are interacting with.
13974 /// See @ref HAPI_Sessions for more on sessions.
13975 /// Pass NULL to just use the default in-process session.
13976 /// <!-- default NULL -->
13977 ///
13978 /// @param[in] node_id
13979 /// The node id.
13980 ///
13981 /// @param[in] work_item_id
13982 /// The id of the work_item
13983 ///
13984 /// @param[in] attribute_name
13985 /// null-terminated name of the work item attribute
13986 ///
13987 /// @param[out] data_array
13988 /// buffer of at least size length to copy the data into. The required
13989 /// length should be determined by ::HAPI_GetWorkItemDataLength().
13990 ///
13991 /// @param[in] length
13992 /// The length of the @p data_array
13993 ///
13995  HAPI_NodeId node_id,
13996  HAPI_PDG_WorkItemId work_item_id,
13997  const char * attribute_name,
13998  float * data_array,
13999  int length );
14000 
14001 /// @brief Gets string ids from a work item attribute.
14002 ///
14003 /// @ingroup PDG
14004 ///
14005 /// @param[in] session
14006 /// The session of Houdini you are interacting with.
14007 /// See @ref HAPI_Sessions for more on sessions.
14008 /// Pass NULL to just use the default in-process session.
14009 /// <!-- default NULL -->
14010 ///
14011 /// @param[in] node_id
14012 /// The node id.
14013 ///
14014 /// @param[in] work_item_id
14015 /// The id of the work item
14016 ///
14017 /// @param[in] attribute_name
14018 /// null-terminated name of the work item attribute
14019 ///
14020 /// @param[out] data_array
14021 /// buffer of at least size length to copy the data into. The required
14022 /// length should be determined by ::HAPI_GetWorkItemDataLength().
14023 /// The data is an array of ::HAPI_StringHandle which can be used with
14024 /// ::HAPI_GetString(). The string handles are valid until the
14025 /// next call to this function.
14026 ///
14027 /// @param[in] length
14028 /// The length of @p data_array
14029 ///
14031  HAPI_NodeId node_id,
14032  HAPI_PDG_WorkItemId work_item_id,
14033  const char * attribute_name,
14034  HAPI_StringHandle * data_array,
14035  int length );
14036 
14037 /// @brief Gets the info for work item output files.
14038 /// The number of work item results is found on the ::HAPI_PDG_WorkItemInfo
14039 /// returned by ::HAPI_GetWorkItemInfo()
14040 ///
14041 /// @ingroup PDG
14042 ///
14043 /// @param[in] session
14044 /// The session of Houdini you are interacting with.
14045 /// See @ref HAPI_Sessions for more on sessions.
14046 /// Pass NULL to just use the default in-process session.
14047 /// <!-- default NULL -->
14048 ///
14049 /// @param[in] node_id
14050 /// The node id.
14051 ///
14052 /// @param[in] work_item_id
14053 /// The id of the work item
14054 ///
14055 /// @param[out] resultinfo_array
14056 /// Buffer to fill with info structs. String handles are valid
14057 /// until the next call of this function.
14058 ///
14059 /// @param[in] resultinfo_count
14060 /// The length of @p resultinfo_array
14061 ///
14063  HAPI_NodeId node_id,
14064  HAPI_PDG_WorkItemId work_item_id,
14065  HAPI_PDG_WorkItemOutputFile * resultinfo_array,
14066  int resultinfo_count );
14067 
14068 /// @brief Dirties the given node. Cancels the cook if necessary and then
14069 /// deletes all workitems on the node.
14070 ///
14071 /// @ingroup PDG
14072 ///
14073 /// @param[in] session
14074 /// The session of Houdini you are interacting with.
14075 /// See @ref HAPI_Sessions for more on sessions.
14076 /// Pass NULL to just use the default in-process session.
14077 /// <!-- default NULL -->
14078 ///
14079 /// @param[in] node_id
14080 /// The node id.
14081 ///
14082 /// @param[in] clean_results
14083 /// Remove the results generated by the node.
14084 /// <!-- default 0 -->
14085 ///
14086 HAPI_DECL HAPI_DirtyPDGNode( const HAPI_Session * session,
14087  HAPI_NodeId node_id,
14088  HAPI_Bool clean_results );
14089 
14090 /// @brief Pause the PDG cooking operation.
14091 ///
14092 /// @ingroup PDG
14093 ///
14094 /// @param[in] session
14095 /// The session of Houdini you are interacting with.
14096 /// See @ref HAPI_Sessions for more on sessions.
14097 /// Pass NULL to just use the default in-process session.
14098 /// <!-- default NULL -->
14099 ///
14100 /// @param[in] graph_context_id
14101 /// The id of the graph context
14102 ///
14103 HAPI_DECL HAPI_PausePDGCook( const HAPI_Session * session,
14104  HAPI_PDG_GraphContextId graph_context_id );
14105 
14106 /// @brief Cancel the PDG cooking operation.
14107 ///
14108 /// @ingroup PDG
14109 ///
14110 /// @param[in] session
14111 /// The session of Houdini you are interacting with.
14112 /// See @ref HAPI_Sessions for more on sessions.
14113 /// Pass NULL to just use the default in-process session.
14114 /// <!-- default NULL -->
14115 ///
14116 /// @param[in] graph_context_id
14117 /// The id of the graph context
14118 ///
14119 HAPI_DECL HAPI_CancelPDGCook( const HAPI_Session * session,
14120  HAPI_PDG_GraphContextId graph_context_id );
14121 
14122 #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:1848
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_GetTime(const HAPI_Session *session, double *time)
Gets the global time of the scene. All API calls deal with this time to cook.
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:519
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:2094
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:864
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...
GT_API const UT_StringHolder time
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_RenderCOPOutputToImage(const HAPI_Session *session, HAPI_NodeId cop_node_id, const char *cop_output_name)
Render a single texture from a COP to an image for later extraction. COPs may have multiple outputs...
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.
GLuint start
Definition: glcorearb.h:475
GLsizei const GLfloat * value
Definition: glcorearb.h:824
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.
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
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:769
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.
GT_API const UT_StringHolder cache_name
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.
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
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:831
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.
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glcorearb.h:2539
Info for a PDG work item.
Definition: HAPI_Common.h:2077
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...
GLuint buffer
Definition: glcorearb.h:660
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:1195
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:571
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...
PUGI__FN xpath_string string_value(const xpath_node &na, xpath_allocator *alloc)
Definition: pugixml.cpp:7990
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:1629
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:502
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:1152
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.
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
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:782
Data associated with a PDG Event.
Definition: HAPI_Common.h:2051
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:1722
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 ...
GA_API const UT_StringHolder trans
#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:277
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_ImagePacking
Definition: HAPI_Common.h:809
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.
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
Meta-data for a Houdini Node.
Definition: HAPI_Common.h:1353
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:279
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872
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:2159
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:909
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...
GLuint const GLchar * name
Definition: glcorearb.h:786
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_SetTime(const HAPI_Session *session, double time)
Sets the global time of the scene. All API calls will deal with this time to cook.
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:1123
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:1254
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_CreateCOPImage(const HAPI_Session *session, HAPI_NodeId parent_node_id, const int width, const int height, const HAPI_ImagePacking packing, HAPI_Bool flip_x, HAPI_Bool flip_y, const float *data_array, int start, int length)
Loads some raw image data into a COP node.
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.
GA_API const UT_StringHolder transform
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:1110
#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:1678
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...
GLsizeiptr size
Definition: glcorearb.h:664
A Transform with Euler rotation.
Definition: HAPI_Common.h:1095
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:1183
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_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 ...
GLuint index
Definition: glcorearb.h:786
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:491
Data for a Box Part.
Definition: HAPI_Common.h:2032
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...
GT_API const UT_StringHolder profile_id
HAPI_DECL HAPI_GetConnectionErrorLength(int *buffer_length)
Return the length of string buffer storing connection error message.
GLint GLsizei width
Definition: glcorearb.h:103
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:559
Data for a Sphere Part.
Definition: HAPI_Common.h:2041
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:1083
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:561
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 HAPI_Nodes_Basics.
Definition: HAPI_Common.h:165
Describes an image format, used with HAPI_GetSupportedImageFileFormats()
Definition: HAPI_Common.h:1839
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:876
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:1877
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:751
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...
GLint GLsizei count
Definition: glcorearb.h:405
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:1584
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