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 ///
40 
41 /// @brief Starts a Thrift RPC server process on the local host serving
42 /// clients on a TCP socket and waits for it to start serving.
43 /// It is safe to create an RPC session on local host using the
44 /// specified port after this call succeeds.
45 ///
46 /// @ingroup Sessions
47 /// @param[in] options
48 /// Options to configure the server being started.
49 ///
50 /// @param[in] port
51 /// The TCP socket to create on the server.
52 ///
53 /// @param[out] process_id
54 /// The process id of the server, if started successfully.
55 ///
56 /// @param[in] log_file
57 /// When a filepath is provided for this argument, all logs will
58 /// be appended to the specified file. The specfied path must be
59 /// an absolute path. The server will create any intermediate
60 /// directories in the filepath that do not already exist. When
61 /// this argument is NULL/nullptr, logging will be directed to
62 /// the standard streams.
63 ///
65  const HAPI_ThriftServerOptions * options,
66  int port,
67  HAPI_ProcessId * process_id,
68  const char * log_file );
69 
70 /// @brief Creates a Thrift RPC session using a TCP socket as transport.
71 ///
72 /// @ingroup Sessions
73 /// @param[out] session
74 /// A ::HAPI_Session struct to receive the unique session id
75 /// of the new session.
76 ///
77 /// @param[in] host_name
78 /// The name of the server host.
79 ///
80 /// @param[in] port
81 /// The server port to connect to.
82 ///
84  const char * host_name,
85  int port );
86 
87 /// @brief Starts a Thrift RPC server process on the local host serving
88 /// clients on a Windows named pipe or a Unix domain socket and
89 /// waits for it to start serving. It is safe to create an RPC
90 /// session using the specified pipe or socket after this call
91 /// succeeds.
92 ///
93 /// @ingroup Sessions
94 ///
95 /// @param[in] options
96 /// Options to configure the server being started.
97 ///
98 /// @param[in] pipe_name
99 /// The name of the pipe or socket.
100 ///
101 /// @param[out] process_id
102 /// The process id of the server, if started successfully.
103 ///
104 /// @param[in] log_file
105 /// When a filepath is provided for this argument, all logs will
106 /// be appended to the specified file. The specfied path must be
107 /// an absolute path. The server will create any intermediate
108 /// directories in the filepath that do not already exist. When
109 /// this argument is NULL/nullptr, logging will be directed to
110 /// the standard streams.
111 ///
113  const HAPI_ThriftServerOptions * options,
114  const char * pipe_name,
115  HAPI_ProcessId * process_id,
116  const char * log_file );
117 
118 /// @brief Creates a Thrift RPC session using a Windows named pipe
119 /// or a Unix domain socket as transport.
120 ///
121 /// @ingroup Sessions
122 ///
123 /// @param[out] session
124 /// A ::HAPI_Session struct to receive the unique session id
125 /// of the new session.
126 ///
127 /// @param[in] pipe_name
128 /// The name of the pipe or socket.
129 ///
131  const char * pipe_name );
132 
133 /// @brief Binds a new implementation DLL to one of the custom session
134 /// slots.
135 ///
136 /// @ingroup Sessions
137 ///
138 /// @param[in] session_type
139 /// Which custom implementation slot to bind the
140 /// DLL to. Must be one of ::HAPI_SESSION_CUSTOM1,
141 /// ::HAPI_SESSION_CUSTOM2, or ::HAPI_SESSION_CUSTOM3.
142 ///
143 /// @param[in] dll_path
144 /// The path to the custom implementation DLL.
145 ///
147  const char * dll_path );
148 
149 /// @brief Creates a new session using a custom implementation.
150 /// Note that the implementation DLL must already have
151 /// been bound to the session via calling
152 /// ::HAPI_BindCustomImplementation().
153 ///
154 /// @ingroup Sessions
155 ///
156 /// @param[in] session_type
157 /// session_type indicates which custom session
158 /// slot to create the session on.
159 ///
160 /// @param[in,out] session_info
161 /// Any data required by the custom implementation to
162 /// create its session.
163 ///
164 /// @param[out] session
165 /// A ::HAPI_Session struct to receive the session id,
166 /// The sessionType parameter of the struct should
167 /// also match the session_type parameter passed in.
168 ///
170  void * session_info,
171  HAPI_Session * session );
172 
173 /// @brief Checks whether the session identified by ::HAPI_Session::id is
174 /// a valid session opened in the implementation identified by
175 /// ::HAPI_Session::type.
176 ///
177 /// @ingroup Sessions
178 ///
179 /// @param[in] session
180 /// The ::HAPI_Session to check.
181 ///
182 /// @return ::HAPI_RESULT_SUCCESS if the session is valid.
183 /// Otherwise, the session is invalid and passing it to
184 /// other HAPI calls may result in undefined behavior.
185 ///
186 HAPI_DECL HAPI_IsSessionValid( const HAPI_Session * session );
187 
188 /// @brief Closes a session. If the session has been established using
189 /// RPC, then the RPC connection is closed.
190 ///
191 /// @ingroup Sessions
192 ///
193 /// @param[in] session
194 /// The HAPI_Session to close. After this call, this
195 /// session is invalid and passing it to HAPI calls other
196 /// than ::HAPI_IsSessionValid() may result in undefined
197 /// behavior.
198 ///
199 HAPI_DECL HAPI_CloseSession( const HAPI_Session * session );
200 
201 // INITIALIZATION / CLEANUP -------------------------------------------------
202 
203 /// @brief Check whether the runtime has been initialized yet using
204 /// ::HAPI_Initialize(). Function will return ::HAPI_RESULT_SUCCESS
205 /// if the runtime has been initialized and ::HAPI_RESULT_NOT_INITIALIZED
206 /// otherwise.
207 ///
208 /// @ingroup Sessions
209 ///
210 /// @param[in] session
211 /// The session of Houdini you are interacting with.
212 /// See @ref HAPI_Sessions for more on sessions.
213 /// Pass NULL to just use the default in-process session.
214 /// <!-- default NULL -->
215 ///
216 HAPI_DECL HAPI_IsInitialized( const HAPI_Session * session );
217 
218 /// @brief Create the asset manager, set up environment variables, and
219 /// initialize the main Houdini scene. No license check is done
220 /// during this step. Only when you try to load an asset library
221 /// (OTL) do we actually check for licenses.
222 ///
223 /// @ingroup Sessions
224 ///
225 /// @param[in] session
226 /// The session of Houdini you are interacting with.
227 /// See @ref HAPI_Sessions for more on sessions.
228 /// Pass NULL to just use the default in-process session.
229 /// <!-- default NULL -->
230 ///
231 /// @param[in] cook_options
232 /// Global cook options used by subsequent default cooks.
233 /// This can be overwritten by individual cooks but if
234 /// you choose to instantiate assets with cook_on_load
235 /// set to true then these cook options will be used.
236 ///
237 /// @param[in] use_cooking_thread
238 /// Use a separate thread for cooking of assets. This
239 /// allows for asynchronous cooking and larger stack size.
240 /// <!-- default true -->
241 ///
242 /// @param[in] cooking_thread_stack_size
243 /// Set the stack size of the cooking thread. Use -1 to
244 /// set the stack size to the Houdini default. This
245 /// value is in bytes.
246 /// <!-- default -1 -->
247 ///
248 /// @param[in] houdini_environment_files
249 /// A list of paths, separated by a ";" on Windows and a ":"
250 /// on Linux and Mac, to .env files that follow the same
251 /// syntax as the houdini.env file in Houdini's user prefs
252 /// folder. These will be applied after the default
253 /// houdini.env file and will overwrite the process'
254 /// environment variable values. You an use this to enforce
255 /// a stricter environment when running engine.
256 /// For more info, see:
257 /// http://www.sidefx.com/docs/houdini/basics/config_env
258 /// <!-- default NULL -->
259 ///
260 /// @param[in] otl_search_path
261 /// The directory where OTLs are searched for. You can
262 /// pass NULL here which will only use the default
263 /// Houdini OTL search paths. You can also pass in
264 /// multiple paths separated by a ";" on Windows and a ":"
265 /// on Linux and Mac. If something other than NULL is
266 /// passed the default Houdini search paths will be
267 /// appended to the end of the path string.
268 /// <!-- default NULL -->
269 ///
270 /// @param[in] dso_search_path
271 /// The directory where generic DSOs (custom plugins) are
272 /// searched for. You can pass NULL here which will
273 /// only use the default Houdini DSO search paths. You
274 /// can also pass in multiple paths separated by a ";"
275 /// on Windows and a ":" on Linux and Mac. If something
276 /// other than NULL is passed the default Houdini search
277 /// paths will be appended to the end of the path string.
278 /// <!-- default NULL -->
279 ///
280 /// @param[in] image_dso_search_path
281 /// The directory where image DSOs (custom plugins) are
282 /// searched for. You can pass NULL here which will
283 /// only use the default Houdini DSO search paths. You
284 /// can also pass in multiple paths separated by a ";"
285 /// on Windows and a ":" on Linux and Mac. If something
286 /// other than NULL is passed the default Houdini search
287 /// paths will be appended to the end of the path string.
288 /// <!-- default NULL -->
289 ///
290 /// @param[in] audio_dso_search_path
291 /// The directory where audio DSOs (custom plugins) are
292 /// searched for. You can pass NULL here which will
293 /// only use the default Houdini DSO search paths. You
294 /// can also pass in multiple paths separated by a ";"
295 /// on Windows and a ":" on Linux and Mac. If something
296 /// other than NULL is passed the default Houdini search
297 /// paths will be appended to the end of the path string.
298 /// <!-- default NULL -->
299 ///
300 HAPI_DECL HAPI_Initialize( const HAPI_Session * session,
301  const HAPI_CookOptions * cook_options,
302  HAPI_Bool use_cooking_thread,
303  int cooking_thread_stack_size,
304  const char * houdini_environment_files,
305  const char * otl_search_path,
306  const char * dso_search_path,
307  const char * image_dso_search_path,
308  const char * audio_dso_search_path );
309 
310 /// @brief Clean up memory. This will unload all assets and you will
311 /// need to call ::HAPI_Initialize() again to be able to use any
312 /// HAPI methods again.
313 ///
314 /// @note This does not release any licenses. The license will be returned when
315 /// the process terminates.
316 ///
317 /// @ingroup Sessions
318 ///
319 /// @param[in] session
320 /// The session of Houdini you are interacting with.
321 /// See @ref HAPI_Sessions for more on sessions.
322 /// Pass NULL to just use the default in-process session.
323 /// <!-- default NULL -->
324 ///
325 HAPI_DECL HAPI_Cleanup( const HAPI_Session * session );
326 
327 /// @brief When using an in-process session, this method **must** be called in
328 /// order for the host process to shutdown cleanly. This method should
329 /// be called before ::HAPI_CloseSession().
330 ///
331 /// @note This method should only be called before exiting the program,
332 /// because HAPI can no longer be used by the process once this method
333 /// has been called.
334 ///
335 /// @ingroup Sessions
336 ///
337 /// @param[in] session
338 /// The session of Houdini you are interacting with.
339 /// See @ref HAPI_Sessions for more on sessions.
340 /// Pass NULL to just use the default in-process session.
341 /// <!-- default NULL -->
342 ///
343 HAPI_DECL HAPI_Shutdown( const HAPI_Session * session );
344 
345 /// @defgroup Environment
346 /// Functions for reading and writing to the session environment
347 
348 /// @brief Gives back a certain environment integers like version number.
349 /// Note that you do not need a session for this. These constants
350 /// are hard-coded in all HAPI implementations, including HARC and
351 /// HAPIL. This should be the first API you call to determine if
352 /// any future API calls will mismatch implementation.
353 ///
354 /// @ingroup Environment
355 ///
356 /// @param[in] int_type
357 /// One of ::HAPI_EnvIntType.
358 ///
359 /// @param[out] value
360 /// Int value.
361 ///
362 HAPI_DECL HAPI_GetEnvInt( HAPI_EnvIntType int_type, int * value );
363 
364 /// @brief Gives back a certain session-specific environment integers
365 /// like current license type being used.
366 ///
367 /// @ingroup Environment
368 ///
369 /// @param[in] session
370 /// The session of Houdini you are interacting with.
371 /// See @ref HAPI_Sessions for more on sessions.
372 /// Pass NULL to just use the default in-process session.
373 /// <!-- default NULL -->
374 ///
375 /// @param[in] int_type
376 /// One of ::HAPI_SessionEnvIntType.
377 ///
378 /// @param[out] value
379 /// Int value.
380 ///
382  HAPI_SessionEnvIntType int_type,
383  int * value );
384 
385 /// @brief Get environment variable from the server process as an integer.
386 ///
387 /// @ingroup Environment
388 ///
389 /// @param[in] session
390 /// The session of Houdini you are interacting with.
391 /// See @ref HAPI_Sessions for more on sessions.
392 /// Pass NULL to just use the default in-process session.
393 /// <!-- default NULL -->
394 ///
395 /// @param[in] variable_name
396 /// Name of the environmnet variable.
397 ///
398 /// @param[out] value
399 /// The int pointer to return the value in.
400 ///
402  const char * variable_name,
403  int * value );
404 
405 /// @brief Get environment variable from the server process as a string.
406 ///
407 /// @ingroup Environment
408 ///
409 /// @param[in] session
410 /// The session of Houdini you are interacting with.
411 /// See @ref HAPI_Sessions for more on sessions.
412 /// Pass NULL to just use the default in-process session.
413 /// <!-- default NULL -->
414 ///
415 /// @param[in] variable_name
416 /// Name of the environmnet variable.
417 ///
418 /// @param[out] value
419 /// The HAPI_StringHandle pointer to return the value in.
420 ///
422  const char * variable_name,
424 
425 /// @brief Provides the number of environment variables that are in
426 /// the server environment's process
427 ///
428 /// Note that ::HAPI_GetServerEnvVarList() should be called directly after
429 /// this method, otherwise there is the possibility that the environment
430 /// variable count of the server will have changed by the time that
431 /// ::HAPI_GetServerEnvVarList() is called.
432 ///
433 /// @ingroup Environment
434 ///
435 /// @param[in] session
436 /// The session of Houdini you are interacting with.
437 /// See @ref HAPI_Sessions for more on sessions.
438 /// Pass NULL to just use the default in-process session.
439 /// <!-- default NULL -->
440 ///
441 /// @param[out] env_count
442 /// A pointer to an int to return the value in
444  int * env_count );
445 
446 /// @brief Provides a list of all of the environment variables
447 /// in the server's process
448 ///
449 /// @ingroup Environment
450 ///
451 /// @param[in] session
452 /// The session of Houdini you are interacting with.
453 /// See @ref HAPI_Sessions for more on sessions.
454 /// Pass NULL to just use the default in-process session.
455 /// <!-- default NULL -->
456 ///
457 /// @param[out] values_array
458 /// An ::HAPI_StringHandle array at least the size of length
459 ///
460 /// @param[in] start
461 /// First index of range. Must be at least @c 0 and at most
462 /// @c env_count - 1 where @c env_count is the count returned by
463 /// ::HAPI_GetServerEnvVarCount()
464 /// <!-- min 0 -->
465 /// <!-- max ::HAPI_GetServerEnvVarCount -->
466 /// <!-- default 0 -->
467 ///
468 /// @param[in] length
469 /// Given @c env_count returned by ::HAPI_GetServerEnvVarCount(),
470 /// length should be at least @c 0 and at most <tt>env_count - start.</tt>
471 /// <!-- default 0 -->
473  HAPI_StringHandle * values_array,
474  int start,
475  int length );
476 
477 /// @brief Set environment variable for the server process as an integer.
478 ///
479 /// Note that this may affect other sessions on the same server
480 /// process. The session parameter is mainly there to identify the
481 /// server process, not the specific session.
482 ///
483 /// For in-process sessions, this will affect the current process's
484 /// environment.
485 ///
486 /// @ingroup Environment
487 ///
488 /// @param[in] session
489 /// The session of Houdini you are interacting with.
490 /// See @ref HAPI_Sessions for more on sessions.
491 /// Pass NULL to just use the default in-process session.
492 /// <!-- default NULL -->
493 ///
494 /// @param[in] variable_name
495 /// Name of the environment variable.
496 ///
497 /// @param[in] value
498 /// The integer value.
499 ///
501  const char * variable_name,
502  int value );
503 
504 /// @brief Set environment variable for the server process as a string.
505 ///
506 /// Note that this may affect other sessions on the same server
507 /// process. The session parameter is mainly there to identify the
508 /// server process, not the specific session.
509 ///
510 /// For in-process sessions, this will affect the current process's
511 /// environment.
512 ///
513 /// @ingroup Environment
514 ///
515 /// @param[in] session
516 /// The session of Houdini you are interacting with.
517 /// See @ref HAPI_Sessions for more on sessions.
518 /// Pass NULL to just use the default in-process session.
519 /// <!-- default NULL -->
520 ///
521 /// @param[in] variable_name
522 /// Name of the environmnet variable.
523 ///
524 /// @param[in] value
525 /// The string value.
526 ///
528  const char * variable_name,
529  const char * value );
530 
531 /// @defgroup Status
532 /// Functions for reading session connection and cook status.
533 
534 /// @brief Gives back the status code for a specific status type.
535 ///
536 /// @ingroup Status
537 ///
538 /// @param[in] session
539 /// The session of Houdini you are interacting with.
540 /// See @ref HAPI_Sessions for more on sessions.
541 /// Pass NULL to just use the default in-process session.
542 /// <!-- default NULL -->
543 ///
544 /// @param[in] status_type
545 /// One of ::HAPI_StatusType.
546 ///
547 /// @param[out] status
548 /// Actual status code for the status type given. That is,
549 /// if you pass in ::HAPI_STATUS_CALL_RESULT as
550 /// status_type, you'll get back a ::HAPI_Result for this
551 /// argument. If you pass in ::HAPI_STATUS_COOK_STATE
552 /// as status_type, you'll get back a ::HAPI_State enum
553 /// for this argument.
554 ///
555 HAPI_DECL HAPI_GetStatus( const HAPI_Session * session,
556  HAPI_StatusType status_type,
557  int * status );
558 
559 /// @brief Return length of string buffer storing status string message.
560 ///
561 /// If called with ::HAPI_STATUS_COOK_RESULT this will actually
562 /// parse the node networks for the previously cooked asset(s)
563 /// and aggregate all node errors, warnings, and messages
564 /// (depending on the @c verbosity level set). Usually this is done
565 /// just for the last cooked single asset but if you load a whole
566 /// Houdini scene using ::HAPI_LoadHIPFile() then you'll have
567 /// multiple "previously cooked assets".
568 ///
569 /// You MUST call ::HAPI_GetStatusStringBufLength() before calling
570 /// ::HAPI_GetStatusString() because ::HAPI_GetStatusString() will
571 /// not return the real status string and instead return a
572 /// cached version of the string that was created inside
573 /// ::HAPI_GetStatusStringBufLength(). The reason for this is that
574 /// the length of the real status string may change between
575 /// the call to ::HAPI_GetStatusStringBufLength() and the call to
576 /// ::HAPI_GetStatusString().
577 ///
578 /// @ingroup Status
579 ///
580 /// @param[in] session
581 /// The session of Houdini you are interacting with.
582 /// See @ref HAPI_Sessions for more on sessions.
583 /// Pass NULL to just use the default in-process session.
584 /// <!-- default NULL -->
585 ///
586 /// @param[in] status_type
587 /// One of ::HAPI_StatusType.
588 ///
589 /// @param[in] verbosity
590 /// Preferred verbosity level.
591 ///
592 /// @param[out] buffer_length
593 /// Length of buffer char array ready to be filled.
594 ///
596  HAPI_StatusType status_type,
597  HAPI_StatusVerbosity verbosity,
598  int * buffer_length );
599 
600 /// @brief Return status string message.
601 ///
602 /// You MUST call ::HAPI_GetStatusStringBufLength() before calling
603 /// ::HAPI_GetStatusString() because ::HAPI_GetStatusString() will
604 /// not return the real status string and instead return a
605 /// cached version of the string that was created inside
606 /// ::HAPI_GetStatusStringBufLength(). The reason for this is that
607 /// the length of the real status string may change between
608 /// the call to ::HAPI_GetStatusStringBufLength() and the call to
609 /// ::HAPI_GetStatusString().
610 ///
611 /// @ingroup Status
612 ///
613 /// @param[in] session
614 /// The session of Houdini you are interacting with.
615 /// See @ref HAPI_Sessions for more on sessions.
616 /// Pass NULL to just use the default in-process session.
617 /// <!-- default NULL -->
618 ///
619 /// @param[in] status_type
620 /// One of ::HAPI_StatusType.
621 ///
622 /// @param[out] string_value
623 /// Buffer char array ready to be filled.
624 ///
625 /// @param[in] length
626 /// Length of the string buffer (must match size of
627 /// @p string_value - so including NULL terminator).
628 /// <!-- source ::HAPI_GetStatusStringBufLength -->
629 ///
631  HAPI_StatusType status_type,
632  char * string_value,
633  int length );
634 
635 /// @brief Compose the cook result string (errors and warnings) of a
636 /// specific node.
637 ///
638 /// This will actually parse the node network inside the given
639 /// node and return ALL errors/warnings/messages of all child nodes,
640 /// combined into a single string. If you'd like a more narrowed
641 /// search, call this function on one of the child nodes.
642 ///
643 /// You MUST call ::HAPI_ComposeNodeCookResult() before calling
644 /// ::HAPI_GetComposedNodeCookResult() because
645 /// ::HAPI_GetComposedNodeCookResult() will
646 /// not return the real result string and instead return a
647 /// cached version of the string that was created inside
648 /// ::HAPI_ComposeNodeCookResult(). The reason for this is that
649 /// the length of the real status string may change between
650 /// the call to ::HAPI_ComposeNodeCookResult() and the call to
651 /// ::HAPI_GetComposedNodeCookResult().
652 ///
653 /// @ingroup Status
654 ///
655 /// @param[in] session
656 /// The session of Houdini you are interacting with.
657 /// See @ref HAPI_Sessions for more on sessions.
658 /// Pass NULL to just use the default in-process session.
659 /// <!-- default NULL -->
660 ///
661 /// @param[in] node_id
662 /// The node id.
663 ///
664 /// @param[in] verbosity
665 /// Preferred verbosity level.
666 ///
667 /// @param[out] buffer_length
668 /// Length of buffer char array ready to be filled.
669 ///
671  HAPI_NodeId node_id,
672  HAPI_StatusVerbosity verbosity,
673  int * buffer_length );
674 
675 /// @brief Return cook result string message on a single node.
676 ///
677 /// You MUST call ::HAPI_ComposeNodeCookResult() before calling
678 /// ::HAPI_GetComposedNodeCookResult() because
679 /// ::HAPI_GetComposedNodeCookResult() will
680 /// not return the real result string and instead return a
681 /// cached version of the string that was created inside
682 /// ::HAPI_ComposeNodeCookResult(). The reason for this is that
683 /// the length of the real status string may change between
684 /// the call to ::HAPI_ComposeNodeCookResult() and the call to
685 /// ::HAPI_GetComposedNodeCookResult().
686 ///
687 /// @ingroup Status
688 ///
689 /// @param[in] session
690 /// The session of Houdini you are interacting with.
691 /// See @ref HAPI_Sessions for more on sessions.
692 /// Pass NULL to just use the default in-process session.
693 /// <!-- default NULL -->
694 ///
695 /// @param[out] string_value
696 /// Buffer char array ready to be filled.
697 ///
698 /// @param[in] length
699 /// Length of the string buffer (must match size of
700 /// @p string_value - so including NULL terminator).
701 /// <!-- source ::HAPI_ComposeNodeCookResult -->
702 ///
704  char * string_value,
705  int length );
706 
707 /// @brief Gets the length of the cook result string (errors and warnings) of
708 /// a specific node.
709 ///
710 /// Unlike ::HAPI_ComposeNodeCookResult(), this node does not parse
711 /// inside the node network. Only errors, warnings, and messages that
712 /// appear on the specified node will be a part of the cook result
713 /// string.
714 ///
715 /// You MUST call ::HAPI_GetNodeCookResultLength() before calling
716 /// ::HAPI_GetNodeCookResult() because ::HAPI_GetNodeCookResult() will
717 /// not return the real result and instead returns a cached version of
718 /// the string that was created during the call to
719 /// ::HAPI_GetNodeCookResultLength(). The reason for this is that the
720 /// length of the real status string may change between the call to
721 /// ::HAPI_GetNodeCookResultLength() and ::HAPI_GetNodeCookResult().
722 ///
723 /// @ingroup Status
724 ///
725 /// @param[in] session
726 /// The session of Houdini you are interacting with.
727 /// See @ref HAPI_Sessions for more on sessions.
728 /// Pass NULL to just use the default in-process session.
729 /// <!-- default NULL -->
730 ///
731 /// @param[in] node_id
732 /// The node id.
733 ///
734 /// @param[in] verbosity
735 /// Preferred verbosity level.
736 ///
737 /// @param[out] buffer_length
738 /// Lenght of buffer char array ready to be filled.
739 ///
741  HAPI_NodeId node_id,
742  HAPI_StatusVerbosity verbosity,
743  int * buffer_length );
744 
745 /// @brief Return the cook result string that was composed during a call to
746 /// ::HAPI_GetNodeCookResultLength().
747 ///
748 /// You MUST call ::HAPI_GetNodeCookResultLength() before calling
749 /// ::HAPI_GetNodeCookResult() because ::HAPI_GetNodeCookResult() will
750 /// not return the real result and instead returns a cached version of
751 /// the string that was created during the call to
752 /// ::HAPI_GetNodeCookResultLength(). The reason for this is that the
753 /// length of the real status string may change between the call to
754 /// ::HAPI_GetNodeCookResultLength() and ::HAPI_GetNodeCookResult().
755 ///
756 /// @ingroup Status
757 ///
758 /// @param[in] session
759 /// The session of Houdini you are interacting with.
760 /// See @ref HAPI_Sessions for more on sessions.
761 /// Pass NULL to just use the default in-process session.
762 /// <!-- default NULL -->
763 ///
764 /// @param[out] string_value
765 /// Buffer char array that will be filled with the cook result
766 /// string.
767 ///
768 /// @param[in] length
769 /// Length of the char buffer (must match size of
770 /// @p string_value - so include NULL terminator).
771 /// <!-- source ::HAPI_GetNodeCookResultLength -->
772 ///
774  char * string_value,
775  int length );
776 
777 /// @brief Get the number of message nodes set in "Type Properties".
778 ///
779 /// @ingroup Status
780 ///
781 /// @param[in] session
782 /// The session of Houdini you are interacting with.
783 /// See @ref HAPI_Sessions for more on sessions.
784 /// Pass NULL to just use the default in-process session.
785 /// <!-- default NULL -->
786 ///
787 /// @param[in] node_id
788 /// The node id.
789 ///
790 /// @param[out] count
791 /// The number of message nodes.
792 ///
794  HAPI_NodeId node_id,
795  int * count );
796 
797 /// @brief Get the ids of message nodes set in the "Type Properties".
798 ///
799 /// @ingroup Status
800 ///
801 /// @param[in] session
802 /// The session of Houdini you are interacting with.
803 /// See @ref HAPI_Sessions for more on sessions.
804 /// Pass NULL to just use the default in-process session.
805 /// <!-- default NULL -->
806 ///
807 /// @param[in] node_id
808 /// The node id.
809 ///
810 /// @param[out] message_node_ids_array
811 /// The array of node IDs to be filled.
812 ///
813 /// @param[in] count
814 /// The number of message nodes.
815 ///
817  HAPI_NodeId node_id,
818  HAPI_NodeId * message_node_ids_array,
819  int count );
820 
821 /// @brief Recursively check for specific errors by error code on a node.
822 ///
823 /// Note that checking for errors can be expensive because it checks
824 /// ALL child nodes within a node and then tries to do a string match
825 /// for the errors being looked for. This is why such error checking
826 /// is part of a standalone function and not done during the cooking
827 /// step.
828 ///
829 /// @ingroup Status
830 ///
831 /// @param[in] session
832 /// The session of Houdini you are interacting with.
833 /// See @ref HAPI_Sessions for more on sessions.
834 /// Pass NULL to just use the default in-process session.
835 /// <!-- default NULL -->
836 ///
837 /// @param[in] node_id
838 /// The node id.
839 ///
840 /// @param[in] errors_to_look_for
841 /// The HAPI_ErrorCode error codes (as a bitfield) to look for.
842 ///
843 /// @param[out] errors_found
844 /// Returned HAPI_ErrorCode bitfield indicating which of the
845 /// looked for errors have been found.
846 ///
848  HAPI_NodeId node_id,
849  HAPI_ErrorCodeBits errors_to_look_for,
850  HAPI_ErrorCodeBits * errors_found );
851 
852 /// @brief Clears the connection error. Should be used before starting
853 /// or creating Thrift server.
854 ///
855 /// Only available when using Thrift connections.
856 ///
857 /// @ingroup Status
858 ///
860 
861 /// @brief Return the length of string buffer storing connection error
862 /// message.
863 ///
864 /// @ingroup Status
865 ///
866 /// Only available when using Thrift connections.
867 ///
868 /// @param[out] buffer_length
869 /// Length of buffer char array ready to be filled.
870 ///
871 HAPI_DECL HAPI_GetConnectionErrorLength( int * buffer_length );
872 
873 /// @brief Return the connection error message.
874 ///
875 /// You MUST call ::HAPI_GetConnectionErrorLength() before calling
876 /// this to get the correct string length.
877 ///
878 /// Only available when using Thrift connections.
879 ///
880 /// @ingroup Status
881 ///
882 /// @param[out] string_value
883 /// Buffer char array ready to be filled.
884 ///
885 /// @param[in] length
886 /// Length of the string buffer (must match size of
887 /// string_value - so including NULL terminator).
888 /// Use ::HAPI_GetConnectionErrorLength to get this length.
889 ///
890 /// @param[in] clear
891 /// If true, will clear the error when HAPI_RESULT_SUCCESS
892 /// is returned.
893 ///
895  int length,
896  HAPI_Bool clear );
897 
898 /// @brief Get total number of nodes that need to cook in the current
899 /// session.
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[out] count
910 /// Total cook count.
911 ///
913  int * count );
914 
915 /// @brief Get current number of nodes that have already cooked in the
916 /// current session. Note that this is a very crude approximation
917 /// of the cooking progress - it may never make it to 100% or it
918 /// might spend another hour at 100%. Use ::HAPI_GetStatusString
919 /// to get a better idea of progress if this number gets stuck.
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[out] count
930 /// Current cook count.
931 ///
933  int * count );
934 
935 /// @brief Interrupt a cook or load operation.
936 ///
937 /// @ingroup Status
938 ///
939 /// @param[in] session
940 /// The session of Houdini you are interacting with.
941 /// See @ref HAPI_Sessions for more on sessions.
942 /// Pass NULL to just use the default in-process session.
943 /// <!-- default NULL -->
944 ///
945 HAPI_DECL HAPI_Interrupt( const HAPI_Session * session );
946 
947 /// @defgroup Utility
948 /// Utility math and other functions
949 
950 /// @brief Converts the transform described by a ::HAPI_TransformEuler
951 /// struct into a different transform and rotation order.
952 ///
953 /// @ingroup Utility
954 ///
955 /// @param[in] session
956 /// The session of Houdini you are interacting with.
957 /// See @ref HAPI_Sessions for more on sessions.
958 /// Pass NULL to just use the default in-process session.
959 /// <!-- default NULL -->
960 ///
961 /// @param[in] transform_in
962 /// The transform to be converted.
963 ///
964 /// @param[in] rst_order
965 /// The desired transform order of the output.
966 ///
967 /// @param[in] rot_order
968 /// The desired rotation order of the output.
969 ///
970 /// @param[out] transform_out
971 /// The converted transform.
972 ///
974  const HAPI_TransformEuler * transform_in,
975  HAPI_RSTOrder rst_order,
976  HAPI_XYZOrder rot_order,
977  HAPI_TransformEuler * transform_out );
978 
979 /// @brief Converts a 4x4 matrix into its TRS form.
980 ///
981 /// @ingroup Utility
982 ///
983 /// @param[in] session
984 /// The session of Houdini you are interacting with.
985 /// See @ref HAPI_Sessions for more on sessions.
986 /// Pass NULL to just use the default in-process session.
987 /// <!-- default NULL -->
988 ///
989 /// @param[in] matrix
990 /// A 4x4 matrix expressed in a 16 element float array.
991 ///
992 /// @param[in] rst_order
993 /// The desired transform order of the output.
994 ///
995 /// @param[out] transform_out
996 /// Used for the output.
997 ///
999  const float * matrix,
1000  HAPI_RSTOrder rst_order,
1001  HAPI_Transform * transform_out );
1002 
1003 /// @brief Converts a 4x4 matrix into its TRS form.
1004 ///
1005 /// @ingroup Utility
1006 ///
1007 /// @param[in] session
1008 /// The session of Houdini you are interacting with.
1009 /// See @ref HAPI_Sessions for more on sessions.
1010 /// Pass NULL to just use the default in-process session.
1011 /// <!-- default NULL -->
1012 ///
1013 /// @param[in] matrix
1014 /// A 4x4 matrix expressed in a 16 element float array.
1015 ///
1016 /// @param[in] rst_order
1017 /// The desired transform order of the output.
1018 ///
1019 /// @param[in] rot_order
1020 /// The desired rotation order of the output.
1021 ///
1022 /// @param[out] transform_out
1023 /// Used for the output.
1024 ///
1026  const float * matrix,
1027  HAPI_RSTOrder rst_order,
1028  HAPI_XYZOrder rot_order,
1029  HAPI_TransformEuler * transform_out );
1030 
1031 /// @brief Converts ::HAPI_Transform into a 4x4 transform matrix.
1032 ///
1033 /// @ingroup Utility
1034 ///
1035 /// @param[in] session
1036 /// The session of Houdini you are interacting with.
1037 /// See @ref HAPI_Sessions for more on sessions.
1038 /// Pass NULL to just use the default in-process session.
1039 /// <!-- default NULL -->
1040 ///
1041 /// @param[in] transform
1042 /// The ::HAPI_Transform you wish to convert.
1043 ///
1044 /// @param[out] matrix
1045 /// A 16 element float array that will contain the result.
1046 ///
1048  const HAPI_Transform * transform,
1049  float * matrix );
1050 
1051 /// @brief Converts ::HAPI_TransformEuler into a 4x4 transform matrix.
1052 ///
1053 /// @ingroup Utility
1054 ///
1055 /// @param[in] session
1056 /// The session of Houdini you are interacting with.
1057 /// See @ref HAPI_Sessions for more on sessions.
1058 /// Pass NULL to just use the default in-process session.
1059 /// <!-- default NULL -->
1060 ///
1061 /// @param[in] transform
1062 /// The ::HAPI_TransformEuler you wish to convert.
1063 ///
1064 /// @param[out] matrix
1065 /// A 16 element float array that will contain the result.
1066 ///
1068  const HAPI_Session * session,
1070  float * matrix );
1071 
1072 /// @brief Acquires or releases the Python interpreter lock. This is
1073 /// needed if HAPI is called from Python and HAPI is in threaded
1074 /// mode (see ::HAPI_Initialize()).
1075 ///
1076 /// The problem arises when async functions like
1077 /// ::HAPI_CreateNode() may start a cooking thread that
1078 /// may try to run Python code. That is, we would now have
1079 /// Python running on two different threads - something not
1080 /// allowed by Python by default.
1081 ///
1082 /// We need to tell Python to explicitly "pause" the Python state
1083 /// on the client thread while we run Python in our cooking thread.
1084 ///
1085 /// You must call this function first with locked == true before
1086 /// any async HAPI call. Then, after the async call finished,
1087 /// detected via calls to ::HAPI_GetStatus(), call this method
1088 /// again to release the lock with locked == false.
1089 ///
1090 /// @ingroup Utility
1091 ///
1092 /// @param[in] session
1093 /// The session of Houdini you are interacting with.
1094 /// See @ref HAPI_Sessions for more on sessions.
1095 /// Pass NULL to just use the default in-process session.
1096 /// <!-- default NULL -->
1097 ///
1098 /// @param[in] locked
1099 /// True will acquire the interpreter lock to use it for
1100 /// the HAPI cooking thread. False will release the lock
1101 /// back to the client thread.
1102 ///
1104  HAPI_Bool locked );
1105 
1106 /// @defgroup Strings
1107 /// Functions for handling strings.
1108 
1109 /// @brief Gives back the string length of the string with the
1110 /// given handle.
1111 ///
1112 /// @ingroup Strings
1113 ///
1114 /// @param[in] session
1115 /// The session of Houdini you are interacting with.
1116 /// See @ref HAPI_Sessions for more on sessions.
1117 /// Pass NULL to just use the default in-process session.
1118 /// <!-- default NULL -->
1119 ///
1120 /// @param[in] string_handle
1121 /// Handle of the string to query.
1122 ///
1123 /// @param[out] buffer_length
1124 /// Buffer length of the queried string (including NULL
1125 /// terminator).
1126 ///
1128  HAPI_StringHandle string_handle,
1129  int * buffer_length );
1130 
1131 /// @brief Gives back the string value of the string with the
1132 /// given handle.
1133 ///
1134 /// @ingroup Strings
1135 ///
1136 /// @param[in] session
1137 /// The session of Houdini you are interacting with.
1138 /// See @ref HAPI_Sessions for more on sessions.
1139 /// Pass NULL to just use the default in-process session.
1140 /// <!-- default NULL -->
1141 ///
1142 /// @param[in] string_handle
1143 /// Handle of the string to query.
1144 ///
1145 /// @param[out] string_value
1146 /// Actual string value (character array).
1147 ///
1148 /// @param[in] length
1149 /// Length of the string buffer (must match size of
1150 /// @p string_value - so including NULL terminator).
1151 ///
1152 HAPI_DECL HAPI_GetString( const HAPI_Session * session,
1153  HAPI_StringHandle string_handle,
1154  char * string_value,
1155  int length );
1156 
1157 /// @brief Adds the given string to the string table and returns
1158 /// the handle. It is the responsibility of the caller to
1159 /// manage access to the string. The intended use for custom strings
1160 /// is to allow structs that reference strings to be passed in to HAPI
1161 ///
1162 /// @ingroup Strings
1163 ///
1164 /// @param[in] session
1165 /// The session of Houdini you are interacting with.
1166 /// See @ref HAPI_Sessions for more on sessions.
1167 /// Pass NULL to just use the default in-process session.
1168 /// <!-- default NULL -->
1169 ///
1170 /// @param[in] string_value
1171 /// Actual string value (character array).
1172 ///
1173 /// @param[out] handle_value
1174 /// Handle of the string that was added
1175 ///
1177  const char * string_value,
1178  HAPI_StringHandle * handle_value );
1179 
1180 /// @brief Removes the specified string from the server
1181 /// and invalidates the handle
1182 ///
1183 /// @ingroup Strings
1184 ///
1185 /// @param[in] session
1186 /// The session of Houdini you are interacting with.
1187 /// See @ref HAPI_Sessions for more on sessions.
1188 /// Pass NULL to just use the default in-process session.
1189 /// <!-- default NULL -->
1190 ///
1191 /// @param[in] string_handle
1192 /// Handle of the string that was added
1193 ///
1195  const HAPI_StringHandle string_handle );
1196 
1197 /// @brief Gives back the length of the buffer needed to hold
1198 /// all the values null-separated for the given string
1199 /// handles. Used with ::HAPI_GetStringBatch().
1200 ///
1201 /// @ingroup Strings
1202 ///
1203 /// @param[in] session
1204 /// The session of Houdini you are interacting with.
1205 /// See @ref HAPI_Sessions for more on sessions.
1206 /// Pass NULL to just use the default in-process session.
1207 /// <!-- default NULL -->
1208 ///
1209 /// @param[in] string_handle_array
1210 /// Array of string handles to be read.
1211 ///
1212 /// @param[in] string_handle_count
1213 /// Length of @p string_handle_array
1214 ///
1215 /// @param[out] string_buffer_size
1216 /// Buffer length required for subsequent call to
1217 /// HAPI_GetStringBatch to hold all the given
1218 /// string values null-terminated
1219 ///
1221  const int * string_handle_array,
1222  int string_handle_count,
1223  int * string_buffer_size );
1224 
1225 /// @brief Gives back the values of the given string handles.
1226 /// The given char array is filled with null-separated
1227 /// values, and the final value is null-terminated.
1228 /// Used with ::HAPI_GetStringBatchSize(). Using this function
1229 /// instead of repeated calls to ::HAPI_GetString() can be more
1230 /// more efficient for a large number of strings.
1231 ///
1232 /// @ingroup Strings
1233 ///
1234 /// @param[in] session
1235 /// The session of Houdini you are interacting with.
1236 /// See @ref HAPI_Sessions for more on sessions.
1237 /// Pass NULL to just use the default in-process session.
1238 /// <!-- default NULL -->
1239 ///
1240 /// @param[out] char_buffer
1241 /// Array of characters to hold string values.
1242 ///
1243 /// @param[in] char_array_length
1244 /// Length of @p char_array. Must be large enough to hold
1245 /// all the string values including null separators.
1246 /// <!-- min ::HAPI_GetStringBatchSize -->
1247 /// <!-- source ::HAPI_GetStringBatchSize -->
1248 ///
1249 HAPI_DECL HAPI_GetStringBatch( const HAPI_Session * session,
1250  char * char_buffer,
1251  int char_array_length );
1252 
1253 
1254 /// @defgroup Time
1255 /// Time related functions
1256 
1257 /// @brief Gets the global time of the scene. All API calls deal with
1258 /// this time to cook.
1259 ///
1260 /// @ingroup Time
1261 ///
1262 /// @param[in] session
1263 /// The session of Houdini you are interacting with.
1264 /// See @ref HAPI_Sessions for more on sessions.
1265 /// Pass NULL to just use the default in-process session.
1266 /// <!-- default NULL -->
1267 ///
1268 /// @param[out] time
1269 /// Time as a float in seconds.
1270 ///
1271 HAPI_DECL HAPI_GetTime( const HAPI_Session * session, float * time );
1272 
1273 /// @brief Sets the global time of the scene. All API calls will deal
1274 /// with this time to cook.
1275 ///
1276 /// @ingroup Time
1277 ///
1278 /// @param[in] session
1279 /// The session of Houdini you are interacting with.
1280 /// See @ref HAPI_Sessions for more on sessions.
1281 /// Pass NULL to just use the default in-process session.
1282 /// <!-- default NULL -->
1283 ///
1284 /// @param[in] time
1285 /// Time as a float in seconds.
1286 ///
1287 HAPI_DECL HAPI_SetTime( const HAPI_Session * session, float time );
1288 
1289 /// @brief Returns whether the Houdini session will use the current time in
1290 /// Houdini when cooking and retrieving data. By default this is
1291 /// disabled and the Houdini session uses time 0 (i.e. frame 1).
1292 /// In SessionSync, it is enabled by default, but can be overridden.
1293 /// Note that this function will ALWAYS return
1294 /// ::HAPI_RESULT_SUCCESS.
1295 ///
1296 /// @ingroup Time
1297 ///
1298 /// @param[in] session
1299 /// The session of Houdini you are interacting with.
1300 /// See @ref HAPI_Sessions for more on sessions.
1301 /// Pass NULL to just use the default in-process session.
1302 /// <!-- default NULL -->
1303 ///
1304 /// @param[out] enabled
1305 /// Whether use Houdini time is enabled or not.
1306 ///
1308  HAPI_Bool * enabled );
1309 
1310 /// @brief Sets whether the Houdini session should use the current time in
1311 /// Houdini when cooking and retrieving data. By default this is
1312 /// disabled and the Houdini session uses time 0 (i.e. frame 1).
1313 /// In SessionSync, it is enabled by default, but can be overridden.
1314 /// Note that this function will ALWAYS return
1315 /// ::HAPI_RESULT_SUCCESS.
1316 ///
1317 /// @ingroup Time
1318 ///
1319 /// @param[in] session
1320 /// The session of Houdini you are interacting with.
1321 /// See @ref HAPI_Sessions for more on sessions.
1322 /// Pass NULL to just use the default in-process session.
1323 /// <!-- default NULL -->
1324 ///
1325 /// @param[in] enabled
1326 /// Set to true to use Houdini time.
1327 ///
1329  HAPI_Bool enabled );
1330 
1331 /// @brief Gets the current global timeline options.
1332 ///
1333 /// @ingroup Time
1334 ///
1335 /// @param[in] session
1336 /// The session of Houdini you are interacting with.
1337 /// See @ref HAPI_Sessions for more on sessions.
1338 /// Pass NULL to just use the default in-process session.
1339 /// <!-- default NULL -->
1340 ///
1341 /// @param[out] timeline_options
1342 /// The global timeline options struct.
1343 ///
1345  HAPI_TimelineOptions * timeline_options );
1346 
1347 /// @brief Sets the global timeline options.
1348 ///
1349 /// @ingroup Time
1350 ///
1351 /// @param[in] session
1352 /// The session of Houdini you are interacting with.
1353 /// See @ref HAPI_Sessions for more on sessions.
1354 /// Pass NULL to just use the default in-process session.
1355 /// <!-- default NULL -->
1356 ///
1357 /// @param[in] timeline_options
1358 /// The global timeline options struct.
1359 ///
1361  const HAPI_Session * session,
1362  const HAPI_TimelineOptions * timeline_options );
1363 
1364 /// @brief Gets the global compositor options.
1365 ///
1366 /// @param[in] session
1367 /// The session of Houdini you are interacting with.
1368 /// See @ref HAPI_Sessions for more on sessions.
1369 /// Pass NULL to just use the default in-process session.
1370 /// <!-- default NULL -->
1371 ///
1372 /// @param[out] compositor_options
1373 /// The compositor options struct.
1374 ///
1376  const HAPI_Session * session,
1377  HAPI_CompositorOptions * compositor_options);
1378 
1379 /// @brief Sets the global compositor options.
1380 ///
1381 /// @param[in] session
1382 /// The session of Houdini you are interacting with.
1383 /// See @ref HAPI_Sessions for more on sessions.
1384 /// Pass NULL to just use the default in-process session.
1385 /// <!-- default NULL -->
1386 ///
1387 /// @param[in] compositor_options
1388 /// The compositor options.
1389 ///
1391  const HAPI_Session * session,
1392  const HAPI_CompositorOptions * compositor_options);
1393 
1394 /// @defgroup Assets
1395 /// Functions for managing asset libraries
1396 
1397 /// @brief Loads a Houdini asset library (OTL) from a .otl file.
1398 /// It does NOT create anything inside the Houdini scene.
1399 ///
1400 /// @note This is when we actually check for valid licenses.
1401 ///
1402 /// The next step is to call ::HAPI_GetAvailableAssetCount()
1403 /// to get the number of assets contained in the library using the
1404 /// returned library_id. Then call ::HAPI_GetAvailableAssets()
1405 /// to get the list of available assets by name. Use the asset
1406 /// names with ::HAPI_CreateNode() to actually create
1407 /// one of these nodes in the Houdini scene and get back
1408 /// an asset_id.
1409 ///
1410 /// @note The HIP file saved using ::HAPI_SaveHIPFile() will only
1411 /// have an absolute path reference to the loaded OTL meaning
1412 /// that if the OTL is moved or renamed the HIP file won't
1413 /// load properly. It also means that if you change the OTL
1414 /// using the saved HIP scene the same OTL file will change
1415 /// as the one used with Houdini Engine.
1416 /// See @ref HAPI_Fundamentals_SavingHIPFile.
1417 ///
1418 /// @ingroup Assets
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[in] file_path
1427 /// Absolute path to the .otl file.
1428 ///
1429 /// @param[in] allow_overwrite
1430 /// With this true, if the library file being loaded
1431 /// contains asset definitions that have already been
1432 /// loaded they will overwrite the existing definitions.
1433 /// Otherwise, a library containing asset definitions that
1434 /// already exist will fail to load, returning a
1435 /// ::HAPI_Result of
1436 /// ::HAPI_RESULT_ASSET_DEF_ALREADY_LOADED.
1437 ///
1438 /// @param[out] library_id
1439 /// Newly loaded otl id to be used with
1440 /// ::HAPI_GetAvailableAssetCount() and
1441 /// ::HAPI_GetAvailableAssets().
1442 ///
1444  const char * file_path,
1445  HAPI_Bool allow_overwrite,
1446  HAPI_AssetLibraryId * library_id );
1447 
1448 /// @brief Loads a Houdini asset library (OTL) from memory.
1449 /// It does NOT create anything inside the Houdini scene.
1450 ///
1451 /// @note This is when we actually check for valid licenses.
1452 ///
1453 /// Please note that the performance benefit of loading a library
1454 /// from memory are negligible at best. Due to limitations of
1455 /// Houdini's library manager, there is still some disk access
1456 /// and file writes because every asset library needs to be
1457 /// saved to a real file. Use this function only as a convenience
1458 /// if you already have the library file in memory and don't wish
1459 /// to have to create your own temporary library file and then
1460 /// call ::HAPI_LoadAssetLibraryFromFile().
1461 ///
1462 /// The next step is to call ::HAPI_GetAvailableAssetCount()
1463 /// to get the number of assets contained in the library using the
1464 /// returned library_id. Then call ::HAPI_GetAvailableAssets()
1465 /// to get the list of available assets by name. Use the asset
1466 /// names with ::HAPI_CreateNode() to actually create
1467 /// one of these nodes in the Houdini scene and get back
1468 /// an asset_id.
1469 ///
1470 /// @note The saved HIP file using ::HAPI_SaveHIPFile() will
1471 /// @a contain the OTL loaded as part of its @b Embedded OTLs.
1472 /// This means that you can safely move or rename the original
1473 /// OTL file and the HIP will continue to work but if you make
1474 /// changes to the OTL while using the saved HIP the changes
1475 /// won't be saved to the original OTL.
1476 /// See @ref HAPI_Fundamentals_SavingHIPFile.
1477 ///
1478 /// @ingroup Assets
1479 ///
1480 /// @param[in] session
1481 /// The session of Houdini you are interacting with.
1482 /// See @ref HAPI_Sessions for more on sessions.
1483 /// Pass NULL to just use the default in-process session.
1484 /// <!-- default NULL -->
1485 ///
1486 /// @param[in] library_buffer
1487 /// The memory buffer containing the asset definitions
1488 /// in the same format as a standard Houdini .otl file.
1489 ///
1490 /// @param[in] library_buffer_length
1491 /// The size of the OTL memory buffer.
1492 ///
1493 /// @param[in] allow_overwrite
1494 /// With this true, if the library file being loaded
1495 /// contains asset definitions that have already been
1496 /// loaded they will overwrite the existing definitions.
1497 /// Otherwise, a library containing asset definitions that
1498 /// already exist will fail to load, returning a
1499 /// ::HAPI_Result of
1500 /// ::HAPI_RESULT_ASSET_DEF_ALREADY_LOADED.
1501 ///
1502 /// @param[out] library_id
1503 /// Newly loaded otl id to be used with
1504 /// ::HAPI_GetAvailableAssetCount() and
1505 /// ::HAPI_GetAvailableAssets().
1506 ///
1508  const char * library_buffer,
1509  int library_buffer_length,
1510  HAPI_Bool allow_overwrite,
1511  HAPI_AssetLibraryId * library_id );
1512 
1513 /// @brief Get the number of assets contained in an asset library.
1514 /// You should call ::HAPI_LoadAssetLibraryFromFile() prior to
1515 /// get a library_id.
1516 ///
1517 /// @ingroup Assets
1518 ///
1519 /// @param[in] session
1520 /// The session of Houdini you are interacting with.
1521 /// See @ref HAPI_Sessions for more on sessions.
1522 /// Pass NULL to just use the default in-process session.
1523 /// <!-- default NULL -->
1524 ///
1525 /// @param[in] library_id
1526 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1527 /// <!-- source ::HAPI_LoadAssetLibraryFromFile -->
1528 ///
1529 /// @param[out] asset_count
1530 /// The number of assets contained in this asset library.
1531 ///
1533  HAPI_AssetLibraryId library_id,
1534  int * asset_count );
1535 
1536 /// @brief Get the names of the assets contained in an asset library.
1537 ///
1538 /// The asset names will contain additional information about
1539 /// the type of asset, namespace, and version, along with the
1540 /// actual asset name. For example, if you have an Object type
1541 /// asset, in the "hapi" namespace, of version 2.0, named
1542 /// "foo", the asset name returned here will be:
1543 /// hapi::Object/foo::2.0
1544 ///
1545 /// However, you should not need to worry about this detail. Just
1546 /// pass this string directly to ::HAPI_CreateNode() to
1547 /// create the node. You can then get the pretty name
1548 /// using ::HAPI_GetAssetInfo().
1549 ///
1550 /// You should call ::HAPI_LoadAssetLibraryFromFile() prior to
1551 /// get a library_id. Then, you should call
1552 /// ::HAPI_GetAvailableAssetCount() to get the number of assets to
1553 /// know how large of a string handles array you need to allocate.
1554 ///
1555 /// @ingroup Assets
1556 ///
1557 /// @param[in] session
1558 /// The session of Houdini you are interacting with.
1559 /// See @ref HAPI_Sessions for more on sessions.
1560 /// Pass NULL to just use the default in-process session.
1561 /// <!-- default NULL -->
1562 ///
1563 /// @param[in] library_id
1564 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1565 /// <!-- source ::HAPI_LoadAssetLibraryFromFile -->
1566 ///
1567 /// @param[out] asset_names_array
1568 /// Array of string handles (integers) that should be
1569 /// at least the size of asset_count.
1570 ///
1571 /// @param[in] asset_count
1572 /// Should be the same or less than the value returned by
1573 /// ::HAPI_GetAvailableAssetCount().
1574 /// <!-- max ::HAPI_GetAvailableAssetCount -->
1575 /// <!-- source ::HAPI_GetAvailableAssetCount -->
1576 ///
1578  HAPI_AssetLibraryId library_id,
1579  HAPI_StringHandle * asset_names_array,
1580  int asset_count );
1581 
1582 /// @brief Fill an asset_info struct from a node.
1583 ///
1584 /// @ingroup Assets
1585 ///
1586 /// @param[in] session
1587 /// The session of Houdini you are interacting with.
1588 /// See @ref HAPI_Sessions for more on sessions.
1589 /// Pass NULL to just use the default in-process session.
1590 /// <!-- default NULL -->
1591 ///
1592 /// @param[in] node_id
1593 /// The node id.
1594 ///
1595 /// @param[out] asset_info
1596 /// Returned ::HAPI_AssetInfo struct.
1597 ///
1598 HAPI_DECL HAPI_GetAssetInfo( const HAPI_Session * session,
1599  HAPI_NodeId node_id,
1600  HAPI_AssetInfo * asset_info );
1601 
1602 /// @brief Get the number of asset parameters contained in an asset
1603 /// library, as well as the number of parameter int, float,
1604 /// string, and choice values.
1605 ///
1606 /// This does not create the asset in the session.
1607 /// Use this for faster querying of asset parameters compared to
1608 /// creating the asset node and querying the node's parameters.
1609 ///
1610 /// This does require ::HAPI_LoadAssetLibraryFromFile() to be
1611 /// called prior, in order to load the asset library and
1612 /// acquire library_id. Then ::HAPI_GetAvailableAssetCount and
1613 /// ::HAPI_GetAvailableAssets should be called to get the
1614 /// asset_name.
1615 ///
1616 /// @ingroup Assets
1617 ///
1618 /// @param[in] session
1619 /// The session of Houdini you are interacting with.
1620 /// See @ref HAPI_Sessions for more on sessions.
1621 /// Pass NULL to just use the default in-process session.
1622 /// <!-- default NULL -->
1623 ///
1624 /// @param[in] library_id
1625 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1626 /// <!-- source ::HAPI_LoadAssetLibraryFromFile -->
1627 ///
1628 /// @param[in] asset_name
1629 /// Name of the asset to get the parm counts for.
1630 ///
1631 /// @param[out] parm_count
1632 /// The number of parameters in the asset library.
1633 ///
1634 /// @param[out] int_value_count
1635 /// The number of int values for parameters in the asset
1636 /// library.
1637 ///
1638 /// @param[out] float_value_count
1639 /// The number of float values for parameters in the asset
1640 /// library.
1641 ///
1642 /// @param[out] string_value_count
1643 /// The number of string values for parameters in the asset
1644 /// library.
1645 ///
1646 /// @param[out] choice_value_count
1647 /// The number of choice values for parameters in the asset
1648 /// library.
1649 ///
1651  HAPI_AssetLibraryId library_id,
1652  const char * asset_name,
1653  int * parm_count,
1654  int * int_value_count,
1655  int * float_value_count,
1656  int * string_value_count,
1657  int * choice_value_count );
1658 
1659 /// @brief Fill an array of ::HAPI_ParmInfo structs with parameter
1660 /// information for the specified asset in the specified asset
1661 /// library.
1662 ///
1663 /// This does not create the asset in the session.
1664 /// Use this for faster querying of asset parameters compared to
1665 /// creating the asset node and querying the node's parameters.
1666 ///
1667 /// This does require ::HAPI_LoadAssetLibraryFromFile() to be
1668 /// called prior, in order to load the asset library and
1669 /// acquire library_id. ::HAPI_GetAssetDefinitionParmCounts should
1670 /// be called prior to acquire the count for the size of
1671 /// parm_infos_array.
1672 ///
1673 /// @ingroup Assets
1674 ///
1675 /// @param[in] session
1676 /// The session of Houdini you are interacting with.
1677 /// See @ref HAPI_Sessions for more on sessions.
1678 /// Pass NULL to just use the default in-process session.
1679 /// <!-- default NULL -->
1680 ///
1681 /// @param[in] library_id
1682 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1683 /// <!-- source ::HAPI_LoadAssetLibraryFromFile -->
1684 ///
1685 /// @param[in] asset_name
1686 /// Name of the asset to get the parm counts for.
1687 ///
1688 /// @param[out] parm_infos_array
1689 /// Array of ::HAPI_ParmInfo at least the size of
1690 /// length.
1691 ///
1692 /// @param[in] start
1693 /// First index of range. Must be at least 0 and at
1694 /// most parm_count - 1 acquired from
1695 /// ::HAPI_GetAssetInfo.
1696 /// <!-- min 0 -->
1697 /// <!-- max ::HAPI_GetAssetInfo::parm_count - 1 -->
1698 /// <!-- default 0 -->
1699 ///
1700 /// @param[in] length
1701 /// Must be at least 1 and at most parm_count - start acquired
1702 /// from ::HAPI_GetAssetInfo
1703 /// <!-- min 1 -->
1704 /// <!-- max ::HAPI_GetAssetInfo::parm_count - start -->
1705 /// <!-- source ::HAPI_GetAssetInfo::parm_count -->
1706 ///
1708  HAPI_AssetLibraryId library_id,
1709  const char * asset_name,
1710  HAPI_ParmInfo * parm_infos_array,
1711  int start,
1712  int length );
1713 
1714 /// @brief Fill arrays of parameter int values, float values, string values,
1715 /// and choice values for parameters in the specified asset in the
1716 /// specified asset library.
1717 ///
1718 /// This does not create the asset in the session.
1719 /// Use this for faster querying of asset parameters compared to
1720 /// creating the asset node and querying the node's parameters.
1721 /// Note that only default values are retrieved.
1722 ///
1723 /// This does require ::HAPI_LoadAssetLibraryFromFile() to be
1724 /// called prior, in order to load the asset library and
1725 /// acquire library_id. ::HAPI_GetAssetDefinitionParmCounts should
1726 /// be called prior to acquire the counts for the sizes of
1727 /// the values arrays.
1728 ///
1729 /// @ingroup Assets
1730 ///
1731 /// @param[in] session
1732 /// The session of Houdini you are interacting with.
1733 /// See @ref HAPI_Sessions for more on sessions.
1734 /// Pass NULL to just use the default in-process session.
1735 /// <!-- default NULL -->
1736 ///
1737 /// @param[in] library_id
1738 /// Returned by ::HAPI_LoadAssetLibraryFromFile().
1739 /// <!-- source ::HAPI_LoadAssetLibraryFromFile -->
1740 ///
1741 /// @param[in] asset_name
1742 /// Name of the asset to get the parm counts for.
1743 ///
1744 /// @param[out] int_values_array
1745 /// Array of ints at least the size of int_length.
1746 ///
1747 /// @param[in] int_start
1748 /// First index of range for int_values_array. Must be at
1749 /// least 0 and at most int_value_count - 1 acquired from
1750 /// ::HAPI_GetAssetDefinitionParmCounts.
1751 /// <!-- min 0 -->
1752 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::int_value_count - 1 -->
1753 /// <!-- default 0 -->
1754 ///
1755 /// @param[in] int_length
1756 /// Must be at least 0 and at most int_value_count - int_start
1757 /// acquired from ::HAPI_GetAssetDefinitionParmCounts.
1758 /// <!-- min 0 -->
1759 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::int_value_count - int_start -->
1760 /// <!-- source ::HAPI_GetAssetDefinitionParmCounts::int_value_count - int_start -->
1761 ///
1762 /// @param[out] float_values_array
1763 /// Array of floats at least the size of float_length.
1764 ///
1765 /// @param[in] float_start
1766 /// First index of range for float_values_array. Must be at
1767 /// least 0 and at most float_value_count - 1 acquired from
1768 /// ::HAPI_GetAssetDefinitionParmCounts.
1769 /// <!-- min 0 -->
1770 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::float_value_count - 1 -->
1771 /// <!-- default 0 -->
1772 ///
1773 /// @param[in] float_length
1774 /// Must be at least 0 and at most float_value_count -
1775 /// float_start acquired from
1776 /// ::HAPI_GetAssetDefinitionParmCounts.
1777 /// <!-- min 0 -->
1778 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::float_value_count - float_start -->
1779 /// <!-- source ::HAPI_GetAssetDefinitionParmCounts::float_value_count - float_start -->
1780 ///
1781 /// @param[in] string_evaluate
1782 /// Whether or not to evaluate the string expressions.
1783 /// For example, the string "$F" would evaluate to the
1784 /// current frame number. So, passing in evaluate = false
1785 /// would give you back the string "$F" and passing
1786 /// in evaluate = true would give you back "1" (assuming
1787 /// the current frame is 1).
1788 /// <!-- default true -->
1789 ///
1790 /// @param[out] string_values_array
1791 /// Array of HAPI_StringHandle at least the size of
1792 /// string_length.
1793 ///
1794 /// @param[in] string_start
1795 /// First index of range for string_values_array. Must be at
1796 /// least 0 and at most string_value_count - 1 acquired from
1797 /// ::HAPI_GetAssetDefinitionParmCounts.
1798 /// <!-- min 0 -->
1799 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::string_value_count - 1 -->
1800 /// <!-- default 0 -->
1801 ///
1802 /// @param[in] string_length
1803 /// Must be at least 0 and at most string_value_count -
1804 /// string_start acquired from
1805 /// ::HAPI_GetAssetDefinitionParmCounts.
1806 /// <!-- min 0 -->
1807 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::string_value_count - string_start -->
1808 /// <!-- source ::HAPI_GetAssetDefinitionParmCounts::string_value_count - string_start -->
1809 ///
1810 /// @param[out] choice_values_array
1811 /// Array of ::HAPI_ParmChoiceInfo at least the size of
1812 /// choice_length.
1813 ///
1814 /// @param[in] choice_start
1815 /// First index of range for choice_values_array. Must be at
1816 /// least 0 and at most choice_value_count - 1 acquired from
1817 /// ::HAPI_GetAssetDefinitionParmCounts.
1818 /// <!-- min 0 -->
1819 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::choice_value_count - 1 -->
1820 /// <!-- default 0 -->
1821 ///
1822 /// @param[in] choice_length
1823 /// Must be at least 0 and at most choice_value_count -
1824 /// choice_start acquired from
1825 /// ::HAPI_GetAssetDefinitionParmCounts.
1826 /// <!-- min 0 -->
1827 /// <!-- max ::HAPI_GetAssetDefinitionParmCounts::choice_value_count - choice_start -->
1828 /// <!-- source ::HAPI_GetAssetDefinitionParmCounts::choice_value_count - choice_start -->
1829 ///
1831  const HAPI_Session * session,
1832  HAPI_AssetLibraryId library_id,
1833  const char * asset_name,
1834  int * int_values_array,
1835  int int_start,
1836  int int_length,
1837  float * float_values_array,
1838  int float_start,
1839  int float_length,
1840  HAPI_Bool string_evaluate,
1841  HAPI_StringHandle * string_values_array,
1842  int string_start,
1843  int string_length,
1844  HAPI_ParmChoiceInfo * choice_values_array,
1845  int choice_start,
1846  int choice_length );
1847 
1848 /// @brief Gets the number of HDAs that have been loaded by Houdini.
1849 ///
1850 /// @note This only includes HDAs that have been loaded from disk.
1851 /// Embedded HDAs will be excluded.
1852 ///
1853 /// @ingroup Assets
1854 ///
1855 /// @param[in] session
1856 /// The session of Houdini you are interacting with.
1857 /// See @ref HAPI_Sessions for more on sessions.
1858 /// Pass NULL to just use the default in-process session.
1859 /// <!-- default NULL -->
1860 ///
1861 /// @param[out] count
1862 /// The returned number of loaded HDAs.
1863 ///
1865  const HAPI_Session * session,
1866  int * count);
1867 
1868 /// @brief Gets the HAPI_AssetLibraryId's for HDAs that are loaded in Houdini.
1869 ///
1870 /// @ingroup Assets
1871 ///
1872 /// @param[in] session
1873 /// The session of Houdini you are interacting with.
1874 /// See @ref HAPI_Sessions for more on sessions.
1875 /// Pass NULL to just use the default in-process session.
1876 /// <!-- default NULL -->
1877 ///
1878 /// @param[out] asset_library_ids_array
1879 /// Array of HAPI_AssetLibraryId's at least the size of length.
1880 ///
1881 /// @param[in] start
1882 /// First index from the list of HAPI_AssetLibraryId's to
1883 /// return. Must be at least 0 and at most count - 1 where count
1884 /// is the value returned by ::HAPI_GetLoadedAssetLibraryCount.
1885 ///
1886 /// @param[in] length
1887 /// The number of HAPI_AssetLibraryId's to return. Must be at
1888 /// least 0 and at most count - start where count is the value
1889 /// returned by HAPI_GetLoadedAssetLibraryCount.
1890 ///
1892  const HAPI_Session * session,
1893  HAPI_AssetLibraryId * asset_library_ids_array,
1894  int start,
1895  int length);
1896 
1897 /// @brief Gets the HAPI_StringHandle for the file path of a loaded asset
1898 /// library.
1899 ///
1900 /// @ingroup Assets
1901 ///
1902 /// @param[in] session
1903 /// The session of Houdini you are interacting with.
1904 /// See @ref HAPI_Sessions for more on sessions.
1905 /// Pass NULL to just use the default in-process session.
1906 ///
1907 /// @param[in] asset_library_id
1908 /// The HAPI_AssetLibraryId of the asset library.
1909 ///
1910 /// @param[out] file_path_sh
1911 /// The returned HAPI_StringHandle of the asset's file path on
1912 /// disk.
1913 ///
1915  const HAPI_Session * session,
1916  HAPI_AssetLibraryId asset_library_id,
1917  HAPI_StringHandle * file_path_sh);
1918 
1919 /// @defgroup HipFiles Hip Files
1920 /// Functions for managing hip files
1921 
1922 /// @brief Loads a .hip file into the main Houdini scene.
1923 ///
1924 /// @note In threaded mode, this is an _async call_!
1925 ///
1926 /// @note This method will load the HIP file into the scene. This means
1927 /// that any registered `hou.hipFile` event callbacks will be triggered
1928 /// with the `hou.hipFileEventType.BeforeMerge` and
1929 /// `hou.hipFileEventType.AfterMerge` events.
1930 ///
1931 /// @note This method loads a HIP file, completely overwriting
1932 /// everything that already exists in the scene. Therefore, any HAPI ids
1933 /// (node ids, part ids, etc.) that were obtained before calling this
1934 /// method will be invalidated.
1935 ///
1936 /// @ingroup HipFiles
1937 ///
1938 /// @param[in] session
1939 /// The session of Houdini you are interacting with.
1940 /// See @ref HAPI_Sessions for more on sessions.
1941 /// Pass NULL to just use the default in-process session.
1942 /// <!-- default NULL -->
1943 ///
1944 /// @param[in] file_name
1945 /// Absolute path to the .hip file to load.
1946 ///
1947 /// @param[in] cook_on_load
1948 /// Set to true if you wish the nodes to cook as soon
1949 /// as they are created. Otherwise, you will have to
1950 /// call ::HAPI_CookNode() explicitly for each after you
1951 /// call this function.
1952 /// <!-- default false -->
1953 ///
1954 HAPI_DECL HAPI_LoadHIPFile( const HAPI_Session * session,
1955  const char * file_name,
1956  HAPI_Bool cook_on_load );
1957 
1958 /// @brief Loads a .hip file into the main Houdini scene.
1959 ///
1960 /// @note In threaded mode, this is an _async call_!
1961 ///
1962 /// @note This method will merge the HIP file into the scene. This means
1963 /// that any registered `hou.hipFile` event callbacks will be triggered
1964 /// with the `hou.hipFileEventType.BeforeMerge` and
1965 /// `hou.hipFileEventType.AfterMerge` events.
1966 ///
1967 /// @ingroup HipFiles
1968 ///
1969 /// @param[in] session
1970 /// The session of Houdini you are interacting with.
1971 /// See @ref HAPI_Sessions for more on sessions.
1972 /// Pass NULL to just use the default in-process session.
1973 ///
1974 /// @param[in] file_name
1975 /// Absolute path to the .hip file to load.
1976 ///
1977 /// @param[in] cook_on_load
1978 /// Set to true if you wish the nodes to cook as soon
1979 /// as they are created. Otherwise, you will have to
1980 /// call ::HAPI_CookNode() explicitly for each after you
1981 /// call this function.
1982 ///
1983 /// @param[out] file_id
1984 /// This parameter will be set to the HAPI_HIPFileId of the
1985 /// loaded HIP file. This can be used to lookup nodes that were
1986 /// created as a result of loading this HIP file.
1987 ///
1988 HAPI_DECL HAPI_MergeHIPFile(const HAPI_Session * session,
1989  const char * file_name,
1990  HAPI_Bool cook_on_load,
1991  HAPI_HIPFileId * file_id);
1992 
1993 /// @brief Saves a .hip file of the current Houdini scene.
1994 ///
1995 /// @ingroup HipFiles
1996 ///
1997 /// @param[in] session
1998 /// The session of Houdini you are interacting with.
1999 /// See @ref HAPI_Sessions for more on sessions.
2000 /// Pass NULL to just use the default in-process session.
2001 /// <!-- default NULL -->
2002 ///
2003 /// @param[in] file_path
2004 /// Absolute path to the .hip file to save to.
2005 ///
2006 /// @param[in] lock_nodes
2007 /// Specify whether to lock all SOP nodes before saving
2008 /// the scene file. This way, when you load the scene
2009 /// file you can see exactly the state of each SOP at
2010 /// the time it was saved instead of relying on the
2011 /// re-cook to accurately reproduce the state. It does,
2012 /// however, take a lot more space and time locking all
2013 /// nodes like this.
2014 /// <!-- default false -->
2015 ///
2016 HAPI_DECL HAPI_SaveHIPFile( const HAPI_Session * session,
2017  const char * file_path,
2018  HAPI_Bool lock_nodes );
2019 
2020 /// @brief Gets the number of nodes that were created as a result of loading a
2021 /// .hip file
2022 ///
2023 /// @ingroup HipFiles
2024 ///
2025 /// @param[in] session
2026 /// The session of Houdini you are interacting with.
2027 /// See @ref HAPI_Sessions for more on sessions.
2028 /// Pass NULL to just use the default in-process session.
2029 ///
2030 /// @param[in] id
2031 /// The HIP file id.
2032 ///
2033 /// @param[out] count
2034 /// Pointer to an int where the HIP file node count will be
2035 /// stored.
2037  HAPI_HIPFileId id,
2038  int * count);
2039 
2040 /// @brief Fills an array of ::HAPI_NodeId of nodes that were created as a
2041 /// result of loading the HIP file specified by the ::HAPI_HIPFileId
2042 ///
2043 /// @ingroup HipFiles
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 ///
2050 /// @param[in] id
2051 /// The HIP file id.
2052 ///
2053 /// @param[out] node_ids
2054 /// Array of ::HAPI_NodeId at least the size of length.
2055 ///
2056 /// @param[in] length
2057 /// The number of ::HAPI_NodeId to be stored. This should be at
2058 /// least 0 and at most the count provided by
2059 /// HAPI_GetHIPFileNodeCount
2061  HAPI_HIPFileId id,
2062  HAPI_NodeId * node_ids,
2063  int length);
2064 
2065 /// @defgroup Nodes
2066 /// Functions for working with nodes
2067 
2068 /// @brief Determine if your instance of the node actually still exists
2069 /// inside the Houdini scene. This is what can be used to
2070 /// determine when the Houdini scene needs to be re-populated
2071 /// using the host application's instances of the nodes.
2072 /// Note that this function will ALWAYS return
2073 /// ::HAPI_RESULT_SUCCESS.
2074 ///
2075 /// @ingroup Nodes
2076 ///
2077 /// @param[in] session
2078 /// The session of Houdini you are interacting with.
2079 /// See @ref HAPI_Sessions for more on sessions.
2080 /// Pass NULL to just use the default in-process session.
2081 /// <!-- default NULL -->
2082 ///
2083 /// @param[in] node_id
2084 /// The node id.
2085 ///
2086 /// @param[in] unique_node_id
2087 /// The unique node id from
2088 /// ::HAPI_NodeInfo::uniqueHoudiniNodeId.
2089 /// <!-- source ::HAPI_NodeInfo::uniqueHoudiniNodeId -->
2090 ///
2091 /// @param[out] answer
2092 /// Answer to the question.
2093 ///
2094 HAPI_DECL HAPI_IsNodeValid( const HAPI_Session * session,
2095  HAPI_NodeId node_id,
2096  int unique_node_id,
2097  HAPI_Bool * answer );
2098 
2099 /// @brief Fill an ::HAPI_NodeInfo struct.
2100 ///
2101 /// @ingroup Nodes
2102 ///
2103 /// @param[in] session
2104 /// The session of Houdini you are interacting with.
2105 /// See @ref HAPI_Sessions for more on sessions.
2106 /// Pass NULL to just use the default in-process session.
2107 /// <!-- default NULL -->
2108 ///
2109 /// @param[in] node_id
2110 /// The node id.
2111 ///
2112 /// @param[out] node_info
2113 /// Return value - contains things like asset id.
2114 ///
2115 HAPI_DECL HAPI_GetNodeInfo( const HAPI_Session * session,
2116  HAPI_NodeId node_id,
2117  HAPI_NodeInfo * node_info );
2118 
2119 /// @brief Get the node absolute path in the Houdini node network or a
2120 /// relative path any other node.
2121 ///
2122 /// @ingroup Nodes
2123 ///
2124 /// @param[in] session
2125 /// The session of Houdini you are interacting with.
2126 /// See @ref HAPI_Sessions for more on sessions.
2127 /// Pass NULL to just use the default in-process session.
2128 /// <!-- default NULL -->
2129 ///
2130 /// @param[in] node_id
2131 /// The node id.
2132 ///
2133 /// @param[in] relative_to_node_id
2134 /// Set this to -1 to get the absolute path of the node_id.
2135 /// Otherwise, the path will be relative to this node id.
2136 ///
2137 /// @param[out] path
2138 /// The returned path string, valid until the next call to
2139 /// this function.
2140 ///
2141 HAPI_DECL HAPI_GetNodePath( const HAPI_Session * session,
2142  HAPI_NodeId node_id,
2143  HAPI_NodeId relative_to_node_id,
2144  HAPI_StringHandle * path );
2145 
2146 /// @brief Get the root node of a particular network type (ie. OBJ).
2147 ///
2148 /// @ingroup Nodes
2149 ///
2150 /// @param[in] session
2151 /// The session of Houdini you are interacting with.
2152 /// See @ref HAPI_Sessions for more on sessions.
2153 /// Pass NULL to just use the default in-process session.
2154 /// <!-- default NULL -->
2155 ///
2156 /// @param[in] node_type
2157 /// The node network type.
2158 ///
2159 /// @param[out] node_id
2160 /// The node id of the root node network.
2161 ///
2163  HAPI_NodeType node_type,
2164  HAPI_NodeId * node_id );
2165 
2166 /// @brief Compose a list of child nodes based on given filters.
2167 ///
2168 /// This function will only compose the list of child nodes. It will
2169 /// not return this list. After your call to this function, call
2170 /// HAPI_GetComposedChildNodeList() to get the list of child node ids.
2171 ///
2172 /// Note: When looking for all Display SOP nodes using this function,
2173 /// and using recursive mode, the recursion will stop as soon as a
2174 /// display SOP is found within each OBJ geometry network. It is
2175 /// almost never useful to get a list of ALL display SOP nodes
2176 /// recursively as they would all containt the same geometry. Even so,
2177 /// this special case only comes up if the display SOP itself is a
2178 /// subnet.
2179 ///
2180 /// @ingroup Nodes
2181 ///
2182 /// @param[in] session
2183 /// The session of Houdini you are interacting with.
2184 /// See @ref HAPI_Sessions for more on sessions.
2185 /// Pass NULL to just use the default in-process session.
2186 /// <!-- default NULL -->
2187 ///
2188 /// @param[in] parent_node_id
2189 /// The node id of the parent node.
2190 ///
2191 /// @param[in] node_type_filter
2192 /// The node type by which to filter the children.
2193 ///
2194 /// @param[in] node_flags_filter
2195 /// The node flags by which to filter the children.
2196 ///
2197 /// @param[in] recursive
2198 /// Whether or not to compose the list recursively.
2199 ///
2200 /// @param[out] count
2201 /// The number of child nodes composed. Use this as the
2202 /// argument to ::HAPI_GetComposedChildNodeList().
2203 ///
2205  HAPI_NodeId parent_node_id,
2206  HAPI_NodeTypeBits node_type_filter,
2207  HAPI_NodeFlagsBits node_flags_filter,
2208  HAPI_Bool recursive,
2209  int * count );
2210 
2211 /// @brief Get the composed list of child node ids from the previous call
2212 /// to HAPI_ComposeChildNodeList().
2213 ///
2214 /// @ingroup Nodes
2215 ///
2216 /// @param[in] session
2217 /// The session of Houdini you are interacting with.
2218 /// See @ref HAPI_Sessions for more on sessions.
2219 /// Pass NULL to just use the default in-process session.
2220 /// <!-- default NULL -->
2221 ///
2222 /// @param[in] parent_node_id
2223 /// The node id of the parent node.
2224 ///
2225 /// @param[out] child_node_ids_array
2226 /// The array of ::HAPI_NodeId for the child nodes.
2227 ///
2228 /// @param[in] count
2229 /// The number of children in the composed list. MUST match
2230 /// the count returned by HAPI_ComposeChildNodeList().
2231 /// <!-- source ::HAPI_ComposeChildNodeList -->
2232 /// <!-- min ::HAPI_ComposeChildNodeList -->
2233 /// <!-- max ::HAPI_ComposeChildNodeList -->
2234 ///
2236  HAPI_NodeId parent_node_id,
2237  HAPI_NodeId * child_node_ids_array,
2238  int count );
2239 
2240 /// @brief Create a node inside a node network. Nodes created this way
2241 /// will have their ::HAPI_NodeInfo::createdPostAssetLoad set
2242 /// to true.
2243 ///
2244 /// @note In threaded mode, this is an _async call_!
2245 ///
2246 /// @note This is also when we actually check for valid licenses.
2247 ///
2248 /// This API will invoke the cooking thread if threading is
2249 /// enabled. This means it will return immediately with a call
2250 /// result of ::HAPI_RESULT_SUCCESS, even if fed garbage. Use
2251 /// the status and cooking count APIs under DIAGNOSTICS to get
2252 /// a sense of the progress. All other API calls will block
2253 /// until the creation (and, optionally, the first cook)
2254 /// of the node has finished.
2255 ///
2256 /// Also note that the cook result won't be of type
2257 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2258 /// Whenever the threading cook is done it will fill the
2259 /// @a cook result which is queried using
2260 /// ::HAPI_STATUS_COOK_RESULT.
2261 ///
2262 /// @ingroup Nodes
2263 ///
2264 /// @param[in] session
2265 /// The session of Houdini you are interacting with.
2266 /// See @ref HAPI_Sessions for more on sessions.
2267 /// Pass NULL to just use the default in-process session.
2268 /// <!-- default NULL -->
2269 ///
2270 /// @param[in] parent_node_id
2271 /// The parent node network's node id or -1 if the parent
2272 /// network is the manager (top-level) node. In that case,
2273 /// the manager must be identified by the table name in the
2274 /// operator_name.
2275 /// <!-- min -1 -->
2276 /// <!-- default -1 -->
2277 ///
2278 /// @param[in] operator_name
2279 /// The name of the node operator type.
2280 ///
2281 /// If you passed parent_node_id == -1, then the operator_name
2282 /// has to include the table name (ie. Object/ or Sop/).
2283 /// This is the common case for when creating asset nodes
2284 /// from a loaded asset library. In that case, just pass
2285 /// whatever ::HAPI_GetAvailableAssets() returns.
2286 ///
2287 /// If you have a parent_node_id then you should
2288 /// include only the namespace, name, and version.
2289 ///
2290 /// For example, lets say you have an Object type asset, in
2291 /// the "hapi" namespace, of version 2.0, named "foo". If
2292 /// you pass parent_node_id == -1, then set the operator_name
2293 /// as "Object/hapi::foo::2.0". Otherwise, if you have a valid
2294 /// parent_node_id, then just pass operator_name as
2295 /// "hapi::foo::2.0".
2296 ///
2297 /// @param[in] node_label
2298 /// (Optional) The label of the newly created node.
2299 /// <!-- default NULL -->
2300 ///
2301 /// @param[in] cook_on_creation
2302 /// Set whether the node should cook once created or not.
2303 /// <!-- default false -->
2304 ///
2305 /// @param[out] new_node_id
2306 /// The returned node id of the just-created node.
2307 ///
2308 HAPI_DECL HAPI_CreateNode( const HAPI_Session * session,
2309  HAPI_NodeId parent_node_id,
2310  const char * operator_name,
2311  const char * node_label,
2312  HAPI_Bool cook_on_creation,
2313  HAPI_NodeId * new_node_id );
2314 
2315 /// @brief Creates a simple geometry SOP node that can accept geometry input.
2316 /// This will create a dummy OBJ node with a Null SOP inside that
2317 /// you can set the geometry of using the geometry SET APIs.
2318 /// You can then connect this node to any other node as a geometry
2319 /// input.
2320 ///
2321 /// Note that when saving the Houdini scene using
2322 /// ::HAPI_SaveHIPFile() the nodes created with this
2323 /// method will be green and will start with the name "input".
2324 ///
2325 /// @ingroup Nodes
2326 ///
2327 /// @param[in] session
2328 /// The session of Houdini you are interacting with.
2329 /// See @ref HAPI_Sessions for more on sessions.
2330 /// Pass NULL to just use the default in-process session.
2331 /// <!-- default NULL -->
2332 ///
2333 /// @param[out] node_id
2334 /// Newly created node's id. Use ::HAPI_GetNodeInfo()
2335 /// to get more information about the node.
2336 ///
2337 /// @param[in] name
2338 /// Give this input node a name for easy debugging.
2339 /// The node's parent OBJ node and the Null SOP node will both
2340 /// get this given name with "input_" prepended.
2341 /// You can also pass NULL in which case the name will
2342 /// be "input#" where # is some number.
2343 /// <!-- default NULL -->
2344 ///
2346  HAPI_NodeId * node_id,
2347  const char * name );
2348 
2349 /// @brief Helper for creating specifically creating a curve input geometry SOP.
2350 /// This will create a dummy OBJ node with a Null SOP inside that
2351 /// contains the the HAPI_ATTRIB_INPUT_CURVE_COORDS attribute.
2352 /// It will setup the node as a curve part with no points.
2353 /// In addition to creating the input node, it will also commit and cook
2354 /// the geometry.
2355 ///
2356 /// Note that when saving the Houdini scene using
2357 /// ::HAPI_SaveHIPFile() the nodes created with this
2358 /// method will be green and will start with the name "input".
2359 ///
2360 /// @ingroup InputCurves
2361 ///
2362 /// @param[in] session
2363 /// The session of Houdini you are interacting with.
2364 /// See @ref HAPI_Sessions for more on sessions.
2365 /// Pass NULL to just use the default in-process session.
2366 /// <!-- default NULL -->
2367 ///
2368 /// @param[out] node_id
2369 /// Newly created node's id. Use ::HAPI_GetNodeInfo()
2370 /// to get more information about the node.
2371 ///
2372 /// @param[in] name
2373 /// Give this input node a name for easy debugging.
2374 /// The node's parent OBJ node and the Null SOP node will both
2375 /// get this given name with "input_" prepended.
2376 /// You can also pass NULL in which case the name will
2377 /// be "input#" where # is some number.
2378 /// <!-- default NULL -->
2379 ///
2381  HAPI_NodeId * node_id,
2382  const char * name );
2383 
2384 
2385 /// @defgroup HeightFields Height Fields
2386 /// Functions for creating and inspecting HAPI session state.
2387 
2388 /// @brief Creates the required node hierarchy needed for heightfield inputs.
2389 ///
2390 /// Note that when saving the Houdini scene using
2391 /// ::HAPI_SaveHIPFile() the nodes created with this
2392 /// method will be green and will start with the name "input".
2393 ///
2394 /// @ingroup HeightFields
2395 ///
2396 /// @param[in] session
2397 /// The session of Houdini you are interacting with.
2398 /// See @ref HAPI_Sessions for more on sessions.
2399 /// Pass NULL to just use the default in-process session.
2400 /// <!-- default NULL -->
2401 ///
2402 /// @param[in] parent_node_id
2403 /// The parent node network's node id or -1 if the parent
2404 /// network is the manager (top-level) node. In that case,
2405 /// the manager must be identified by the table name in the
2406 /// operator_name.
2407 /// <!-- min -1 -->
2408 /// <!-- default -1 -->
2409 ///
2410 /// @param[in] name
2411 /// Give this input node a name for easy debugging.
2412 /// The node's parent OBJ node and the Null SOP node will both
2413 /// get this given name with "input_" prepended.
2414 /// You can also pass NULL in which case the name will
2415 /// be "input#" where # is some number.
2416 /// <!-- default NULL -->
2417 ///
2418 /// @param[in] xsize
2419 /// size of the heightfield in X
2420 ///
2421 /// @param[in] ysize
2422 /// size of the heightfield in y
2423 ///
2424 /// @param[in] voxelsize
2425 /// Size of the voxel
2426 ///
2427 /// @param[in] sampling
2428 /// Type of sampling which should be either center or corner.
2429 ///
2430 /// @param[out] heightfield_node_id
2431 /// Newly created node id for the heightfield node.
2432 /// Use ::HAPI_GetNodeInfo() to get more information about
2433 /// the node.
2434 ///
2435 /// @param[out] height_node_id
2436 /// Newly created node id for the height volume.
2437 /// Use ::HAPI_GetNodeInfo() to get more information about the node.
2438 ///
2439 /// @param[out] mask_node_id
2440 /// Newly created node id for the mask volume.
2441 /// Use ::HAPI_GetNodeInfo() to get more information about the
2442 /// node.
2443 ///
2444 /// @param[out] merge_node_id
2445 /// Newly created merge node id.
2446 /// The merge node can be used to connect additional input masks.
2447 /// Use ::HAPI_GetNodeInfo() to get more information about the node.
2448 ///
2450  HAPI_NodeId parent_node_id,
2451  const char * name,
2452  int xsize,
2453  int ysize,
2454  float voxelsize,
2455  HAPI_HeightFieldSampling sampling,
2456  HAPI_NodeId * heightfield_node_id,
2457  HAPI_NodeId * height_node_id,
2458  HAPI_NodeId * mask_node_id,
2459  HAPI_NodeId * merge_node_id );
2460 
2461 /// @brief Creates a volume input node that can be used with Heightfields
2462 ///
2463 /// Note that when saving the Houdini scene using
2464 /// ::HAPI_SaveHIPFile() the nodes created with this
2465 /// method will be green and will start with the name "input".
2466 ///
2467 /// @ingroup HeightFields
2468 ///
2469 /// @param[in] session
2470 /// The session of Houdini you are interacting with.
2471 /// See @ref HAPI_Sessions for more on sessions.
2472 /// Pass NULL to just use the default in-process session.
2473 /// <!-- default NULL -->
2474 ///
2475 /// @param[in] parent_node_id
2476 /// The parent node network's node id or -1 if the parent
2477 /// network is the manager (top-level) node. In that case,
2478 /// the manager must be identified by the table name in the
2479 /// operator_name.
2480 /// <!-- min -1 -->
2481 /// <!-- default -1 -->
2482 ///
2483 /// @param[out] new_node_id
2484 /// Newly created node id for the volume.
2485 /// Use ::HAPI_GetNodeInfo() to get more information about the
2486 /// node.
2487 ///
2488 /// @param[in] name
2489 /// The name of the volume to create.
2490 /// You can also pass NULL in which case the name will
2491 /// be "input#" where # is some number.
2492 /// <!-- default NULL -->
2493 ///
2494 /// @param[in] xsize
2495 /// size of the heightfield in X
2496 ///
2497 /// @param[in] ysize
2498 /// size of the heightfield in y
2499 ///
2500 /// @param[in] voxelsize
2501 /// Size of the voxel
2502 ///
2504  HAPI_NodeId parent_node_id,
2505  HAPI_NodeId * new_node_id,
2506  const char * name,
2507  int xsize,
2508  int ysize,
2509  float voxelsize );
2510 
2511 /// @brief Initiate a cook on this node. Note that this may trigger
2512 /// cooks on other nodes if they are connected.
2513 ///
2514 /// @note In threaded mode, this is an _async call_!
2515 ///
2516 /// This API will invoke the cooking thread if threading is
2517 /// enabled. This means it will return immediately. Use
2518 /// the status and cooking count APIs under DIAGNOSTICS to get
2519 /// a sense of the progress. All other API calls will block
2520 /// until the cook operation has finished.
2521 ///
2522 /// Also note that the cook result won't be of type
2523 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
2524 /// Whenever the threading cook is done it will fill the
2525 /// @a cook result which is queried using
2526 /// ::HAPI_STATUS_COOK_RESULT.
2527 ///
2528 /// @ingroup Nodes
2529 ///
2530 /// @param[in] session
2531 /// The session of Houdini you are interacting with.
2532 /// See @ref HAPI_Sessions for more on sessions.
2533 /// Pass NULL to just use the default in-process session.
2534 /// <!-- default NULL -->
2535 ///
2536 /// @param[in] node_id
2537 /// The node id.
2538 ///
2539 /// @param[in] cook_options
2540 /// The cook options. Pass in NULL to use the global
2541 /// cook options that you specified when calling
2542 /// ::HAPI_Initialize().
2543 ///
2544 HAPI_DECL HAPI_CookNode( const HAPI_Session * session,
2545  HAPI_NodeId node_id,
2546  const HAPI_CookOptions * cook_options );
2547 
2548 /// @brief Delete a node from a node network. Only nodes with their
2549 /// ::HAPI_NodeInfo::createdPostAssetLoad set to true can be
2550 /// deleted this way.
2551 ///
2552 /// @ingroup Nodes
2553 ///
2554 /// @param[in] session
2555 /// The session of Houdini you are interacting with.
2556 /// See @ref HAPI_Sessions for more on sessions.
2557 /// Pass NULL to just use the default in-process session.
2558 /// <!-- default NULL -->
2559 ///
2560 /// @param[in] node_id
2561 /// The node to delete.
2562 ///
2563 HAPI_DECL HAPI_DeleteNode( const HAPI_Session * session,
2564  HAPI_NodeId node_id );
2565 
2566 /// @brief Rename a node that you created. Only nodes with their
2567 /// ::HAPI_NodeInfo::createdPostAssetLoad set to true can be
2568 /// renamed this way.
2569 ///
2570 /// @ingroup Nodes
2571 ///
2572 /// @param[in] session
2573 /// The session of Houdini you are interacting with.
2574 /// See @ref HAPI_Sessions for more on sessions.
2575 /// Pass NULL to just use the default in-process session.
2576 /// <!-- default NULL -->
2577 ///
2578 /// @param[in] node_id
2579 /// The node to rename.
2580 ///
2581 /// @param[in] new_name
2582 /// The new node name.
2583 ///
2584 HAPI_DECL HAPI_RenameNode( const HAPI_Session * session,
2585  HAPI_NodeId node_id,
2586  const char * new_name );
2587 
2588 /// @brief Connect two nodes together.
2589 ///
2590 /// @param[in] session
2591 /// The session of Houdini you are interacting with.
2592 /// See @ref HAPI_Sessions for more on sessions.
2593 /// Pass NULL to just use the default in-process session.
2594 /// <!-- default NULL -->
2595 ///
2596 /// @ingroup Nodes
2597 ///
2598 /// @param[in] node_id
2599 /// The node whom's input to connect to.
2600 ///
2601 /// @param[in] input_index
2602 /// The input index. Should be between 0 and the
2603 /// to_node's ::HAPI_NodeInfo::inputCount - 1.
2604 /// <!-- min 0 -->
2605 ///
2606 /// @param[in] node_id_to_connect
2607 /// The node to connect to node_id's input.
2608 ///
2609 /// @param[in] output_index
2610 /// The output index. Should be between 0 and the
2611 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2612 /// <!-- min 0 -->
2613 ///
2615  HAPI_NodeId node_id,
2616  int input_index,
2617  HAPI_NodeId node_id_to_connect,
2618  int output_index );
2619 
2620 /// @brief Disconnect a node input.
2621 ///
2622 /// @param[in] session
2623 /// The session of Houdini you are interacting with.
2624 /// See @ref HAPI_Sessions for more on sessions.
2625 /// Pass NULL to just use the default in-process session.
2626 /// <!-- default NULL -->
2627 ///
2628 /// @ingroup Nodes
2629 ///
2630 /// @param[in] node_id
2631 /// The node whom's input to disconnect.
2632 ///
2633 /// @param[in] input_index
2634 /// The input index. Should be between 0 and the
2635 /// to_node's ::HAPI_NodeInfo::inputCount - 1.
2636 /// <!-- min 0 -->
2637 ///
2639  HAPI_NodeId node_id,
2640  int input_index );
2641 
2642 /// @brief Query which node is connected to another node's input.
2643 ///
2644 /// @param[in] session
2645 /// The session of Houdini you are interacting with.
2646 /// See @ref HAPI_Sessions for more on sessions.
2647 /// Pass NULL to just use the default in-process session.
2648 /// <!-- default NULL -->
2649 ///
2650 /// @ingroup Nodes
2651 ///
2652 /// @param[in] node_to_query
2653 /// The node to query.
2654 ///
2655 /// @param[in] input_index
2656 /// The input index. Should be between 0 and the
2657 /// to_node's ::HAPI_NodeInfo::inputCount - 1.
2658 /// <!-- min 0 -->
2659 ///
2660 /// @param[out] connected_node_id
2661 /// The node id of the connected node to this input. If
2662 /// nothing is connected then -1 will be returned.
2663 ///
2664 HAPI_DECL HAPI_QueryNodeInput( const HAPI_Session * session,
2665  HAPI_NodeId node_to_query,
2666  int input_index,
2667  HAPI_NodeId * connected_node_id );
2668 
2669 /// @brief Get the name of an node's input. This function will return
2670 /// a string handle for the name which will be valid (persist)
2671 /// until the next call to this function.
2672 ///
2673 /// @ingroup Nodes
2674 ///
2675 /// @param[in] session
2676 /// The session of Houdini you are interacting with.
2677 /// See @ref HAPI_Sessions for more on sessions.
2678 /// Pass NULL to just use the default in-process session.
2679 /// <!-- default NULL -->
2680 ///
2681 /// @param[in] node_id
2682 /// The node id.
2683 ///
2684 /// @param[in] input_idx
2685 /// The input index. Should be between 0 and the
2686 /// node_to_query's ::HAPI_NodeInfo::inputCount - 1.
2687 /// <!-- min 0 -->
2688 ///
2689 /// @param[out] name
2690 /// Input name string handle return value - valid until
2691 /// the next call to this function.
2692 ///
2694  HAPI_NodeId node_id,
2695  int input_idx,
2696  HAPI_StringHandle * name );
2697 
2698 /// @brief Disconnect all of the node's output connections at the output index.
2699 ///
2700 /// @ingroup Nodes
2701 ///
2702 /// @param[in] session
2703 /// The session of Houdini you are interacting with.
2704 /// See @ref HAPI_Sessions for more on sessions.
2705 /// Pass NULL to just use the default in-process session.
2706 /// <!-- default NULL -->
2707 ///
2708 /// @param[in] node_id
2709 /// The node whom's outputs to disconnect.
2710 ///
2711 /// @param[in] output_index
2712 /// The output index. Should be between 0 and the
2713 /// to_node's ::HAPI_NodeInfo::outputCount.
2714 /// <!-- min 0 -->
2715 ///
2717  HAPI_NodeId node_id,
2718  int output_index );
2719 
2720 /// @brief Get the number of nodes currently connected to the given node at
2721 /// the output index.
2722 ///
2723 /// @ingroup Nodes
2724 ///
2725 /// Use the @c count returned by this function to get the
2726 /// ::HAPI_NodeId of connected nodes using
2727 /// ::HAPI_QueryNodeOutputConnectedNodes().
2728 ///
2729 /// @param[in] session
2730 /// The session of Houdini you are interacting with.
2731 /// See @ref HAPI_Sessions for more on sessions.
2732 /// Pass NULL to just use the default in-process session.
2733 /// <!-- default NULL -->
2734 ///
2735 /// @param[in] node_id
2736 /// The node id.
2737 ///
2738 /// @param[in] output_idx
2739 /// The output index. Should be between 0 and the
2740 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2741 /// <!-- min 0 -->
2742 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
2743 ///
2744 /// @param[in] into_subnets
2745 /// Whether to search by diving into subnets.
2746 /// <!-- default true -->
2747 ///
2748 /// @param[in] through_dots
2749 /// Whether to search through dots.
2750 /// <!-- default true -->
2751 ///
2752 /// @param[out] connected_count
2753 /// The number of nodes currently connected to this node at
2754 /// given output index. Use this count with a call to
2755 /// ::HAPI_QueryNodeOutputConnectedNodes() to get list of
2756 /// connected nodes.
2757 ///
2759  HAPI_NodeId node_id,
2760  int output_idx,
2761  HAPI_Bool into_subnets,
2762  HAPI_Bool through_dots,
2763  int * connected_count );
2764 
2765 /// @brief Get the ids of nodes currently connected to the given node
2766 /// at the output index.
2767 ///
2768 /// Use the @c connected_count returned by
2769 /// ::HAPI_QueryNodeOutputConnectedCount().
2770 ///
2771 /// @ingroup Nodes
2772 ///
2773 /// @param[in] session
2774 /// The session of Houdini you are interacting with.
2775 /// See @ref HAPI_Sessions for more on sessions.
2776 /// Pass NULL to just use the default in-process session.
2777 /// <!-- default NULL -->
2778 ///
2779 /// @param[in] node_id
2780 /// The node id.
2781 ///
2782 /// @param[in] output_idx
2783 /// The output index. Should be between 0 and the
2784 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2785 /// <!-- min 0 -->
2786 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
2787 ///
2788 /// @param[in] into_subnets
2789 /// Whether to search by diving into subnets.
2790 /// <!-- default true -->
2791 ///
2792 /// @param[in] through_dots
2793 /// Whether to search through dots.
2794 /// <!-- default true -->
2795 ///
2796 /// @param[out] connected_node_ids_array
2797 /// Array of ::HAPI_NodeId at least the size of @c length.
2798 ///
2799 /// @param[in] start
2800 /// At least @c 0 and at most @c connected_count returned by
2801 /// ::HAPI_QueryNodeOutputConnectedCount().
2802 /// <!-- min 0 -->
2803 /// <!-- max ::HAPI_QueryNodeOutputConnectedCount -->
2804 /// <!-- default 0 -->
2805 ///
2806 /// @param[in] length
2807 /// Given @c connected_count returned by
2808 /// ::HAPI_QueryNodeOutputConnectedCount(), @c length should
2809 /// be at least @c 1 and at most <tt>connected_count - start</tt>.
2810 /// <!-- min 1 -->
2811 /// <!-- max ::HAPI_QueryNodeOutputConnectedCount - start -->
2812 /// <!-- source ::HAPI_QueryNodeOutputConnectedCount - start -->
2813 ///
2815  HAPI_NodeId node_id,
2816  int output_idx,
2817  HAPI_Bool into_subnets,
2818  HAPI_Bool through_dots,
2819  HAPI_NodeId * connected_node_ids_array,
2820  int start, int length );
2821 
2822 /// @brief Get the name of an node's output. This function will return
2823 /// a string handle for the name which will be valid (persist)
2824 /// until the next call to this function.
2825 ///
2826 /// @ingroup Nodes
2827 ///
2828 /// @param[in] session
2829 /// The session of Houdini you are interacting with.
2830 /// See @ref HAPI_Sessions for more on sessions.
2831 /// Pass NULL to just use the default in-process session.
2832 /// <!-- default NULL -->
2833 ///
2834 /// @param[in] node_id
2835 /// The node id.
2836 ///
2837 /// @param[in] output_idx
2838 /// The output index. Should be between 0 and the
2839 /// to_node's ::HAPI_NodeInfo::outputCount - 1.
2840 /// <!-- min 0 -->
2841 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
2842 ///
2843 /// @param[out] name
2844 /// Output name string handle return value - valid until
2845 /// the next call to this function.
2846 ///
2848  HAPI_NodeId node_id,
2849  int output_idx,
2850  HAPI_StringHandle * name );
2851 
2852 /// @brief Get the id of the node with the specified path.
2853 ///
2854 /// @ingroup Nodes
2855 ///
2856 /// @param[in] session
2857 /// The session of Houdini you are interacting with.
2858 /// See @ref HAPI_Sessions for more on sessions.
2859 /// Pass NULL to just use the default in-process session.
2860 /// <!-- default NULL -->
2861 ///
2862 /// @param[in] parent_node_id
2863 /// If @c path does not start with "/", search for the path
2864 /// relative to this node. Provide -1 if @c path is an absolute
2865 /// path.
2866 ///
2867 /// @param[in] path
2868 /// The path of the node. If the path does not start with "/",
2869 /// it is treated as a relative path from the node specified in
2870 /// @c parent_node_id.
2871 ///
2872 /// @param[out] node_id
2873 /// The id of the found node.
2874 ///
2876  const HAPI_NodeId parent_node_id,
2877  const char * path,
2878  HAPI_NodeId * node_id );
2879 
2880 /// @brief Gets the node id of an output node in a SOP network.
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 of a SOP node with at least one output node. The
2892 /// total number of node outputs can be found from the node's
2893 /// ::HAPI_NodeInfo::outputCount
2894 ///
2895 /// @param[in] output
2896 /// The output index. Should be between 0 and the node's
2897 /// ::HAPI_NodeInfo::outputCount - 1.
2898 /// <!-- min 0 -->
2899 /// <!-- max ::HAPI_NodeInfo::outputCount - 1 -->
2900 ///
2901 /// @param[out] output_node_id
2902 /// Pointer to a HAPI_NodeId where the node id of the output
2903 /// node will be stored.
2905  HAPI_NodeId node_id,
2906  int output,
2907  HAPI_NodeId * output_node_id );
2908 
2909 /// @defgroup Parms Parms
2910 /// Functions for wroking with Node parameters (parms)
2911 
2912 /// @brief Fill an array of ::HAPI_ParmInfo structs with parameter
2913 /// information from the asset instance node.
2914 ///
2915 /// @ingroup Parms
2916 ///
2917 /// @param[in] session
2918 /// The session of Houdini you are interacting with.
2919 /// See @ref HAPI_Sessions for more on sessions.
2920 /// Pass NULL to just use the default in-process session.
2921 /// <!-- default NULL -->
2922 ///
2923 /// @param[in] node_id
2924 /// The node id.
2925 ///
2926 /// @param[out] parm_infos_array
2927 /// Array of ::HAPI_ParmInfo at least the size of
2928 /// length.
2929 ///
2930 /// @param[in] start
2931 /// First index of range. Must be at least 0 and at
2932 /// most ::HAPI_NodeInfo::parmCount - 1.
2933 /// <!-- min 0 -->
2934 /// <!-- max ::HAPI_NodeInfo::parmCount - 1 -->
2935 /// <!-- default 0 -->
2936 ///
2937 /// @param[in] length
2938 /// Must be at least 1 and at most
2939 /// ::HAPI_NodeInfo::parmCount - start.
2940 /// <!-- min 1 -->
2941 /// <!-- max ::HAPI_NodeInfo::parmCount - start -->
2942 /// <!-- source ::HAPI_NodeInfo::parmCount - start -->
2943 ///
2944 HAPI_DECL HAPI_GetParameters( const HAPI_Session * session,
2945  HAPI_NodeId node_id,
2946  HAPI_ParmInfo * parm_infos_array,
2947  int start, int length );
2948 
2949 /// @brief Get the parm info of a parameter by parm id.
2950 ///
2951 /// @ingroup Parms
2952 ///
2953 /// @param[in] session
2954 /// The session of Houdini you are interacting with.
2955 /// See @ref HAPI_Sessions for more on sessions.
2956 /// Pass NULL to just use the default in-process session.
2957 /// <!-- default NULL -->
2958 ///
2959 /// @param[in] node_id
2960 /// The node id.
2961 ///
2962 /// @param[in] parm_id
2963 /// The parm id.
2964 ///
2965 /// @param[out] parm_info
2966 /// The returned parm info.
2967 ///
2968 HAPI_DECL HAPI_GetParmInfo( const HAPI_Session * session,
2969  HAPI_NodeId node_id,
2970  HAPI_ParmId parm_id,
2971  HAPI_ParmInfo * parm_info );
2972 
2973 /// @brief All parameter APIs require a ::HAPI_ParmId but if you know the
2974 /// parameter you wish to operate on by name than you can use
2975 /// this function to get its ::HAPI_ParmId. If the parameter with
2976 /// the given name is not found the parameter id returned
2977 /// will be -1.
2978 ///
2979 /// @ingroup Parms
2980 ///
2981 /// @param[in] session
2982 /// The session of Houdini you are interacting with.
2983 /// See @ref HAPI_Sessions for more on sessions.
2984 /// Pass NULL to just use the default in-process session.
2985 /// <!-- default NULL -->
2986 ///
2987 /// @param[in] node_id
2988 /// The node id.
2989 ///
2990 /// @param[in] parm_name
2991 /// The parm name.
2992 ///
2993 /// @param[out] parm_id
2994 /// The return value. The parameter's ::HAPI_ParmId. If
2995 /// the parameter with the given name is not found the
2996 /// parameter id returned will be -1.
2997 ///
2999  HAPI_NodeId node_id,
3000  const char * parm_name,
3001  HAPI_ParmId * parm_id );
3002 
3003 /// @brief Get the parm info of a parameter by name.
3004 ///
3005 /// @ingroup Parms
3006 ///
3007 /// @param[in] session
3008 /// The session of Houdini you are interacting with.
3009 /// See @ref HAPI_Sessions for more on sessions.
3010 /// Pass NULL to just use the default in-process session.
3011 /// <!-- default NULL -->
3012 ///
3013 /// @param[in] node_id
3014 /// The node id.
3015 ///
3016 /// @param[in] parm_name
3017 /// The parm name.
3018 ///
3019 /// @param[out] parm_info
3020 /// The returned parm info.
3021 ///
3023  HAPI_NodeId node_id,
3024  const char * parm_name,
3025  HAPI_ParmInfo * parm_info );
3026 
3027 /// @brief Get the tag name on a parameter given an index.
3028 ///
3029 /// @ingroup Parms
3030 ///
3031 /// @param[in] session
3032 /// The session of Houdini you are interacting with.
3033 /// See @ref HAPI_Sessions for more on sessions.
3034 /// Pass NULL to just use the default in-process session.
3035 /// <!-- default NULL -->
3036 ///
3037 /// @param[in] node_id
3038 /// The node id.
3039 ///
3040 /// @param[in] parm_id
3041 /// The parm id.
3042 ///
3043 /// @param[in] tag_index
3044 /// The tag index, which should be between 0 and
3045 /// ::HAPI_ParmInfo::tagCount - 1.
3046 /// @note These indices are invalidated whenever tags are added
3047 /// to parameters. Do not store these or expect them to be the
3048 /// same if the scene is modified.
3049 /// <!-- min 0 -->
3050 /// <!-- max ::HAPI_ParmInfo::tagCount - 1 -->
3051 ///
3052 /// @param[out] tag_name
3053 /// The returned tag name. This string handle will be valid
3054 /// until another call to ::HAPI_GetParmTagName().
3055 ///
3056 HAPI_DECL HAPI_GetParmTagName( const HAPI_Session * session,
3057  HAPI_NodeId node_id,
3058  HAPI_ParmId parm_id,
3059  int tag_index,
3060  HAPI_StringHandle * tag_name );
3061 
3062 /// @brief Get the tag value on a parameter given the tag name.
3063 ///
3064 /// @ingroup Parms
3065 ///
3066 /// @param[in] session
3067 /// The session of Houdini you are interacting with.
3068 /// See @ref HAPI_Sessions for more on sessions.
3069 /// Pass NULL to just use the default in-process session.
3070 /// <!-- default NULL -->
3071 ///
3072 /// @param[in] node_id
3073 /// The node id.
3074 ///
3075 /// @param[in] parm_id
3076 /// The parm id.
3077 ///
3078 /// @param[in] tag_name
3079 /// The tag name, either known or returned by
3080 /// ::HAPI_GetParmTagName().
3081 ///
3082 /// @param[out] tag_value
3083 /// The returned tag value. This string handle will be valid
3084 /// until another call to ::HAPI_GetParmTagValue().
3085 ///
3087  HAPI_NodeId node_id,
3088  HAPI_ParmId parm_id,
3089  const char * tag_name,
3090  HAPI_StringHandle * tag_value );
3091 
3092 /// @brief See if a parameter has a specific tag.
3093 ///
3094 /// @ingroup Parms
3095 ///
3096 /// @param[in] session
3097 /// The session of Houdini you are interacting with.
3098 /// See @ref HAPI_Sessions for more on sessions.
3099 /// Pass NULL to just use the default in-process session.
3100 /// <!-- default NULL -->
3101 ///
3102 /// @param[in] node_id
3103 /// The node id.
3104 ///
3105 /// @param[in] parm_id
3106 /// The parm id.
3107 ///
3108 /// @param[in] tag_name
3109 /// The tag name to look for.
3110 ///
3111 /// @param[out] has_tag
3112 /// True if the tag exists on the parameter, false otherwise.
3113 ///
3114 HAPI_DECL HAPI_ParmHasTag( const HAPI_Session * session,
3115  HAPI_NodeId node_id,
3116  HAPI_ParmId parm_id,
3117  const char * tag_name,
3118  HAPI_Bool * has_tag );
3119 
3120 /// @brief See if a parameter has an expression
3121 ///
3122 /// @ingroup Parms
3123 ///
3124 /// @param[in] session
3125 /// The session of Houdini you are interacting with.
3126 /// See @ref HAPI_Sessions for more on sessions.
3127 /// Pass NULL to just use the default in-process session.
3128 /// <!-- default NULL -->
3129 ///
3130 /// @param[in] node_id
3131 /// The node id.
3132 ///
3133 /// @param[in] parm_name
3134 /// The parm name.
3135 ///
3136 /// @param[in] index
3137 /// The parm index.
3138 ///
3139 /// @param[out] has_expression
3140 /// True if an expression exists on the parameter, false otherwise.
3141 ///
3143  HAPI_NodeId node_id,
3144  const char * parm_name,
3145  int index,
3146  HAPI_Bool * has_expression );
3147 
3148 /// @brief Get the first parm with a specific, ideally unique, tag on it.
3149 /// This is particularly useful for getting the ogl parameters on a
3150 /// material node.
3151 ///
3152 /// @ingroup Parms
3153 ///
3154 /// @param[in] session
3155 /// The session of Houdini you are interacting with.
3156 /// See @ref HAPI_Sessions for more on sessions.
3157 /// Pass NULL to just use the default in-process session.
3158 /// <!-- default NULL -->
3159 ///
3160 /// @param[in] node_id
3161 /// The node id.
3162 ///
3163 /// @param[in] tag_name
3164 /// The tag name to look for.
3165 ///
3166 /// @param[out] parm_id
3167 /// The returned parm id. This will be -1 if no parm was found
3168 /// with this tag.
3169 ///
3170 HAPI_DECL HAPI_GetParmWithTag( const HAPI_Session * session,
3171  HAPI_NodeId node_id,
3172  const char * tag_name,
3173  HAPI_ParmId * parm_id );
3174 
3175 /// @brief Get single integer or float parm expression by name
3176 /// or Null string if no expression is present
3177 ///
3178 /// @ingroup Parms
3179 ///
3180 /// @param[in] session
3181 /// The session of Houdini you are interacting with.
3182 /// See @ref HAPI_Sessions for more on sessions.
3183 /// Pass NULL to just use the default in-process session.
3184 /// <!-- default NULL -->
3185 ///
3186 /// @param[in] node_id
3187 /// The node id.
3188 ///
3189 /// @param[in] parm_name
3190 /// The parm name.
3191 ///
3192 /// @param[in] index
3193 /// Index within the parameter's values tuple.
3194 ///
3195 /// @param[out] value
3196 /// The returned string value.
3197 ///
3199  HAPI_NodeId node_id,
3200  const char * parm_name,
3201  int index,
3203 
3204 /// @brief Revert single parm by name to default
3205 ///
3206 /// @ingroup Parms
3207 ///
3208 /// @param[in] session
3209 /// The session of Houdini you are interacting with.
3210 /// See @ref HAPI_Sessions for more on sessions.
3211 /// Pass NULL to just use the default in-process session.
3212 /// <!-- default NULL -->
3213 ///
3214 /// @param[in] node_id
3215 /// The node id.
3216 ///
3217 /// @param[in] parm_name
3218 /// The parm name.
3219 ///
3220 /// @param[in] index
3221 /// Index within the parameter's values tuple.
3222 ///
3224  HAPI_NodeId node_id,
3225  const char * parm_name,
3226  int index );
3227 
3228 /// @brief Revert all instances of the parm by name to defaults
3229 ///
3230 /// @ingroup Parms
3231 ///
3232 /// @param[in] session
3233 /// The session of Houdini you are interacting with.
3234 /// See @ref HAPI_Sessions for more on sessions.
3235 /// Pass NULL to just use the default in-process session.
3236 /// <!-- default NULL -->
3237 ///
3238 /// @param[in] node_id
3239 /// The node id.
3240 ///
3241 /// @param[in] parm_name
3242 /// The parm name.
3243 ///
3245  HAPI_NodeId node_id,
3246  const char * parm_name );
3247 
3248 /// @brief Set (push) an expression string. We can only set a single value at
3249 /// a time because we want to avoid fixed size string buffers.
3250 ///
3251 /// @note Regardless of the value, when calling this function
3252 /// on a parameter, if that parameter has a callback function
3253 /// attached to it, that callback function will be called. For
3254 /// example, if the parameter is a button the button will be
3255 /// pressed.
3256 ///
3257 /// @note In threaded mode, this is an _async call_!
3258 ///
3259 /// This API will invoke the cooking thread if threading is
3260 /// enabled. This means it will return immediately. Use
3261 /// the status and cooking count APIs under DIAGNOSTICS to get
3262 /// a sense of the progress. All other API calls will block
3263 /// until the cook operation has finished.
3264 ///
3265 /// Also note that the cook result won't be of type
3266 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3267 /// Whenever the threading cook is done it will fill the
3268 /// @a cook result which is queried using
3269 /// ::HAPI_STATUS_COOK_RESULT.
3270 ///
3271 /// @ingroup Parms
3272 ///
3273 /// @param[in] session
3274 /// The session of Houdini you are interacting with.
3275 /// See @ref HAPI_Sessions for more on sessions.
3276 /// Pass NULL to just use the default in-process session.
3277 /// <!-- default NULL -->
3278 ///
3279 /// @param[in] node_id
3280 /// The node id.
3281 ///
3282 /// @param[in] value
3283 /// The expression string.
3284 ///
3285 /// @param[in] parm_id
3286 /// Parameter id of the parameter being updated.
3287 ///
3288 /// @param[in] index
3289 /// Index within the parameter's values tuple.
3290 ///
3292  HAPI_NodeId node_id,
3293  const char * value,
3294  HAPI_ParmId parm_id, int index );
3295 
3296 /// @brief Remove the expression string, leaving the value of the
3297 /// parm at the current value of the expression
3298 ///
3299 /// @note Regardless of the value, when calling this function
3300 /// on a parameter, if that parameter has a callback function
3301 /// attached to it, that callback function will be called. For
3302 /// example, if the parameter is a button the button will be
3303 /// pressed.
3304 ///
3305 /// @note In threaded mode, this is an _async call_!
3306 ///
3307 /// This API will invoke the cooking thread if threading is
3308 /// enabled. This means it will return immediately. Use
3309 /// the status and cooking count APIs under DIAGNOSTICS to get
3310 /// a sense of the progress. All other API calls will block
3311 /// until the cook operation has finished.
3312 ///
3313 /// Also note that the cook result won't be of type
3314 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3315 /// Whenever the threading cook is done it will fill the
3316 /// @a cook result which is queried using
3317 /// ::HAPI_STATUS_COOK_RESULT.
3318 ///
3319 /// @ingroup Parms
3320 ///
3321 /// @param[in] session
3322 /// The session of Houdini you are interacting with.
3323 /// See @ref HAPI_Sessions for more on sessions.
3324 /// Pass NULL to just use the default in-process session.
3325 /// <!-- default NULL -->
3326 ///
3327 /// @param[in] node_id
3328 /// The node id.
3329 ///
3330 /// @param[in] parm_id
3331 /// Parameter id of the parameter being updated.
3332 ///
3333 /// @param[in] index
3334 /// Index within the parameter's values tuple.
3335 ///
3337  HAPI_NodeId node_id,
3338  HAPI_ParmId parm_id, int index );
3339 
3340 /// @brief Get single parm int value by name.
3341 ///
3342 /// @ingroup Parms
3343 ///
3344 /// @param[in] session
3345 /// The session of Houdini you are interacting with.
3346 /// See @ref HAPI_Sessions for more on sessions.
3347 /// Pass NULL to just use the default in-process session.
3348 /// <!-- default NULL -->
3349 ///
3350 /// @param[in] node_id
3351 /// The node id.
3352 ///
3353 /// @param[in] parm_name
3354 /// The parm name.
3355 ///
3356 /// @param[in] index
3357 /// Index within the parameter's values tuple.
3358 ///
3359 /// @param[out] value
3360 /// The returned int value.
3361 ///
3363  HAPI_NodeId node_id,
3364  const char * parm_name,
3365  int index,
3366  int * value );
3367 
3368 /// @brief Fill an array of parameter int values. This is more efficient
3369 /// than calling ::HAPI_GetParmIntValue() individually for each
3370 /// parameter value.
3371 ///
3372 /// @ingroup Parms
3373 ///
3374 /// @param[in] session
3375 /// The session of Houdini you are interacting with.
3376 /// See @ref HAPI_Sessions for more on sessions.
3377 /// Pass NULL to just use the default in-process session.
3378 /// <!-- default NULL -->
3379 ///
3380 /// @param[in] node_id
3381 /// The node id.
3382 ///
3383 /// @param[out] values_array
3384 /// Array of ints at least the size of length.
3385 ///
3386 /// @param[in] start
3387 /// First index of range. Must be at least 0 and at
3388 /// most ::HAPI_NodeInfo::parmIntValueCount - 1.
3389 /// <!-- min 0 -->
3390 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - 1 -->
3391 /// <!-- default 0 -->
3392 ///
3393 /// @param[in] length
3394 /// Must be at least 1 and at most
3395 /// ::HAPI_NodeInfo::parmIntValueCount - start.
3396 /// <!-- min 1 -->
3397 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - start -->
3398 /// <!-- source ::HAPI_NodeInfo::parmIntValueCount - start -->
3399 ///
3401  HAPI_NodeId node_id,
3402  int * values_array,
3403  int start, int length );
3404 
3405 /// @brief Get single parm float value by name.
3406 ///
3407 /// @ingroup Parms
3408 ///
3409 /// @param[in] session
3410 /// The session of Houdini you are interacting with.
3411 /// See @ref HAPI_Sessions for more on sessions.
3412 /// Pass NULL to just use the default in-process session.
3413 /// <!-- default NULL -->
3414 ///
3415 /// @param[in] node_id
3416 /// The node id.
3417 ///
3418 /// @param[in] parm_name
3419 /// The parm name.
3420 ///
3421 /// @param[in] index
3422 /// Index within the parameter's values tuple.
3423 ///
3424 /// @param[out] value
3425 /// The returned float value.
3426 ///
3428  HAPI_NodeId node_id,
3429  const char * parm_name,
3430  int index,
3431  float * value );
3432 
3433 /// @brief Fill an array of parameter float values. This is more efficient
3434 /// than calling ::HAPI_GetParmFloatValue() individually for each
3435 /// parameter value.
3436 ///
3437 /// @ingroup Parms
3438 ///
3439 /// @param[in] session
3440 /// The session of Houdini you are interacting with.
3441 /// See @ref HAPI_Sessions for more on sessions.
3442 /// Pass NULL to just use the default in-process session.
3443 /// <!-- default NULL -->
3444 ///
3445 /// @param[in] node_id
3446 /// The node id.
3447 ///
3448 /// @param[out] values_array
3449 /// Array of floats at least the size of length.
3450 ///
3451 /// @param[in] start
3452 /// First index of range. Must be at least 0 and at
3453 /// most ::HAPI_NodeInfo::parmFloatValueCount - 1.
3454 /// <!-- min 0 -->
3455 /// <!-- max ::HAPI_NodeInfo::parmFloatValueCount - 1 -->
3456 /// <!-- default 0 -->
3457 ///
3458 /// @param[in] length
3459 /// Must be at least 1 and at most
3460 /// ::HAPI_NodeInfo::parmFloatValueCount - start.
3461 /// <!-- min 1 -->
3462 /// <!-- max ::HAPI_NodeInfo::parmFloatValueCount - start -->
3463 /// <!-- source ::HAPI_NodeInfo::parmFloatValueCount - start -->
3464 ///
3466  HAPI_NodeId node_id,
3467  float * values_array,
3468  int start, int length );
3469 
3470 /// @brief Get single parm string value by name.
3471 ///
3472 /// @ingroup Parms
3473 ///
3474 /// @param[in] session
3475 /// The session of Houdini you are interacting with.
3476 /// See @ref HAPI_Sessions for more on sessions.
3477 /// Pass NULL to just use the default in-process session.
3478 /// <!-- default NULL -->
3479 ///
3480 /// @param[in] node_id
3481 /// The node id.
3482 ///
3483 /// @param[in] parm_name
3484 /// The name of the parameter.
3485 ///
3486 /// @param[in] index
3487 /// Index within the parameter's values tuple.
3488 ///
3489 /// @param[in] evaluate
3490 /// Whether or not to evaluate the string expression.
3491 /// For example, the string "$F" would evaluate to the
3492 /// current frame number. So, passing in evaluate = false
3493 /// would give you back the string "$F" and passing
3494 /// in evaluate = true would give you back "1" (assuming
3495 /// the current frame is 1).
3496 /// <!-- default true -->
3497 ///
3498 /// @param[out] value
3499 /// The returned string value.
3500 ///
3502  HAPI_NodeId node_id,
3503  const char * parm_name,
3504  int index,
3505  HAPI_Bool evaluate,
3507 
3508 /// @brief Fill an array of parameter string handles. These handles must
3509 /// be used in conjunction with ::HAPI_GetString() to get the
3510 /// actual string values. This is more efficient than calling
3511 /// ::HAPI_GetParmStringValue() individually for each
3512 /// parameter value.
3513 ///
3514 /// @ingroup Parms
3515 ///
3516 /// @param[in] session
3517 /// The session of Houdini you are interacting with.
3518 /// See @ref HAPI_Sessions for more on sessions.
3519 /// Pass NULL to just use the default in-process session.
3520 /// <!-- default NULL -->
3521 ///
3522 /// @param[in] node_id
3523 /// The node id.
3524 ///
3525 /// @param[in] evaluate
3526 /// Whether or not to evaluate the string expression.
3527 /// For example, the string "$F" would evaluate to the
3528 /// current frame number. So, passing in evaluate = false
3529 /// would give you back the string "$F" and passing
3530 /// in evaluate = true would give you back "1" (assuming
3531 /// the current frame is 1).
3532 ///
3533 /// @param[out] values_array
3534 /// Array of integers at least the size of length.
3535 ///
3536 /// @param[in] start
3537 /// First index of range. Must be at least 0 and at
3538 /// most ::HAPI_NodeInfo::parmStringValueCount - 1.
3539 /// <!-- min 0 -->
3540 /// <!-- max ::HAPI_NodeInfo::parmStringValueCount - 1 -->
3541 /// <!-- default 0 -->
3542 ///
3543 /// @param[in] length
3544 /// Must be at least 1 and at most
3545 /// ::HAPI_NodeInfo::parmStringValueCount - start.
3546 /// <!-- min 1 -->
3547 /// <!-- max ::HAPI_NodeInfo::parmStringValueCount - start -->
3548 /// <!-- source ::HAPI_NodeInfo::parmStringValueCount - start -->
3549 ///
3551  HAPI_NodeId node_id,
3552  HAPI_Bool evaluate,
3553  HAPI_StringHandle * values_array,
3554  int start, int length );
3555 
3556 /// @brief Get a single node id parm value of an Op Path parameter. This is
3557 /// how you see which node is connected as an input for the current
3558 /// node (via parameter).
3559 ///
3560 /// @ingroup Parms
3561 ///
3562 /// @param[in] session
3563 /// The session of Houdini you are interacting with.
3564 /// See @ref HAPI_Sessions for more on sessions.
3565 /// Pass NULL to just use the default in-process session.
3566 /// <!-- default NULL -->
3567 ///
3568 /// @param[in] node_id
3569 /// The node id.
3570 ///
3571 /// @param[in] parm_name
3572 /// The name of the parameter.
3573 ///
3574 /// @param[out] value
3575 /// The node id of the node being pointed to by the parm.
3576 /// If there is no node found, -1 will be returned.
3577 ///
3579  HAPI_NodeId node_id,
3580  const char * parm_name,
3581  HAPI_NodeId * value );
3582 
3583 /// @brief Extract a file specified by path on a parameter. This will copy
3584 /// the file to the destination directory from wherever it might be,
3585 /// inlcuding inside the asset definition or online.
3586 ///
3587 /// @ingroup Parms
3588 ///
3589 /// @param[in] session
3590 /// The session of Houdini you are interacting with.
3591 /// See @ref HAPI_Sessions for more on sessions.
3592 /// Pass NULL to just use the default in-process session.
3593 /// <!-- default NULL -->
3594 ///
3595 /// @param[in] node_id
3596 /// The node id.
3597 ///
3598 /// @param[in] parm_name
3599 /// The name of the parameter.
3600 ///
3601 /// @param[in] destination_directory
3602 /// The destination directory to copy the file to.
3603 ///
3604 /// @param[in] destination_file_name
3605 /// The destination file name.
3606 ///
3607 HAPI_DECL HAPI_GetParmFile( const HAPI_Session * session,
3608  HAPI_NodeId node_id,
3609  const char * parm_name,
3610  const char * destination_directory,
3611  const char * destination_file_name );
3612 
3613 /// @brief Fill an array of ::HAPI_ParmChoiceInfo structs with parameter
3614 /// choice list information from the asset instance node.
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[out] parm_choices_array
3628 /// Array of ::HAPI_ParmChoiceInfo exactly the size of
3629 /// length.
3630 ///
3631 /// @param[in] start
3632 /// First index of range. Must be at least 0 and at
3633 /// most ::HAPI_NodeInfo::parmChoiceCount - 1.
3634 /// <!-- min 0 -->
3635 /// <!-- max ::HAPI_NodeInfo::parmChoiceCount - 1 -->
3636 /// <!-- default 0 -->
3637 ///
3638 /// @param[in] length
3639 /// Must be at least 1 and at most
3640 /// ::HAPI_NodeInfo::parmChoiceCount - start.
3641 /// <!-- min 1 -->
3642 /// <!-- max ::HAPI_NodeInfo::parmChoiceCount - start -->
3643 /// <!-- source ::HAPI_NodeInfo::parmChoiceCount - start -->
3644 ///
3646  HAPI_NodeId node_id,
3647  HAPI_ParmChoiceInfo * parm_choices_array,
3648  int start, int length );
3649 
3650 /// @brief Set single parm int value by name.
3651 ///
3652 /// @note Regardless of the value, when calling this function
3653 /// on a parameter, if that parameter has a callback function
3654 /// attached to it, that callback function will be called. For
3655 /// example, if the parameter is a button the button will be
3656 /// pressed.
3657 ///
3658 /// @note In threaded mode, this is an _async call_!
3659 ///
3660 /// This API will invoke the cooking thread if threading is
3661 /// enabled. This means it will return immediately. Use
3662 /// the status and cooking count APIs under DIAGNOSTICS to get
3663 /// a sense of the progress. All other API calls will block
3664 /// until the cook operation has finished.
3665 ///
3666 /// Also note that the cook result won't be of type
3667 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3668 /// Whenever the threading cook is done it will fill the
3669 /// @a cook result which is queried using
3670 /// ::HAPI_STATUS_COOK_RESULT.
3671 ///
3672 /// @ingroup Parms
3673 ///
3674 /// @param[in] session
3675 /// The session of Houdini you are interacting with.
3676 /// See @ref HAPI_Sessions for more on sessions.
3677 /// Pass NULL to just use the default in-process session.
3678 /// <!-- default NULL -->
3679 ///
3680 /// @param[in] node_id
3681 /// The node id.
3682 ///
3683 /// @param[in] parm_name
3684 /// The parm name.
3685 ///
3686 /// @param[in] index
3687 /// Index within the parameter's values tuple.
3688 ///
3689 /// @param[in] value
3690 /// The int value.
3691 ///
3693  HAPI_NodeId node_id,
3694  const char * parm_name,
3695  int index,
3696  int value );
3697 
3698 /// @brief Set (push) an array of parameter int values.
3699 ///
3700 /// @note Regardless of the values, when calling this function
3701 /// on a set of parameters, if any parameter has a callback
3702 /// function attached to it, that callback function will be called.
3703 /// For example, if the parameter is a button the button will be
3704 /// pressed.
3705 ///
3706 /// @note In threaded mode, this is an _async call_!
3707 ///
3708 /// This API will invoke the cooking thread if threading is
3709 /// enabled. This means it will return immediately. Use
3710 /// the status and cooking count APIs under DIAGNOSTICS to get
3711 /// a sense of the progress. All other API calls will block
3712 /// until the cook operation has finished.
3713 ///
3714 /// Also note that the cook result won't be of type
3715 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3716 /// Whenever the threading cook is done it will fill the
3717 /// @a cook result which is queried using
3718 /// ::HAPI_STATUS_COOK_RESULT.
3719 ///
3720 /// @ingroup Parms
3721 ///
3722 /// @param[in] session
3723 /// The session of Houdini you are interacting with.
3724 /// See @ref HAPI_Sessions for more on sessions.
3725 /// Pass NULL to just use the default in-process session.
3726 /// <!-- default NULL -->
3727 ///
3728 /// @param[in] node_id
3729 /// The node id.
3730 ///
3731 /// @param[in] values_array
3732 /// Array of integers at least the size of length.
3733 /// <!-- min length -->
3734 ///
3735 /// @param[in] start
3736 /// First index of range. Must be at least 0 and at
3737 /// most ::HAPI_NodeInfo::parmIntValueCount - 1.
3738 /// <!-- min 0 -->
3739 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - 1 -->
3740 /// <!-- default 0 -->
3741 ///
3742 /// @param[in] length
3743 /// Must be at least 1 and at most
3744 /// ::HAPI_NodeInfo::parmIntValueCount - start.
3745 /// <!-- min 1 -->
3746 /// <!-- max ::HAPI_NodeInfo::parmIntValueCount - start -->
3747 /// <!-- source ::HAPI_NodeInfo::parmIntValueCount - start -->
3748 ///
3750  HAPI_NodeId node_id,
3751  const int * values_array,
3752  int start, int length );
3753 
3754 /// @brief Set single parm float value by name.
3755 ///
3756 /// @note Regardless of the value, when calling this function
3757 /// on a parameter, if that parameter has a callback function
3758 /// attached to it, that callback function will be called. For
3759 /// example, if the parameter is a button the button will be
3760 /// pressed.
3761 ///
3762 /// @note In threaded mode, this is an _async call_!
3763 ///
3764 /// This API will invoke the cooking thread if threading is
3765 /// enabled. This means it will return immediately. Use
3766 /// the status and cooking count APIs under DIAGNOSTICS to get
3767 /// a sense of the progress. All other API calls will block
3768 /// until the cook operation has finished.
3769 ///
3770 /// Also note that the cook result won't be of type
3771 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3772 /// Whenever the threading cook is done it will fill the
3773 /// @a cook result which is queried using
3774 /// ::HAPI_STATUS_COOK_RESULT.
3775 ///
3776 /// @ingroup Parms
3777 ///
3778 /// @param[in] session
3779 /// The session of Houdini you are interacting with.
3780 /// See @ref HAPI_Sessions for more on sessions.
3781 /// Pass NULL to just use the default in-process session.
3782 /// <!-- default NULL -->
3783 ///
3784 /// @param[in] node_id
3785 /// The node id.
3786 ///
3787 /// @param[in] parm_name
3788 /// The parm name.
3789 ///
3790 /// @param[in] index
3791 /// Index within the parameter's values tuple.
3792 ///
3793 /// @param[in] value
3794 /// The float value.
3795 ///
3797  HAPI_NodeId node_id,
3798  const char * parm_name,
3799  int index,
3800  float value );
3801 
3802 /// @brief Set (push) an array of parameter float values.
3803 ///
3804 /// @note Regardless of the values, when calling this function
3805 /// on a set of parameters, if any parameter has a callback
3806 /// function attached to it, that callback function will be called.
3807 /// For example, if the parameter is a button the button will be
3808 /// pressed.
3809 ///
3810 /// @note In threaded mode, this is an _async call_!
3811 ///
3812 /// This API will invoke the cooking thread if threading is
3813 /// enabled. This means it will return immediately. Use
3814 /// the status and cooking count APIs under DIAGNOSTICS to get
3815 /// a sense of the progress. All other API calls will block
3816 /// until the cook operation has finished.
3817 ///
3818 /// Also note that the cook result won't be of type
3819 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3820 /// Whenever the threading cook is done it will fill the
3821 /// @a cook result which is queried using
3822 /// ::HAPI_STATUS_COOK_RESULT.
3823 ///
3824 /// @ingroup Parms
3825 ///
3826 /// @param[in] session
3827 /// The session of Houdini you are interacting with.
3828 /// See @ref HAPI_Sessions for more on sessions.
3829 /// Pass NULL to just use the default in-process session.
3830 /// <!-- default NULL -->
3831 ///
3832 /// @param[in] node_id
3833 /// The node id.
3834 ///
3835 /// @param[in] values_array
3836 /// Array of floats at least the size of length.
3837 ///
3838 /// @param[in] start
3839 /// First index of range. Must be at least 0 and at
3840 /// most ::HAPI_NodeInfo::parmFloatValueCount - 1.
3841 ///
3842 /// @param[in] length
3843 /// Must be at least 1 and at most
3844 /// ::HAPI_NodeInfo::parmFloatValueCount - start.
3845 ///
3847  HAPI_NodeId node_id,
3848  const float * values_array,
3849  int start, int length );
3850 
3851 /// @brief Set (push) a string value. We can only set a single value at
3852 /// a time because we want to avoid fixed size string buffers.
3853 ///
3854 /// @note Regardless of the value, when calling this function
3855 /// on a parameter, if that parameter has a callback function
3856 /// attached to it, that callback function will be called. For
3857 /// example, if the parameter is a button the button will be
3858 /// pressed.
3859 ///
3860 /// @note In threaded mode, this is an _async call_!
3861 ///
3862 /// This API will invoke the cooking thread if threading is
3863 /// enabled. This means it will return immediately. Use
3864 /// the status and cooking count APIs under DIAGNOSTICS to get
3865 /// a sense of the progress. All other API calls will block
3866 /// until the cook operation has finished.
3867 ///
3868 /// Also note that the cook result won't be of type
3869 /// ::HAPI_STATUS_CALL_RESULT like all calls (including this one).
3870 /// Whenever the threading cook is done it will fill the
3871 /// @a cook result which is queried using
3872 /// ::HAPI_STATUS_COOK_RESULT.
3873 ///
3874 /// @ingroup Parms
3875 ///
3876 /// @param[in] session
3877 /// The session of Houdini you are interacting with.
3878 /// See @ref HAPI_Sessions for more on sessions.
3879 /// Pass NULL to just use the default in-process session.
3880 /// <!-- default NULL -->
3881 ///
3882 /// @param[in] node_id
3883 /// The node id.
3884 ///
3885 /// @param[in] value
3886 /// The string value.
3887 ///
3888 /// @param[in] parm_id
3889 /// Parameter id of the parameter being updated.
3890 ///
3891 /// @param[in] index
3892 /// Index within the parameter's values tuple.
3893 ///
3895  HAPI_NodeId node_id,
3896  const char * value,
3897  HAPI_ParmId parm_id, int index );
3898 
3899 /// @brief Set a node id parm value of an Op Path parameter. For example,
3900 /// This is how you connect the geometry output of an asset to the
3901 /// geometry input of another asset - whether the input is a parameter
3902 /// or a node input (the top of the node). Node inputs get converted
3903 /// top parameters in HAPI.
3904 ///
3905 /// @ingroup Parms
3906 ///
3907 /// @param[in] session
3908 /// The session of Houdini you are interacting with.
3909 /// See @ref HAPI_Sessions for more on sessions.
3910 /// Pass NULL to just use the default in-process session.
3911 /// <!-- default NULL -->
3912 ///
3913 /// @param[in] node_id
3914 /// The node id.
3915 ///
3916 /// @param[in] parm_name
3917 /// The name of the parameter.
3918 ///
3919 /// @param[in] value
3920 /// The node id of the node being connected. Pass -1 to
3921 /// disconnect.
3922 ///
3924  HAPI_NodeId node_id,
3925  const char * parm_name,
3926  HAPI_NodeId value );
3927 
3928 /// @brief Insert an instance of a multiparm before instance_position.
3929 ///
3930 /// @ingroup Parms
3931 ///
3932 /// @param[in] session
3933 /// The session of Houdini you are interacting with.
3934 /// See @ref HAPI_Sessions for more on sessions.
3935 /// Pass NULL to just use the default in-process session.
3936 /// <!-- default NULL -->
3937 ///
3938 /// @param[in] node_id
3939 /// The node id.
3940 ///
3941 /// @param[in] parm_id
3942 /// A parm id given by a ::HAPI_ParmInfo struct that
3943 /// has type ::HAPI_PARMTYPE_MULTIPARMLIST.
3944 ///
3945 /// @param[in] instance_position
3946 /// The new instance will be inserted at this position
3947 /// index. Do note the multiparms can start at position
3948 /// 1 or 0. Use ::HAPI_ParmInfo::instanceStartOffset to
3949 /// distinguish.
3950 ///
3952  HAPI_NodeId node_id,
3953  HAPI_ParmId parm_id,
3954  int instance_position );
3955 
3956 /// @brief Remove the instance of a multiparm given by instance_position.
3957 ///
3958 /// @ingroup Parms
3959 ///
3960 /// @param[in] session
3961 /// The session of Houdini you are interacting with.
3962 /// See @ref HAPI_Sessions for more on sessions.
3963 /// Pass NULL to just use the default in-process session.
3964 /// <!-- default NULL -->
3965 ///
3966 /// @param[in] node_id
3967 /// The node id.
3968 ///
3969 /// @param[in] parm_id
3970 /// A parm id given by a ::HAPI_ParmInfo struct that
3971 /// has type ::HAPI_PARMTYPE_MULTIPARMLIST.
3972 ///
3973 /// @param[in] instance_position
3974 /// The instance at instance_position will removed.
3975 ///
3977  HAPI_NodeId node_id,
3978  HAPI_ParmId parm_id,
3979  int instance_position );
3980 
3981 // HANDLES ------------------------------------------------------------------
3982 
3983 /// @brief Fill an array of ::HAPI_HandleInfo structs with information
3984 /// about every exposed user manipulation handle on the node.
3985 ///
3986 /// @ingroup Parms
3987 ///
3988 /// @param[in] session
3989 /// The session of Houdini you are interacting with.
3990 /// See @ref HAPI_Sessions for more on sessions.
3991 /// Pass NULL to just use the default in-process session.
3992 /// <!-- default NULL -->
3993 ///
3994 /// @param[in] node_id
3995 /// The node id.
3996 ///
3997 /// @param[out] handle_infos_array
3998 /// Array of ::HAPI_HandleInfo at least the size of length.
3999 ///
4000 /// @param[in] start
4001 /// First index of range. Must be at least 0 and at
4002 /// most ::HAPI_AssetInfo::handleCount - 1.
4003 /// <!-- default 0 -->
4004 ///
4005 /// @param[in] length
4006 /// Must be at least 1 and at most
4007 /// ::HAPI_AssetInfo::handleCount - start.
4008 /// <!-- source ::HAPI_AssetInfo::handleCount - start -->
4009 ///
4010 HAPI_DECL HAPI_GetHandleInfo( const HAPI_Session * session,
4011  HAPI_NodeId node_id,
4012  HAPI_HandleInfo * handle_infos_array,
4013  int start, int length );
4014 
4015 /// @brief Fill an array of ::HAPI_HandleBindingInfo structs with information
4016 /// about the binding of a particular handle on the given node.
4017 ///
4018 /// @ingroup Parms
4019 ///
4020 /// @param[in] session
4021 /// The session of Houdini you are interacting with.
4022 /// See @ref HAPI_Sessions for more on sessions.
4023 /// Pass NULL to just use the default in-process session.
4024 /// <!-- default NULL -->
4025 ///
4026 /// @param[in] node_id
4027 /// The node id.
4028 ///
4029 /// @param[in] handle_index
4030 /// The index of the handle, from 0 to handleCount - 1
4031 /// from the call to ::HAPI_GetAssetInfo().
4032 ///
4033 /// @param[out] handle_binding_infos_array
4034 /// Array of ::HAPI_HandleBindingInfo at least the size
4035 /// of length.
4036 ///
4037 /// @param[in] start
4038 /// First index of range. Must be at least 0 and at
4039 /// most ::HAPI_HandleInfo::bindingsCount - 1.
4040 /// <!-- default 0 -->
4041 ///
4042 /// @param[in] length
4043 /// Must be at least 1 and at most
4044 /// ::HAPI_HandleInfo::bindingsCount - start.
4045 /// <!-- source ::HAPI_AssetInfo::bindingsCount - start -->
4046 ///
4048  const HAPI_Session * session,
4049  HAPI_NodeId node_id,
4050  int handle_index,
4051  HAPI_HandleBindingInfo * handle_binding_infos_array,
4052  int start, int length );
4053 
4054 /// @defgroup Presets Presets
4055 /// Functions for working with Node presets
4056 
4057 /// @brief Generate a preset blob of the current state of all the
4058 /// parameter values, cache it, and return its size in bytes.
4059 ///
4060 /// @ingroup Presets
4061 ///
4062 /// @param[in] session
4063 /// The session of Houdini you are interacting with.
4064 /// See @ref HAPI_Sessions for more on sessions.
4065 /// Pass NULL to just use the default in-process session.
4066 /// <!-- default NULL -->
4067 ///
4068 /// @param[in] node_id
4069 /// The exposed node id.
4070 ///
4071 /// @param[in] preset_type
4072 /// The preset type.
4073 ///
4074 /// @param[in] preset_name
4075 /// Optional. This is only used if the @p preset_type is
4076 /// ::HAPI_PRESETTYPE_IDX. If NULL is given, the preset
4077 /// name will be the same as the name of the node with
4078 /// the given @p node_id.
4079 ///
4080 /// @param[out] buffer_length
4081 /// Size of the buffer.
4082 ///
4084  HAPI_NodeId node_id,
4085  HAPI_PresetType preset_type,
4086  const char * preset_name,
4087  int * buffer_length );
4088 
4089 /// @brief Generates a preset for the given asset.
4090 ///
4091 /// @ingroup Presets
4092 ///
4093 /// @param[in] session
4094 /// The session of Houdini you are interacting with.
4095 /// See @ref HAPI_Sessions for more on sessions.
4096 /// Pass NULL to just use the default in-process session.
4097 /// <!-- default NULL -->
4098 ///
4099 /// @param[in] node_id
4100 /// The exposed node id.
4101 ///
4102 /// @param[out] buffer
4103 /// Buffer to hold the preset data.
4104 ///
4105 /// @param[in] buffer_length
4106 /// Size of the buffer. Should be the same as the length
4107 /// returned by ::HAPI_GetPresetBufLength().
4108 ///
4109 HAPI_DECL HAPI_GetPreset( const HAPI_Session * session,
4110  HAPI_NodeId node_id,
4111  char * buffer,
4112  int buffer_length );
4113 
4114 /// @brief Sets a particular asset to a given preset.
4115 ///
4116 /// @ingroup Presets
4117 ///
4118 /// @param[in] session
4119 /// The session of Houdini you are interacting with.
4120 /// See @ref HAPI_Sessions for more on sessions.
4121 /// Pass NULL to just use the default in-process session.
4122 /// <!-- default NULL -->
4123 ///
4124 /// @param[in] node_id
4125 /// The exposed node id.
4126 ///
4127 /// @param[in] preset_type
4128 /// The preset type.
4129 ///
4130 /// @param[in] preset_name
4131 /// Optional. This is only used if the @p preset_type is
4132 /// ::HAPI_PRESETTYPE_IDX. If NULL is give, the first
4133 /// preset in the IDX file will be chosen.
4134 /// <!-- default NULL -->
4135 ///
4136 /// @param[in] buffer
4137 /// Buffer to hold the preset data.
4138 ///
4139 /// @param[in] buffer_length
4140 /// Size of the buffer.
4141 ///
4142 HAPI_DECL HAPI_SetPreset( const HAPI_Session * session,
4143  HAPI_NodeId node_id,
4144  HAPI_PresetType preset_type,
4145  const char * preset_name,
4146  const char * buffer,
4147  int buffer_length );
4148 
4149 /// @defgroup Objects
4150 /// Functions for working with OBJ Nodes
4151 
4152 /// @brief Get the object info on an OBJ node.
4153 ///
4154 /// @ingroup Objects
4155 ///
4156 /// @param[in] session
4157 /// The session of Houdini you are interacting with.
4158 /// See @ref HAPI_Sessions for more on sessions.
4159 /// Pass NULL to just use the default in-process session.
4160 /// <!-- default NULL -->
4161 ///
4162 /// @param[in] node_id
4163 /// The node id.
4164 ///
4165 /// @param[out] object_info
4166 /// The output ::HAPI_ObjectInfo.
4167 ///
4168 HAPI_DECL HAPI_GetObjectInfo( const HAPI_Session * session,
4169  HAPI_NodeId node_id,
4170  HAPI_ObjectInfo * object_info );
4171 
4172 /// @brief Get the tranform of an OBJ node.
4173 ///
4174 /// @ingroup Objects
4175 ///
4176 /// @param[in] session
4177 /// The session of Houdini you are interacting with.
4178 /// See @ref HAPI_Sessions for more on sessions.
4179 /// Pass NULL to just use the default in-process session.
4180 /// <!-- default NULL -->
4181 ///
4182 /// @param[in] node_id
4183 /// The object node id.
4184 ///
4185 /// @param[in] relative_to_node_id
4186 /// The object node id for the object to which the returned
4187 /// transform will be relative to. Pass -1 or the node_id
4188 /// to just get the object's local transform.
4189 ///
4190 /// @param[in] rst_order
4191 /// The order of application of translation, rotation and
4192 /// scale.
4193 ///
4194 /// @param[out] transform
4195 /// The output ::HAPI_Transform transform.
4196 ///
4198  HAPI_NodeId node_id,
4199  HAPI_NodeId relative_to_node_id,
4200  HAPI_RSTOrder rst_order,
4202 
4203 /// @brief Compose a list of child object nodes given a parent node id.
4204 ///
4205 /// Use the @c object_count returned by this function to get the
4206 /// ::HAPI_ObjectInfo structs for each child object using
4207 /// ::HAPI_GetComposedObjectList().
4208 ///
4209 /// Note, if not using the @c categories arg, this is equivalent to:
4210 /// @code
4211 /// HAPI_ComposeChildNodeList(
4212 /// session, parent_node_id,
4213 /// HAPI_NODETYPE_OBJ,
4214 /// HAPI_NODEFLAGS_OBJ_GEOMETRY,
4215 /// true, &object_count );
4216 /// @endcode
4217 ///
4218 /// @ingroup Objects
4219 ///
4220 /// @param[in] session
4221 /// The session of Houdini you are interacting with.
4222 /// See @ref HAPI_Sessions for more on sessions.
4223 /// Pass NULL to just use the default in-process session.
4224 /// <!-- default NULL -->
4225 ///
4226 /// @param[in] parent_node_id
4227 /// The parent node id.
4228 ///
4229 /// @param[in] categories
4230 /// (Optional) Lets you filter object nodes by their render
4231 /// categories. This is a standard OBJ parameter, usually
4232 /// under the Render > Shading tab. If an OBJ node does not
4233 /// have this parameter, one can always add it as a spare.
4234 ///
4235 /// The value of this string argument should be NULL if not
4236 /// used or a space-separated list of category names.
4237 /// Multiple category names will be treated as an AND op.
4238 /// <!-- default NULL -->
4239 ///
4240 /// @param[out] object_count
4241 /// The number of object nodes currently under the parent.
4242 /// Use this count with a call to
4243 /// ::HAPI_GetComposedObjectList() to get the object infos.
4244 ///
4246  HAPI_NodeId parent_node_id,
4247  const char * categories,
4248  int * object_count );
4249 
4250 /// @brief Fill an array of ::HAPI_ObjectInfo structs.
4251 ///
4252 /// This is best used with ::HAPI_ComposeObjectList() with.
4253 ///
4254 /// @ingroup Objects
4255 ///
4256 /// @param[in] session
4257 /// The session of Houdini you are interacting with.
4258 /// See @ref HAPI_Sessions for more on sessions.
4259 /// Pass NULL to just use the default in-process session.
4260 /// <!-- default NULL -->
4261 ///
4262 /// @param[in] parent_node_id
4263 /// The parent node id.
4264 ///
4265 /// @param[out] object_infos_array
4266 /// Array of ::HAPI_ObjectInfo at least the size of
4267 /// @c length.
4268 ///
4269 /// @param[in] start
4270 /// At least @c 0 and at most @c object_count returned by
4271 /// ::HAPI_ComposeObjectList().
4272 /// <!-- default 0 -->
4273 ///
4274 /// @param[in] length
4275 /// Given @c object_count returned by
4276 /// ::HAPI_ComposeObjectList(), @c length should be at least
4277 /// @c 0 and at most <tt>object_count - start</tt>.
4278 /// <!-- source ::HAPI_ComposeObjectList - start -->
4279 ///
4281  HAPI_NodeId parent_node_id,
4282  HAPI_ObjectInfo * object_infos_array,
4283  int start, int length );
4284 
4285 /// @brief Fill an array of ::HAPI_Transform structs.
4286 ///
4287 /// This is best used with ::HAPI_ComposeObjectList() with.
4288 ///
4289 /// Note that these transforms will be relative to the
4290 /// @c parent_node_id originally given to ::HAPI_ComposeObjectList()
4291 /// and expected to be the same with this call. If @c parent_node_id
4292 /// is not an OBJ node, the transforms will be given as they are on
4293 /// the object node itself.
4294 ///
4295 /// @ingroup Objects
4296 ///
4297 /// @param[in] session
4298 /// The session of Houdini you are interacting with.
4299 /// See @ref HAPI_Sessions for more on sessions.
4300 /// Pass NULL to just use the default in-process session.
4301 /// <!-- default NULL -->
4302 ///
4303 /// @param[in] parent_node_id
4304 /// The parent node id. The object transforms will be
4305 /// relative to this node unless this node is not an OBJ.
4306 ///
4307 /// @param[in] rst_order
4308 /// The order of application of translation, rotation and
4309 /// scale.
4310 ///
4311 /// @param[out] transform_array
4312 /// Array of ::HAPI_Transform at least the size of
4313 /// length.
4314 ///
4315 /// @param[in] start
4316 /// At least @c 0 and at most @c object_count returned by
4317 /// ::HAPI_ComposeObjectList().
4318 /// <!-- default 0 -->
4319 ///
4320 /// @param[in] length
4321 /// Given @c object_count returned by
4322 /// ::HAPI_ComposeObjectList(), @c length should be at least
4323 /// @c 0 and at most <tt>object_count - start</tt>.
4324 /// <!-- source ::HAPI_ComposeObjectList - start -->
4325 ///
4327  HAPI_NodeId parent_node_id,
4328  HAPI_RSTOrder rst_order,
4329  HAPI_Transform * transform_array,
4330  int start, int length );
4331 
4332 /// @brief Get the node ids for the objects being instanced by an
4333 /// Instance OBJ node.
4334 ///
4335 /// @ingroup Objects
4336 ///
4337 /// @param[in] session
4338 /// The session of Houdini you are interacting with.
4339 /// See @ref HAPI_Sessions for more on sessions.
4340 /// Pass NULL to just use the default in-process session.
4341 /// <!-- default NULL -->
4342 ///
4343 /// @param[in] object_node_id
4344 /// The object node id.
4345 ///
4346 /// @param[out] instanced_node_id_array
4347 /// Array of ::HAPI_NodeId at least the size of length.
4348 ///
4349 /// @param[in] start
4350 /// At least @c 0 and at most @c object_count returned by
4351 /// ::HAPI_ComposeObjectList().
4352 /// <!-- default 0 -->
4353 ///
4354 /// @param[in] length
4355 /// Given @c object_count returned by
4356 /// ::HAPI_ComposeObjectList(), @c length should be at least
4357 /// @c 0 and at most <tt>object_count - start</tt>.
4358 /// <!-- source ::HAPI_ComposeObjectList - start -->
4359 ///
4361  HAPI_NodeId object_node_id,
4362  HAPI_NodeId * instanced_node_id_array,
4363  int start, int length );
4364 
4365 /// @brief Fill an array of ::HAPI_Transform structs with the transforms
4366 /// of each instance of this instancer object for a given part.
4367 ///
4368 /// @ingroup Objects
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] node_id
4377 /// The object node id.
4378 ///
4379 /// @param[in] part_id
4380 /// The part id.
4381 ///
4382 /// @param[in] rst_order
4383 /// The order of application of translation, rotation and
4384 /// scale.
4385 ///
4386 /// @param[out] transforms_array
4387 /// Array of ::HAPI_Transform at least the size of length.
4388 ///
4389 /// @param[in] start
4390 /// First index of range. Must be at least 0 and at
4391 /// most ::HAPI_PartInfo::pointCount - 1. This is the 0th
4392 /// part of the display geo of the instancer object node.
4393 /// <!-- default 0 -->
4394 ///
4395 /// @param[in] length
4396 /// Must be at least 0 and at most
4397 /// ::HAPI_PartInfo::pointCount - @p start. This is the 0th
4398 /// part of the display geo of the instancer object node.
4399 /// <!-- source ::HAPI_PartInfo::pointCount - start -->
4400 ///
4402  HAPI_NodeId node_id,
4403  HAPI_PartId part_id,
4404  HAPI_RSTOrder rst_order,
4405  HAPI_Transform * transforms_array,
4406  int start, int length );
4407 
4408 /// @brief Set the transform of an individual object. Note that the object
4409 /// nodes have to either be editable or have their transform
4410 /// parameters exposed at the asset level. This won't work otherwise.
4411 ///
4412 /// @ingroup Objects
4413 ///
4414 /// @param[in] session
4415 /// The session of Houdini you are interacting with.
4416 /// See @ref HAPI_Sessions for more on sessions.
4417 /// Pass NULL to just use the default in-process session.
4418 /// <!-- default NULL -->
4419 ///
4420 /// @param[in] node_id
4421 /// The object node id.
4422 ///
4423 /// @param[in] trans
4424 /// A ::HAPI_TransformEuler that stores the transform.
4425 ///
4427  HAPI_NodeId node_id,
4428  const HAPI_TransformEuler * trans );
4429 
4430 /// @defgroup GeometryGetters Geometry Getters
4431 /// Functions for reading Geometry (SOP) data
4432 
4433 /// @brief Get the display geo (SOP) node inside an Object node. If there
4434 /// there are multiple display SOP nodes, only the first one is
4435 /// returned. If the node is a display SOP itself, even if a network,
4436 /// it will return its own geo info. If the node is a SOP but not
4437 /// a network and not the display SOP, this function will fail.
4438 ///
4439 /// The above implies that you can safely call this function on both
4440 /// OBJ and SOP asset nodes and get the same (equivalent) geometry
4441 /// display node back. SOP asset nodes will simply return themselves.
4442 ///
4443 /// @ingroup GeometryGetters
4444 ///
4445 /// @param[in] session
4446 /// The session of Houdini you are interacting with.
4447 /// See @ref HAPI_Sessions for more on sessions.
4448 /// Pass NULL to just use the default in-process session.
4449 /// <!-- default NULL -->
4450 ///
4451 /// @param[in] object_node_id
4452 /// The object node id.
4453 ///
4454 /// @param[out] geo_info
4455 /// ::HAPI_GeoInfo return value.
4456 ///
4458  HAPI_NodeId object_node_id,
4459  HAPI_GeoInfo * geo_info );
4460 
4461 /// @brief A helper method that gets the number of main geometry outputs inside
4462 /// an Object node or SOP node. If the node is an Object node, this
4463 /// method will return the cumulative number of geometry outputs for all
4464 /// geometry nodes that it contains. When searching for output geometry,
4465 /// this method will only consider subnetworks that have their display
4466 /// flag enabled.
4467 ///
4468 /// This method must be called before HAPI_GetOutputGeoInfos() is
4469 /// called.
4470 ///
4471 /// @ingroup GeometryGetters
4472 ///
4473 /// @param[in] session
4474 /// The session of Houdini you are interacting with.
4475 /// See @ref HAPI_Sessions for more on sessions.
4476 /// Pass NULL to just use the default in-process session.
4477 /// <!-- default NULL -->
4478 ///
4479 /// @param[in] node_id
4480 /// The node id of the Object or SOP node to get the geometry
4481 /// output count of.
4482 ///
4483 /// @param[out] count
4484 /// The number of geometry (SOP) outputs.
4486  HAPI_NodeId node_id,
4487  int* count);
4488 
4489 /// @brief Gets the geometry info structs (::HAPI_GeoInfo) for a node's
4490 /// main geometry outputs. This method can only be called after
4491 /// HAPI_GetOutputGeoCount() has been called with the same node id.
4492 ///
4493 /// @ingroup GeometryGetters
4494 ///
4495 /// @param[in] session
4496 /// The session of Houdini you are interacting with.
4497 /// See @ref HAPI_Sessions for more on sessions.
4498 /// Pass NULL to just use the default in-process session.
4499 /// <!-- default NULL -->
4500 ///
4501 /// @param[in] node_id
4502 /// The node id of the Object or SOP node to get the output
4503 /// geometry info structs (::HAPI_GeoInfo) for.
4504 ///
4505 /// @param[out] geo_infos_array
4506 /// Output array where the output geometry info structs will be
4507 /// stored. The size of the array must match the count argument
4508 /// returned by the HAPI_GetOutputGeoCount() method.
4509 ///
4510 /// @param[in] count
4511 /// Sanity check count. The count must be equal to the count
4512 /// returned by the HAPI_GetOutputGeoCount() method.
4514  HAPI_NodeId node_id,
4515  HAPI_GeoInfo* geo_infos_array,
4516  int count );
4517 
4518 /// @brief Get the geometry info struct (::HAPI_GeoInfo) on a SOP node.
4519 ///
4520 /// @ingroup GeometryGetters
4521 ///
4522 /// @param[in] session
4523 /// The session of Houdini you are interacting with.
4524 /// See @ref HAPI_Sessions for more on sessions.
4525 /// Pass NULL to just use the default in-process session.
4526 /// <!-- default NULL -->
4527 ///
4528 /// @param[in] node_id
4529 /// The node id.
4530 ///
4531 /// @param[out] geo_info
4532 /// ::HAPI_GeoInfo return value.
4533 ///
4534 HAPI_DECL HAPI_GetGeoInfo( const HAPI_Session * session,
4535  HAPI_NodeId node_id,
4536  HAPI_GeoInfo * geo_info );
4537 
4538 /// @brief Get a particular part info struct.
4539 ///
4540 /// @ingroup GeometryGetters
4541 ///
4542 /// @param[in] session
4543 /// The session of Houdini you are interacting with.
4544 /// See @ref HAPI_Sessions for more on sessions.
4545 /// Pass NULL to just use the default in-process session.
4546 /// <!-- default NULL -->
4547 ///
4548 /// @param[in] node_id
4549 /// The SOP node id.
4550 ///
4551 /// @param[in] part_id
4552 /// The part id.
4553 ///
4554 /// @param[out] part_info
4555 /// ::HAPI_PartInfo return value.
4556 ///
4557 HAPI_DECL HAPI_GetPartInfo( const HAPI_Session * session,
4558  HAPI_NodeId node_id,
4559  HAPI_PartId part_id,
4560  HAPI_PartInfo * part_info );
4561 
4562 
4563 /// @brief Gets the number of edges that belong to an edge group on a geometry
4564 /// part.
4565 ///
4566 /// @ingroup GeometryGetters
4567 ///
4568 /// @param[in] session
4569 /// The session of Houdini you are interacting with.
4570 /// See @ref HAPI_Sessions for more on sessions.
4571 /// Pass NULL to just use the default in-process session.
4572 /// <!-- default NULL -->
4573 ///
4574 /// @param[in] node_id
4575 /// The SOP node id.
4576 ///
4577 /// @param[in] part_id
4578 /// The part id.
4579 ///
4580 /// @param[in] group_name
4581 /// The name of the edge group.
4582 ///
4583 /// @param[out] edge_count
4584 /// The number of edges that belong to the group.
4585 ///
4587  HAPI_NodeId node_id,
4588  HAPI_PartId part_id,
4589  const char * group_name,
4590  int * edge_count );
4591 
4592 /// @brief Get the array of faces where the nth integer in the array is
4593 /// the number of vertices the nth face has.
4594 ///
4595 /// @ingroup GeometryGetters
4596 ///
4597 /// @param[in] session
4598 /// The session of Houdini you are interacting with.
4599 /// See @ref HAPI_Sessions for more on sessions.
4600 /// Pass NULL to just use the default in-process session.
4601 /// <!-- default NULL -->
4602 ///
4603 /// @param[in] node_id
4604 /// The node id.
4605 ///
4606 /// @param[in] part_id
4607 /// The part id.
4608 ///
4609 /// @param[out] face_counts_array
4610 /// An integer array at least the size of length.
4611 ///
4612 /// @param[in] start
4613 /// First index of range. Must be at least 0 and at
4614 /// most ::HAPI_PartInfo::faceCount - 1.
4615 /// <!-- default 0 -->
4616 ///
4617 /// @param[in] length
4618 /// Must be at least 0 and at most
4619 /// ::HAPI_PartInfo::faceCount - @p start.
4620 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
4621 ///
4622 HAPI_DECL HAPI_GetFaceCounts( const HAPI_Session * session,
4623  HAPI_NodeId node_id,
4624  HAPI_PartId part_id,
4625  int * face_counts_array,
4626  int start, int length );
4627 
4628 /// @brief Get array containing the vertex-point associations where the
4629 /// ith element in the array is the point index the ith vertex
4630 /// associates with.
4631 ///
4632 /// @ingroup GeometryGetters
4633 ///
4634 /// @param[in] session
4635 /// The session of Houdini you are interacting with.
4636 /// See @ref HAPI_Sessions for more on sessions.
4637 /// Pass NULL to just use the default in-process session.
4638 /// <!-- default NULL -->
4639 ///
4640 /// @param[in] node_id
4641 /// The node id.
4642 ///
4643 /// @param[in] part_id
4644 /// The part id.
4645 ///
4646 /// @param[out] vertex_list_array
4647 /// An integer array at least the size of length.
4648 ///
4649 /// @param[in] start
4650 /// First index of range. Must be at least 0 and at
4651 /// most ::HAPI_PartInfo::vertexCount - 1.
4652 /// <!-- default 0 -->
4653 ///
4654 /// @param[in] length
4655 /// Must be at least 0 and at most
4656 /// ::HAPI_PartInfo::vertexCount - @p start.
4657 /// <!-- source ::HAPI_PartInfo::vertexCount - start -->
4658 ///
4659 HAPI_DECL HAPI_GetVertexList( const HAPI_Session * session,
4660  HAPI_NodeId node_id,
4661  HAPI_PartId part_id,
4662  int * vertex_list_array,
4663  int start, int length );
4664 
4665 /// @defgroup Attributes
4666 /// Functions for working with attributes.
4667 
4668 /// @brief Get the attribute info struct for the attribute specified by name.
4669 ///
4670 /// @ingroup Attributes
4671 ///
4672 /// @param[in] session
4673 /// The session of Houdini you are interacting with.
4674 /// See @ref HAPI_Sessions for more on sessions.
4675 /// Pass NULL to just use the default in-process session.
4676 /// <!-- default NULL -->
4677 ///
4678 /// @param[in] node_id
4679 /// The node id.
4680 ///
4681 /// @param[in] part_id
4682 /// The part id.
4683 ///
4684 /// @param[in] name
4685 /// Attribute name.
4686 ///
4687 /// @param[in] owner
4688 /// Attribute owner.
4689 ///
4690 /// @param[out] attr_info
4691 /// ::HAPI_AttributeInfo to be filled. Check
4692 /// ::HAPI_AttributeInfo::exists to see if this attribute
4693 /// exists.
4694 ///
4696  HAPI_NodeId node_id,
4697  HAPI_PartId part_id,
4698  const char * name,
4699  HAPI_AttributeOwner owner,
4700  HAPI_AttributeInfo * attr_info );
4701 
4702 /// @brief Get list of attribute names by attribute owner. Note that the
4703 /// name string handles are only valid until the next time this
4704 /// function is called.
4705 ///
4706 /// @ingroup Attributes
4707 ///
4708 /// @param[in] session
4709 /// The session of Houdini you are interacting with.
4710 /// See @ref HAPI_Sessions for more on sessions.
4711 /// Pass NULL to just use the default in-process session.
4712 /// <!-- default NULL -->
4713 ///
4714 /// @param[in] node_id
4715 /// The node id.
4716 ///
4717 /// @param[in] part_id
4718 /// The part id.
4719 ///
4720 /// @param[in] owner
4721 /// The ::HAPI_AttributeOwner enum value specifying the
4722 /// owner of the attribute.
4723 ///
4724 /// @param[out] attribute_names_array
4725 /// Array of ints (string handles) to house the
4726 /// attribute names. Should be exactly the size of the
4727 /// appropriate attribute owner type count
4728 /// in ::HAPI_PartInfo.
4729 ///
4730 /// @param[in] count
4731 /// Sanity check count. Must be equal to the appropriate
4732 /// attribute owner type count in ::HAPI_PartInfo.
4733 ///
4735  HAPI_NodeId node_id,
4736  HAPI_PartId part_id,
4737  HAPI_AttributeOwner owner,
4738  HAPI_StringHandle * attribute_names_array,
4739  int count );
4740 
4741 /// @brief Get attribute integer data.
4742 ///
4743 /// @ingroup GeometryGetters Attributes
4744 ///
4745 /// @param[in] session
4746 /// The session of Houdini you are interacting with.
4747 /// See @ref HAPI_Sessions for more on sessions.
4748 /// Pass NULL to just use the default in-process session.
4749 /// <!-- default NULL -->
4750 ///
4751 /// @param[in] node_id
4752 /// The node id.
4753 ///
4754 /// @param[in] part_id
4755 /// The part id.
4756 ///
4757 /// @param[in] name
4758 /// Attribute name.
4759 ///
4760 /// @param[in] attr_info
4761 /// ::HAPI_AttributeInfo used as input for what tuple size.
4762 /// you want. Also contains some sanity checks like
4763 /// data type. Generally should be the same struct
4764 /// returned by ::HAPI_GetAttributeInfo().
4765 ///
4766 /// @param[in] stride
4767 /// Specifies how many items to skip over for each element.
4768 /// With a stride of -1, the stride will be set to
4769 /// @c attr_info->tuple_size. Otherwise, the stride will be
4770 /// set to the maximum of @c attr_info->tuple_size and
4771 /// @c stride.
4772 ///
4773 /// @param[out] data_array
4774 /// An integer array at least the size of
4775 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4776 ///
4777 /// @param[in] start
4778 /// First index of range. Must be at least 0 and at
4779 /// most ::HAPI_AttributeInfo::count - 1.
4780 /// <!-- default 0 -->
4781 ///
4782 /// @param[in] length
4783 /// Must be at least 0 and at most
4784 /// ::HAPI_AttributeInfo::count - @p start.
4785 /// Note, if 0 is passed for length, the function will just
4786 /// do nothing and return ::HAPI_RESULT_SUCCESS.
4787 /// <!-- source ::HAPI_AttributeInfo::count - start -->
4788 ///
4790  HAPI_NodeId node_id,
4791  HAPI_PartId part_id,
4792  const char * name,
4793  HAPI_AttributeInfo * attr_info,
4794  int stride,
4795  int * data_array,
4796  int start, int length );
4797 
4798 /// @brief Get array attribute integer data.
4799 /// Each entry in an array attribute can have varying array lengths.
4800 /// Therefore the array values are returned as a flat array, with
4801 /// another sizes array containing the lengths of each array entry.
4802 ///
4803 /// @ingroup GeometryGetters Attributes
4804 ///
4805 /// @param[in] session
4806 /// The session of Houdini you are interacting with.
4807 /// See @ref HAPI_Sessions for more on sessions.
4808 /// Pass NULL to just use the default in-process session.
4809 /// <!-- default NULL -->
4810 ///
4811 /// @param[in] node_id
4812 /// The node id.
4813 ///
4814 /// @param[in] part_id
4815 /// The part id.
4816 ///
4817 /// @param[in] name
4818 /// Attribute name.
4819 ///
4820 /// @param[in] attr_info
4821 /// ::HAPI_AttributeInfo used as input for what tuple size.
4822 /// you want. Also contains some sanity checks like
4823 /// data type. Generally should be the same struct
4824 /// returned by ::HAPI_GetAttributeInfo().
4825 ///
4826 /// @param[out] data_fixed_array
4827 /// An integer array at least the size of
4828 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
4829 ///
4830 /// @param[in] data_fixed_length
4831 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
4832 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
4833 ///
4834 /// @param[out] sizes_fixed_array
4835 /// An integer array at least the size of
4836 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
4837 /// <!-- source ::HAPI_AttributeInfo::count -->
4838 ///
4839 /// @param[in] start
4840 /// First index of range. Must be at least 0 and at
4841 /// most ::HAPI_AttributeInfo::count - 1.
4842 /// <!-- default 0 -->
4843 ///
4844 /// @param[in] sizes_fixed_length
4845 /// Must be at least 0 and at most
4846 /// ::HAPI_AttributeInfo::count - @p start.
4847 /// Note, if 0 is passed for length, the function will just
4848 /// do nothing and return ::HAPI_RESULT_SUCCESS.
4849 /// <!-- source ::HAPI_AttributeInfo::count - start -->
4850 ///
4852  HAPI_NodeId node_id,
4853  HAPI_PartId part_id,
4854  const char * name,
4855  HAPI_AttributeInfo * attr_info,
4856  int * data_fixed_array,
4857  int data_fixed_length,
4858  int * sizes_fixed_array,
4859  int start, int sizes_fixed_length );
4860 
4861 /// @brief Get attribute unsigned 8-bit integer data.
4862 ///
4863 /// @ingroup GeometryGetters Attributes
4864 ///
4865 /// @param[in] session
4866 /// The session of Houdini you are interacting with.
4867 /// See @ref HAPI_Sessions for more on sessions.
4868 /// Pass NULL to just use the default in-process session.
4869 /// <!-- default NULL -->
4870 ///
4871 /// @param[in] node_id
4872 /// The node id.
4873 ///
4874 /// @param[in] part_id
4875 /// The part id.
4876 ///
4877 /// @param[in] name
4878 /// Attribute name.
4879 ///
4880 /// @param[in] attr_info
4881 /// ::HAPI_AttributeInfo used as input for what tuple size.
4882 /// you want. Also contains some sanity checks like
4883 /// data type. Generally should be the same struct
4884 /// returned by ::HAPI_GetAttributeInfo().
4885 ///
4886 /// @param[in] stride
4887 /// Specifies how many items to skip over for each element.
4888 /// With a stride of -1, the stride will be set to
4889 /// @c attr_info->tuple_size. Otherwise, the stride will be
4890 /// set to the maximum of @c attr_info->tuple_size and
4891 /// @c stride.
4892 ///
4893 /// @param[out] data_array
4894 /// An unsigned 8-bit integer array at least the size of
4895 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
4896 ///
4897 /// @param[in] start
4898 /// First index of range. Must be at least 0 and at
4899 /// most ::HAPI_AttributeInfo::count - 1.
4900 /// <!-- default 0 -->
4901 ///
4902 /// @param[in] length
4903 /// Must be at least 0 and at most
4904 /// ::HAPI_AttributeInfo::count - @p start.
4905 /// Note, if 0 is passed for length, the function will just
4906 /// do nothing and return ::HAPI_RESULT_SUCCESS.
4907 /// <!-- source ::HAPI_AttributeInfo::count - start -->
4908 ///
4910  HAPI_NodeId node_id,
4911  HAPI_PartId part_id,
4912  const char * name,
4913  HAPI_AttributeInfo * attr_info,
4914  int stride,
4915  HAPI_UInt8 * data_array,
4916  int start, int length );
4917 
4918 /// @brief Get array attribute unsigned 8-bit integer data.
4919 /// Each entry in an array attribute can have varying array lengths.
4920 /// Therefore the array values are returned as a flat array, with
4921 /// another sizes array containing the lengths of each array entry.
4922 ///
4923 /// @ingroup GeometryGetters Attributes
4924 ///
4925 /// @param[in] session
4926 /// The session of Houdini you are interacting with.
4927 /// See @ref HAPI_Sessions for more on sessions.
4928 /// Pass NULL to just use the default in-process session.
4929 /// <!-- default NULL -->
4930 ///
4931 /// @param[in] node_id
4932 /// The node id.
4933 ///
4934 /// @param[in] part_id
4935 /// The part id.
4936 ///
4937 /// @param[in] name
4938 /// Attribute name.
4939 ///
4940 /// @param[in] attr_info
4941 /// ::HAPI_AttributeInfo used as input for what tuple size.
4942 /// you want. Also contains some sanity checks like
4943 /// data type. Generally should be the same struct
4944 /// returned by ::HAPI_GetAttributeInfo().
4945 ///
4946 /// @param[out] data_fixed_array
4947 /// An unsigned 8-bit integer array at least the size of
4948 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
4949 ///
4950 /// @param[in] data_fixed_length
4951 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
4952 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
4953 ///
4954 /// @param[out] sizes_fixed_array
4955 /// An integer array at least the size of
4956 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
4957 ///
4958 /// @param[in] start
4959 /// First index of range. Must be at least 0 and at
4960 /// most ::HAPI_AttributeInfo::count - 1.
4961 /// <!-- default 0 -->
4962 ///
4963 /// @param[in] sizes_fixed_length
4964 /// Must be at least 0 and at most
4965 /// ::HAPI_AttributeInfo::count - @p start.
4966 /// Note, if 0 is passed for length, the function will just
4967 /// do nothing and return ::HAPI_RESULT_SUCCESS.
4968 /// <!-- source ::HAPI_AttributeInfo::count - start -->
4969 ///
4971  HAPI_NodeId node_id,
4972  HAPI_PartId part_id,
4973  const char * name,
4974  HAPI_AttributeInfo * attr_info,
4975  HAPI_UInt8 * data_fixed_array,
4976  int data_fixed_length,
4977  int * sizes_fixed_array,
4978  int start, int sizes_fixed_length );
4979 
4980 /// @brief Get attribute 8-bit integer data.
4981 ///
4982 /// @ingroup GeometryGetters Attributes
4983 ///
4984 /// @param[in] session
4985 /// The session of Houdini you are interacting with.
4986 /// See @ref HAPI_Sessions for more on sessions.
4987 /// Pass NULL to just use the default in-process session.
4988 /// <!-- default NULL -->
4989 ///
4990 /// @param[in] node_id
4991 /// The node id.
4992 ///
4993 /// @param[in] part_id
4994 /// The part id.
4995 ///
4996 /// @param[in] name
4997 /// Attribute name.
4998 ///
4999 /// @param[in] attr_info
5000 /// ::HAPI_AttributeInfo used as input for what tuple size.
5001 /// you want. Also contains some sanity checks like
5002 /// data type. Generally should be the same struct
5003 /// returned by ::HAPI_GetAttributeInfo().
5004 ///
5005 /// @param[in] stride
5006 /// Specifies how many items to skip over for each element.
5007 /// With a stride of -1, the stride will be set to
5008 /// @c attr_info->tuple_size. Otherwise, the stride will be
5009 /// set to the maximum of @c attr_info->tuple_size and
5010 /// @c stride.
5011 ///
5012 /// @param[out] data_array
5013 /// An 8-bit integer array at least the size of
5014 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5015 ///
5016 /// @param[in] start
5017 /// First index of range. Must be at least 0 and at
5018 /// most ::HAPI_AttributeInfo::count - 1.
5019 /// <!-- default 0 -->
5020 ///
5021 /// @param[in] length
5022 /// Must be at least 0 and at most
5023 /// ::HAPI_AttributeInfo::count - @p start.
5024 /// Note, if 0 is passed for length, the function will just
5025 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5026 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5027 ///
5029  HAPI_NodeId node_id,
5030  HAPI_PartId part_id,
5031  const char * name,
5032  HAPI_AttributeInfo * attr_info,
5033  int stride,
5034  HAPI_Int8 * data_array,
5035  int start, int length );
5036 
5037 /// @brief Get array attribute 8-bit integer data.
5038 /// Each entry in an array attribute can have varying array lengths.
5039 /// Therefore the array values are returned as a flat array, with
5040 /// another sizes array containing the lengths of each array entry.
5041 ///
5042 /// @ingroup GeometryGetters Attributes
5043 ///
5044 /// @param[in] session
5045 /// The session of Houdini you are interacting with.
5046 /// See @ref HAPI_Sessions for more on sessions.
5047 /// Pass NULL to just use the default in-process session.
5048 /// <!-- default NULL -->
5049 ///
5050 /// @param[in] node_id
5051 /// The node id.
5052 ///
5053 /// @param[in] part_id
5054 /// The part id.
5055 ///
5056 /// @param[in] name
5057 /// Attribute name.
5058 ///
5059 /// @param[in] attr_info
5060 /// ::HAPI_AttributeInfo used as input for what tuple size.
5061 /// you want. Also contains some sanity checks like
5062 /// data type. Generally should be the same struct
5063 /// returned by ::HAPI_GetAttributeInfo().
5064 ///
5065 /// @param[out] data_fixed_array
5066 /// An 8-bit integer array at least the size of
5067 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5068 ///
5069 /// @param[in] data_fixed_length
5070 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5071 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5072 ///
5073 /// @param[out] sizes_fixed_array
5074 /// An integer array at least the size of
5075 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5076 ///
5077 /// @param[in] start
5078 /// First index of range. Must be at least 0 and at
5079 /// most ::HAPI_AttributeInfo::count - 1.
5080 /// <!-- default 0 -->
5081 ///
5082 /// @param[in] sizes_fixed_length
5083 /// Must be at least 0 and at most
5084 /// ::HAPI_AttributeInfo::count - @p start.
5085 /// Note, if 0 is passed for length, the function will just
5086 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5087 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5088 ///
5090  HAPI_NodeId node_id,
5091  HAPI_PartId part_id,
5092  const char * name,
5093  HAPI_AttributeInfo * attr_info,
5094  HAPI_Int8 * data_fixed_array,
5095  int data_fixed_length,
5096  int * sizes_fixed_array,
5097  int start, int sizes_fixed_length );
5098 
5099 /// @brief Get attribute 16-bit integer data.
5100 ///
5101 /// @ingroup GeometryGetters Attributes
5102 ///
5103 /// @param[in] session
5104 /// The session of Houdini you are interacting with.
5105 /// See @ref HAPI_Sessions for more on sessions.
5106 /// Pass NULL to just use the default in-process session.
5107 /// <!-- default NULL -->
5108 ///
5109 /// @param[in] node_id
5110 /// The node id.
5111 ///
5112 /// @param[in] part_id
5113 /// The part id.
5114 ///
5115 /// @param[in] name
5116 /// Attribute name.
5117 ///
5118 /// @param[in] attr_info
5119 /// ::HAPI_AttributeInfo used as input for what tuple size.
5120 /// you want. Also contains some sanity checks like
5121 /// data type. Generally should be the same struct
5122 /// returned by ::HAPI_GetAttributeInfo().
5123 ///
5124 /// @param[in] stride
5125 /// Specifies how many items to skip over for each element.
5126 /// With a stride of -1, the stride will be set to
5127 /// @c attr_info->tuple_size. Otherwise, the stride will be
5128 /// set to the maximum of @c attr_info->tuple_size and
5129 /// @c stride.
5130 ///
5131 /// @param[out] data_array
5132 /// An 16-bit integer array at least the size of
5133 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5134 ///
5135 /// @param[in] start
5136 /// First index of range. Must be at least 0 and at
5137 /// most ::HAPI_AttributeInfo::count - 1.
5138 /// <!-- default 0 -->
5139 ///
5140 /// @param[in] length
5141 /// Must be at least 0 and at most
5142 /// ::HAPI_AttributeInfo::count - @p start.
5143 /// Note, if 0 is passed for length, the function will just
5144 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5145 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5146 ///
5148  HAPI_NodeId node_id,
5149  HAPI_PartId part_id,
5150  const char * name,
5151  HAPI_AttributeInfo * attr_info,
5152  int stride,
5153  HAPI_Int16 * data_array,
5154  int start, int length );
5155 
5156 /// @brief Get array attribute 16-bit integer data.
5157 /// Each entry in an array attribute can have varying array lengths.
5158 /// Therefore the array values are returned as a flat array, with
5159 /// another sizes array containing the lengths of each array entry.
5160 ///
5161 /// @ingroup GeometryGetters Attributes
5162 ///
5163 /// @param[in] session
5164 /// The session of Houdini you are interacting with.
5165 /// See @ref HAPI_Sessions for more on sessions.
5166 /// Pass NULL to just use the default in-process session.
5167 /// <!-- default NULL -->
5168 ///
5169 /// @param[in] node_id
5170 /// The node id.
5171 ///
5172 /// @param[in] part_id
5173 /// The part id.
5174 ///
5175 /// @param[in] name
5176 /// Attribute name.
5177 ///
5178 /// @param[in] attr_info
5179 /// ::HAPI_AttributeInfo used as input for what tuple size.
5180 /// you want. Also contains some sanity checks like
5181 /// data type. Generally should be the same struct
5182 /// returned by ::HAPI_GetAttributeInfo().
5183 ///
5184 /// @param[out] data_fixed_array
5185 /// An 16-bit integer array at least the size of
5186 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5187 ///
5188 /// @param[in] data_fixed_length
5189 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5190 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5191 ///
5192 /// @param[out] sizes_fixed_array
5193 /// An integer array at least the size of
5194 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5195 ///
5196 /// @param[in] start
5197 /// First index of range. Must be at least 0 and at
5198 /// most ::HAPI_AttributeInfo::count - 1.
5199 /// <!-- default 0 -->
5200 ///
5201 /// @param[in] sizes_fixed_length
5202 /// Must be at least 0 and at most
5203 /// ::HAPI_AttributeInfo::count - @p start.
5204 /// Note, if 0 is passed for length, the function will just
5205 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5206 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5207 ///
5209  HAPI_NodeId node_id,
5210  HAPI_PartId part_id,
5211  const char * name,
5212  HAPI_AttributeInfo * attr_info,
5213  HAPI_Int16 * data_fixed_array,
5214  int data_fixed_length,
5215  int * sizes_fixed_array,
5216  int start, int sizes_fixed_length );
5217 
5218 /// @brief Get attribute 64-bit integer data.
5219 ///
5220 /// @ingroup GeometryGetters Attributes
5221 ///
5222 /// @param[in] session
5223 /// The session of Houdini you are interacting with.
5224 /// See @ref HAPI_Sessions for more on sessions.
5225 /// Pass NULL to just use the default in-process session.
5226 /// <!-- default NULL -->
5227 ///
5228 /// @param[in] node_id
5229 /// The node id.
5230 ///
5231 /// @param[in] part_id
5232 /// The part id.
5233 ///
5234 /// @param[in] name
5235 /// Attribute name.
5236 ///
5237 /// @param[in] attr_info
5238 /// ::HAPI_AttributeInfo used as input for what tuple size.
5239 /// you want. Also contains some sanity checks like
5240 /// data type. Generally should be the same struct
5241 /// returned by ::HAPI_GetAttributeInfo().
5242 ///
5243 /// @param[in] stride
5244 /// Specifies how many items to skip over for each element.
5245 /// With a stride of -1, the stride will be set to
5246 /// @c attr_info->tuple_size. Otherwise, the stride will be
5247 /// set to the maximum of @c attr_info->tuple_size and
5248 /// @c stride.
5249 ///
5250 /// @param[out] data_array
5251 /// An 64-bit integer array at least the size of
5252 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5253 ///
5254 /// @param[in] start
5255 /// First index of range. Must be at least 0 and at
5256 /// most ::HAPI_AttributeInfo::count - 1.
5257 /// <!-- default 0 -->
5258 ///
5259 /// @param[in] length
5260 /// Must be at least 0 and at most
5261 /// ::HAPI_AttributeInfo::count - @p start.
5262 /// Note, if 0 is passed for length, the function will just
5263 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5264 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5265 ///
5267  HAPI_NodeId node_id,
5268  HAPI_PartId part_id,
5269  const char * name,
5270  HAPI_AttributeInfo * attr_info,
5271  int stride,
5272  HAPI_Int64 * data_array,
5273  int start, int length );
5274 
5275 /// @brief Get array attribute 64-bit integer data.
5276 /// Each entry in an array attribute can have varying array lengths.
5277 /// Therefore the array values are returned as a flat array, with
5278 /// another sizes array containing the lengths of each array entry.
5279 ///
5280 /// @ingroup GeometryGetters Attributes
5281 ///
5282 /// @param[in] session
5283 /// The session of Houdini you are interacting with.
5284 /// See @ref HAPI_Sessions for more on sessions.
5285 /// Pass NULL to just use the default in-process session.
5286 /// <!-- default NULL -->
5287 ///
5288 /// @param[in] node_id
5289 /// The node id.
5290 ///
5291 /// @param[in] part_id
5292 /// The part id.
5293 ///
5294 /// @param[in] name
5295 /// Attribute name.
5296 ///
5297 /// @param[in] attr_info
5298 /// ::HAPI_AttributeInfo used as input for what tuple size.
5299 /// you want. Also contains some sanity checks like
5300 /// data type. Generally should be the same struct
5301 /// returned by ::HAPI_GetAttributeInfo().
5302 ///
5303 /// @param[out] data_fixed_array
5304 /// An 64-bit integer array at least the size of
5305 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5306 ///
5307 /// @param[in] data_fixed_length
5308 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5309 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5310 ///
5311 /// @param[out] sizes_fixed_array
5312 /// An integer array at least the size of
5313 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5314 ///
5315 /// @param[in] start
5316 /// First index of range. Must be at least 0 and at
5317 /// most ::HAPI_AttributeInfo::count - 1.
5318 /// <!-- default 0 -->
5319 ///
5320 /// @param[in] sizes_fixed_length
5321 /// Must be at least 0 and at most
5322 /// ::HAPI_AttributeInfo::count - @p start.
5323 /// Note, if 0 is passed for length, the function will just
5324 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5325 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5326 ///
5328  HAPI_NodeId node_id,
5329  HAPI_PartId part_id,
5330  const char * name,
5331  HAPI_AttributeInfo * attr_info,
5332  HAPI_Int64 * data_fixed_array,
5333  int data_fixed_length,
5334  int * sizes_fixed_array,
5335  int start, int sizes_fixed_length );
5336 
5337 /// @brief Get attribute float data.
5338 ///
5339 /// @ingroup GeometryGetters Attributes
5340 ///
5341 /// @param[in] session
5342 /// The session of Houdini you are interacting with.
5343 /// See @ref HAPI_Sessions for more on sessions.
5344 /// Pass NULL to just use the default in-process session.
5345 /// <!-- default NULL -->
5346 ///
5347 /// @param[in] node_id
5348 /// The node id.
5349 ///
5350 /// @param[in] part_id
5351 /// The part id.
5352 ///
5353 /// @param[in] name
5354 /// Attribute name.
5355 ///
5356 /// @param[in] attr_info
5357 /// ::HAPI_AttributeInfo used as input for what tuple size.
5358 /// you want. Also contains some sanity checks like
5359 /// data type. Generally should be the same struct
5360 /// returned by ::HAPI_GetAttributeInfo().
5361 ///
5362 /// @param[in] stride
5363 /// Specifies how many items to skip over for each element.
5364 /// With a stride of -1, the stride will be set to
5365 /// @c attr_info->tuple_size. Otherwise, the stride will be
5366 /// set to the maximum of @c attr_info->tuple_size and
5367 /// @c stride.
5368 ///
5369 /// @param[out] data_array
5370 /// An float array at least the size of
5371 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5372 ///
5373 /// @param[in] start
5374 /// First index of range. Must be at least 0 and at
5375 /// most ::HAPI_AttributeInfo::count - 1.
5376 /// <!-- default 0 -->
5377 ///
5378 /// @param[in] length
5379 /// Must be at least 0 and at most
5380 /// ::HAPI_AttributeInfo::count - @p start.
5381 /// Note, if 0 is passed for length, the function will just
5382 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5383 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5384 ///
5386  HAPI_NodeId node_id,
5387  HAPI_PartId part_id,
5388  const char * name,
5389  HAPI_AttributeInfo * attr_info,
5390  int stride,
5391  float * data_array,
5392  int start, int length );
5393 
5394 /// @brief Get array attribute float data.
5395 /// Each entry in an array attribute can have varying array lengths.
5396 /// Therefore the array values are returned as a flat array, with
5397 /// another sizes array containing the lengths of each array entry.
5398 ///
5399 /// @ingroup GeometryGetters Attributes
5400 ///
5401 /// @param[in] session
5402 /// The session of Houdini you are interacting with.
5403 /// See @ref HAPI_Sessions for more on sessions.
5404 /// Pass NULL to just use the default in-process session.
5405 /// <!-- default NULL -->
5406 ///
5407 /// @param[in] node_id
5408 /// The node id.
5409 ///
5410 /// @param[in] part_id
5411 /// The part id.
5412 ///
5413 /// @param[in] name
5414 /// Attribute name.
5415 ///
5416 /// @param[in] attr_info
5417 /// ::HAPI_AttributeInfo used as input for what tuple size.
5418 /// you want. Also contains some sanity checks like
5419 /// data type. Generally should be the same struct
5420 /// returned by ::HAPI_GetAttributeInfo().
5421 ///
5422 /// @param[out] data_fixed_array
5423 /// An float array at least the size of
5424 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5425 ///
5426 /// @param[in] data_fixed_length
5427 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5428 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5429 ///
5430 /// @param[out] sizes_fixed_array
5431 /// An integer array at least the size of
5432 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5433 ///
5434 /// @param[in] start
5435 /// First index of range. Must be at least 0 and at
5436 /// most ::HAPI_AttributeInfo::count - 1.
5437 /// <!-- default 0 -->
5438 ///
5439 /// @param[in] sizes_fixed_length
5440 /// Must be at least 0 and at most
5441 /// ::HAPI_AttributeInfo::count - @p start.
5442 /// Note, if 0 is passed for length, the function will just
5443 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5444 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5445 ///
5447  HAPI_NodeId node_id,
5448  HAPI_PartId part_id,
5449  const char * name,
5450  HAPI_AttributeInfo * attr_info,
5451  float * data_fixed_array,
5452  int data_fixed_length,
5453  int * sizes_fixed_array,
5454  int start, int sizes_fixed_length );
5455 
5456 /// @brief Get 64-bit attribute float data.
5457 ///
5458 /// @ingroup GeometryGetters Attributes
5459 ///
5460 /// @param[in] session
5461 /// The session of Houdini you are interacting with.
5462 /// See @ref HAPI_Sessions for more on sessions.
5463 /// Pass NULL to just use the default in-process session.
5464 /// <!-- default NULL -->
5465 ///
5466 /// @param[in] node_id
5467 /// The node id.
5468 ///
5469 /// @param[in] part_id
5470 /// The part id.
5471 ///
5472 /// @param[in] name
5473 /// Attribute name.
5474 ///
5475 /// @param[in] attr_info
5476 /// ::HAPI_AttributeInfo used as input for what tuple size.
5477 /// you want. Also contains some sanity checks like
5478 /// data type. Generally should be the same struct
5479 /// returned by ::HAPI_GetAttributeInfo().
5480 ///
5481 /// @param[in] stride
5482 /// Specifies how many items to skip over for each element.
5483 /// With a stride of -1, the stride will be set to
5484 /// @c attr_info->tuple_size. Otherwise, the stride will be
5485 /// set to the maximum of @c attr_info->tuple_size and
5486 /// @c stride.
5487 ///
5488 /// @param[out] data_array
5489 /// An 64-bit float array at least the size of
5490 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5491 ///
5492 /// @param[in] start
5493 /// First index of range. Must be at least 0 and at
5494 /// most ::HAPI_AttributeInfo::count - 1.
5495 /// <!-- default 0 -->
5496 ///
5497 /// @param[in] length
5498 /// Must be at least 0 and at most
5499 /// ::HAPI_AttributeInfo::count - @p start.
5500 /// Note, if 0 is passed for length, the function will just
5501 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5502 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5503 ///
5505  HAPI_NodeId node_id,
5506  HAPI_PartId part_id,
5507  const char * name,
5508  HAPI_AttributeInfo * attr_info,
5509  int stride,
5510  double * data_array,
5511  int start, int length );
5512 
5513 /// @brief Get array attribute 64-bit float data.
5514 /// Each entry in an array attribute can have varying array lengths.
5515 /// Therefore the array values are returned as a flat array, with
5516 /// another sizes array containing the lengths of each array entry.
5517 ///
5518 /// @ingroup GeometryGetters Attributes
5519 ///
5520 /// @param[in] session
5521 /// The session of Houdini you are interacting with.
5522 /// See @ref HAPI_Sessions for more on sessions.
5523 /// Pass NULL to just use the default in-process session.
5524 /// <!-- default NULL -->
5525 ///
5526 /// @param[in] node_id
5527 /// The node id.
5528 ///
5529 /// @param[in] part_id
5530 /// The part id.
5531 ///
5532 /// @param[in] name
5533 /// Attribute name.
5534 ///
5535 /// @param[in] attr_info
5536 /// ::HAPI_AttributeInfo used as input for the.
5537 /// totalArrayElements. Also contains some sanity checks like
5538 /// data type. Generally should be the same struct
5539 /// returned by ::HAPI_GetAttributeInfo().
5540 ///
5541 /// @param[out] data_fixed_array
5542 /// An 64-bit float array at least the size of
5543 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5544 ///
5545 /// @param[in] data_fixed_length
5546 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5547 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5548 ///
5549 /// @param[out] sizes_fixed_array
5550 /// An integer array at least the size of
5551 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5552 ///
5553 /// @param[in] start
5554 /// First index of range. Must be at least 0 and at
5555 /// most ::HAPI_AttributeInfo::count - 1.
5556 /// <!-- default 0 -->
5557 ///
5558 /// @param[in] sizes_fixed_length
5559 /// Must be at least 0 and at most
5560 /// ::HAPI_AttributeInfo::count - @p start.
5561 /// Note, if 0 is passed for length, the function will just
5562 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5563 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5564 ///
5566  HAPI_NodeId node_id,
5567  HAPI_PartId part_id,
5568  const char * name,
5569  HAPI_AttributeInfo * attr_info,
5570  double * data_fixed_array,
5571  int data_fixed_length,
5572  int * sizes_fixed_array,
5573  int start, int sizes_fixed_length );
5574 
5575 /// @brief Get attribute string data. Note that the string handles
5576 /// returned are only valid until the next time this function
5577 /// is called.
5578 ///
5579 /// @ingroup GeometryGetters Attributes
5580 ///
5581 /// @param[in] session
5582 /// The session of Houdini you are interacting with.
5583 /// See @ref HAPI_Sessions for more on sessions.
5584 /// Pass NULL to just use the default in-process session.
5585 /// <!-- default NULL -->
5586 ///
5587 /// @param[in] node_id
5588 /// The node id.
5589 ///
5590 /// @param[in] part_id
5591 /// The part id.
5592 ///
5593 /// @param[in] name
5594 /// Attribute name.
5595 ///
5596 /// @param[in] attr_info
5597 /// ::HAPI_AttributeInfo used as input for what tuple size.
5598 /// you want. Also contains some sanity checks like
5599 /// data type. Generally should be the same struct
5600 /// returned by ::HAPI_GetAttributeInfo().
5601 ///
5602 /// @param[out] data_array
5603 /// An ::HAPI_StringHandle array at least the size of
5604 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5605 ///
5606 /// @param[in] start
5607 /// First index of range. Must be at least 0 and at
5608 /// most ::HAPI_AttributeInfo::count - 1.
5609 /// <!-- default 0 -->
5610 ///
5611 /// @param[in] length
5612 /// Must be at least 0 and at most
5613 /// ::HAPI_AttributeInfo::count - @p start.
5614 /// Note, if 0 is passed for length, the function will just
5615 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5616 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5617 ///
5619  HAPI_NodeId node_id,
5620  HAPI_PartId part_id,
5621  const char * name,
5622  HAPI_AttributeInfo * attr_info,
5623  HAPI_StringHandle * data_array,
5624  int start, int length );
5625 
5626 /// @brief Get array attribute string data.
5627 /// Each entry in an array attribute can have varying array lengths.
5628 /// Therefore the array values are returned as a flat array, with
5629 /// another sizes array containing the lengths of each array entry.
5630 /// Note that the string handles returned are only valid until
5631 /// the next time this function is called.
5632 ///
5633 /// @ingroup GeometryGetters Attributes
5634 ///
5635 /// @param[in] session
5636 /// The session of Houdini you are interacting with.
5637 /// See @ref HAPI_Sessions for more on sessions.
5638 /// Pass NULL to just use the default in-process session.
5639 /// <!-- default NULL -->
5640 ///
5641 /// @param[in] node_id
5642 /// The node id.
5643 ///
5644 /// @param[in] part_id
5645 /// The part id.
5646 ///
5647 /// @param[in] name
5648 /// Attribute name.
5649 ///
5650 /// @param[in] attr_info
5651 /// ::HAPI_AttributeInfo used as input for the.
5652 /// totalArrayElements. Also contains some sanity checks like
5653 /// data type. Generally should be the same struct
5654 /// returned by ::HAPI_GetAttributeInfo().
5655 ///
5656 /// @param[out] data_fixed_array
5657 /// An ::HAPI_StringHandle array at least the size of
5658 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5659 ///
5660 /// @param[in] data_fixed_length
5661 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5662 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5663 ///
5664 /// @param[out] sizes_fixed_array
5665 /// An integer array at least the size of
5666 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5667 ///
5668 /// @param[in] start
5669 /// First index of range. Must be at least 0 and at
5670 /// most ::HAPI_AttributeInfo::count - 1.
5671 /// <!-- default 0 -->
5672 ///
5673 /// @param[in] sizes_fixed_length
5674 /// Must be at least 0 and at most
5675 /// ::HAPI_AttributeInfo::count - @p start.
5676 /// Note, if 0 is passed for length, the function will just
5677 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5678 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5679 ///
5681  HAPI_NodeId node_id,
5682  HAPI_PartId part_id,
5683  const char * name,
5684  HAPI_AttributeInfo * attr_info,
5685  HAPI_StringHandle * data_fixed_array,
5686  int data_fixed_length,
5687  int * sizes_fixed_array,
5688  int start, int sizes_fixed_length );
5689 
5690 /// @brief Get attribute dictionary data.
5691 ///
5692 /// Dictionary data is serialized as JSON-encoded strings.
5693 /// Note that the string handles returned are only valid until the next
5694 /// time this function is called.
5695 ///
5696 /// @ingroup GeometryGetters Attributes
5697 ///
5698 /// @param[in] session
5699 /// The session of Houdini you are interacting with.
5700 /// See @ref HAPI_Sessions for more on sessions.
5701 /// Pass NULL to just use the default in-process session.
5702 /// <!-- default NULL -->
5703 ///
5704 /// @param[in] node_id
5705 /// The node id.
5706 ///
5707 /// @param[in] part_id
5708 /// The part id.
5709 ///
5710 /// @param[in] name
5711 /// Attribute name.
5712 ///
5713 /// @param[in] attr_info
5714 /// ::HAPI_AttributeInfo used as input for what tuple size.
5715 /// you want. Also contains some sanity checks like
5716 /// data type. Generally should be the same struct
5717 /// returned by ::HAPI_GetAttributeInfo().
5718 ///
5719 /// @param[out] data_array
5720 /// An ::HAPI_StringHandle array at least the size of
5721 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
5722 ///
5723 /// @param[in] start
5724 /// First index of range. Must be at least 0 and at
5725 /// most ::HAPI_AttributeInfo::count - 1.
5726 /// <!-- default 0 -->
5727 ///
5728 /// @param[in] length
5729 /// Must be at least 0 and at most
5730 /// ::HAPI_AttributeInfo::count - @p start.
5731 /// Note, if 0 is passed for length, the function will just
5732 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5733 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5734 ///
5736  HAPI_NodeId node_id,
5737  HAPI_PartId part_id,
5738  const char* name,
5739  HAPI_AttributeInfo* attr_info,
5740  HAPI_StringHandle* data_array,
5741  int start,
5742  int length );
5743 
5744 /// @brief Get array attribute dictionary data.
5745 /// Each entry in an array attribute can have varying array lengths.
5746 /// Therefore the array values are returned as a flat array, with
5747 /// another sizes array containing the lengths of each array entry.
5748 ///
5749 /// Dictionary data is serialized as JSON-encoded strings.
5750 /// Note that the string handles returned are only valid until
5751 /// the next time this function is called.
5752 ///
5753 /// @ingroup GeometryGetters Attributes
5754 ///
5755 /// @param[in] session
5756 /// The session of Houdini you are interacting with.
5757 /// See @ref HAPI_Sessions for more on sessions.
5758 /// Pass NULL to just use the default in-process session.
5759 /// <!-- default NULL -->
5760 ///
5761 /// @param[in] node_id
5762 /// The node id.
5763 ///
5764 /// @param[in] part_id
5765 /// The part id.
5766 ///
5767 /// @param[in] name
5768 /// Attribute name.
5769 ///
5770 /// @param[in] attr_info
5771 /// ::HAPI_AttributeInfo used as input for the.
5772 /// totalArrayElements. Also contains some sanity checks like
5773 /// data type. Generally should be the same struct
5774 /// returned by ::HAPI_GetAttributeInfo().
5775 ///
5776 /// @param[out] data_fixed_array
5777 /// An ::HAPI_StringHandle array at least the size of
5778 /// <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5779 ///
5780 /// @param[in] data_fixed_length
5781 /// Must be <tt>::HAPI_AttributeInfo::totalArrayElements</tt>.
5782 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
5783 ///
5784 /// @param[out] sizes_fixed_array
5785 /// An integer array at least the size of
5786 /// <tt>sizes_fixed_length</tt> to hold the size of each entry.
5787 ///
5788 /// @param[in] start
5789 /// First index of range. Must be at least 0 and at
5790 /// most ::HAPI_AttributeInfo::count - 1.
5791 /// <!-- default 0 -->
5792 ///
5793 /// @param[in] sizes_fixed_length
5794 /// Must be at least 0 and at most
5795 /// ::HAPI_AttributeInfo::count - @p start.
5796 /// Note, if 0 is passed for length, the function will just
5797 /// do nothing and return ::HAPI_RESULT_SUCCESS.
5798 /// <!-- source ::HAPI_AttributeInfo::count - start -->
5799 ///
5801  HAPI_NodeId node_id,
5802  HAPI_PartId part_id,
5803  const char* name,
5804  HAPI_AttributeInfo* attr_info,
5805  HAPI_StringHandle* data_fixed_array,
5806  int data_fixed_length,
5807  int* sizes_fixed_array,
5808  int start,
5809  int sizes_fixed_length );
5810 
5811 /// @brief Get group names for an entire geo. Please note that this
5812 /// function is NOT per-part, but it is per-geo. The companion
5813 /// function ::HAPI_GetGroupMembership() IS per-part. Also keep
5814 /// in mind that the name string handles are only
5815 /// valid until the next time this function is called.
5816 ///
5817 /// @ingroup GeometryGetters
5818 ///
5819 /// @param[in] session
5820 /// The session of Houdini you are interacting with.
5821 /// See @ref HAPI_Sessions for more on sessions.
5822 /// Pass NULL to just use the default in-process session.
5823 /// <!-- default NULL -->
5824 ///
5825 /// @param[in] node_id
5826 /// The node id.
5827 ///
5828 /// @param[in] group_type
5829 /// The group type.
5830 ///
5831 /// @param[out] group_names_array
5832 /// The array of names to be filled. Should be the size
5833 /// given by ::HAPI_GeoInfo_GetGroupCountByType() with
5834 /// @p group_type and the ::HAPI_GeoInfo of @p geo_id.
5835 /// @note These string handles are only valid until the
5836 /// next call to ::HAPI_GetGroupNames().
5837 ///
5838 /// @param[in] group_count
5839 /// Sanity check. Should be less than or equal to the size
5840 /// of @p group_names.
5841 ///
5842 HAPI_DECL HAPI_GetGroupNames( const HAPI_Session * session,
5843  HAPI_NodeId node_id,
5844  HAPI_GroupType group_type,
5845  HAPI_StringHandle * group_names_array,
5846  int group_count );
5847 
5848 /// @brief Get group membership.
5849 ///
5850 /// @ingroup GeometryGetters
5851 ///
5852 /// @param[in] session
5853 /// The session of Houdini you are interacting with.
5854 /// See @ref HAPI_Sessions for more on sessions.
5855 /// Pass NULL to just use the default in-process session.
5856 /// <!-- default NULL -->
5857 ///
5858 /// @param[in] node_id
5859 /// The node id.
5860 ///
5861 /// @param[in] part_id
5862 /// The part id.
5863 ///
5864 /// @param[in] group_type
5865 /// The group type.
5866 ///
5867 /// @param[in] group_name
5868 /// The group name.
5869 ///
5870 /// @param[out] membership_array_all_equal
5871 /// (optional) Quick way to determine if all items are in
5872 /// the given group or all items our not in the group.
5873 /// If you do not need this information or you are getting edge
5874 /// group information, you can just pass NULL for this argument.
5875 ///
5876 /// @param[out] membership_array
5877 /// Array of ints that represent the membership of this
5878 /// group. When getting membership information for a point or
5879 /// primitive group, the size of the array should be the size
5880 /// given by ::HAPI_PartInfo_GetElementCountByGroupType() with
5881 /// @p group_type and the ::HAPI_PartInfo of @p part_id. When
5882 /// retrieving the edges belonging to an edge group, the
5883 /// membership array will be filled with point numbers that
5884 /// comprise the edges of the edge group. Each edge is specified
5885 /// by two points, which means that the size of the array should
5886 /// be the size given by ::HAPI_GetEdgeCountOfEdgeGroup() * 2.
5887 ///
5888 /// @param[in] start
5889 /// Start offset into the membership array. Must be
5890 /// less than ::HAPI_PartInfo_GetElementCountByGroupType() when
5891 /// it is a point or primitive group. When getting the
5892 /// membership information for an edge group, this argument must
5893 /// be less than the size returned by
5894 /// ::HAPI_GetEdgeCountOfEdgeGroup() * 2 - 1.
5895 /// <!-- default 0 -->
5896 ///
5897 /// @param[in] length
5898 /// Should be less than or equal to the size
5899 /// of @p membership_array.
5900 ///
5902  HAPI_NodeId node_id,
5903  HAPI_PartId part_id,
5904  HAPI_GroupType group_type,
5905  const char * group_name,
5906  HAPI_Bool * membership_array_all_equal,
5907  int * membership_array,
5908  int start, int length );
5909 
5910 /// @brief Get group counts for a specific packed instanced part.
5911 ///
5912 /// @ingroup GeometryGetters
5913 ///
5914 /// @param[in] session
5915 /// The session of Houdini you are interacting with.
5916 /// See @ref HAPI_Sessions for more on sessions.
5917 /// Pass NULL to just use the default in-process session.
5918 /// <!-- default NULL -->
5919 ///
5920 /// @param[in] node_id
5921 /// The node id.
5922 ///
5923 /// @param[in] part_id
5924 /// The part id. (should be a packed primitive)
5925 ///
5926 /// @param[out] pointGroupCount
5927 /// Number of point groups on the packed instance part.
5928 /// Will be set to -1 if the part is not a valid packed part.
5929 ///
5930 /// @param[out] primitiveGroupCount
5931 /// Number of primitive groups on the instanced part.
5932 /// Will be set to -1 if the part is not a valid instancer
5933 ///
5935  HAPI_NodeId node_id,
5936  HAPI_PartId part_id,
5937  int * pointGroupCount,
5938  int * primitiveGroupCount );
5939 
5940 /// @brief Get the group names for a packed instance part
5941 /// This functions allows you to get the group name for a specific
5942 /// packed primitive part.
5943 /// Keep in mind that the name string handles are only
5944 /// valid until the next time this function is called.
5945 ///
5946 /// @ingroup GeometryGetters
5947 ///
5948 /// @param[in] session
5949 /// The session of Houdini you are interacting with.
5950 /// See @ref HAPI_Sessions for more on sessions.
5951 /// Pass NULL to just use the default in-process session.
5952 /// <!-- default NULL -->
5953 ///
5954 /// @param[in] node_id
5955 /// The node id.
5956 ///
5957 /// @param[in] part_id
5958 /// The part id. (should be a packed primitive)
5959 ///
5960 /// @param[in] group_type
5961 /// The group type.
5962 ///
5963 /// @param[out] group_names_array
5964 /// The array of names to be filled. Should be the size
5965 /// given by ::HAPI_GetGroupCountOnPackedInstancePart() with
5966 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
5967 /// @note These string handles are only valid until the
5968 /// next call to ::HAPI_GetGroupNamesOnPackedInstancePart().
5969 ///
5970 /// @param[in] group_count
5971 /// Sanity check. Should be less than or equal to the size
5972 /// of @p group_names.
5973 ///
5975  HAPI_NodeId node_id,
5976  HAPI_PartId part_id,
5977  HAPI_GroupType group_type,
5978  HAPI_StringHandle * group_names_array,
5979  int group_count );
5980 
5981 /// @brief Get group membership for a packed instance part
5982 /// This functions allows you to get the group membership for a specific
5983 /// packed primitive part.
5984 ///
5985 /// @ingroup GeometryGetters
5986 ///
5987 /// @param[in] session
5988 /// The session of Houdini you are interacting with.
5989 /// See @ref HAPI_Sessions for more on sessions.
5990 /// Pass NULL to just use the default in-process session.
5991 /// <!-- default NULL -->
5992 ///
5993 /// @param[in] node_id
5994 /// The node id.
5995 ///
5996 /// @param[in] part_id
5997 /// The part id. (should be a packed primitive)
5998 ///
5999 /// @param[in] group_type
6000 /// The group type.
6001 ///
6002 /// @param[in] group_name
6003 /// The group name.
6004 ///
6005 /// @param[out] membership_array_all_equal
6006 /// (optional) Quick way to determine if all items are in
6007 /// the given group or all items our not in the group.
6008 /// You can just pass NULL here if not interested.
6009 ///
6010 /// @param[out] membership_array
6011 /// Array of ints that represent the membership of this
6012 /// group. Should be the size given by
6013 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
6014 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
6015 ///
6016 /// @param[in] start
6017 /// Start offset into the membership array. Must be
6018 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
6019 /// <!-- default 0 -->
6020 ///
6021 /// @param[in] length
6022 /// Should be less than or equal to the size
6023 /// of @p membership_array.
6024 /// <!-- source ::HAPI_PartInfo_GetElementCountByGroupType -->
6025 ///
6027  HAPI_NodeId node_id,
6028  HAPI_PartId part_id,
6029  HAPI_GroupType group_type,
6030  const char * group_name,
6031  HAPI_Bool * membership_array_all_equal,
6032  int * membership_array,
6033  int start, int length );
6034 
6035 /// @brief Get the part ids that this instancer part is instancing.
6036 ///
6037 /// @ingroup GeometryGetters
6038 ///
6039 /// @param[in] session
6040 /// The session of Houdini you are interacting with.
6041 /// See @ref HAPI_Sessions for more on sessions.
6042 /// Pass NULL to just use the default in-process session.
6043 /// <!-- default NULL -->
6044 ///
6045 /// @param[in] node_id
6046 /// The node id.
6047 ///
6048 /// @param[in] part_id
6049 /// The instancer part id.
6050 ///
6051 /// @param[out] instanced_parts_array
6052 /// Array of ::HAPI_PartId's to instance.
6053 ///
6054 /// @param[in] start
6055 /// Should be less than @p part_id's
6056 /// ::HAPI_PartInfo::instancedPartCount but more than or
6057 /// equal to 0.
6058 /// <!-- default 0 -->
6059 ///
6060 /// @param[in] length
6061 /// Should be less than @p part_id's
6062 /// ::HAPI_PartInfo::instancedPartCount - @p start.
6063 /// <!-- source ::HAPI_PartInfo::instancedPartCount - start -->
6064 ///
6066  HAPI_NodeId node_id,
6067  HAPI_PartId part_id,
6068  HAPI_PartId * instanced_parts_array,
6069  int start, int length );
6070 
6071 /// @brief Get the instancer part's list of transforms on which to
6072 /// instance the instanced parts you got from
6073 /// ::HAPI_GetInstancedPartIds().
6074 ///
6075 /// @ingroup GeometryGetters
6076 ///
6077 /// @param[in] session
6078 /// The session of Houdini you are interacting with.
6079 /// See @ref HAPI_Sessions for more on sessions.
6080 /// Pass NULL to just use the default in-process session.
6081 /// <!-- default NULL -->
6082 ///
6083 /// @param[in] node_id
6084 /// The node id.
6085 ///
6086 /// @param[in] part_id
6087 /// The instancer part id.
6088 ///
6089 /// @param[in] rst_order
6090 /// The order of application of translation, rotation and
6091 /// scale.
6092 ///
6093 /// @param[out] transforms_array
6094 /// Array of ::HAPI_PartId's to instance.
6095 ///
6096 /// @param[in] start
6097 /// Should be less than @p part_id's
6098 /// ::HAPI_PartInfo::instanceCount but more than or
6099 /// equal to 0.
6100 /// <!-- default 0 -->
6101 ///
6102 /// @param[in] length
6103 /// Should be less than @p part_id's
6104 /// ::HAPI_PartInfo::instanceCount - @p start.
6105 /// <!-- source ::HAPI_PartInfo::instanceCount - start -->
6106 ///
6108  HAPI_NodeId node_id,
6109  HAPI_PartId part_id,
6110  HAPI_RSTOrder rst_order,
6111  HAPI_Transform * transforms_array,
6112  int start, int length );
6113 
6114 /// @defgroup GeometrySetters Geometry Setters
6115 /// Functions for setting geometry (SOP) data
6116 
6117 /// @brief Set the main part info struct (::HAPI_PartInfo).
6118 ///
6119 /// @ingroup GeometrySetters
6120 ///
6121 /// @param[in] session
6122 /// The session of Houdini you are interacting with.
6123 /// See @ref HAPI_Sessions for more on sessions.
6124 /// Pass NULL to just use the default in-process session.
6125 /// <!-- default NULL -->
6126 ///
6127 /// @param[in] node_id
6128 /// The SOP node id.
6129 ///
6130 /// @param[in] part_id
6131 /// Currently not used. Just pass 0.
6132 /// <!-- default 0 -->
6133 ///
6134 /// @param[in] part_info
6135 /// ::HAPI_PartInfo value that describes the input
6136 /// geometry.
6137 ///
6138 HAPI_DECL HAPI_SetPartInfo( const HAPI_Session * session,
6139  HAPI_NodeId node_id,
6140  HAPI_PartId part_id,
6141  const HAPI_PartInfo * part_info );
6142 
6143 /// @brief Set the array of faces where the nth integer in the array is
6144 /// the number of vertices the nth face has.
6145 ///
6146 /// @ingroup GeometrySetters
6147 ///
6148 /// @param[in] session
6149 /// The session of Houdini you are interacting with.
6150 /// See @ref HAPI_Sessions for more on sessions.
6151 /// Pass NULL to just use the default in-process session.
6152 /// <!-- default NULL -->
6153 ///
6154 /// @param[in] node_id
6155 /// The SOP node id.
6156 ///
6157 /// @param[in] part_id
6158 /// Currently not used. Just pass 0.
6159 /// <!-- default 0 -->
6160 ///
6161 /// @param[in] face_counts_array
6162 /// An integer array at least the size of @p length.
6163 ///
6164 /// @param[in] start
6165 /// First index of range. Must be at least 0 and at
6166 /// most ::HAPI_PartInfo::faceCount - 1.
6167 /// <!-- default 0 -->
6168 ///
6169 /// @param[in] length
6170 /// Must be at least 0 and at most
6171 /// ::HAPI_PartInfo::faceCount - @p start.
6172 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
6173 ///
6174 HAPI_DECL HAPI_SetFaceCounts( const HAPI_Session * session,
6175  HAPI_NodeId node_id,
6176  HAPI_PartId part_id,
6177  const int * face_counts_array,
6178  int start, int length );
6179 
6180 /// @brief Set array containing the vertex-point associations where the
6181 /// ith element in the array is the point index the ith vertex
6182 /// associates with.
6183 ///
6184 /// @ingroup GeometrySetters
6185 ///
6186 /// @param[in] session
6187 /// The session of Houdini you are interacting with.
6188 /// See @ref HAPI_Sessions for more on sessions.
6189 /// Pass NULL to just use the default in-process session.
6190 /// <!-- default NULL -->
6191 ///
6192 /// @param[in] node_id
6193 /// The SOP node id.
6194 ///
6195 /// @param[in] part_id
6196 /// Currently not used. Just pass 0.
6197 ///
6198 /// @param[in] vertex_list_array
6199 /// An integer array at least the size of length.
6200 ///
6201 /// @param[in] start
6202 /// First index of range. Must be at least 0 and at
6203 /// most ::HAPI_PartInfo::vertexCount - 1.
6204 /// <!-- default 0 -->
6205 ///
6206 /// @param[in] length
6207 /// Must be at least 0 and at most
6208 /// ::HAPI_PartInfo::vertexCount - @p start.
6209 /// <!-- source ::HAPI_PartInfo::vertexCount - start -->
6210 ///
6211 HAPI_DECL HAPI_SetVertexList( const HAPI_Session * session,
6212  HAPI_NodeId node_id,
6213  HAPI_PartId part_id,
6214  const int * vertex_list_array,
6215  int start, int length );
6216 
6217 /// @brief Add an attribute.
6218 ///
6219 /// @ingroup GeometrySetters Attributes
6220 ///
6221 /// @param[in] session
6222 /// The session of Houdini you are interacting with.
6223 /// See @ref HAPI_Sessions for more on sessions.
6224 /// Pass NULL to just use the default in-process session.
6225 /// <!-- default NULL -->
6226 ///
6227 /// @param[in] node_id
6228 /// The SOP node id.
6229 ///
6230 /// @param[in] part_id
6231 /// Currently not used. Just pass 0.
6232 ///
6233 /// @param[in] name
6234 /// Attribute name.
6235 ///
6236 /// @param[in] attr_info
6237 /// ::HAPI_AttributeInfo stores attribute properties.
6238 ///
6239 HAPI_DECL HAPI_AddAttribute( const HAPI_Session * session,
6240  HAPI_NodeId node_id,
6241  HAPI_PartId part_id,
6242  const char * name,
6243  const HAPI_AttributeInfo * attr_info );
6244 
6245 /// @brief Delete an attribute from an input geo
6246 ///
6247 /// @ingroup GeometrySetters Attributes
6248 ///
6249 /// @param[in] session
6250 /// The session of Houdini you are interacting with.
6251 /// See @ref HAPI_Sessions for more on sessions.
6252 /// Pass NULL to just use the default in-process session.
6253 /// <!-- default NULL -->
6254 ///
6255 /// @param[in] node_id
6256 /// The SOP node id.
6257 ///
6258 /// @param[in] part_id
6259 /// Currently not used. Just pass 0.
6260 ///
6261 /// @param[in] name
6262 /// Attribute name.
6263 ///
6264 /// @param[in] attr_info
6265 /// ::HAPI_AttributeInfo stores attribute properties.
6266 ///
6268  HAPI_NodeId node_id,
6269  HAPI_PartId part_id,
6270  const char * name,
6271  const HAPI_AttributeInfo * attr_info );
6272 
6273 /// @brief Set attribute integer data.
6274 ///
6275 /// @ingroup GeometrySetters Attributes
6276 ///
6277 /// @param[in] session
6278 /// The session of Houdini you are interacting with.
6279 /// See @ref HAPI_Sessions for more on sessions.
6280 /// Pass NULL to just use the default in-process session.
6281 /// <!-- default NULL -->
6282 ///
6283 /// @param[in] node_id
6284 /// The SOP node id.
6285 ///
6286 /// @param[in] part_id
6287 /// Currently not used. Just pass 0.
6288 ///
6289 /// @param[in] name
6290 /// Attribute name.
6291 ///
6292 /// @param[in] attr_info
6293 /// ::HAPI_AttributeInfo used as input for what tuple size.
6294 /// you want. Also contains some sanity checks like
6295 /// data type. Generally should be the same struct
6296 /// returned by ::HAPI_GetAttributeInfo().
6297 ///
6298 /// @param[in] data_array
6299 /// An integer array at least the size of
6300 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6301 ///
6302 /// @param[in] start
6303 /// First index of range. Must be at least 0 and at
6304 /// most ::HAPI_AttributeInfo::count - 1.
6305 /// <!-- default 0 -->
6306 ///
6307 /// @param[in] length
6308 /// Must be at least 0 and at most
6309 /// ::HAPI_AttributeInfo::count - @p start.
6310 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6311 ///
6313  HAPI_NodeId node_id,
6314  HAPI_PartId part_id,
6315  const char * name,
6316  const HAPI_AttributeInfo * attr_info,
6317  const int * data_array,
6318  int start, int length );
6319 
6320 /// @brief Set unsigned 8-bit attribute integer data.
6321 ///
6322 /// @ingroup GeometrySetters Attributes
6323 ///
6324 /// @param[in] session
6325 /// The session of Houdini you are interacting with.
6326 /// See @ref HAPI_Sessions for more on sessions.
6327 /// Pass NULL to just use the default in-process session.
6328 /// <!-- default NULL -->
6329 ///
6330 /// @param[in] node_id
6331 /// The SOP node id.
6332 ///
6333 /// @param[in] part_id
6334 /// Currently not used. Just pass 0.
6335 ///
6336 /// @param[in] name
6337 /// Attribute name.
6338 ///
6339 /// @param[in] attr_info
6340 /// ::HAPI_AttributeInfo used as input for what tuple size.
6341 /// you want. Also contains some sanity checks like
6342 /// data type. Generally should be the same struct
6343 /// returned by ::HAPI_GetAttributeInfo().
6344 ///
6345 /// @param[in] data_array
6346 /// An unsigned 8-bit integer array at least the size of
6347 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6348 ///
6349 /// @param[in] start
6350 /// First index of range. Must be at least 0 and at
6351 /// most ::HAPI_AttributeInfo::count - 1.
6352 /// <!-- default 0 -->
6353 ///
6354 /// @param[in] length
6355 /// Must be at least 0 and at most
6356 /// ::HAPI_AttributeInfo::count - @p start.
6357 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6358 ///
6360  HAPI_NodeId node_id,
6361  HAPI_PartId part_id,
6362  const char * name,
6363  const HAPI_AttributeInfo * attr_info,
6364  const HAPI_UInt8 * data_array,
6365  int start, int length );
6366 
6367 /// @brief Set 8-bit attribute integer data.
6368 ///
6369 /// @ingroup GeometrySetters Attributes
6370 ///
6371 /// @param[in] session
6372 /// The session of Houdini you are interacting with.
6373 /// See @ref HAPI_Sessions for more on sessions.
6374 /// Pass NULL to just use the default in-process session.
6375 /// <!-- default NULL -->
6376 ///
6377 /// @param[in] node_id
6378 /// The SOP node id.
6379 ///
6380 /// @param[in] part_id
6381 /// Currently not used. Just pass 0.
6382 ///
6383 /// @param[in] name
6384 /// Attribute name.
6385 ///
6386 /// @param[in] attr_info
6387 /// ::HAPI_AttributeInfo used as input for what tuple size.
6388 /// you want. Also contains some sanity checks like
6389 /// data type. Generally should be the same struct
6390 /// returned by ::HAPI_GetAttributeInfo().
6391 ///
6392 /// @param[in] data_array
6393 /// An 8-bit integer array at least the size of
6394 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6395 ///
6396 /// @param[in] start
6397 /// First index of range. Must be at least 0 and at
6398 /// most ::HAPI_AttributeInfo::count - 1.
6399 /// <!-- default 0 -->
6400 ///
6401 /// @param[in] length
6402 /// Must be at least 0 and at most
6403 /// ::HAPI_AttributeInfo::count - @p start.
6404 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6405 ///
6407  HAPI_NodeId node_id,
6408  HAPI_PartId part_id,
6409  const char * name,
6410  const HAPI_AttributeInfo * attr_info,
6411  const HAPI_Int8 * data_array,
6412  int start, int length );
6413 
6414 /// @brief Set 16-bit attribute integer data.
6415 ///
6416 /// @ingroup GeometrySetters Attributes
6417 ///
6418 /// @param[in] session
6419 /// The session of Houdini you are interacting with.
6420 /// See @ref HAPI_Sessions for more on sessions.
6421 /// Pass NULL to just use the default in-process session.
6422 /// <!-- default NULL -->
6423 ///
6424 /// @param[in] node_id
6425 /// The SOP node id.
6426 ///
6427 /// @param[in] part_id
6428 /// Currently not used. Just pass 0.
6429 ///
6430 /// @param[in] name
6431 /// Attribute name.
6432 ///
6433 /// @param[in] attr_info
6434 /// ::HAPI_AttributeInfo used as input for what tuple size.
6435 /// you want. Also contains some sanity checks like
6436 /// data type. Generally should be the same struct
6437 /// returned by ::HAPI_GetAttributeInfo().
6438 ///
6439 /// @param[in] data_array
6440 /// An 16-bit integer array at least the size of
6441 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6442 ///
6443 /// @param[in] start
6444 /// First index of range. Must be at least 0 and at
6445 /// most ::HAPI_AttributeInfo::count - 1.
6446 /// <!-- default 0 -->
6447 ///
6448 /// @param[in] length
6449 /// Must be at least 0 and at most
6450 /// ::HAPI_AttributeInfo::count - @p start.
6451 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6452 ///
6454  HAPI_NodeId node_id,
6455  HAPI_PartId part_id,
6456  const char * name,
6457  const HAPI_AttributeInfo * attr_info,
6458  const HAPI_Int16 * data_array,
6459  int start, int length );
6460 
6461 /// @brief Set 64-bit attribute integer data.
6462 ///
6463 /// @ingroup GeometrySetters Attributes
6464 ///
6465 /// @param[in] session
6466 /// The session of Houdini you are interacting with.
6467 /// See @ref HAPI_Sessions for more on sessions.
6468 /// Pass NULL to just use the default in-process session.
6469 /// <!-- default NULL -->
6470 ///
6471 /// @param[in] node_id
6472 /// The SOP node id.
6473 ///
6474 /// @param[in] part_id
6475 /// Currently not used. Just pass 0.
6476 ///
6477 /// @param[in] name
6478 /// Attribute name.
6479 ///
6480 /// @param[in] attr_info
6481 /// ::HAPI_AttributeInfo used as input for what tuple size.
6482 /// you want. Also contains some sanity checks like
6483 /// data type. Generally should be the same struct
6484 /// returned by ::HAPI_GetAttributeInfo().
6485 ///
6486 /// @param[in] data_array
6487 /// An 64-bit integer array at least the size of
6488 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6489 ///
6490 /// @param[in] start
6491 /// First index of range. Must be at least 0 and at
6492 /// most ::HAPI_AttributeInfo::count - 1.
6493 /// <!-- default 0 -->
6494 ///
6495 /// @param[in] length
6496 /// Must be at least 0 and at most
6497 /// ::HAPI_AttributeInfo::count - @p start.
6498 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6499 ///
6501  HAPI_NodeId node_id,
6502  HAPI_PartId part_id,
6503  const char * name,
6504  const HAPI_AttributeInfo * attr_info,
6505  const HAPI_Int64 * data_array,
6506  int start, int length );
6507 
6508 /// @brief Set attribute float data.
6509 ///
6510 /// @ingroup GeometrySetters Attributes
6511 ///
6512 /// @param[in] session
6513 /// The session of Houdini you are interacting with.
6514 /// See @ref HAPI_Sessions for more on sessions.
6515 /// Pass NULL to just use the default in-process session.
6516 /// <!-- default NULL -->
6517 ///
6518 /// @param[in] node_id
6519 /// The SOP node id.
6520 ///
6521 /// @param[in] part_id
6522 /// Currently not used. Just pass 0.
6523 ///
6524 /// @param[in] name
6525 /// Attribute name.
6526 ///
6527 /// @param[in] attr_info
6528 /// ::HAPI_AttributeInfo used as input for what tuple size.
6529 /// you want. Also contains some sanity checks like
6530 /// data type. Generally should be the same struct
6531 /// returned by ::HAPI_GetAttributeInfo().
6532 ///
6533 /// @param[in] data_array
6534 /// An float array at least the size of
6535 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6536 ///
6537 /// @param[in] start
6538 /// First index of range. Must be at least 0 and at
6539 /// most ::HAPI_AttributeInfo::count - 1.
6540 /// <!-- default 0 -->
6541 ///
6542 /// @param[in] length
6543 /// Must be at least 0 and at most
6544 /// ::HAPI_AttributeInfo::count - @p start.
6545 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6546 ///
6548  HAPI_NodeId node_id,
6549  HAPI_PartId part_id,
6550  const char * name,
6551  const HAPI_AttributeInfo * attr_info,
6552  const float * data_array,
6553  int start, int length );
6554 
6555 /// @brief Set 64-bit attribute float data.
6556 ///
6557 /// @ingroup GeometrySetters Attributes
6558 ///
6559 /// @param[in] session
6560 /// The session of Houdini you are interacting with.
6561 /// See @ref HAPI_Sessions for more on sessions.
6562 /// Pass NULL to just use the default in-process session.
6563 /// <!-- default NULL -->
6564 ///
6565 /// @param[in] node_id
6566 /// The SOP node id.
6567 ///
6568 /// @param[in] part_id
6569 /// Currently not used. Just pass 0.
6570 ///
6571 /// @param[in] name
6572 /// Attribute name.
6573 ///
6574 /// @param[in] attr_info
6575 /// ::HAPI_AttributeInfo used as input for what tuple size.
6576 /// you want. Also contains some sanity checks like
6577 /// data type. Generally should be the same struct
6578 /// returned by ::HAPI_GetAttributeInfo().
6579 ///
6580 /// @param[in] data_array
6581 /// An 64-bit float array at least the size of
6582 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6583 ///
6584 /// @param[in] start
6585 /// First index of range. Must be at least 0 and at
6586 /// most ::HAPI_AttributeInfo::count - 1.
6587 /// <!-- default 0 -->
6588 ///
6589 /// @param[in] length
6590 /// Must be at least 0 and at most
6591 /// ::HAPI_AttributeInfo::count - @p start.
6592 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6593 ///
6595  HAPI_NodeId node_id,
6596  HAPI_PartId part_id,
6597  const char * name,
6598  const HAPI_AttributeInfo * attr_info,
6599  const double * data_array,
6600  int start, int length );
6601 
6602 /// @brief Set attribute string data.
6603 ///
6604 /// @ingroup GeometrySetters Attributes
6605 ///
6606 /// @param[in] session
6607 /// The session of Houdini you are interacting with.
6608 /// See @ref HAPI_Sessions for more on sessions.
6609 /// Pass NULL to just use the default in-process session.
6610 /// <!-- default NULL -->
6611 ///
6612 /// @param[in] node_id
6613 /// The SOP node id.
6614 ///
6615 /// @param[in] part_id
6616 /// Currently not used. Just pass 0.
6617 ///
6618 /// @param[in] name
6619 /// Attribute name.
6620 ///
6621 /// @param[in] attr_info
6622 /// ::HAPI_AttributeInfo used as input for what tuple size
6623 /// you want. Also contains some sanity checks like
6624 /// data type. Generally should be the same struct
6625 /// returned by ::HAPI_GetAttributeInfo().
6626 ///
6627 /// @param[in] data_array
6628 /// An ::HAPI_StringHandle array at least the size of
6629 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
6630 ///
6631 /// @param[in] start
6632 /// First index of range. Must be at least 0 and at
6633 /// most ::HAPI_AttributeInfo::count - 1.
6634 /// <!-- default 0 -->
6635 ///
6636 /// @param[in] length
6637 /// Must be at least 0 and at most
6638 /// ::HAPI_AttributeInfo::count - @p start.
6639 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6640 ///
6642  HAPI_NodeId node_id,
6643  HAPI_PartId part_id,
6644  const char * name,
6645  const HAPI_AttributeInfo * attr_info,
6646  const char ** data_array,
6647  int start, int length );
6648 
6649 /// @brief Set attribute string data by index.
6650 ///
6651 /// @ingroup GeometrySetters 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 SOP node id.
6661 ///
6662 /// @param[in] part_id
6663 /// Currently not used. Just pass 0.
6664 ///
6665 /// @param[in] 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[in] string_array
6675 /// An array of strings at least the size of
6676 /// <tt>string_count/tt>.
6677 ///
6678 /// @param[in] string_count
6679 /// Number of strings that are indexed.
6680 ///
6681 /// @param[in] indices_array
6682 /// integer array at least the size of
6683 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>. Each
6684 /// entry indexes string_array.
6685 ///
6686 /// @param[in] indices_start
6687 /// First index of range. Must be at least 0 and at
6688 /// most ::HAPI_AttributeInfo::count - 1.
6689 /// <!-- default 0 -->
6690 ///
6691 /// @param[in] indices_length
6692 /// Must be at least 0 and at most
6693 /// ::HAPI_AttributeInfo::count - @p start.
6694 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6695 ///
6697  HAPI_NodeId node_id,
6698  HAPI_PartId part_id,
6699  const char* name,
6700  const HAPI_AttributeInfo* attr_info,
6701  const char** string_array,
6702  int string_count,
6703  const int* indices_array,
6704  int indices_start,
6705  int indices_length);
6706 
6707 /// @brief Set multiple attribute string data to the same unique value.
6708 ///
6709 /// @ingroup GeometrySetters Attributes
6710 ///
6711 /// @param[in] session
6712 /// The session of Houdini you are interacting with.
6713 /// See @ref HAPI_Sessions for more on sessions.
6714 /// Pass NULL to just use the default in-process session.
6715 /// <!-- default NULL -->
6716 ///
6717 /// @param[in] node_id
6718 /// The SOP node id.
6719 ///
6720 /// @param[in] part_id
6721 /// Currently not used. Just pass 0.
6722 ///
6723 /// @param[in] name
6724 /// Attribute name.
6725 ///
6726 /// @param[in] attr_info
6727 /// ::HAPI_AttributeInfo used as input for what tuple size.
6728 /// you want. Also contains some sanity checks like
6729 /// data type. Generally should be the same struct
6730 /// returned by ::HAPI_GetAttributeInfo().
6731 ///
6732 /// @param[in] data_array
6733 /// A string
6734 ///
6735 /// @param[in] data_length
6736 /// Must be the length of string data.
6737 ///
6738 /// @param[in] start_index
6739 /// Must be at least 0 and at most
6740 /// ::HAPI_AttributeInfo::count - @p start.
6741 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6742 ///
6743 /// @param[in] num_indices
6744 /// Must be at least 0 and at most
6745 /// ::HAPI_AttributeInfo::count - @p start.
6746 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6747 ///
6749  const HAPI_Session* session,
6750  HAPI_NodeId node_id,
6751  HAPI_PartId part_id,
6752  const char* name,
6753  const HAPI_AttributeInfo* attr_info,
6754  const char* data_array,
6755  int data_length,
6756  int start_index,
6757  int num_indices);
6758 
6759 /// @brief Set multiple attribute int data to the same unique value.
6760 ///
6761 /// @ingroup GeometrySetters Attributes
6762 ///
6763 /// @param[in] session
6764 /// The session of Houdini you are interacting with.
6765 /// See @ref HAPI_Sessions for more on sessions.
6766 /// Pass NULL to just use the default in-process session.
6767 /// <!-- default NULL -->
6768 ///
6769 /// @param[in] node_id
6770 /// The SOP node id.
6771 ///
6772 /// @param[in] part_id
6773 /// Currently not used. Just pass 0.
6774 ///
6775 /// @param[in] name
6776 /// Attribute name.
6777 ///
6778 /// @param[in] attr_info
6779 /// ::HAPI_AttributeInfo used as input for what tuple size.
6780 /// you want. Also contains some sanity checks like
6781 /// data type. Generally should be the same struct
6782 /// returned by ::HAPI_GetAttributeInfo().
6783 ///
6784 /// @param[in] data_array
6785 /// A integer array at least the size of
6786 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6787 ///
6788 /// @param[in] data_length
6789 /// An integer of at least the size of
6790 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6791 ///
6792 /// @param[in] start_index
6793 /// First index of range. Must be at least 0 and at
6794 /// most ::HAPI_AttributeInfo::count - 1.
6795 /// <!-- default 0 -->
6796 ///
6797 /// @param[in] num_indices
6798 /// Must be at least 0 and at most
6799 /// ::HAPI_AttributeInfo::count - @p start_index.
6800 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6801 ///
6803  const HAPI_Session* session,
6804  HAPI_NodeId node_id,
6805  HAPI_PartId part_id,
6806  const char* name,
6807  const HAPI_AttributeInfo* attr_info,
6808  const int* data_array,
6809  int data_length,
6810  int start_index,
6811  int num_indices);
6812 
6813 /// @brief Set multiple attribute unsigned 8-bit int data to the same unique value.
6814 ///
6815 /// @ingroup GeometrySetters Attributes
6816 ///
6817 /// @param[in] session
6818 /// The session of Houdini you are interacting with.
6819 /// See @ref HAPI_Sessions for more on sessions.
6820 /// Pass NULL to just use the default in-process session.
6821 /// <!-- default NULL -->
6822 ///
6823 /// @param[in] node_id
6824 /// The SOP node id.
6825 ///
6826 /// @param[in] part_id
6827 /// Currently not used. Just pass 0.
6828 ///
6829 /// @param[in] name
6830 /// Attribute name.
6831 ///
6832 /// @param[in] attr_info
6833 /// ::HAPI_AttributeInfo used as input for what tuple size.
6834 /// you want. Also contains some sanity checks like
6835 /// data type. Generally should be the same struct
6836 /// returned by ::HAPI_GetAttributeInfo().
6837 ///
6838 /// @param[in] data_array
6839 /// A integer array at least the size of
6840 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6841 ///
6842 /// @param[in] data_length
6843 /// An integer of at least the size of
6844 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6845 ///
6846 /// @param[in] start_index
6847 /// First index of range. Must be at least 0 and at
6848 /// most ::HAPI_AttributeInfo::count - 1.
6849 /// <!-- default 0 -->
6850 ///
6851 /// @param[in] num_indices
6852 /// Must be at least 0 and at most
6853 /// ::HAPI_AttributeInfo::count - @p start_index.
6854 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6855 ///
6857  const HAPI_Session* session,
6858  HAPI_NodeId node_id,
6859  HAPI_PartId part_id,
6860  const char* name,
6861  const HAPI_AttributeInfo* attr_info,
6862  const HAPI_UInt8* data_array,
6863  int data_length,
6864  int start_index,
6865  int num_indices);
6866 
6867 /// @brief Set multiple attribute 8-bit int data to the same unique value.
6868 ///
6869 ///
6870 /// @ingroup GeometrySetters Attributes
6871 ///
6872 /// @param[in] session
6873 /// The session of Houdini you are interacting with.
6874 /// See @ref HAPI_Sessions for more on sessions.
6875 /// Pass NULL to just use the default in-process session.
6876 /// <!-- default NULL -->
6877 ///
6878 /// @param[in] node_id
6879 /// The SOP node id.
6880 ///
6881 /// @param[in] part_id
6882 /// Currently not used. Just pass 0.
6883 ///
6884 /// @param[in] name
6885 /// Attribute name.
6886 ///
6887 /// @param[in] attr_info
6888 /// ::HAPI_AttributeInfo used as input for what tuple size.
6889 /// you want. Also contains some sanity checks like
6890 /// data type. Generally should be the same struct
6891 /// returned by ::HAPI_GetAttributeInfo().
6892 ///
6893 /// @param[in] data_array
6894 /// A integer array at least the size of
6895 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6896 ///
6897 /// @param[in] data_length
6898 /// An integer of at least the size of
6899 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6900 ///
6901 /// @param[in] start_index
6902 /// First index of range. Must be at least 0 and at
6903 /// most ::HAPI_AttributeInfo::count - 1.
6904 /// <!-- default 0 -->
6905 ///
6906 /// @param[in] num_indices
6907 /// Must be at least 0 and at most
6908 /// ::HAPI_AttributeInfo::count - @p start_index.
6909 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6910 ///
6912  const HAPI_Session* session,
6913  HAPI_NodeId node_id,
6914  HAPI_PartId part_id,
6915  const char* name,
6916  const HAPI_AttributeInfo* attr_info,
6917  const HAPI_Int8* data_array,
6918  int data_length,
6919  int start_index,
6920  int num_indices);
6921 
6922 /// @brief Set multiple attribute 16-bit int data to the same unique value.
6923 ///
6924 /// @ingroup GeometrySetters Attributes
6925 ///
6926 /// @param[in] session
6927 /// The session of Houdini you are interacting with.
6928 /// See @ref HAPI_Sessions for more on sessions.
6929 /// Pass NULL to just use the default in-process session.
6930 /// <!-- default NULL -->
6931 ///
6932 /// @param[in] node_id
6933 /// The SOP node id.
6934 ///
6935 /// @param[in] part_id
6936 /// Currently not used. Just pass 0.
6937 ///
6938 /// @param[in] name
6939 /// Attribute name.
6940 ///
6941 /// @param[in] attr_info
6942 /// ::HAPI_AttributeInfo used as input for what tuple size.
6943 /// you want. Also contains some sanity checks like
6944 /// data type. Generally should be the same struct
6945 /// returned by ::HAPI_GetAttributeInfo().
6946 ///
6947 /// @param[in] data_array
6948 /// A integer array at least the size of
6949 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6950 ///
6951 /// @param[in] data_length
6952 /// An integer of at least the size of
6953 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
6954 ///
6955 /// @param[in] start_index
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] num_indices
6961 /// Must be at least 0 and at most
6962 /// ::HAPI_AttributeInfo::count - @p start_index.
6963 /// <!-- source ::HAPI_AttributeInfo::count - start -->
6964 ///
6966  const HAPI_Session* session,
6967  HAPI_NodeId node_id,
6968  HAPI_PartId part_id,
6969  const char* name,
6970  const HAPI_AttributeInfo* attr_info,
6971  const HAPI_Int16* data_array,
6972  int data_length,
6973  int start_index,
6974  int num_indices);
6975 
6976 /// @brief Set multiple attribute 64-bit int data to the same unique value.
6977 ///
6978 /// @ingroup GeometrySetters Attributes
6979 ///
6980 /// @param[in] session
6981 /// The session of Houdini you are interacting with.
6982 /// See @ref HAPI_Sessions for more on sessions.
6983 /// Pass NULL to just use the default in-process session.
6984 /// <!-- default NULL -->
6985 ///
6986 /// @param[in] node_id
6987 /// The SOP node id.
6988 ///
6989 /// @param[in] part_id
6990 /// Currently not used. Just pass 0.
6991 ///
6992 /// @param[in] name
6993 /// Attribute name.
6994 ///
6995 /// @param[in] attr_info
6996 /// ::HAPI_AttributeInfo used as input for what tuple size.
6997 /// you want. Also contains some sanity checks like
6998 /// data type. Generally should be the same struct
6999 /// returned by ::HAPI_GetAttributeInfo().
7000 ///
7001 /// @param[in] data_array
7002 /// A integer array at least the size of
7003 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
7004 ///
7005 /// @param[in] data_length
7006 /// An integer of at least the size of
7007 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
7008 ///
7009 /// @param[in] start_index
7010 /// First index of range. Must be at least 0 and at
7011 /// most ::HAPI_AttributeInfo::count - 1.
7012 /// <!-- default 0 -->
7013 ///
7014 /// @param[in] num_indices
7015 /// Must be at least 0 and at most
7016 /// ::HAPI_AttributeInfo::count - @p start_index.
7017 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7018 ///
7020  const HAPI_Session* session,
7021  HAPI_NodeId node_id,
7022  HAPI_PartId part_id,
7023  const char* name,
7024  const HAPI_AttributeInfo* attr_info,
7025  const HAPI_Int64* data_array,
7026  int data_length,
7027  int start_index,
7028  int num_indices);
7029 
7030 /// @brief Set multiple attribute float data to the same unique value.
7031 ///
7032 /// @ingroup GeometrySetters Attributes
7033 ///
7034 /// @param[in] session
7035 /// The session of Houdini you are interacting with.
7036 /// See @ref HAPI_Sessions for more on sessions.
7037 /// Pass NULL to just use the default in-process session.
7038 /// <!-- default NULL -->
7039 ///
7040 /// @param[in] node_id
7041 /// The SOP node id.
7042 ///
7043 /// @param[in] part_id
7044 /// Currently not used. Just pass 0.
7045 ///
7046 /// @param[in] name
7047 /// Attribute name.
7048 ///
7049 /// @param[in] attr_info
7050 /// ::HAPI_AttributeInfo used as input for what tuple size.
7051 /// you want. Also contains some sanity checks like
7052 /// data type. Generally should be the same struct
7053 /// returned by ::HAPI_GetAttributeInfo().
7054 ///
7055 /// @param[in] data_array
7056 /// A floating point array at least the size of
7057 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
7058 ///
7059 /// @param[in] data_length
7060 /// An integer of at least the size of
7061 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
7062 ///
7063 /// @param[in] start_index
7064 /// First index of range. Must be at least 0 and at
7065 /// most ::HAPI_AttributeInfo::count - 1.
7066 /// <!-- default 0 -->
7067 ///
7068 /// @param[in] num_indices
7069 /// Must be at least 0 and at most
7070 /// ::HAPI_AttributeInfo::count - @p start_index.
7071 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7072 ///
7074  const HAPI_Session* session,
7075  HAPI_NodeId node_id,
7076  HAPI_PartId part_id,
7077  const char* name,
7078  const HAPI_AttributeInfo* attr_info,
7079  const float* data_array,
7080  int data_length,
7081  int start_index,
7082  int num_indices);
7083 
7084 /// @brief Set multiple attribute 64-bit float data to the same unique value.
7085 ///
7086 /// @ingroup GeometrySetters Attributes
7087 ///
7088 /// @param[in] session
7089 /// The session of Houdini you are interacting with.
7090 /// See @ref HAPI_Sessions for more on sessions.
7091 /// Pass NULL to just use the default in-process session.
7092 /// <!-- default NULL -->
7093 ///
7094 /// @param[in] node_id
7095 /// The SOP node id.
7096 ///
7097 /// @param[in] part_id
7098 /// Currently not used. Just pass 0.
7099 ///
7100 /// @param[in] name
7101 /// Attribute name.
7102 ///
7103 /// @param[in] attr_info
7104 /// ::HAPI_AttributeInfo used as input for what tuple size.
7105 /// you want. Also contains some sanity checks like
7106 /// data type. Generally should be the same struct
7107 /// returned by ::HAPI_GetAttributeInfo().
7108 ///
7109 /// @param[in] data_array
7110 /// A floating point array at least the size of
7111 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
7112 ///
7113 /// @param[in] data_length
7114 /// An integer of at least the size of
7115 /// <tt>::HAPI_AttributeInfo::tupleSize</tt>.
7116 ///
7117 /// @param[in] start_index
7118 /// First index of range. Must be at least 0 and at
7119 /// most ::HAPI_AttributeInfo::count - 1.
7120 /// <!-- default 0 -->
7121 ///
7122 /// @param[in] num_indices
7123 /// Must be at least 0 and at most
7124 /// ::HAPI_AttributeInfo::count - @p start_index.
7125 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7126 ///
7128  const HAPI_Session* session,
7129  HAPI_NodeId node_id,
7130  HAPI_PartId part_id,
7131  const char* name,
7132  const HAPI_AttributeInfo* attr_info,
7133  const double* data_array,
7134  int data_length,
7135  int start_index,
7136  int num_indices);
7137 
7138 /// @brief Set attribute dictionary data. The dictionary data should
7139 /// be provided as JSON-encoded strings.
7140 ///
7141 /// @ingroup GeometrySetters Attributes
7142 ///
7143 /// @param[in] session
7144 /// The session of Houdini you are interacting with.
7145 /// See @ref HAPI_Sessions for more on sessions.
7146 /// Pass NULL to just use the default in-process session.
7147 /// <!-- default NULL -->
7148 ///
7149 /// @param[in] node_id
7150 /// The SOP node id.
7151 ///
7152 /// @param[in] part_id
7153 /// Currently not used. Just pass 0.
7154 ///
7155 /// @param[in] name
7156 /// Attribute name.
7157 ///
7158 /// @param[in] attr_info
7159 /// ::HAPI_AttributeInfo used as input for what tuple size
7160 /// you want. Also contains some sanity checks like
7161 /// data type. Generally should be the same struct
7162 /// returned by ::HAPI_GetAttributeInfo().
7163 ///
7164 /// @param[in] data_array
7165 /// An ::HAPI_StringHandle array at least the size of
7166 /// <tt>length * ::HAPI_AttributeInfo::tupleSize</tt>.
7167 ///
7168 /// @param[in] start
7169 /// First index of range. Must be at least 0 and at
7170 /// most ::HAPI_AttributeInfo::count - 1.
7171 /// <!-- default 0 -->
7172 ///
7173 /// @param[in] length
7174 /// Must be at least 0 and at most
7175 /// ::HAPI_AttributeInfo::count - @p start.
7176 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7177 ///
7179  HAPI_NodeId node_id,
7180  HAPI_PartId part_id,
7181  const char* name,
7182  const HAPI_AttributeInfo* attr_info,
7183  const char** data_array,
7184  int start, int length );
7185 
7186 /// @brief
7187 ///
7188 /// @ingroup GeometrySetters Attributes
7189 ///
7190 /// @param[in] session
7191 /// The session of Houdini you are interacting with.
7192 /// See @ref HAPI_Sessions for more on sessions.
7193 /// Pass NULL to just use the default in-process session.
7194 /// <!-- default NULL -->
7195 ///
7196 /// @param[in] node_id
7197 /// The SOP node id.
7198 ///
7199 /// @param[in] part_id
7200 /// Currently not used. Just pass 0.
7201 ///
7202 /// @param[in] name
7203 /// Attribute name.
7204 ///
7205 /// @param[in] attr_info
7206 /// ::HAPI_AttributeInfo that contains the description for the
7207 /// attribute that is being set.
7208 ///
7209 /// @param[in] data_fixed_array
7210 /// An array containing the int values of the attribute.
7211 ///
7212 /// @param[in] data_fixed_length
7213 /// The total size of the data array. The size can be no greater
7214 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7215 /// of the attribute.
7216 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7217 ///
7218 /// @param[in] sizes_fixed_array
7219 /// An array of integers that contains the sizes of each
7220 /// attribute array. This is required because the attribute
7221 /// array for each geometry component can be of variable size.
7222 ///
7223 /// @param[in] start
7224 /// First index of range. Must be at least 0 and at most
7225 /// ::HAPI_AttributeInfo::count - 1.
7226 /// <!-- default 0 -->
7227 ///
7228 /// @param[in] sizes_fixed_length
7229 /// Must be at least 0 and at most
7230 /// ::HAPI_AttributeInfo::count - @p start.
7231 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7233  HAPI_NodeId node_id,
7234  HAPI_PartId part_id,
7235  const char * name,
7236  const HAPI_AttributeInfo * attr_info,
7237  const int * data_fixed_array,
7238  int data_fixed_length,
7239  const int * sizes_fixed_array,
7240  int start,
7241  int sizes_fixed_length );
7242 
7243 /// @brief
7244 ///
7245 /// @ingroup GeometrySetters Attributes
7246 ///
7247 /// @param[in] session
7248 /// The session of Houdini you are interacting with.
7249 /// See @ref HAPI_Sessions for more on sessions.
7250 /// Pass NULL to just use the default in-process session.
7251 /// <!-- default NULL -->
7252 ///
7253 /// @param[in] node_id
7254 /// The SOP node id.
7255 ///
7256 /// @param[in] part_id
7257 /// Currently not used. Just pass 0.
7258 ///
7259 /// @param[in] name
7260 /// Attribute name.
7261 ///
7262 /// @param[in] attr_info
7263 /// ::HAPI_AttributeInfo that contains the description for the
7264 /// attribute that is being set.
7265 ///
7266 /// @param[in] data_fixed_array
7267 /// An array containing the HAPI_UInt8 values of the attribute.
7268 ///
7269 /// @param[in] data_fixed_length
7270 /// The total size of the data array. The size can be no greater
7271 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7272 /// of the attribute.
7273 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7274 ///
7275 /// @param[in] sizes_fixed_array
7276 /// An array of integers that contains the sizes of each
7277 /// attribute array. This is required because the attribute
7278 /// array for each geometry component can be of variable size.
7279 ///
7280 /// @param[in] start
7281 /// First index of range. Must be at least 0 and at most
7282 /// ::HAPI_AttributeInfo::count - 1.
7283 /// <!-- default 0 -->
7284 ///
7285 /// @param[in] sizes_fixed_length
7286 /// Must be at least 0 and at most
7287 /// ::HAPI_AttributeInfo::count - @p start.
7288 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7290  HAPI_NodeId node_id,
7291  HAPI_PartId part_id,
7292  const char * name,
7293  const HAPI_AttributeInfo * attr_info,
7294  const HAPI_UInt8 * data_fixed_array,
7295  int data_fixed_length,
7296  const int * sizes_fixed_array,
7297  int start,
7298  int sizes_fixed_length );
7299 
7300 /// @brief
7301 ///
7302 /// @ingroup GeometrySetters Attributes
7303 ///
7304 /// @param[in] session
7305 /// The session of Houdini you are interacting with.
7306 /// See @ref HAPI_Sessions for more on sessions.
7307 /// Pass NULL to just use the default in-process session.
7308 /// <!-- default NULL -->
7309 ///
7310 /// @param[in] node_id
7311 /// The SOP node id.
7312 ///
7313 /// @param[in] part_id
7314 /// Currently not used. Just pass 0.
7315 ///
7316 /// @param[in] name
7317 /// Attribute name.
7318 ///
7319 /// @param[in] attr_info
7320 /// ::HAPI_AttributeInfo that contains the description for the
7321 /// attribute that is being set.
7322 ///
7323 /// @param[in] data_fixed_array
7324 /// An array containing the HAPI_Int8 values of the attribute.
7325 ///
7326 /// @param[in] data_fixed_length
7327 /// The total size of the data array. The size can be no greater
7328 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7329 /// of the attribute.
7330 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7331 ///
7332 /// @param[in] sizes_fixed_array
7333 /// An array of integers that contains the sizes of each
7334 /// attribute array. This is required because the attribute
7335 /// array for each geometry component can be of variable size.
7336 ///
7337 /// @param[in] start
7338 /// First index of range. Must be at least 0 and at most
7339 /// ::HAPI_AttributeInfo::count - 1.
7340 /// <!-- default 0 -->
7341 ///
7342 /// @param[in] sizes_fixed_length
7343 /// Must be at least 0 and at most
7344 /// ::HAPI_AttributeInfo::count - @p start.
7345 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7347  HAPI_NodeId node_id,
7348  HAPI_PartId part_id,
7349  const char * name,
7350  const HAPI_AttributeInfo * attr_info,
7351  const HAPI_Int8 * data_fixed_array,
7352  int data_fixed_length,
7353  const int * sizes_fixed_array,
7354  int start,
7355  int sizes_fixed_length);
7356 
7357 /// @brief
7358 ///
7359 /// @ingroup GeometrySetters Attributes
7360 ///
7361 /// @param[in] session
7362 /// The session of Houdini you are interacting with.
7363 /// See @ref HAPI_Sessions for more on sessions.
7364 /// Pass NULL to just use the default in-process session.
7365 /// <!-- default NULL -->
7366 ///
7367 /// @param[in] node_id
7368 /// The SOP node id.
7369 ///
7370 /// @param[in] part_id
7371 /// Currently not used. Just pass 0.
7372 ///
7373 /// @param[in] name
7374 /// Attribute name.
7375 ///
7376 /// @param[in] attr_info
7377 /// ::HAPI_AttributeInfo that contains the description for the
7378 /// attribute that is being set.
7379 ///
7380 /// @param[in] data_fixed_array
7381 /// An array containing the HAPI_Int16 values of the attribute.
7382 ///
7383 /// @param[in] data_fixed_length
7384 /// The total size of the data array. The size can be no greater
7385 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7386 /// of the attribute.
7387 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7388 ///
7389 /// @param[in] sizes_fixed_array
7390 /// An array of integers that contains the sizes of each
7391 /// attribute array. This is required because the attribute
7392 /// array for each geometry component can be of variable size.
7393 ///
7394 /// @param[in] start
7395 /// First index of range. Must be at least 0 and at most
7396 /// ::HAPI_AttributeInfo::count - 1.
7397 /// <!-- default 0 -->
7398 ///
7399 /// @param[in] sizes_fixed_length
7400 /// Must be at least 0 and at most
7401 /// ::HAPI_AttributeInfo::count - @p start.
7402 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7404  HAPI_NodeId node_id,
7405  HAPI_PartId part_id,
7406  const char * name,
7407  const HAPI_AttributeInfo * attr_info,
7408  const HAPI_Int16 * data_fixed_array,
7409  int data_fixed_length,
7410  const int * sizes_fixed_array,
7411  int start,
7412  int sizes_fixed_length );
7413 
7414 /// @brief
7415 ///
7416 /// @ingroup GeometrySetters Attributes
7417 ///
7418 /// @param[in] session
7419 /// The session of Houdini you are interacting with.
7420 /// See @ref HAPI_Sessions for more on sessions.
7421 /// Pass NULL to just use the default in-process session.
7422 /// <!-- default NULL -->
7423 ///
7424 /// @param[in] node_id
7425 /// The SOP node id.
7426 ///
7427 /// @param[in] part_id
7428 /// Currently not used. Just pass 0.
7429 ///
7430 /// @param[in] name
7431 /// Attribute name.
7432 ///
7433 /// @param[in] attr_info
7434 /// ::HAPI_AttributeInfo that contains the description for the
7435 /// attribute that is being set.
7436 ///
7437 /// @param[in] data_fixed_array
7438 /// An array containing the HAPI_Int64 values of the attribute.
7439 ///
7440 /// @param[in] data_fixed_length
7441 /// The total size of the data array. The size can be no greater
7442 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7443 /// of the attribute.
7444 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7445 ///
7446 /// @param[in] sizes_fixed_array
7447 /// An array of integers that contains the sizes of each
7448 /// attribute array. This is required because the attribute
7449 /// array for each geometry component can be of variable size.
7450 ///
7451 /// @param[in] start
7452 /// First index of range. Must be at least 0 and at most
7453 /// ::HAPI_AttributeInfo::count - 1.
7454 /// <!-- default 0 -->
7455 ///
7456 /// @param[in] sizes_fixed_length
7457 /// Must be at least 0 and at most
7458 /// ::HAPI_AttributeInfo::count - @p start.
7459 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7461  HAPI_NodeId node_id,
7462  HAPI_PartId part_id,
7463  const char * name,
7464  const HAPI_AttributeInfo * attr_info,
7465  const HAPI_Int64 * data_fixed_array,
7466  int data_fixed_length,
7467  const int * sizes_fixed_array,
7468  int start,
7469  int sizes_fixed_length );
7470 
7471 /// @brief
7472 ///
7473 /// @ingroup GeometrySetters Attributes
7474 ///
7475 /// @param[in] session
7476 /// The session of Houdini you are interacting with.
7477 /// See @ref HAPI_Sessions for more on sessions.
7478 /// Pass NULL to just use the default in-process session.
7479 /// <!-- default NULL -->
7480 ///
7481 /// @param[in] node_id
7482 /// The SOP node id.
7483 ///
7484 /// @param[in] part_id
7485 /// Currently not used. Just pass 0.
7486 ///
7487 /// @param[in] name
7488 /// Attribute name.
7489 ///
7490 /// @param[in] attr_info
7491 /// ::HAPI_AttributeInfo that contains the description for the
7492 /// attribute that is being set.
7493 ///
7494 /// @param[in] data_fixed_array
7495 /// An array containing the float values of the attribute.
7496 ///
7497 /// @param[in] data_fixed_length
7498 /// The total size of the data array. The size can be no greater
7499 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7500 /// of the attribute.
7501 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7502 ///
7503 /// @param[in] sizes_fixed_array
7504 /// An array of integers that contains the sizes of each
7505 /// attribute array. This is required because the attribute
7506 /// array for each geometry component can be of variable size.
7507 ///
7508 /// @param[in] start
7509 /// First index of range. Must be at least 0 and at most
7510 /// ::HAPI_AttributeInfo::count - 1.
7511 /// <!-- default 0 -->
7512 ///
7513 /// @param[in] sizes_fixed_length
7514 /// Must be at least 0 and at most
7515 /// ::HAPI_AttributeInfo::count - @p start.
7516 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7518  HAPI_NodeId node_id,
7519  HAPI_PartId part_id,
7520  const char * name,
7521  const HAPI_AttributeInfo * attr_info,
7522  const float * data_fixed_array,
7523  int data_fixed_length,
7524  const int * sizes_fixed_array,
7525  int start,
7526  int sizes_fixed_length );
7527 
7528 /// @brief
7529 ///
7530 /// @ingroup GeometrySetters Attributes
7531 ///
7532 /// @param[in] session
7533 /// The session of Houdini you are interacting with.
7534 /// See @ref HAPI_Sessions for more on sessions.
7535 /// Pass NULL to just use the default in-process session.
7536 /// <!-- default NULL -->
7537 ///
7538 /// @param[in] node_id
7539 /// The SOP node id.
7540 ///
7541 /// @param[in] part_id
7542 /// Currently not used. Just pass 0.
7543 ///
7544 /// @param[in] name
7545 /// Attribute name.
7546 ///
7547 /// @param[in] attr_info
7548 /// ::HAPI_AttributeInfo that contains the description for the
7549 /// attribute that is being set.
7550 ///
7551 /// @param[in] data_fixed_array
7552 /// An array containing the double values of the attribute.
7553 ///
7554 /// @param[in] data_fixed_length
7555 /// The total size of the data array. The size can be no greater
7556 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7557 /// of the attribute.
7558 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7559 ///
7560 /// @param[in] sizes_fixed_array
7561 /// An array of integers that contains the sizes of each
7562 /// attribute array. This is required because the attribute
7563 /// array for each geometry component can be of variable size.
7564 ///
7565 /// @param[in] start
7566 /// First index of range. Must be at least 0 and at most
7567 /// ::HAPI_AttributeInfo::count - 1.
7568 /// <!-- default 0 -->
7569 ///
7570 /// @param[in] sizes_fixed_length
7571 /// Must be at least 0 and at most
7572 /// ::HAPI_AttributeInfo::count - @p start.
7573 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7575  HAPI_NodeId node_id,
7576  HAPI_PartId part_id,
7577  const char * name,
7578  const HAPI_AttributeInfo * attr_info,
7579  const double * data_fixed_array,
7580  int data_fixed_length,
7581  const int * sizes_fixed_array,
7582  int start,
7583  int sizes_fixed_length );
7584 
7585 /// @brief Set attribute string array data.
7586 ///
7587 /// @ingroup GeometrySetters Attributes
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 ///
7601 /// @param[in] name
7602 /// Attribute name.
7603 ///
7604 /// @param[in] attr_info
7605 /// ::HAPI_AttributeInfo that contains the description for the
7606 /// attribute that is being set.
7607 ///
7608 /// @param[in] data_fixed_array
7609 /// An array containing the string values of the attribute.
7610 ///
7611 /// @param[in] data_fixed_length
7612 /// The total size of the data array. The size can be no greater
7613 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7614 /// of the attribute.
7615 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7616 ///
7617 /// @param[in] sizes_fixed_array
7618 /// An array of integers that contains the sizes of each
7619 /// attribute array. This is required because the attribute
7620 /// array for each geometry component can be of variable size.
7621 ///
7622 /// @param[in] start
7623 /// First index of range. Must be at least 0 and at most
7624 /// ::HAPI_AttributeInfo::count - 1.
7625 /// <!-- default 0 -->
7626 ///
7627 /// @param[in] sizes_fixed_length
7628 /// Must be at least 0 and at most
7629 /// ::HAPI_AttributeInfo::count - @p start.
7630 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7632  HAPI_NodeId node_id,
7633  HAPI_PartId part_id,
7634  const char * name,
7635  const HAPI_AttributeInfo * attr_info,
7636  const char ** data_fixed_array,
7637  int data_fixed_length,
7638  const int * sizes_fixed_array,
7639  int start,
7640  int sizes_fixed_length );
7641 
7642 /// @brief Set attribute dictionary array data. The dictionary data should
7643 /// be provided as JSON-encoded strings.
7644 ///
7645 /// @ingroup GeometrySetters Attributes
7646 ///
7647 /// @param[in] session
7648 /// The session of Houdini you are interacting with.
7649 /// See @ref HAPI_Sessions for more on sessions.
7650 /// Pass NULL to just use the default in-process session.
7651 /// <!-- default NULL -->
7652 ///
7653 /// @param[in] node_id
7654 /// The SOP node id.
7655 ///
7656 /// @param[in] part_id
7657 /// Currently not used. Just pass 0.
7658 ///
7659 /// @param[in] name
7660 /// Attribute name.
7661 ///
7662 /// @param[in] attr_info
7663 /// ::HAPI_AttributeInfo that contains the description for the
7664 /// attribute that is being set.
7665 ///
7666 /// @param[in] data_fixed_array
7667 /// An array containing the dictionary values of the attribute.
7668 ///
7669 /// @param[in] data_fixed_length
7670 /// The total size of the data array. The size can be no greater
7671 /// than the <tt>::HAPI_AttributeInfo::totalArrayElements</tt>
7672 /// of the attribute.
7673 /// <!-- source ::HAPI_AttributeInfo::totalArrayElements -->
7674 ///
7675 /// @param[in] sizes_fixed_array
7676 /// An array of integers that contains the sizes of each
7677 /// attribute array. This is required because the attribute
7678 /// array for each geometry component can be of variable size.
7679 ///
7680 /// @param[in] start
7681 /// First index of range. Must be at least 0 and at most
7682 /// ::HAPI_AttributeInfo::count - 1.
7683 /// <!-- default 0 -->
7684 ///
7685 /// @param[in] sizes_fixed_length
7686 /// Must be at least 0 and at most
7687 /// ::HAPI_AttributeInfo::count - @p start.
7688 /// <!-- source ::HAPI_AttributeInfo::count - start -->
7690  HAPI_NodeId node_id,
7691  HAPI_PartId part_id,
7692  const char* name,
7693  const HAPI_AttributeInfo* attr_info,
7694  const char** data_fixed_array,
7695  int data_fixed_length,
7696  const int* sizes_fixed_array,
7697  int start,
7698  int sizes_fixed_length);
7699 
7700 /// @brief Add a group to the input geo with the given type and name.
7701 ///
7702 /// @ingroup GeometrySetters
7703 ///
7704 /// @param[in] session
7705 /// The session of Houdini you are interacting with.
7706 /// See @ref HAPI_Sessions for more on sessions.
7707 /// Pass NULL to just use the default in-process session.
7708 /// <!-- default NULL -->
7709 ///
7710 /// @param[in] node_id
7711 /// The SOP node id.
7712 ///
7713 /// @param[in] part_id
7714 /// Currently not used. Just pass 0.
7715 ///
7716 /// @param[in] group_type
7717 /// The group type.
7718 ///
7719 /// @param[in] group_name
7720 /// Name of new group to be added.
7721 ///
7722 HAPI_DECL HAPI_AddGroup( const HAPI_Session * session,
7723  HAPI_NodeId node_id,
7724  HAPI_PartId part_id,
7725  HAPI_GroupType group_type,
7726  const char * group_name );
7727 
7728 /// @brief Remove a group from the input geo with the given type and name.
7729 ///
7730 /// @ingroup GeometrySetters
7731 ///
7732 /// @param[in] session
7733 /// The session of Houdini you are interacting with.
7734 /// See @ref HAPI_Sessions for more on sessions.
7735 /// Pass NULL to just use the default in-process session.
7736 /// <!-- default NULL -->
7737 ///
7738 /// @param[in] node_id
7739 /// The SOP node id.
7740 ///
7741 /// @param[in] part_id
7742 /// Currently not used. Just pass 0.
7743 ///
7744 /// @param[in] group_type
7745 /// The group type.
7746 ///
7747 /// @param[in] group_name
7748 /// Name of the group to be removed
7749 ///
7750 HAPI_DECL HAPI_DeleteGroup( const HAPI_Session * session,
7751  HAPI_NodeId node_id,
7752  HAPI_PartId part_id,
7753  HAPI_GroupType group_type,
7754  const char * group_name );
7755 
7756 /// @brief Set group membership.
7757 ///
7758 /// @ingroup GeometrySetters
7759 ///
7760 /// @param[in] session
7761 /// The session of Houdini you are interacting with.
7762 /// See @ref HAPI_Sessions for more on sessions.
7763 /// Pass NULL to just use the default in-process session.
7764 /// <!-- default NULL -->
7765 ///
7766 /// @param[in] node_id
7767 /// The SOP node id.
7768 ///
7769 /// @param[in] part_id
7770 /// Currently not used. Just pass 0.
7771 /// <!-- default 0 -->
7772 ///
7773 /// @param[in] group_type
7774 /// The group type.
7775 ///
7776 /// @param[in] group_name
7777 /// The group name.
7778 ///
7779 /// @param[in] membership_array
7780 /// Array of ints that represent the membership of this
7781 /// group. Should be the size given by
7782 /// ::HAPI_PartInfo_GetElementCountByGroupType() with
7783 /// @p group_type and the ::HAPI_PartInfo of @p part_id.
7784 ///
7785 /// @param[in] start
7786 /// Start offset into the membership array. Must be
7787 /// less than ::HAPI_PartInfo_GetElementCountByGroupType().
7788 /// <!-- default 0 -->
7789 ///
7790 /// @param[in] length
7791 /// Should be less than or equal to the size
7792 /// of @p membership_array. When setting edge group membership,
7793 /// this parameter should be set to the number of points (which
7794 /// are used to implictly define the edges), not to the number
7795 /// edges in the group.
7796 /// <!-- source ::HAPI_PartInfo_GetElementCountByGroupType -->
7797 ///
7799  HAPI_NodeId node_id,
7800  HAPI_PartId part_id,
7801  HAPI_GroupType group_type,
7802  const char * group_name,
7803  const int * membership_array,
7804  int start, int length );
7805 
7806 /// @brief Commit the current input geometry to the cook engine. Nodes
7807 /// that use this geometry node will re-cook using the input
7808 /// geometry given through the geometry setter API calls.
7809 ///
7810 /// @ingroup GeometrySetters
7811 ///
7812 /// @param[in] session
7813 /// The session of Houdini you are interacting with.
7814 /// See @ref HAPI_Sessions for more on sessions.
7815 /// Pass NULL to just use the default in-process session.
7816 /// <!-- default NULL -->
7817 ///
7818 /// @param[in] node_id
7819 /// The SOP node id.
7820 ///
7821 HAPI_DECL HAPI_CommitGeo( const HAPI_Session * session,
7822  HAPI_NodeId node_id );
7823 
7824 /// @brief Remove all changes that have been committed to this
7825 /// geometry. If this is an intermediate result node (Edit SOP), all
7826 /// deltas will be removed. If it's any other type of node, the node
7827 /// will be unlocked if it is locked.
7828 ///
7829 /// @ingroup GeometrySetters
7830 ///
7831 /// @param[in] session
7832 /// The session of Houdini you are interacting with.
7833 /// See @ref HAPI_Sessions for more on sessions.
7834 /// Pass NULL to just use the default in-process session.
7835 /// <!-- default NULL -->
7836 ///
7837 /// @param[in] node_id
7838 /// The SOP node id.
7839 ///
7840 HAPI_DECL HAPI_RevertGeo( const HAPI_Session * session,
7841  HAPI_NodeId node_id );
7842 
7843 /// @defgroup Materials
7844 /// Functions for working with materials
7845 
7846 /// @brief Get material ids by face/primitive. The material ids returned
7847 /// will be valid as long as the asset is alive. You should query
7848 /// this list after every cook to see if the material assignments
7849 /// have changed. You should also query each material individually
7850 /// using ::HAPI_GetMaterialInfo() to see if it is dirty and needs
7851 /// to be re-imported.
7852 ///
7853 /// @ingroup Materials
7854 ///
7855 /// @param[in] session
7856 /// The session of Houdini you are interacting with.
7857 /// See @ref HAPI_Sessions for more on sessions.
7858 /// Pass NULL to just use the default in-process session.
7859 /// <!-- default NULL -->
7860 ///
7861 /// @param[in] geometry_node_id
7862 /// The geometry node id.
7863 ///
7864 /// @param[in] part_id
7865 /// The part id.
7866 ///
7867 /// @param[out] are_all_the_same
7868 /// (optional) If true, all faces on this part have the
7869 /// same material assignment. You can pass NULL here.
7870 ///
7871 /// @param[out] material_ids_array
7872 /// An array of ::HAPI_NodeId at least the size of
7873 /// @p length and at most the size of
7874 /// ::HAPI_PartInfo::faceCount.
7875 ///
7876 /// @param[in] start
7877 /// The starting index into the list of faces from which
7878 /// you wish to get the material ids from. Note that
7879 /// this should be less than ::HAPI_PartInfo::faceCount.
7880 /// <!-- default 0 -->
7881 ///
7882 /// @param[in] length
7883 /// The number of material ids you wish to get. Note that
7884 /// this should be at most:
7885 /// ::HAPI_PartInfo::faceCount - @p start.
7886 /// <!-- source ::HAPI_PartInfo::faceCount - start -->
7887 ///
7889  HAPI_NodeId geometry_node_id,
7890  HAPI_PartId part_id,
7891  HAPI_Bool * are_all_the_same,
7892  HAPI_NodeId * material_ids_array,
7893  int start, int length );
7894 
7895 /// @brief Get the material info.
7896 ///
7897 /// @ingroup Materials
7898 ///
7899 /// @param[in] session
7900 /// The session of Houdini you are interacting with.
7901 /// See @ref HAPI_Sessions for more on sessions.
7902 /// Pass NULL to just use the default in-process session.
7903 /// <!-- default NULL -->
7904 ///
7905 /// @param[in] material_node_id
7906 /// The material node id.
7907 ///
7908 /// @param[out] material_info
7909 /// The returned material info.
7910 ///
7912  HAPI_NodeId material_node_id,
7913  HAPI_MaterialInfo * material_info );
7914 
7915 /// @brief Render a single texture from a COP to an image for
7916 /// later extraction.
7917 ///
7918 /// @ingroup Materials
7919 ///
7920 /// Note that you must call this first for any of the other material
7921 /// APIs to work.
7922 ///
7923 /// @param[in] session
7924 /// The session of Houdini you are interacting with.
7925 /// See @ref HAPI_Sessions for more on sessions.
7926 /// Pass NULL to just use the default in-process session.
7927 /// <!-- default NULL -->
7928 ///
7929 /// @param[in] cop_node_id
7930 /// The COP node id.
7931 ///
7933  HAPI_NodeId cop_node_id );
7934 
7935 /// @brief Render only a single texture to an image for later extraction.
7936 /// An example use of this method might be to render the diffuse,
7937 /// normal, and bump texture maps of a material to individual
7938 /// texture files for use within the client application.
7939 ///
7940 /// Note that you must call this first for any of the other material
7941 /// APIs to work.
7942 ///
7943 /// @ingroup Materials
7944 ///
7945 /// @param[in] session
7946 /// The session of Houdini you are interacting with.
7947 /// See @ref HAPI_Sessions for more on sessions.
7948 /// Pass NULL to just use the default in-process session.
7949 /// <!-- default NULL -->
7950 ///
7951 /// @param[in] material_node_id
7952 /// The material node id.
7953 ///
7954 /// @param[in] parm_id
7955 /// This is the index in the parameter list of the
7956 /// material_id's node of the parameter containing the
7957 /// texture map file path.
7958 ///
7960  HAPI_NodeId material_node_id,
7961  HAPI_ParmId parm_id );
7962 
7963 /// @brief Get information about the image that was just rendered, like
7964 /// resolution and default file format. This information will be
7965 /// used when extracting planes to an image.
7966 ///
7967 /// Note that you must call ::HAPI_RenderTextureToImage() first for
7968 /// this method call to make sense.
7969 ///
7970 /// @ingroup Materials
7971 ///
7972 /// @param[in] session
7973 /// The session of Houdini you are interacting with.
7974 /// See @ref HAPI_Sessions for more on sessions.
7975 /// Pass NULL to just use the default in-process session.
7976 /// <!-- default NULL -->
7977 ///
7978 /// @param[in] material_node_id
7979 /// The material node id.
7980 ///
7981 /// @param[out] image_info
7982 /// The struct containing the image information.
7983 ///
7984 HAPI_DECL HAPI_GetImageInfo( const HAPI_Session * session,
7985  HAPI_NodeId material_node_id,
7986  HAPI_ImageInfo * image_info );
7987 
7988 /// @brief Set image information like resolution and file format.
7989 /// This information will be used when extracting planes to
7990 /// an image.
7991 ///
7992 /// Note that you must call ::HAPI_RenderTextureToImage() first for
7993 /// this method call to make sense.
7994 ///
7995 /// You should also first call ::HAPI_GetImageInfo() to get the
7996 /// current Image Info and change only the properties
7997 /// you don't like.
7998 ///
7999 /// @ingroup Materials
8000 ///
8001 /// @param[in] session
8002 /// The session of Houdini you are interacting with.
8003 /// See @ref HAPI_Sessions for more on sessions.
8004 /// Pass NULL to just use the default in-process session.
8005 /// <!-- default NULL -->
8006 ///
8007 /// @param[in] material_node_id
8008 /// The material node id.
8009 ///
8010 /// @param[in] image_info
8011 /// The struct containing the new image information.
8012 ///
8013 HAPI_DECL HAPI_SetImageInfo( const HAPI_Session * session,
8014  HAPI_NodeId material_node_id,
8015  const HAPI_ImageInfo * image_info );
8016 
8017 /// @brief Get the number of image planes for the just rendered image.
8018 ///
8019 /// Note that you must call ::HAPI_RenderTextureToImage() first for
8020 /// this method call to make sense.
8021 ///
8022 /// @ingroup Materials
8023 ///
8024 /// @param[in] session
8025 /// The session of Houdini you are interacting with.
8026 /// See @ref HAPI_Sessions for more on sessions.
8027 /// Pass NULL to just use the default in-process session.
8028 /// <!-- default NULL -->
8029 ///
8030 /// @param[in] material_node_id
8031 /// The material node id.
8032 ///
8033 /// @param[out] image_plane_count
8034 /// The number of image planes.
8035 ///
8037  HAPI_NodeId material_node_id,
8038  int * image_plane_count );
8039 
8040 /// @brief Get the names of the image planes of the just rendered image.
8041 ///
8042 /// Note that you must call ::HAPI_RenderTextureToImage() first for
8043 /// this method call to make sense.
8044 ///
8045 /// You should also call ::HAPI_GetImagePlaneCount() first to get
8046 /// the total number of image planes so you know how large the
8047 /// image_planes string handle array should be.
8048 ///
8049 /// @ingroup Materials
8050 ///
8051 /// @param[in] session
8052 /// The session of Houdini you are interacting with.
8053 /// See @ref HAPI_Sessions for more on sessions.
8054 /// Pass NULL to just use the default in-process session.
8055 /// <!-- default NULL -->
8056 ///
8057 /// @param[in] material_node_id
8058 /// The material node id.
8059 ///
8060 /// @param[out] image_planes_array
8061 /// The image plane names.
8062 ///
8063 /// @param[in] image_plane_count
8064 /// The number of image planes to get names for. This
8065 /// must be less than or equal to the count returned
8066 /// by ::HAPI_GetImagePlaneCount().
8067 /// <!-- source ::HAPI_GetImagePlaneCount -->
8068 ///
8069 HAPI_DECL HAPI_GetImagePlanes( const HAPI_Session * session,
8070  HAPI_NodeId material_node_id,
8071  HAPI_StringHandle * image_planes_array,
8072  int image_plane_count );
8073 
8074 /// @brief Extract a rendered image to a file.
8075 ///
8076 /// Note that you must call ::HAPI_RenderTextureToImage() first for
8077 /// this method call to make sense.
8078 ///
8079 /// @ingroup Materials
8080 ///
8081 /// @param[in] session
8082 /// The session of Houdini you are interacting with.
8083 /// See @ref HAPI_Sessions for more on sessions.
8084 /// Pass NULL to just use the default in-process session.
8085 /// <!-- default NULL -->
8086 ///
8087 /// @param[in] material_node_id
8088 /// The material node id.
8089 ///
8090 /// @param[in] image_file_format_name
8091 /// The image file format name you wish the image to be
8092 /// extracted as. You can leave this parameter NULL to
8093 /// get the image in the original format if it comes from
8094 /// another texture file or in the default HAPI format,
8095 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
8096 /// is generated.
8097 ///
8098 /// You can get some of the very common standard image
8099 /// file format names from HAPI_Common.h under the
8100 /// "Defines" section.
8101 ///
8102 /// You can also get a list of all supported file formats
8103 /// (and the exact names this parameter expects)
8104 /// by using ::HAPI_GetSupportedImageFileFormats(). This
8105 /// list will include custom file formats you created via
8106 /// custom DSOs (see HDK docs about IMG_Format). You will
8107 /// get back a list of ::HAPI_ImageFileFormat. This
8108 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
8109 /// of a given image file format.
8110 ///
8111 /// @param[in] image_planes
8112 /// The image planes you wish to extract into the file.
8113 /// Multiple image planes should be separated by spaces.
8114 ///
8115 /// @param[in] destination_folder_path
8116 /// The folder where the image file should be created.
8117 ///
8118 /// @param[in] destination_file_name
8119 /// Optional parameter to overwrite the name of the
8120 /// extracted texture file. This should NOT include
8121 /// the extension as the file type will be decided
8122 /// by the ::HAPI_ImageInfo you can set using
8123 /// ::HAPI_SetImageInfo(). You still have to use
8124 /// destination_file_path to get the final file path.
8125 ///
8126 /// Pass in NULL to have the file name be automatically
8127 /// generated from the name of the material SHOP node,
8128 /// the name of the texture map parameter if the
8129 /// image was rendered from a texture, and the image
8130 /// plane names specified.
8131 ///
8132 /// @param[out] destination_file_path
8133 /// The full path string handle, including the
8134 /// destination_folder_path and the texture file name,
8135 /// to the extracted file. Note that this string handle
8136 /// will only be valid until the next call to
8137 /// this function.
8138 ///
8140  HAPI_NodeId material_node_id,
8141  const char * image_file_format_name,
8142  const char * image_planes,
8143  const char * destination_folder_path,
8144  const char * destination_file_name,
8145  int * destination_file_path );
8146 /// @brief Get the file name that this image would be saved to
8147 ///
8148 /// Check to see what file path HAPI_ExtractImageToFile would have
8149 /// saved to given the same parms. Perhaps you might wish to see
8150 /// if it already exists before extracting.
8151 ///
8152 /// @ingroup Materials
8153 ///
8154 /// @param[in] session
8155 /// The session of Houdini you are interacting with.
8156 /// See @ref HAPI_Sessions for more on sessions.
8157 /// Pass NULL to just use the default in-process session.
8158 /// <!-- default NULL -->
8159 ///
8160 /// @param[in] material_node_id
8161 /// The material node id.
8162 ///
8163 /// @param[in] image_file_format_name
8164 /// The image file format name you wish the image to be
8165 /// extracted as. See HAPI_ExtractImageToFile for more information.
8166 ///
8167 /// @param[in] image_planes
8168 /// The image planes you wish to extract into the file.
8169 /// Multiple image planes should be separated by spaces.
8170 ///
8171 /// @param[in] destination_folder_path
8172 /// The folder where the image file sould be created.
8173 ///
8174 /// @param[in] destination_file_name
8175 /// Optional parameter to overwrite the name of the
8176 /// extracted texture file. See HAPI_ExtractImageToFile for more information.
8177 ///
8178 /// @param[in] texture_parm_id
8179 /// The index in the parameter list of the material node.
8180 /// of the parameter containing the texture map file path
8181 ///
8182 /// @param[out] destination_file_path
8183 /// The full path string handle, including the
8184 /// destination_folder_path and the texture file name,
8185 /// to the extracted file. Note that this string handle
8186 /// will only be valid until the next call to
8187 /// this function.
8188 ///
8190  HAPI_NodeId material_node_id,
8191  const char * image_file_format_name,
8192  const char * image_planes,
8193  const char * destination_folder_path,
8194  const char * destination_file_name,
8195  HAPI_ParmId texture_parm_id,
8196  int * destination_file_path );
8197 
8198 /// @brief Extract a rendered image to memory.
8199 ///
8200 /// Note that you must call ::HAPI_RenderTextureToImage() first for
8201 /// this method call to make sense.
8202 ///
8203 /// Also note that this function will do all the work of
8204 /// extracting and compositing the image into a memory buffer
8205 /// but will not return to you that buffer, only its size. Use
8206 /// the returned size to allocated a sufficiently large buffer
8207 /// and call ::HAPI_GetImageMemoryBuffer() to fill your buffer
8208 /// with the just extracted image.
8209 ///
8210 /// @ingroup Materials
8211 ///
8212 /// @param[in] session
8213 /// The session of Houdini you are interacting with.
8214 /// See @ref HAPI_Sessions for more on sessions.
8215 /// Pass NULL to just use the default in-process session.
8216 /// <!-- default NULL -->
8217 ///
8218 /// @param[in] material_node_id
8219 /// The material node id.
8220 ///
8221 /// @param[in] image_file_format_name
8222 /// The image file format name you wish the image to be
8223 /// extracted as. You can leave this parameter NULL to
8224 /// get the image in the original format if it comes from
8225 /// another texture file or in the default HAPI format,
8226 /// which is ::HAPI_DEFAULT_IMAGE_FORMAT_NAME, if the image
8227 /// is generated.
8228 ///
8229 /// You can get some of the very common standard image
8230 /// file format names from HAPI_Common.h under the
8231 /// "Defines" section.
8232 ///
8233 /// You can also get a list of all supported file formats
8234 /// (and the exact names this parameter expects)
8235 /// by using ::HAPI_GetSupportedImageFileFormats(). This
8236 /// list will include custom file formats you created via
8237 /// custom DSOs (see HDK docs about IMG_Format). You will
8238 /// get back a list of ::HAPI_ImageFileFormat. This
8239 /// parameter expects the ::HAPI_ImageFileFormat::nameSH
8240 /// of a given image file format.
8241 ///
8242 /// @param[in] image_planes
8243 /// The image planes you wish to extract into the file.
8244 /// Multiple image planes should be separated by spaces.
8245 ///
8246 /// @param[out] buffer_size
8247 /// The extraction will be done to an internal buffer
8248 /// who's size you get via this parameter. Use the
8249 /// returned buffer_size when calling
8250 /// ::HAPI_GetImageMemoryBuffer() to get the image
8251 /// buffer you just extracted.
8252 ///
8254  HAPI_NodeId material_node_id,
8255  const char * image_file_format_name,
8256  const char * image_planes,
8257  int * buffer_size );
8258 
8259 /// @brief Fill your allocated buffer with the just extracted
8260 /// image buffer.
8261 ///
8262 /// Note that you must call ::HAPI_RenderTextureToImage() first for
8263 /// this method call to make sense.
8264 ///
8265 /// Also note that you must call ::HAPI_ExtractImageToMemory()
8266 /// first in order to perform the extraction and get the
8267 /// extracted image buffer size that you need to know how much
8268 /// memory to allocated to fit your extracted image.
8269 ///
8270 /// @ingroup Materials
8271 ///
8272 /// @param[in] session
8273 /// The session of Houdini you are interacting with.
8274 /// See @ref HAPI_Sessions for more on sessions.
8275 /// Pass NULL to just use the default in-process session.
8276 /// <!-- default NULL -->
8277 ///
8278 /// @param[in] material_node_id
8279 /// The material node id.
8280 ///
8281 /// @param[out] buffer
8282 /// The buffer passed in here will be filled with the
8283 /// image buffer created during the call to
8284 /// ::HAPI_ExtractImageToMemory().
8285 ///
8286 /// @param[in] length
8287 /// Sanity check. This size should be the same as the
8288 /// size allocated for the buffer passed in and should
8289 /// be at least as large as the buffer_size returned by
8290 /// the call to ::HAPI_ExtractImageToMemory().
8291 /// <!-- source ::HAPI_ExtractImageToMemory -->
8292 ///
8294  HAPI_NodeId material_node_id,
8295  char * buffer, int length );
8296 
8297 /// @brief Get the number of supported texture file formats.
8298 ///
8299 /// @ingroup Materials
8300 ///
8301 /// @param[in] session
8302 /// The session of Houdini you are interacting with.
8303 /// See @ref HAPI_Sessions for more on sessions.
8304 /// Pass NULL to just use the default in-process session.
8305 /// <!-- default NULL -->
8306 ///
8307 /// @param[out] file_format_count
8308 /// The number of supported texture file formats.
8309 ///
8311  int * file_format_count );
8312 
8313 /// @brief Get a list of support image file formats - their names,
8314 /// descriptions and a list of recognized extensions.
8315 ///
8316 /// Note that you MUST call
8317 /// ::HAPI_GetSupportedImageFileFormatCount()
8318 /// before calling this function for the first time.
8319 ///
8320 /// @ingroup Materials
8321 ///
8322 /// @param[in] session
8323 /// The session of Houdini you are interacting with.
8324 /// See @ref HAPI_Sessions for more on sessions.
8325 /// Pass NULL to just use the default in-process session.
8326 /// <!-- default NULL -->
8327 ///
8328 /// @param[out] formats_array
8329 /// The list of ::HAPI_ImageFileFormat structs to
8330 /// be filled.
8331 ///
8332 /// @param[in] file_format_count
8333 /// The number of supported texture file formats. This
8334 /// should be at least as large as the count returned
8335 /// by ::HAPI_GetSupportedImageFileFormatCount().
8336 /// <!-- source ::HAPI_GetSupportedImageFileFormatCount -->
8337 ///
8339  const HAPI_Session * session,
8340  HAPI_ImageFileFormat * formats_array,
8341  int file_format_count );
8342 
8343 /// @defgroup Animation
8344 /// Functions for working with animation.
8345 
8346 /// @brief Set an animation curve on a parameter of an exposed node.
8347 ///
8348 /// @ingroup Animation
8349 ///
8350 /// @param[in] session
8351 /// The session of Houdini you are interacting with.
8352 /// See @ref HAPI_Sessions for more on sessions.
8353 /// Pass NULL to just use the default in-process session.
8354 /// <!-- default NULL -->
8355 ///
8356 /// @param[in] node_id
8357 /// The exposed node id.
8358 ///
8359 /// @param[in] parm_id
8360 /// The id of an exposed parameter within the node.
8361 /// @param[in] parm_index
8362 /// The index of the parameter, if it is for example
8363 /// a 3 tuple
8364 ///
8365 /// @param[in] curve_keyframes_array
8366 /// An array of ::HAPI_Keyframe structs that describes
8367 /// the keys on this curve.
8368 ///
8369 /// @param[in] keyframe_count
8370 /// The number of keys on the curve.
8371 ///
8372 HAPI_DECL HAPI_SetAnimCurve( const HAPI_Session * session,
8373  HAPI_NodeId node_id, HAPI_ParmId parm_id,
8374  int parm_index,
8375  const HAPI_Keyframe * curve_keyframes_array,
8376  int keyframe_count );
8377 
8378 /// @brief A specialized convenience function to set the T,R,S values
8379 /// on an exposed node.
8380 ///
8381 /// @ingroup Animation
8382 ///
8383 /// @param[in] session
8384 /// The session of Houdini you are interacting with.
8385 /// See @ref HAPI_Sessions for more on sessions.
8386 /// Pass NULL to just use the default in-process session.
8387 /// <!-- default NULL -->
8388 ///
8389 /// @param[in] node_id
8390 /// The exposed node id.
8391 ///
8392 /// @param[in] trans_comp
8393 /// A value of ::HAPI_TransformComponent that
8394 /// identifies the particular component of the
8395 /// transform to attach the curve to, for example
8396 /// ::HAPI_TRANSFORM_TX.
8397 ///
8398 /// @param[in] curve_keyframes_array
8399 /// An array of ::HAPI_Keyframe structs that describes
8400 /// the keys on this curve.
8401 ///
8402 /// @param[in] keyframe_count
8403 /// The number of keys on the curve.
8404 ///
8406  const HAPI_Session * session,
8407  HAPI_NodeId node_id,
8408  HAPI_TransformComponent trans_comp,
8409  const HAPI_Keyframe * curve_keyframes_array,
8410  int keyframe_count );
8411 
8412 /// @brief Resets the simulation cache of the asset. This is very useful
8413 /// for assets that use dynamics, to be called after some
8414 /// setup has changed for the asset - for example, asset inputs
8415 ///
8416 /// @ingroup Time
8417 ///
8418 /// @param[in] session
8419 /// The session of Houdini you are interacting with.
8420 /// See @ref HAPI_Sessions for more on sessions.
8421 /// Pass NULL to just use the default in-process session.
8422 /// <!-- default NULL -->
8423 ///
8424 /// @param[in] node_id
8425 /// The asset node id.
8426 ///
8428  HAPI_NodeId node_id );
8429 
8430 /// @defgroup Volumes
8431 /// Functions for working with Volume data
8432 
8433 /// @brief Retrieve any meta-data about the volume primitive, including
8434 /// its transform, location, scale, taper, resolution.
8435 ///
8436 /// @ingroup Volumes
8437 ///
8438 /// @param[in] session
8439 /// The session of Houdini you are interacting with.
8440 /// See @ref HAPI_Sessions for more on sessions.
8441 /// Pass NULL to just use the default in-process session.
8442 /// <!-- default NULL -->
8443 ///
8444 /// @param[in] node_id
8445 /// The node id.
8446 ///
8447 /// @param[in] part_id
8448 /// The part id.
8449 ///
8450 /// @param[out] volume_info
8451 /// The meta-data associated with the volume on the
8452 /// part specified by the previous parameters.
8453 ///
8454 HAPI_DECL HAPI_GetVolumeInfo( const HAPI_Session * session,
8455  HAPI_NodeId node_id,
8456  HAPI_PartId part_id,
8457  HAPI_VolumeInfo * volume_info );
8458 
8459 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
8460 /// Start iterating through the value of the volume at part_id.
8461 ///
8462 /// @ingroup Volumes
8463 ///
8464 /// @param[in] session
8465 /// The session of Houdini you are interacting with.
8466 /// See @ref HAPI_Sessions for more on sessions.
8467 /// Pass NULL to just use the default in-process session.
8468 /// <!-- default NULL -->
8469 ///
8470 /// @param[in] node_id
8471 /// The node id.
8472 ///
8473 /// @param[in] part_id
8474 /// The part id.
8475 ///
8476 /// @param[out] tile
8477 /// The tile info referring to the first tile in the
8478 /// volume at part_id.
8479 ///
8481  HAPI_NodeId node_id,
8482  HAPI_PartId part_id,
8483  HAPI_VolumeTileInfo * tile );
8484 
8485 /// @brief Iterate through a volume based on 8x8x8 sections of the volume
8486 /// Continue iterating through the value of the volume at part_id.
8487 ///
8488 /// @ingroup Volumes
8489 ///
8490 /// @param[in] session
8491 /// The session of Houdini you are interacting with.
8492 /// See @ref HAPI_Sessions for more on sessions.
8493 /// Pass NULL to just use the default in-process session.
8494 /// <!-- default NULL -->
8495 ///
8496 /// @param[in] node_id
8497 /// The node id.
8498 ///
8499 /// @param[in] part_id
8500 /// The part id.
8501 ///
8502 /// @param[out] tile
8503 /// The tile info referring to the next tile in the
8504 /// set of tiles associated with the volume at this part.
8505 ///
8507  HAPI_NodeId node_id,
8508  HAPI_PartId part_id,
8509  HAPI_VolumeTileInfo * tile );
8510 
8511 /// @brief Retrieve floating point values of the voxel at a specific
8512 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
8513 /// to this call.
8514 ///
8515 /// @ingroup Volumes
8516 ///
8517 /// @param[in] session
8518 /// The session of Houdini you are interacting with.
8519 /// See @ref HAPI_Sessions for more on sessions.
8520 /// Pass NULL to just use the default in-process session.
8521 /// <!-- default NULL -->
8522 ///
8523 /// @param[in] node_id
8524 /// The node id.
8525 ///
8526 /// @param[in] part_id
8527 /// The part id.
8528 ///
8529 /// @param[in] x_index
8530 /// The x index/coordinate of the voxel.
8531 ///
8532 /// @param[in] y_index
8533 /// The y index/coordinate of the voxel.
8534 ///
8535 /// @param[in] z_index
8536 /// The z index/coordinate of the voxel.
8537 ///
8538 /// @param[out] values_array
8539 /// The values of the voxel.
8540 ///
8541 /// @param[in] value_count
8542 /// Should be equal to the volume's
8543 /// ::HAPI_VolumeInfo::tupleSize.
8544 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
8545 ///
8547  HAPI_NodeId node_id,
8548  HAPI_PartId part_id,
8549  int x_index,
8550  int y_index,
8551  int z_index,
8552  float * values_array,
8553  int value_count );
8554 
8555 /// @brief Retrieve floating point values of the voxels pointed to
8556 /// by a tile. Note that a tile may extend beyond the limits
8557 /// of the volume so not all values in the given buffer will
8558 /// be written to. Voxels outside the volume will be initialized
8559 /// to the given fill value.
8560 ///
8561 /// @ingroup Volumes
8562 ///
8563 /// @param[in] session
8564 /// The session of Houdini you are interacting with.
8565 /// See @ref HAPI_Sessions for more on sessions.
8566 /// Pass NULL to just use the default in-process session.
8567 /// <!-- default NULL -->
8568 ///
8569 /// @param[in] node_id
8570 /// The node id.
8571 ///
8572 /// @param[in] part_id
8573 /// The part id.
8574 ///
8575 /// @param[in] fill_value
8576 /// Value that will be used to fill the @p values_array.
8577 /// This is useful so that you can see what values
8578 /// have actually been written to.
8579 ///
8580 /// @param[in] tile
8581 /// The tile to retrieve.
8582 ///
8583 /// @param[out] values_array
8584 /// The values of the tile.
8585 ///
8586 /// @param[in] length
8587 /// The length should be ( 8 ^ 3 ) * tupleSize.
8588 ///
8590  HAPI_NodeId node_id,
8591  HAPI_PartId part_id,
8592  float fill_value,
8593  const HAPI_VolumeTileInfo * tile,
8594  float * values_array,
8595  int length );
8596 
8597 /// @brief Retrieve integer point values of the voxel at a specific
8598 /// index. Note that you must call ::HAPI_GetVolumeInfo() prior
8599 /// to this call.
8600 ///
8601 /// @ingroup Volumes
8602 ///
8603 /// @param[in] session
8604 /// The session of Houdini you are interacting with.
8605 /// See @ref HAPI_Sessions for more on sessions.
8606 /// Pass NULL to just use the default in-process session.
8607 /// <!-- default NULL -->
8608 ///
8609 /// @param[in] node_id
8610 /// The node id.
8611 ///
8612 /// @param[in] part_id
8613 /// The part id.
8614 ///
8615 /// @param[in] x_index
8616 /// The x index/coordinate of the voxel.
8617 ///
8618 /// @param[in] y_index
8619 /// The y index/coordinate of the voxel.
8620 ///
8621 /// @param[in] z_index
8622 /// The z index/coordinate of the voxel.
8623 ///
8624 /// @param[out] values_array
8625 /// The values of the voxel.
8626 ///
8627 /// @param[in] value_count
8628 /// Should be equal to the volume's
8629 /// ::HAPI_VolumeInfo::tupleSize.
8630 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
8631 ///
8633  HAPI_NodeId node_id,
8634  HAPI_PartId part_id,
8635  int x_index,
8636  int y_index,
8637  int z_index,
8638  int * values_array,
8639  int value_count );
8640 
8641 /// @brief Retrieve integer point values of the voxels pointed to
8642 /// by a tile. Note that a tile may extend beyond the limits
8643 /// of the volume so not all values in the given buffer will
8644 /// be written to. Voxels outside the volume will be initialized
8645 /// to the given fill value.
8646 ///
8647 /// @ingroup Volumes
8648 ///
8649 /// @param[in] session
8650 /// The session of Houdini you are interacting with.
8651 /// See @ref HAPI_Sessions for more on sessions.
8652 /// Pass NULL to just use the default in-process session.
8653 /// <!-- default NULL -->
8654 ///
8655 /// @param[in] node_id
8656 /// The node id.
8657 ///
8658 /// @param[in] part_id
8659 /// The part id.
8660 ///
8661 /// @param[in] fill_value
8662 /// Value that will be used to fill the @p values_array.
8663 /// This is useful so that you can see what values
8664 /// have actually been written to.
8665 ///
8666 /// @param[in] tile
8667 /// The tile to retrieve.
8668 ///
8669 /// @param[out] values_array
8670 /// The values of the tile.
8671 ///
8672 /// @param[in] length
8673 /// The length should be ( 8 ^ 3 ) * tupleSize.
8674 ///
8676  HAPI_NodeId node_id,
8677  HAPI_PartId part_id,
8678  int fill_value,
8679  const HAPI_VolumeTileInfo * tile,
8680  int * values_array,
8681  int length );
8682 
8683 /// @brief Get the height field data for a terrain volume as a flattened
8684 /// 2D array of float heights. Should call ::HAPI_GetVolumeInfo()
8685 /// first to make sure the volume info is initialized.
8686 ///
8687 /// @ingroup Volumes
8688 ///
8689 /// @param[in] session
8690 /// The session of Houdini you are interacting with.
8691 /// See @ref HAPI_Sessions for more on sessions.
8692 /// Pass NULL to just use the default in-process session.
8693 /// <!-- default NULL -->
8694 ///
8695 /// @param[in] node_id
8696 /// The node id.
8697 ///
8698 /// @param[in] part_id
8699 /// The part id.
8700 ///
8701 /// @param[out] values_array
8702 /// Heightfield flattened array. Should be at least the size of
8703 /// @p start + @p length.
8704 ///
8705 /// @param[in] start
8706 /// The start at least 0 and at most
8707 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength )
8708 /// - @p length.
8709 ///
8710 /// @param[in] length
8711 /// The length should be at least 1 or at most
8712 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength )
8713 /// - @p start.
8714 ///
8716  HAPI_NodeId node_id,
8717  HAPI_PartId part_id,
8718  float * values_array,
8719  int start, int length );
8720 
8721 /// @brief Set the volume info of a geo on a geo input.
8722 ///
8723 /// @ingroup Volumes
8724 ///
8725 /// @param[in] session
8726 /// The session of Houdini you are interacting with.
8727 /// See @ref HAPI_Sessions for more on sessions.
8728 /// Pass NULL to just use the default in-process session.
8729 /// <!-- default NULL -->
8730 ///
8731 /// @param[in] node_id
8732 /// The node id.
8733 ///
8734 /// @param[in] part_id
8735 /// The part id.
8736 ///
8737 /// @param[in] volume_info
8738 /// All volume information that can be specified per
8739 /// volume. This includes the position, orientation, scale,
8740 /// data format, tuple size, and taper. The tile size is
8741 /// always 8x8x8.
8742 ///
8743 HAPI_DECL HAPI_SetVolumeInfo( const HAPI_Session * session,
8744  HAPI_NodeId node_id,
8745  HAPI_PartId part_id,
8746  const HAPI_VolumeInfo * volume_info );
8747 
8748 /// @brief Set the values of a float tile: this is an 8x8x8 subsection of
8749 /// the volume.
8750 ///
8751 /// @ingroup Volumes
8752 ///
8753 /// @param[in] session
8754 /// The session of Houdini you are interacting with.
8755 /// See @ref HAPI_Sessions for more on sessions.
8756 /// Pass NULL to just use the default in-process session.
8757 /// <!-- default NULL -->
8758 ///
8759 /// @param[in] node_id
8760 /// The node id.
8761 ///
8762 /// @param[in] part_id
8763 /// The part id.
8764 ///
8765 /// @param[in] tile
8766 /// The tile that the volume will be input into.
8767 ///
8768 /// @param[in] values_array
8769 /// The values of the individual voxel tiles in the
8770 /// volume. The length of this array should
8771 /// be ( 8 ^ 3 ) * tupleSize.
8772 ///
8773 /// @param[in] length
8774 /// The length should be ( 8 ^ 3 ) * tupleSize.
8775 ///
8777  HAPI_NodeId node_id,
8778  HAPI_PartId part_id,
8779  const HAPI_VolumeTileInfo * tile,
8780  const float * values_array,
8781  int length );
8782 
8783 /// @brief Set the values of an int tile: this is an 8x8x8 subsection of
8784 /// the volume.
8785 ///
8786 /// @ingroup Volumes
8787 ///
8788 /// @param[in] session
8789 /// The session of Houdini you are interacting with.
8790 /// See @ref HAPI_Sessions for more on sessions.
8791 /// Pass NULL to just use the default in-process session.
8792 /// <!-- default NULL -->
8793 ///
8794 /// @param[in] node_id
8795 /// The node id.
8796 ///
8797 /// @param[in] part_id
8798 /// The part id.
8799 ///
8800 /// @param[in] tile
8801 /// The tile that the volume will be input into.
8802 ///
8803 /// @param[in] values_array
8804 /// The values of the individual voxel tiles in the
8805 /// volume. The length of this array should
8806 /// be ( 8 ^ 3 ) * tupleSize.
8807 ///
8808 /// @param[in] length
8809 /// The length should be ( 8 ^ 3 ) * tupleSize.
8810 ///
8812  HAPI_NodeId node_id,
8813  HAPI_PartId part_id,
8814  const HAPI_VolumeTileInfo * tile,
8815  const int * values_array,
8816  int length );
8817 
8818 /// @brief Set the values of a float voxel in the volume.
8819 ///
8820 /// @ingroup Volumes
8821 ///
8822 /// @param[in] session
8823 /// The session of Houdini you are interacting with.
8824 /// See @ref HAPI_Sessions for more on sessions.
8825 /// Pass NULL to just use the default in-process session.
8826 /// <!-- default NULL -->
8827 ///
8828 /// @param[in] node_id
8829 /// The node id.
8830 ///
8831 /// @param[in] part_id
8832 /// The part id.
8833 ///
8834 /// @param[in] x_index
8835 /// The x index/coordinate of the voxel.
8836 ///
8837 /// @param[in] y_index
8838 /// The y index/coordinate of the voxel.
8839 ///
8840 /// @param[in] z_index
8841 /// The z index/coordinate of the voxel.
8842 ///
8843 /// @param[in] values_array
8844 /// The values of the voxel.
8845 ///
8846 /// @param[in] value_count
8847 /// Should be equal to the volume's
8848 /// ::HAPI_VolumeInfo::tupleSize.
8849 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
8850 ///
8852  HAPI_NodeId node_id,
8853  HAPI_PartId part_id,
8854  int x_index,
8855  int y_index,
8856  int z_index,
8857  const float * values_array,
8858  int value_count );
8859 
8860 /// @brief Set the values of a integer voxel in the volume.
8861 ///
8862 /// @ingroup Volumes
8863 ///
8864 /// @param[in] session
8865 /// The session of Houdini you are interacting with.
8866 /// See @ref HAPI_Sessions for more on sessions.
8867 /// Pass NULL to just use the default in-process session.
8868 /// <!-- default NULL -->
8869 ///
8870 /// @param[in] node_id
8871 /// The node id.
8872 ///
8873 /// @param[in] part_id
8874 /// The part id.
8875 ///
8876 /// @param[in] x_index
8877 /// The x index/coordinate of the voxel.
8878 ///
8879 /// @param[in] y_index
8880 /// The y index/coordinate of the voxel.
8881 ///
8882 /// @param[in] z_index
8883 /// The z index/coordinate of the voxel.
8884 ///
8885 /// @param[in] values_array
8886 /// The values of the voxel.
8887 ///
8888 /// @param[in] value_count
8889 /// Should be equal to the volume's
8890 /// ::HAPI_VolumeInfo::tupleSize.
8891 /// <!-- source ::HAPI_VolumeInfo::tupleSize -->
8892 ///
8894  HAPI_NodeId node_id,
8895  HAPI_PartId part_id,
8896  int x_index,
8897  int y_index,
8898  int z_index,
8899  const int * values_array,
8900  int value_count );
8901 
8902 /// @brief Get the bounding values of a volume.
8903 ///
8904 /// @ingroup Volumes
8905 ///
8906 /// @param[in] session
8907 /// The session of Houdini you are interacting with.
8908 /// See @ref HAPI_Sessions for more on sessions.
8909 /// Pass NULL to just use the default in-process session.
8910 /// <!-- default NULL -->
8911 ///
8912 /// @param[in] node_id
8913 /// The node id.
8914 ///
8915 /// @param[in] part_id
8916 /// The part id.
8917 ///
8918 /// @param[out] x_min
8919 /// The minimum x value of the volume's bounding box.
8920 /// Can be null if you do not want this value.
8921 ///
8922 /// @param[out] y_min
8923 /// The minimum y value of the volume's bounding box.
8924 /// Can be null if you do not want this value.
8925 ///
8926 /// @param[out] z_min
8927 /// The minimum z value of the volume's bounding box.
8928 /// Can be null if you do not want this value.
8929 ///
8930 /// @param[out] x_max
8931 /// The maximum x value of the volume's bounding box.
8932 /// Can be null if you do not want this value.
8933 ///
8934 /// @param[out] y_max
8935 /// The maximum y value of the volume's bounding box.
8936 /// Can be null if you do not want this value.
8937 ///
8938 /// @param[out] z_max
8939 /// The maximum z value of the volume's bounding box.
8940 /// Can be null if you do not want this value.
8941 ///
8942 /// @param[out] x_center
8943 /// The x value of the volume's bounding box center.
8944 /// Can be null if you do not want this value.
8945 ///
8946 /// @param[out] y_center
8947 /// The y value of the volume's bounding box center.
8948 /// Can be null if you do not want this value.
8949 ///
8950 /// @param[out] z_center
8951 /// The z value of the volume's bounding box center.
8952 /// Can be null if you do not want this value.
8953 ///
8955  HAPI_NodeId node_id,
8956  HAPI_PartId part_id,
8957  float * x_min, float * y_min, float * z_min,
8958  float * x_max, float * y_max, float * z_max,
8959  float * x_center, float * y_center, float * z_center );
8960 
8961 /// @brief Set the height field data for a terrain volume with the values from
8962 /// a flattened 2D array of float.
8963 /// ::HAPI_SetVolumeInfo() should be called first to make sure that the
8964 /// volume and its info are initialized.
8965 ///
8966 /// @ingroup Volumes
8967 ///
8968 /// @param[in] session
8969 /// The session of Houdini you are interacting with.
8970 /// See @ref HAPI_Sessions for more on sessions.
8971 /// Pass NULL to just use the default in-process session.
8972 /// <!-- default NULL -->
8973 ///
8974 /// @param[in] node_id
8975 /// The node id.
8976 ///
8977 /// @param[in] part_id
8978 /// The part id.
8979 ///
8980 /// @param[in] values_array
8981 /// Heightfield flattened array. Should be at least the size of
8982 /// @p start + @p length.
8983 ///
8984 /// @param[in] start
8985 /// The start at least 0 and at most
8986 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength ) - @p length.
8987 ///
8988 /// @param[in] length
8989 /// The length should be at least 1 or at most
8990 /// ( ::HAPI_VolumeInfo::xLength * ::HAPI_VolumeInfo::yLength ) - @p start.
8991 ///
8992 /// @param[in] name
8993 /// The name of the volume used for the heightfield.
8994 /// If set to "height" the values will be used for height information,
8995 /// if not, the data will used as a mask.
8996 ///
8998  HAPI_NodeId node_id,
8999  HAPI_PartId part_id,
9000  const char * name,
9001  const float * values_array,
9002  int start, int length );
9003 
9004 /// @brief Retrieve the visualization meta-data of the volume.
9005 ///
9006 /// @ingroup Volumes
9007 ///
9008 /// @param[in] session
9009 /// The session of Houdini you are interacting with.
9010 /// See @ref HAPI_Sessions for more on sessions.
9011 /// Pass NULL to just use the default in-process session.
9012 /// <!-- default NULL -->
9013 ///
9014 /// @param[in] node_id
9015 /// The node id.
9016 ///
9017 /// @param[in] part_id
9018 /// The part id.
9019 ///
9020 /// @param[out] visual_info
9021 /// The meta-data associated with the visualization
9022 /// settings of the part specified by the previous
9023 /// parameters.
9024 ///
9026  HAPI_NodeId node_id,
9027  HAPI_PartId part_id,
9028  HAPI_VolumeVisualInfo * visual_info );
9029 
9030 /// @defgroup Curves
9031 /// Functions for working with curves
9032 
9033 /// @brief Retrieve any meta-data about the curves, including the
9034 /// curve's type, order, and periodicity.
9035 ///
9036 /// @ingroup Curves
9037 ///
9038 /// @param[in] session
9039 /// The session of Houdini you are interacting with.
9040 /// See @ref HAPI_Sessions for more on sessions.
9041 /// Pass NULL to just use the default in-process session.
9042 /// <!-- default NULL -->
9043 ///
9044 /// @param[in] node_id
9045 /// The node id.
9046 ///
9047 /// @param[in] part_id
9048 /// The part id.
9049 ///
9050 /// @param[out] info
9051 /// The curve info represents the meta-data about
9052 /// the curves, including the type, order,
9053 /// and periodicity.
9054 ///
9055 HAPI_DECL HAPI_GetCurveInfo( const HAPI_Session * session,
9056  HAPI_NodeId node_id,
9057  HAPI_PartId part_id,
9058  HAPI_CurveInfo * info );
9059 
9060 /// @brief Retrieve the number of vertices for each curve in the part.
9061 ///
9062 /// @ingroup Curves
9063 ///
9064 /// @param[in] session
9065 /// The session of Houdini you are interacting with.
9066 /// See @ref HAPI_Sessions for more on sessions.
9067 /// Pass NULL to just use the default in-process session.
9068 /// <!-- default NULL -->
9069 ///
9070 /// @param[in] node_id
9071 /// The node id.
9072 ///
9073 /// @param[in] part_id
9074 /// The part id.
9075 ///
9076 /// @param[out] counts_array
9077 /// The number of cvs each curve contains
9078 ///
9079 /// @param[in] start
9080 /// The index of the first curve.
9081 /// <!-- default 0 -->
9082 ///
9083 /// @param[in] length
9084 /// The number of curves' counts to retrieve.
9085 ///
9086 HAPI_DECL HAPI_GetCurveCounts( const HAPI_Session * session,
9087  HAPI_NodeId node_id,
9088  HAPI_PartId part_id,
9089  int * counts_array,
9090  int start, int length );
9091 
9092 /// @brief Retrieve the orders for each curve in the part if the
9093 /// curve has varying order.
9094 ///
9095 /// @ingroup Curves
9096 ///
9097 /// @param[in] session
9098 /// The session of Houdini you are interacting with.
9099 /// See @ref HAPI_Sessions for more on sessions.
9100 /// Pass NULL to just use the default in-process session.
9101 /// <!-- default NULL -->
9102 ///
9103 /// @param[in] node_id
9104 /// The node id.
9105 ///
9106 /// @param[in] part_id
9107 /// The part id.
9108 ///
9109 /// @param[out] orders_array
9110 /// The order of each curve will be returned in this
9111 /// array.
9112 ///
9113 /// @param[in] start
9114 /// The index of the first curve.
9115 /// <!-- default 0 -->
9116 ///
9117 /// @param[in] length
9118 /// The number of curves' orders to retrieve.
9119 ///
9120 HAPI_DECL HAPI_GetCurveOrders( const HAPI_Session * session,
9121  HAPI_NodeId node_id,
9122  HAPI_PartId part_id,
9123  int * orders_array,
9124  int start, int length );
9125 
9126 /// @brief Retrieve the knots of the curves in this part.
9127 ///
9128 /// @ingroup Curves
9129 ///
9130 /// @param[in] session
9131 /// The session of Houdini you are interacting with.
9132 /// See @ref HAPI_Sessions for more on sessions.
9133 /// Pass NULL to just use the default in-process session.
9134 /// <!-- default NULL -->
9135 ///
9136 /// @param[in] node_id
9137 /// The node id.
9138 ///
9139 /// @param[in] part_id
9140 /// The part id.
9141 ///
9142 /// @param[out] knots_array
9143 /// The knots of each curve will be returned in this
9144 /// array.
9145 ///
9146 /// @param[in] start
9147 /// The index of the first curve.
9148 /// <!-- default 0 -->
9149 ///
9150 /// @param[in] length
9151 /// The number of curves' knots to retrieve. The
9152 /// length of all the knots on a single curve is
9153 /// the order of that curve plus the number of
9154 /// vertices (see ::HAPI_GetCurveOrders(),
9155 /// and ::HAPI_GetCurveCounts()).
9156 ///
9157 HAPI_DECL HAPI_GetCurveKnots( const HAPI_Session * session,
9158  HAPI_NodeId node_id,
9159  HAPI_PartId part_id,
9160  float * knots_array,
9161  int start, int length );
9162 
9163 /// @brief Set meta-data for the curve mesh, including the
9164 /// curve type, order, and periodicity.
9165 ///
9166 /// @ingroup Curves
9167 ///
9168 /// @param[in] session
9169 /// The session of Houdini you are interacting with.
9170 /// See @ref HAPI_Sessions for more on sessions.
9171 /// Pass NULL to just use the default in-process session.
9172 /// <!-- default NULL -->
9173 ///
9174 /// @param[in] node_id
9175 /// The node id.
9176 ///
9177 /// @param[in] part_id
9178 /// Currently unused. Input asset geos are assumed
9179 /// to have only one part.
9180 ///
9181 /// @param[in] info
9182 /// The curve info represents the meta-data about
9183 /// the curves, including the type, order,
9184 /// and periodicity.
9185 ///
9186 HAPI_DECL HAPI_SetCurveInfo( const HAPI_Session * session,
9187  HAPI_NodeId node_id,
9188  HAPI_PartId part_id,
9189  const HAPI_CurveInfo * info );
9190 
9191 /// @brief Set the number of vertices for each curve in the part.
9192 ///
9193 /// @ingroup Curves
9194 ///
9195 /// @param[in] session
9196 /// The session of Houdini you are interacting with.
9197 /// See @ref HAPI_Sessions for more on sessions.
9198 /// Pass NULL to just use the default in-process session.
9199 /// <!-- default NULL -->
9200 ///
9201 /// @param[in] node_id
9202 /// The node id.
9203 ///
9204 /// @param[in] part_id
9205 /// Currently unused. Input asset geos are assumed
9206 /// to have only one part.
9207 ///
9208 /// @param[in] counts_array
9209 /// The number of cvs each curve contains.
9210 ///
9211 /// @param[in] start
9212 /// The index of the first curve.
9213 /// <!-- default 0 -->
9214 ///
9215 /// @param[in] length
9216 /// The number of curves' counts to set.
9217 /// <!-- source arglength(counts_array) -->
9218 ///
9219 HAPI_DECL HAPI_SetCurveCounts( const HAPI_Session * session,
9220  HAPI_NodeId node_id,
9221  HAPI_PartId part_id,
9222  const int * counts_array,
9223  int start, int length );
9224 
9225 /// @brief Set the orders for each curve in the part if the
9226 /// curve has varying order.
9227 ///
9228 /// @ingroup Curves
9229 ///
9230 /// @param[in] session
9231 /// The session of Houdini you are interacting with.
9232 /// See @ref HAPI_Sessions for more on sessions.
9233 /// Pass NULL to just use the default in-process session.
9234 /// <!-- default NULL -->
9235 ///
9236 /// @param[in] node_id
9237 /// The node id.
9238 ///
9239 /// @param[in] part_id
9240 /// Currently unused. Input asset geos are assumed
9241 /// to have only one part.
9242 ///
9243 /// @param[in] orders_array
9244 /// The orders of each curve.
9245 ///
9246 /// @param[in] start
9247 /// The index of the first curve.
9248 /// <!-- default 0 -->
9249 ///
9250 /// @param[in] length
9251 /// The number of curves' orders to retrieve.
9252 /// <!-- source arglength(orders_array) -->
9253 ///
9254 HAPI_DECL HAPI_SetCurveOrders( const HAPI_Session * session,
9255  HAPI_NodeId node_id,
9256  HAPI_PartId part_id,
9257  const int * orders_array,
9258  int start, int length );
9259 
9260 /// @brief Set the knots of the curves in this part.
9261 ///
9262 /// @ingroup Curves
9263 ///
9264 /// @param[in] session
9265 /// The session of Houdini you are interacting with.
9266 /// See @ref HAPI_Sessions for more on sessions.
9267 /// Pass NULL to just use the default in-process session.
9268 /// <!-- default NULL -->
9269 ///
9270 /// @param[in] node_id
9271 /// The node id.
9272 ///
9273 /// @param[in] part_id
9274 /// Currently unused. Input asset geos are assumed
9275 /// to have only one part.
9276 ///
9277 /// @param[in] knots_array
9278 /// The knots of each curve.
9279 ///
9280 /// @param[in] start
9281 /// The index of the first curve.
9282 /// <!-- default 0 -->
9283 ///
9284 /// @param[in] length
9285 /// The number of curves' knots to set. The
9286 /// length of all the knots on a single curve is
9287 /// the order of that curve plus the number of
9288 /// vertices (see ::HAPI_SetCurveOrders(),
9289 /// and ::HAPI_SetCurveCounts()).
9290 ///
9291 HAPI_DECL HAPI_SetCurveKnots( const HAPI_Session * session,
9292  HAPI_NodeId node_id,
9293  HAPI_PartId part_id,
9294  const float * knots_array,
9295  int start, int length );
9296 
9297 // INPUT CURVE INFO ---------------------------------------------------------
9298 
9299 /// @defgroup InputCurves
9300 /// Functions for working with curves
9301 
9302 /// @brief Retrieve meta-data about the input curves, including the
9303 /// curve's type, order, and whether or not the curve is closed and reversed.
9304 ///
9305 /// @ingroup InputCurves
9306 ///
9307 /// @param[in] session
9308 /// The session of Houdini you are interacting with.
9309 /// See @ref HAPI_Sessions for more on sessions.
9310 /// Pass NULL to just use the default in-process session.
9311 /// <!-- default NULL -->
9312 ///
9313 /// @param[in] node_id
9314 /// The node id.
9315 ///
9316 /// @param[in] part_id
9317 /// The part id.
9318 ///
9319 /// @param[out] info
9320 /// The curve info represents the meta-data about
9321 /// the curves, including the type, order,
9322 /// and closed and reversed values.
9323 ///
9325  HAPI_NodeId node_id,
9326  HAPI_PartId part_id,
9327  HAPI_InputCurveInfo * info );
9328 
9329 /// @brief Set meta-data for the input curves, including the
9330 /// curve type, order, reverse and closed properties.
9331 ///
9332 /// @ingroup InputCurves
9333 ///
9334 /// @param[in] session
9335 /// The session of Houdini you are interacting with.
9336 /// See @ref HAPI_Sessions for more on sessions.
9337 /// Pass NULL to just use the default in-process session.
9338 /// <!-- default NULL -->
9339 ///
9340 /// @param[in] node_id
9341 /// The node id.
9342 ///
9343 /// @param[in] part_id
9344 /// Currently unused. Input asset geos are assumed
9345 /// to have only one part.
9346 ///
9347 /// @param[in] info
9348 /// The curve info represents the meta-data about
9349 /// the curves, including the type, order,
9350 /// and closed and reverse properties.
9351 ///
9353  HAPI_NodeId node_id,
9354  HAPI_PartId part_id,
9355  const HAPI_InputCurveInfo * info );
9356 
9357 /// @brief Sets the positions for input curves, doing checks for
9358 /// curve validity, and adjusting the curve settings accordingly.
9359 /// Will also cook the node.
9360 ///
9361 /// @ingroup InputCurves
9362 ///
9363 /// @param[in] session
9364 /// The session of Houdini you are interacting with.
9365 /// See @ref HAPI_Sessions for more on sessions.
9366 /// Pass NULL to just use the default in-process session.
9367 /// <!-- default NULL -->
9368 ///
9369 /// @param[in] node_id
9370 /// The node id.
9371 ///
9372 /// @param[in] part_id
9373 /// Currently unused. Input asset geos are assumed
9374 /// to have only one part.
9375 ///
9376 /// @param[in] positions_array
9377 /// A float array representing the positions attribute.
9378 /// It will read the array assuming a tuple size of 3.
9379 /// Note that this function does not do any coordinate axes
9380 /// conversion.
9381 ///
9382 /// @param[in] start
9383 /// The index of the first position in positions_array.
9384 /// <!-- default 0 -->
9385 ///
9386 /// @param[in] length
9387 /// The size of the positions array.
9388 /// <!-- source arglength(positions_array) -->
9389 ///
9391  const HAPI_Session* session,
9392  HAPI_NodeId node_id,
9393  HAPI_PartId part_id,
9394  const float* positions_array,
9395  int start,
9396  int length);
9397 
9398 /// @brief Sets the positions for input curves, doing checks for
9399 /// curve validity, and adjusting the curve settings accordingly.
9400 /// Will also cook the node. Additionally, adds rotation and scale
9401 /// attributes to the curve.
9402 ///
9403 /// @ingroup InputCurves
9404 ///
9405 /// @param[in] session
9406 /// The session of Houdini you are interacting with.
9407 /// See @ref HAPI_Sessions for more on sessions.
9408 /// Pass NULL to just use the default in-process session.
9409 /// <!-- default NULL -->
9410 ///
9411 /// @param[in] node_id
9412 /// The node id.
9413 ///
9414 /// @param[in] part_id
9415 /// Currently unused. Input asset geos are assumed
9416 /// to have only one part.
9417 ///
9418 /// @param[in] positions_array
9419 /// A float array representing the positions attribute.
9420 /// It will read the array assuming a tuple size of 3.
9421 /// Note that this function does not do any coordinate axes
9422 /// conversion.
9423 ///
9424 /// @param[in] positions_array
9425 /// A float array representing the positions attribute.
9426 /// It will read the array assuming a tuple size of 3.
9427 /// Note that this function does not do any coordinate axes
9428 /// conversion.
9429 ///
9430 /// @param[in] positions_start
9431 /// The index of the first position in positions_array.
9432 /// <!-- default 0 -->
9433 ///
9434 /// @param[in] positions_length
9435 /// The size of the positions array.
9436 /// <!-- source arglength(positions_array) -->
9437 ///
9438 /// @param[in] rotations_array
9439 /// A float array representing the rotation (rot) attribute.
9440 /// It will read the array assuming a tuple size of 4
9441 /// representing quaternion values
9442 ///
9443 /// @param[in] rotations_start
9444 /// The index of the first rotation in rotations_array.
9445 /// <!-- default 0 -->
9446 ///
9447 /// @param[in] rotations_length
9448 /// The size of the rotations array.
9449 /// <!-- source arglength(rotations_array) -->
9450 ///
9451 /// @param[in] scales_array
9452 /// A float array representing the scale attribute.
9453 /// It will read the array assuming a tuple size of 3
9454 ///
9455 /// @param[in] scales_start
9456 /// The index of the first scale in scales_array.
9457 /// <!-- default 0 -->
9458 ///
9459 /// @param[in] scales_length
9460 /// The size of the scales array.
9461 /// <!-- source arglength(scales_array) -->
9462 ///
9464  const HAPI_Session* session,
9465  HAPI_NodeId node_id,
9466  HAPI_PartId part_id,
9467  const float* positions_array,
9468  int positions_start,
9469  int positions_length,
9470  const float* rotations_array,
9471  int rotations_start,
9472  int rotations_length,
9473  const float * scales_array,
9474  int scales_start,
9475  int scales_length);
9476 
9477 // BASIC PRIMITIVES ---------------------------------------------------------
9478 
9479 /// @brief Get the box info on a geo part (if the part is a box).
9480 ///
9481 /// @ingroup Geometry
9482 ///
9483 /// @param[in] session
9484 /// The session of Houdini you are interacting with.
9485 /// See @ref HAPI_Sessions for more on sessions.
9486 /// Pass NULL to just use the default in-process session.
9487 /// <!-- default NULL -->
9488 ///
9489 /// @param[in] geo_node_id
9490 /// The geo node id.
9491 ///
9492 /// @param[in] part_id
9493 /// The part id of the
9494 ///
9495 /// @param[out] box_info
9496 /// The returned box info.
9497 ///
9498 HAPI_DECL HAPI_GetBoxInfo( const HAPI_Session * session,
9499  HAPI_NodeId geo_node_id,
9500  HAPI_PartId part_id,
9501  HAPI_BoxInfo * box_info );
9502 
9503 /// @brief Get the sphere info on a geo part (if the part is a sphere).
9504 ///
9505 /// @ingroup Geometry
9506 ///
9507 /// @param[in] session
9508 /// The session of Houdini you are interacting with.
9509 /// See @ref HAPI_Sessions for more on sessions.
9510 /// Pass NULL to just use the default in-process session.
9511 /// <!-- default NULL -->
9512 ///
9513 /// @param[in] geo_node_id
9514 /// The geo node id.
9515 ///
9516 /// @param[in] part_id
9517 /// The part id of the
9518 ///
9519 /// @param[out] sphere_info
9520 /// The returned sphere info.
9521 ///
9522 HAPI_DECL HAPI_GetSphereInfo( const HAPI_Session * session,
9523  HAPI_NodeId geo_node_id,
9524  HAPI_PartId part_id,
9525  HAPI_SphereInfo * sphere_info );
9526 
9527 /// @defgroup Caching
9528 /// Functions for working with memory and file caches
9529 
9530 /// @brief Get the number of currently active caches.
9531 ///
9532 /// @ingroup Caching
9533 ///
9534 /// @param[in] session
9535 /// The session of Houdini you are interacting with.
9536 /// See @ref HAPI_Sessions for more on sessions.
9537 /// Pass NULL to just use the default in-process session.
9538 /// <!-- default NULL -->
9539 ///
9540 /// @param[out] active_cache_count
9541 /// The number of currently active caches.
9542 ///
9544  int * active_cache_count );
9545 
9546 /// @brief Get the names of the currently active caches.
9547 ///
9548 /// Requires a valid active cache count which you get from:
9549 /// ::HAPI_GetActiveCacheCount().
9550 ///
9551 /// @ingroup Caching
9552 ///
9553 /// @param[in] session
9554 /// The session of Houdini you are interacting with.
9555 /// See @ref HAPI_Sessions for more on sessions.
9556 /// Pass NULL to just use the default in-process session.
9557 /// <!-- default NULL -->
9558 ///
9559 /// @param[out] cache_names_array
9560 /// String array with the returned cache names. Must be
9561 /// at least the size of @a active_cache_count.
9562 ///
9563 /// @param[in] active_cache_count
9564 /// The count returned by ::HAPI_GetActiveCacheCount().
9565 /// <!-- source ::HAPI_GetActiveCacheCount -->
9566 ///
9568  HAPI_StringHandle * cache_names_array,
9569  int active_cache_count );
9570 
9571 /// @brief Lets you inspect specific properties of the different memory
9572 /// caches in the current Houdini context.
9573 ///
9574 /// @ingroup Caching
9575 ///
9576 /// @param[in] session
9577 /// The session of Houdini you are interacting with.
9578 /// See @ref HAPI_Sessions for more on sessions.
9579 /// Pass NULL to just use the default in-process session.
9580 /// <!-- default NULL -->
9581 ///
9582 /// @param[in] cache_name
9583 /// Cache name from ::HAPI_GetActiveCacheNames().
9584 ///
9585 /// @param[in] cache_property
9586 /// The specific property of the cache to get the value for.
9587 ///
9588 /// @param[out] property_value
9589 /// Returned property value.
9590 ///
9592  const char * cache_name,
9593  HAPI_CacheProperty cache_property,
9594  int * property_value );
9595 
9596 /// @brief Lets you modify specific properties of the different memory
9597 /// caches in the current Houdini context. This includes clearing
9598 /// caches, reducing their memory use, or changing how memory limits
9599 /// are respected by a cache.
9600 ///
9601 /// @ingroup Caching
9602 ///
9603 /// @param[in] session
9604 /// The session of Houdini you are interacting with.
9605 /// See @ref HAPI_Sessions for more on sessions.
9606 /// Pass NULL to just use the default in-process session.
9607 /// <!-- default NULL -->
9608 ///
9609 /// @param[in] cache_name
9610 /// Cache name from ::HAPI_GetActiveCacheNames().
9611 ///
9612 /// @param[in] cache_property
9613 /// The specific property of the cache to modify.
9614 ///
9615 /// @param[in] property_value
9616 /// The new property value.
9617 ///
9619  const char * cache_name,
9620  HAPI_CacheProperty cache_property,
9621  int property_value );
9622 
9623 /// @brief Saves a geometry to file. The type of file to save is
9624 /// to be determined by the extension ie. .bgeo, .obj
9625 ///
9626 /// @ingroup Caching
9627 ///
9628 /// @param[in] session
9629 /// The session of Houdini you are interacting with.
9630 /// See @ref HAPI_Sessions for more on sessions.
9631 /// Pass NULL to just use the default in-process session.
9632 /// <!-- default NULL -->
9633 ///
9634 /// @param[in] node_id
9635 /// The node id.
9636 ///
9637 /// @param[in] file_name
9638 /// The name of the file to be saved. The extension
9639 /// of the file determines its type.
9640 ///
9641 HAPI_DECL HAPI_SaveGeoToFile( const HAPI_Session * session,
9642  HAPI_NodeId node_id,
9643  const char * file_name );
9644 
9645 /// @brief Loads a geometry file and put its contents onto a SOP
9646 /// node.
9647 ///
9648 /// @ingroup Caching
9649 ///
9650 /// @param[in] session
9651 /// The session of Houdini you are interacting with.
9652 /// See @ref HAPI_Sessions for more on sessions.
9653 /// Pass NULL to just use the default in-process session.
9654 /// <!-- default NULL -->
9655 ///
9656 /// @param[in] node_id
9657 /// The node id.
9658 ///
9659 /// @param[in] file_name
9660 /// The name of the file to be loaded
9661 ///
9663  HAPI_NodeId node_id,
9664  const char * file_name );
9665 
9666 /// @brief Saves the node and all its contents to file.
9667 /// The saved file can be loaded by calling ::HAPI_LoadNodeFromFile.
9668 ///
9669 /// @ingroup Caching
9670 ///
9671 /// @param[in] session
9672 /// The session of Houdini you are interacting with.
9673 /// See @ref HAPI_Sessions for more on sessions.
9674 /// Pass NULL to just use the default in-process session.
9675 /// <!-- default NULL -->
9676 ///
9677 /// @param[in] node_id
9678 /// The node id.
9679 ///
9680 /// @param[in] file_name
9681 /// The name of the file to be saved. The extension
9682 /// of the file determines its type.
9683 ///
9684 HAPI_DECL HAPI_SaveNodeToFile( const HAPI_Session * session,
9685  HAPI_NodeId node_id,
9686  const char * file_name );
9687 
9688 /// @brief Loads and creates a previously saved node and all
9689 /// its contents from given file.
9690 /// The saved file must have been created by calling
9691 /// ::HAPI_SaveNodeToFile.
9692 ///
9693 /// @ingroup Caching
9694 ///
9695 /// @param[in] session
9696 /// The session of Houdini you are interacting with.
9697 /// See @ref HAPI_Sessions for more on sessions.
9698 /// Pass NULL to just use the default in-process session.
9699 /// <!-- default NULL -->
9700 ///
9701 /// @param[in] file_name
9702 /// The name of the file to be loaded
9703 ///
9704 /// @param[in] parent_node_id
9705 /// The parent node id of the Geometry object.
9706 ///
9707 /// @param[in] node_label
9708 /// The name of the new Geometry object.
9709 ///
9710 /// @param[in] cook_on_load
9711 /// Set to true if you wish the nodes to cook as soon
9712 /// as they are created. Otherwise, you will have to
9713 /// call ::HAPI_CookNode() explicitly for each after you
9714 /// call this function.
9715 ///
9716 /// @param[out] new_node_id
9717 /// The newly created node id.
9718 ///
9720  const char * file_name,
9721  HAPI_NodeId parent_node_id,
9722  const char * node_label,
9723  HAPI_Bool cook_on_load,
9724  HAPI_NodeId * new_node_id );
9725 
9726 /// @brief Cache the current state of the geo to memory, given the
9727 /// format, and return the size. Use this size with your call
9728 /// to ::HAPI_SaveGeoToMemory() to copy the cached geo to your
9729 /// buffer. It is guaranteed that the size will not change between
9730 /// your call to ::HAPI_GetGeoSize() and ::HAPI_SaveGeoToMemory().
9731 ///
9732 /// @ingroup Caching
9733 ///
9734 /// @param[in] session
9735 /// The session of Houdini you are interacting with.
9736 /// See @ref HAPI_Sessions for more on sessions.
9737 /// Pass NULL to just use the default in-process session.
9738 /// <!-- default NULL -->
9739 ///
9740 /// @param[in] node_id
9741 /// The node id.
9742 ///
9743 /// @param[in] format
9744 /// The file format, ie. ".obj", ".bgeo.sc" etc.
9745 ///
9746 /// @param[out] size
9747 /// The size of the buffer required to hold the output.
9748 ///
9749 HAPI_DECL HAPI_GetGeoSize( const HAPI_Session * session,
9750  HAPI_NodeId node_id,
9751  const char * format,
9752  int * size );
9753 
9754 /// @brief Saves the cached geometry to your buffer in memory,
9755 /// whose format and required size is identified by the call to
9756 /// ::HAPI_GetGeoSize(). The call to ::HAPI_GetGeoSize() is
9757 /// required as ::HAPI_GetGeoSize() does the actual saving work.
9758 ///
9759 /// Also note that this call to ::HAPI_SaveGeoToMemory will delete
9760 /// the internal geo buffer that was cached in the previous call
9761 /// to ::HAPI_GetGeoSize(). This means that you will need to call
9762 /// ::HAPI_GetGeoSize() again before you can call this function.
9763 ///
9764 /// @ingroup Caching
9765 ///
9766 /// @param[in] session
9767 /// The session of Houdini you are interacting with.
9768 /// See @ref HAPI_Sessions for more on sessions.
9769 /// Pass NULL to just use the default in-process session.
9770 /// <!-- default NULL -->
9771 ///
9772 /// @param[in] node_id
9773 /// The node id.
9774 ///
9775 /// @param[out] buffer
9776 /// The buffer we will write into.
9777 ///
9778 /// @param[in] length
9779 /// The size of the buffer passed in.
9780 /// <!-- source ::HAPI_GetGeoSize -->
9781 ///
9783  HAPI_NodeId node_id,
9784  char * buffer,
9785  int length );
9786 
9787 /// @brief Loads a geometry from memory and put its
9788 /// contents onto a SOP node.
9789 ///
9790 /// @ingroup Caching
9791 ///
9792 /// @param[in] session
9793 /// The session of Houdini you are interacting with.
9794 /// See @ref HAPI_Sessions for more on sessions.
9795 /// Pass NULL to just use the default in-process session.
9796 /// <!-- default NULL -->
9797 ///
9798 /// @param[in] node_id
9799 /// The node id.
9800 ///
9801 /// @param[in] format
9802 /// The file format, ie. "obj", "bgeo" etc.
9803 ///
9804 /// @param[in] buffer
9805 /// The buffer we will read the geometry from.
9806 ///
9807 /// @param[in] length
9808 /// The size of the buffer passed in.
9809 /// <!-- source arglength(buffer) -->
9810 ///
9812  HAPI_NodeId node_id,
9813  const char * format,
9814  const char * buffer,
9815  int length );
9816 
9817 /// @brief Set the specified node's display flag.
9818 ///
9819 /// @ingroup Nodes
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 node id.
9829 ///
9830 /// @param[in] onOff
9831 /// Display flag.
9832 ///
9833 HAPI_DECL HAPI_SetNodeDisplay( const HAPI_Session * session,
9834  HAPI_NodeId node_id,
9835  int onOff );
9836 
9837 /// @brief Get the specified node's total cook count, including
9838 /// its children, if specified.
9839 ///
9840 /// @ingroup Nodes
9841 ///
9842 /// @param[in] session
9843 /// The session of Houdini you are interacting with.
9844 /// See @ref HAPI_Sessions for more on sessions.
9845 /// Pass NULL to just use the default in-process session.
9846 /// <!-- default NULL -->
9847 ///
9848 /// @param[in] node_id
9849 /// The node id.
9850 ///
9851 /// @param[in] node_type_filter
9852 /// The node type by which to filter the children.
9853 ///
9854 /// @param[in] node_flags_filter
9855 /// The node flags by which to filter the children.
9856 ///
9857 /// @param[in] recursive
9858 /// Whether or not to include the specified node's
9859 /// children cook count in the tally.
9860 ///
9861 /// @param[out] count
9862 /// The number of cooks in total for this session.
9863 ///
9865  HAPI_NodeId node_id,
9866  HAPI_NodeTypeBits node_type_filter,
9867  HAPI_NodeFlagsBits node_flags_filter,
9868  HAPI_Bool recursive,
9869  int * count );
9870 
9871 /// @defgroup SessionSync
9872 /// Functions for working with SessionSync
9873 
9874 /// @brief Enable or disable SessionSync mode.
9875 ///
9876 /// @ingroup SessionSync
9877 ///
9878 /// @param[in] session
9879 /// The session of Houdini you are interacting with.
9880 /// See @ref HAPI_Sessions for more on sessions.
9881 /// Pass NULL to just use the default in-process session.
9882 /// <!-- default NULL -->
9883 ///
9884 /// @param[in] enable
9885 /// Enable or disable SessionSync mode.
9886 ///
9887 HAPI_DECL HAPI_SetSessionSync( const HAPI_Session * session,
9888  HAPI_Bool enable );
9889 
9890 /// @brief Get the ::HAPI_Viewport info for synchronizing viewport in
9891 /// SessionSync. When SessionSync is running this will
9892 /// return Houdini's current viewport information.
9893 ///
9894 /// @ingroup SessionSync
9895 ///
9896 /// @param[in] session
9897 /// The session of Houdini you are interacting with.
9898 /// See @ref HAPI_Sessions for more on sessions.
9899 /// Pass NULL to just use the default in-process session.
9900 ///
9901 /// @param[out] viewport
9902 /// The output ::HAPI_Viewport.
9903 ///
9904 HAPI_DECL HAPI_GetViewport( const HAPI_Session * session,
9905  HAPI_Viewport * viewport );
9906 
9907 /// @brief Set the ::HAPI_Viewport info for synchronizing viewport in
9908 /// SessionSync. When SessionSync is running, this can be
9909 /// used to set the viewport information which Houdini
9910 /// will then synchronizse with for its viewport.
9911 ///
9912 /// @ingroup SessionSync
9913 ///
9914 /// @param[in] session
9915 /// The session of Houdini you are interacting with.
9916 /// See @ref HAPI_Sessions for more on sessions.
9917 /// Pass NULL to just use the default in-process session.
9918 ///
9919 /// @param[in] viewport
9920 /// A ::HAPI_Viewport that stores the viewport.
9921 ///
9922 HAPI_DECL HAPI_SetViewport( const HAPI_Session * session,
9923  const HAPI_Viewport * viewport );
9924 
9925 /// @brief Get the ::HAPI_SessionSyncInfo for synchronizing SessionSync
9926 /// state between Houdini and Houdini Engine integrations.
9927 ///
9928 /// @ingroup SessionSync
9929 ///
9930 /// @param[in] session
9931 /// The session of Houdini you are interacting with.
9932 /// See @ref HAPI_Sessions for more on sessions.
9933 /// Pass NULL to just use the default in-process session.
9934 ///
9935 /// @param[out] session_sync_info
9936 /// The output ::HAPI_SessionSyncInfo.
9937 ///
9939  const HAPI_Session * session,
9940  HAPI_SessionSyncInfo * session_sync_info );
9941 
9942 /// @brief Set the ::HAPI_SessionSyncInfo for synchronizing SessionSync
9943 /// state between Houdini and Houdini Engine integrations.
9944 ///
9945 /// @ingroup SessionSync
9946 ///
9947 /// @param[in] session
9948 /// The session of Houdini you are interacting with.
9949 /// See @ref HAPI_Sessions for more on sessions.
9950 /// Pass NULL to just use the default in-process session.
9951 ///
9952 /// @param[in] session_sync_info
9953 /// A ::HAPI_SessionSyncInfo that stores the state.
9954 ///
9956  const HAPI_Session * session,
9957  const HAPI_SessionSyncInfo * session_sync_info );
9958 
9959 /// @defgroup PDG PDG/TOPs
9960 /// Functions for working with PDG/TOPs
9961 
9962 /// @brief Return an array of PDG graph context names and ids, the first
9963 /// count names will be returned. These ids can be used
9964 /// with ::HAPI_GetPDGEvents and ::HAPI_GetPDGState. The values
9965 /// of the names can be retrieved with ::HAPI_GetString.
9966 ///
9967 /// @ingroup PDG
9968 ///
9969 /// @param[in] session
9970 /// The session of Houdini you are interacting with.
9971 /// See @ref HAPI_Sessions for more on sessions.
9972 /// Pass NULL to just use the default in-process session.
9973 /// <!-- default NULL -->
9974 ///
9975 /// @param[out] context_names_array
9976 /// Array of context names stored as ::HAPI_StringHandle
9977 /// at least the size of length. These can be used
9978 /// with ::HAPI_GetString() and are valid until the
9979 /// next call to this function.
9980 ///
9981 /// @param[out] context_id_array
9982 /// Array of graph context ids at least the size of length.
9983 ///
9984 /// @param[in] start
9985 /// First index of range. Must be at least @c 0 and at most
9986 /// @c context_count - 1 where @c context_count is the count
9987 /// returned by ::HAPI_GetPDGGraphContextsCount()
9988 /// <!-- min 0 -->
9989 /// <!-- max ::HAPI_GetPDGGraphContextsCount -->
9990 /// <!-- default 0 -->
9991 ///
9992 /// @param[in] length
9993 /// Given @c num_contexts returned by ::HAPI_GetPDGGraphContextsCount(),
9994 /// length should be at least @c 0 and at most <tt>num_contexts - start.</tt>
9995 /// <!-- default 0 -->
9997  HAPI_StringHandle * context_names_array,
9998  HAPI_PDG_GraphContextId * context_id_array,
9999  int start,
10000  int length );
10001 
10002 /// @brief Return the total number of PDG graph contexts found.
10003 ///
10004 /// @ingroup PDG
10005 ///
10006 /// @param[in] session
10007 /// The session of Houdini you are interacting with.
10008 /// See @ref HAPI_Sessions for more on sessions.
10009 /// Pass NULL to just use the default in-process session.
10010 /// <!-- default NULL -->
10011 ///
10012 /// @param[out] num_contexts
10013 /// Total PDG graph contexts count.
10014 ///
10016  const HAPI_Session* session,
10017  int* num_contexts );
10018 
10019 /// @brief Get the PDG graph context for the specified TOP node.
10020 ///
10021 /// @ingroup PDG
10022 ///
10023 /// @param[in] session
10024 /// The session of Houdini you are interacting with.
10025 /// See @ref HAPI_Sessions for more on sessions.
10026 /// Pass NULL to just use the default in-process session.
10027 /// <!-- default NULL -->
10028 ///
10029 /// @param[in] top_node_id
10030 /// The id of the TOP node to query its graph context.
10031 ///
10032 /// @param[out] context_id
10033 /// The PDG graph context id.
10034 ///
10036  HAPI_NodeId top_node_id,
10037  HAPI_PDG_GraphContextId * context_id );
10038 
10039 /// @brief Starts a PDG cooking operation. This can be asynchronous.
10040 /// Progress can be checked with ::HAPI_GetPDGState() and
10041 /// ::HAPI_GetPDGState(). Events generated during this cook can be
10042 /// collected with ::HAPI_GetPDGEvents(). Any uncollected events will be
10043 /// discarded at the start of the cook.
10044 ///
10045 /// If there are any $HIPFILE file dependencies on nodes involved in the cook
10046 /// a hip file will be automatically saved to $HOUDINI_TEMP_DIR directory so
10047 /// that it can be copied to the working directory by the scheduler. This means
10048 /// $HIP will be equal to $HOUDINI_TEMP_DIR.
10049 ///
10050 /// @ingroup PDG
10051 ///
10052 /// @param[in] session
10053 /// The session of Houdini you are interacting with.
10054 /// See @ref HAPI_Sessions for more on sessions.
10055 /// Pass NULL to just use the default in-process session.
10056 ///
10057 /// @param[in] cook_node_id
10058 /// The node id of a TOP node for the cook operation.
10059 ///
10060 /// @param[in] generate_only
10061 /// 1 means only static graph generation will done. 0 means
10062 /// a full graph cook. Generation is always blocking.
10063 ///
10064 /// @param[in] blocking
10065 /// 0 means return immediately and cooking will be done
10066 /// asynchronously. 1 means return when cooking completes.
10067 ///
10068 HAPI_DECL HAPI_CookPDG( const HAPI_Session * session,
10069  HAPI_NodeId cook_node_id,
10070  int generate_only,
10071  int blocking );
10072 
10073 /// @brief Starts a PDG cooking operation. This can be asynchronous.
10074 /// Progress can be checked with ::HAPI_GetPDGState() and
10075 /// ::HAPI_GetPDGState(). Events generated during this cook can be
10076 /// collected with ::HAPI_GetPDGEvents(). Any uncollected events will be
10077 /// discarded at the start of the cook.
10078 ///
10079 /// If there are any $HIPFILE file dependencies on nodes involved in the
10080 /// cook a hip file will be automatically saved to $HOUDINI_TEMP_DIR
10081 /// directory so that it can be copied to the working directory by the
10082 /// scheduler. This means $HIP will be equal to $HOUDINI_TEMP_DIR.
10083 ///
10084 /// If cook_node_id is a network / subnet, then if it has output nodes
10085 /// it cooks all of its output nodes and not just output 0. If it does
10086 /// not have output nodes it cooks the node with the output flag.
10087 ///
10088 /// @ingroup PDG
10089 ///
10090 /// @param[in] session
10091 /// The session of Houdini you are interacting with.
10092 /// See @ref HAPI_Sessions for more on sessions.
10093 /// Pass NULL to just use the default in-process session.
10094 ///
10095 /// @param[in] cook_node_id
10096 /// The node id of a TOP node for the cook operation.
10097 ///
10098 /// @param[in] generate_only
10099 /// 1 means only static graph generation will done. 0 means
10100 /// a full graph cook. Generation is always blocking.
10101 ///
10102 /// @param[in] blocking
10103 /// 0 means return immediately and cooking will be done
10104 /// asynchronously. 1 means return when cooking completes.
10105 ///
10107  const HAPI_Session* session,
10108  HAPI_NodeId cook_node_id,
10109  int generate_only,
10110  int blocking);
10111 
10112 /// @brief Returns PDG events that have been collected. Calling this function
10113 /// will remove those events from the queue. Events collection is restarted
10114 /// by calls to ::HAPI_CookPDG().
10115 ///
10116 /// @ingroup PDG
10117 ///
10118 ///
10119 /// @param[in] session
10120 /// The session of Houdini you are interacting with.
10121 /// See @ref HAPI_Sessions for more on sessions.
10122 /// Pass NULL to just use the default in-process session.
10123 /// <!-- default NULL -->
10124 ///
10125 /// @param[in] graph_context_id
10126 /// The id of the graph context
10127 ///
10128 /// @param[out] event_array
10129 /// buffer of ::HAPI_PDG_EventInfo of size at least length.
10130 ///
10131 /// @param[in] length
10132 /// The size of the buffer passed in.
10133 ///
10134 /// @param[out] event_count
10135 /// Number of events removed from queue and copied to buffer.
10136 ///
10137 /// @param[out] remaining_events
10138 /// Number of queued events remaining after this operation.
10139 ///
10140 HAPI_DECL HAPI_GetPDGEvents( const HAPI_Session * session,
10141  HAPI_PDG_GraphContextId graph_context_id,
10142  HAPI_PDG_EventInfo * event_array,
10143  int length,
10144  int * event_count,
10145  int * remaining_events );
10146 
10147 /// @brief Gets the state of a PDG graph
10148 ///
10149 /// @ingroup PDG
10150 ///
10151 ///
10152 /// @param[in] session
10153 /// The session of Houdini you are interacting with.
10154 /// See @ref HAPI_Sessions for more on sessions.
10155 /// Pass NULL to just use the default in-process session.
10156 /// <!-- default NULL -->
10157 ///
10158 /// @param[in] graph_context_id
10159 /// The graph context id
10160 ///
10161 /// @param[out] pdg_state
10162 /// One of ::HAPI_PDG_State.
10163 ///
10164 HAPI_DECL HAPI_GetPDGState( const HAPI_Session * session,
10165  HAPI_PDG_GraphContextId graph_context_id,
10166  int * pdg_state );
10167 
10168 /// @brief Creates a new pending workitem for the given node. The workitem
10169 /// will not be submitted to the graph until it is committed with
10170 /// ::HAPI_CommitWorkitems(). The node is expected to be a generator type.
10171 ///
10172 /// @ingroup PDG
10173 ///
10174 /// @param[in] session
10175 /// The session of Houdini you are interacting with.
10176 /// See @ref HAPI_Sessions for more on sessions.
10177 /// Pass NULL to just use the default in-process session.
10178 /// <!-- default NULL -->
10179 ///
10180 /// @param[in] node_id
10181 /// The node id.
10182 ///
10183 /// @param[out] workitem_id
10184 /// The id of the pending workitem.
10185 ///
10186 /// @param[in] name
10187 /// The null-terminated name of the workitem. The name will
10188 /// be automatically suffixed to make it unique.
10189 ///
10190 /// @param[in] index
10191 /// The index of the workitem. The semantics of the index
10192 /// are user defined.
10193 ///
10196  HAPI_NodeId node_id,
10197  HAPI_PDG_WorkItemId * workitem_id,
10198  const char * name,
10199  int index );
10200 
10201 /// @brief Retrieves the info of a given workitem by id.
10202 ///
10203 /// @ingroup PDG
10204 ///
10205 /// @param[in] session
10206 /// The session of Houdini you are interacting with.
10207 /// See @ref HAPI_Sessions for more on sessions.
10208 /// Pass NULL to just use the default in-process session.
10209 /// <!-- default NULL -->
10210 ///
10211 /// @param[in] graph_context_id
10212 /// The graph context that the workitem is in.
10213 ///
10214 /// @param[in] workitem_id
10215 /// The id of the workitem.
10216 ///
10217 /// @param[out] workitem_info
10218 /// The returned ::HAPI_PDG_WorkItemInfo for the workitem. Note
10219 /// that the enclosed string handle is only valid until the next
10220 /// call to this function.
10221 ///
10224  HAPI_PDG_GraphContextId graph_context_id,
10225  HAPI_PDG_WorkItemId workitem_id,
10226  HAPI_PDG_WorkItemInfo * workitem_info );
10227 
10228 /// @brief Adds integer data to a pending PDG workitem data member for the given node.
10229 ///
10230 /// @ingroup PDG
10231 ///
10232 /// @param[in] session
10233 /// The session of Houdini you are interacting with.
10234 /// See @ref HAPI_Sessions for more on sessions.
10235 /// Pass NULL to just use the default in-process session.
10236 /// <!-- default NULL -->
10237 ///
10238 /// @param[in] node_id
10239 /// The node id.
10240 ///
10241 /// @param[in] workitem_id
10242 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem()
10243 ///
10244 /// @param[in] data_name
10245 /// null-terminated name of the data member
10246 ///
10247 /// @param[in] values_array
10248 /// array of integer values
10249 ///
10250 /// @param[in] length
10251 /// number of values to copy from values_array to the parameter
10252 ///
10255  HAPI_NodeId node_id,
10256  HAPI_PDG_WorkItemId workitem_id,
10257  const char * data_name,
10258  const int * values_array,
10259  int length );
10260 
10261 /// @brief Adds float data to a pending PDG workitem data member for the given node.
10262 ///
10263 /// @ingroup PDG
10264 ///
10265 /// @param[in] session
10266 /// The session of Houdini you are interacting with.
10267 /// See @ref HAPI_Sessions for more on sessions.
10268 /// Pass NULL to just use the default in-process session.
10269 /// <!-- default NULL -->
10270 ///
10271 /// @param[in] node_id
10272 /// The node id.
10273 ///
10274 /// @param[in] workitem_id
10275 /// The id of the pending workitem returned by ::HAPI_CreateWorkitem()
10276 ///
10277 /// @param[in] data_name
10278 /// null-terminated name of the workitem data member
10279 ///
10280 /// @param[in] values_array
10281 /// array of float values
10282 ///
10283 /// @param[in] length
10284 /// number of values to copy from values_array to the parameter
10285 ///
10288  HAPI_NodeId node_id,
10289  HAPI_PDG_WorkItemId workitem_id,
10290  const char * data_name,
10291  const float * values_array,
10292  int length );
10293 
10294 /// @brief Adds integer data to a pending PDG workitem data member for the given node.
10295 ///
10296 /// @ingroup PDG
10297 ///
10298 /// @param[in] session
10299 /// The session of Houdini you are interacting with.
10300 /// See @ref HAPI_Sessions for more on sessions.
10301 /// Pass NULL to just use the default in-process session.
10302 /// <!-- default NULL -->
10303 ///
10304 /// @param[in] node_id
10305 /// The node id.
10306 ///
10307 /// @param[in] workitem_id
10308 /// The id of the created workitem returned by HAPI_CreateWorkitem()
10309 ///
10310 /// @param[in] data_name
10311 /// null-terminated name of the data member
10312 ///
10313 /// @param[in] data_index
10314 /// index of the string data member
10315 ///
10316 /// @param[in] value
10317 /// null-terminated string to copy to the workitem data member
10318 ///
10321  HAPI_NodeId node_id,
10322  HAPI_PDG_WorkItemId workitem_id,
10323  const char * data_name,
10324  int data_index,
10325  const char * value );
10326 
10327 /// @brief Commits any pending workitems.
10328 ///
10329 /// @ingroup PDG
10330 ///
10331 /// @param[in] session
10332 /// The session of Houdini you are interacting with.
10333 /// See @ref HAPI_Sessions for more on sessions.
10334 /// Pass NULL to just use the default in-process session.
10335 /// <!-- default NULL -->
10336 ///
10337 /// @param[in] node_id
10338 /// The node id for which the pending workitems have been
10339 /// created but not yet injected.
10340 ///
10343  HAPI_NodeId node_id );
10344 
10345 /// @brief Gets the number of workitems that are available on the given node.
10346 /// Should be used with ::HAPI_GetWorkitems.
10347 ///
10348 /// @ingroup PDG
10349 ///
10350 /// @param[in] session
10351 /// The session of Houdini you are interacting with.
10352 /// See @ref HAPI_Sessions for more on sessions.
10353 /// Pass NULL to just use the default in-process session.
10354 /// <!-- default NULL -->
10355 ///
10356 /// @param[in] node_id
10357 /// The node id.
10358 ///
10359 /// @param[out] num
10360 /// The number of workitems.
10361 ///
10364  HAPI_NodeId node_id,
10365  int * num );
10366 
10367 /// @brief Gets the list of work item ids for the given node
10368 ///
10369 /// @ingroup PDG
10370 ///
10371 /// @param[in] session
10372 /// The session of Houdini you are interacting with.
10373 /// See @ref HAPI_Sessions for more on sessions.
10374 /// Pass NULL to just use the default in-process session.
10375 /// <!-- default NULL -->
10376 ///
10377 /// @param[in] node_id
10378 /// The node id.
10379 ///
10380 /// @param[out] workitem_ids_array
10381 /// buffer for resulting array of ::HAPI_PDG_WorkItemId
10382 ///
10383 /// @param[in] length
10384 /// The length of the @p workitem_ids buffer
10385 ///
10388  HAPI_NodeId node_id,
10389  int * workitem_ids_array,
10390  int length );
10391 
10392 /// @brief Gets the length of the workitem data member.
10393 /// It is the length of the array of data.
10394 ///
10395 /// @ingroup PDG
10396 ///
10397 /// @param[in] session
10398 /// The session of Houdini you are interacting with.
10399 /// See @ref HAPI_Sessions for more on sessions.
10400 /// Pass NULL to just use the default in-process session.
10401 /// <!-- default NULL -->
10402 ///
10403 /// @param[in] node_id
10404 /// The node id.
10405 ///
10406 /// @param[in] workitem_id
10407 /// The id of the workitem
10408 ///
10409 /// @param[in] data_name
10410 /// null-terminated name of the data member
10411 ///
10412 /// @param[out] length
10413 /// The length of the data member array
10414 ///
10415 HAPI_DECL_DEPRECATED_REPLACE(5.0.0, 19.5.161, HAPI_GetWorkItemDataSize)
10417  HAPI_NodeId node_id,
10418  HAPI_PDG_WorkItemId workitem_id,
10419  const char * data_name,
10420  int * length );
10421 
10422 /// @brief Gets int data from a work item member.
10423 ///
10424 /// @ingroup PDG
10425 ///
10426 /// @param[in] session
10427 /// The session of Houdini you are interacting with.
10428 /// See @ref HAPI_Sessions for more on sessions.
10429 /// Pass NULL to just use the default in-process session.
10430 /// <!-- default NULL -->
10431 ///
10432 /// @param[in] node_id
10433 /// The node id.
10434 ///
10435 /// @param[in] workitem_id
10436 /// The id of the workitem
10437 ///
10438 /// @param[in] data_name
10439 /// null-terminated name of the data member
10440 ///
10441 /// @param[out] data_array
10442 /// buffer of at least size length to copy the data into. The required
10443 /// length should be determined by ::HAPI_GetWorkitemDataLength().
10444 ///
10445 /// @param[in] length
10446 /// The length of @p data_array
10447 ///
10450  HAPI_NodeId node_id,
10451  HAPI_PDG_WorkItemId workitem_id,
10452  const char * data_name,
10453  int * data_array,
10454  int length );
10455 
10456 /// @brief Gets float data from a work item member.
10457 ///
10458 /// @ingroup PDG
10459 ///
10460 /// @param[in] session
10461 /// The session of Houdini you are interacting with.
10462 /// See @ref HAPI_Sessions for more on sessions.
10463 /// Pass NULL to just use the default in-process session.
10464 /// <!-- default NULL -->
10465 ///
10466 /// @param[in] node_id
10467 /// The node id.
10468 ///
10469 /// @param[in] workitem_id
10470 /// The id of the workitem
10471 ///
10472 /// @param[in] data_name
10473 /// null-terminated name of the data member
10474 ///
10475 /// @param[out] data_array
10476 /// buffer of at least size length to copy the data into. The required
10477 /// length should be determined by ::HAPI_GetWorkitemDataLength().
10478 ///
10479 /// @param[in] length
10480 /// The length of the @p data_array
10481 ///
10484  HAPI_NodeId node_id,
10485  HAPI_PDG_WorkItemId workitem_id,
10486  const char * data_name,
10487  float * data_array,
10488  int length );
10489 
10490 /// @brief Gets string ids from a work item member.
10491 ///
10492 /// @ingroup PDG
10493 ///
10494 /// @param[in] session
10495 /// The session of Houdini you are interacting with.
10496 /// See @ref HAPI_Sessions for more on sessions.
10497 /// Pass NULL to just use the default in-process session.
10498 /// <!-- default NULL -->
10499 ///
10500 /// @param[in] node_id
10501 /// The node id.
10502 ///
10503 /// @param[in] workitem_id
10504 /// The id of the workitem
10505 ///
10506 /// @param[in] data_name
10507 /// null-terminated name of the data member
10508 ///
10509 /// @param[out] data_array
10510 /// buffer of at least size length to copy the data into. The required
10511 /// length should be determined by ::HAPI_GetWorkitemDataLength().
10512 /// The data is an array of ::HAPI_StringHandle which can be used with
10513 /// ::HAPI_GetString(). The string handles are valid until the
10514 /// next call to this function.
10515 ///
10516 /// @param[in] length
10517 /// The length of @p data_array
10518 ///
10521  HAPI_NodeId node_id,
10522  HAPI_PDG_WorkItemId workitem_id,
10523  const char * data_name,
10524  HAPI_StringHandle * data_array,
10525  int length );
10526 
10527 /// @brief Gets the info for workitem results.
10528 /// The number of workitem results is found on the ::HAPI_PDG_WorkItemInfo
10529 /// returned by ::HAPI_GetWorkitemInfo()
10530 ///
10531 /// @ingroup PDG
10532 ///
10533 /// @param[in] session
10534 /// The session of Houdini you are interacting with.
10535 /// See @ref HAPI_Sessions for more on sessions.
10536 /// Pass NULL to just use the default in-process session.
10537 /// <!-- default NULL -->
10538 ///
10539 /// @param[in] node_id
10540 /// The node id.
10541 ///
10542 /// @param[in] workitem_id
10543 /// The id of the workitem
10544 ///
10545 /// @param[out] resultinfo_array
10546 /// Buffer to fill with info structs. String handles are valid
10547 /// until the next call of this function.
10548 ///
10549 /// @param[in] resultinfo_count
10550 /// The length of @p resultinfo_array
10551 ///
10554  HAPI_NodeId node_id,
10555  HAPI_PDG_WorkItemId workitem_id,
10556  HAPI_PDG_WorkItemOutputFile * resultinfo_array,
10557  int resultinfo_count );
10558 
10559 /// @brief Creates a new pending work item for the given node. The work item
10560 /// will not be submitted to the graph until it is committed with
10561 /// ::HAPI_CommitWorkItems(). The node is expected to be a generator type.
10562 ///
10563 /// @ingroup PDG
10564 ///
10565 /// @param[in] session
10566 /// The session of Houdini you are interacting with.
10567 /// See @ref HAPI_Sessions for more on sessions.
10568 /// Pass NULL to just use the default in-process session.
10569 /// <!-- default NULL -->
10570 ///
10571 /// @param[in] node_id
10572 /// The node id.
10573 ///
10574 /// @param[out] work_item_id
10575 /// The id of the pending workitem.
10576 ///
10577 /// @param[in] name
10578 /// The null-terminated name of the work item. The name will
10579 /// be automatically suffixed to make it unique.
10580 ///
10581 /// @param[in] index
10582 /// The index of the work item. The semantics of the index
10583 /// are user defined.
10584 ///
10586  HAPI_NodeId node_id,
10587  HAPI_PDG_WorkItemId * work_item_id,
10588  const char * name,
10589  int index );
10590 
10591 /// @brief Retrieves the info of a given work item by id.
10592 ///
10593 /// @ingroup PDG
10594 ///
10595 /// @param[in] session
10596 /// The session of Houdini you are interacting with.
10597 /// See @ref HAPI_Sessions for more on sessions.
10598 /// Pass NULL to just use the default in-process session.
10599 /// <!-- default NULL -->
10600 ///
10601 /// @param[in] graph_context_id
10602 /// The graph context that the work item is in.
10603 ///
10604 /// @param[in] work_item_id
10605 /// The id of the work item.
10606 ///
10607 /// @param[out] work_item_info
10608 /// The returned ::HAPI_PDG_WorkItemInfo for the work item. Note
10609 /// that the enclosed string handle is only valid until the next
10610 /// call to this function.
10611 ///
10613  HAPI_PDG_GraphContextId graph_context_id,
10614  HAPI_PDG_WorkItemId work_item_id,
10615  HAPI_PDG_WorkItemInfo * work_item_info );
10616 
10617 /// @brief Adds integer data to a pending PDG work item attribute for the given node.
10618 ///
10619 /// @ingroup PDG
10620 ///
10621 /// @param[in] session
10622 /// The session of Houdini you are interacting with.
10623 /// See @ref HAPI_Sessions for more on sessions.
10624 /// Pass NULL to just use the default in-process session.
10625 /// <!-- default NULL -->
10626 ///
10627 /// @param[in] node_id
10628 /// The node id.
10629 ///
10630 /// @param[in] work_item_id
10631 /// The id of the pending work item returned by ::HAPI_CreateWorkItem()
10632 ///
10633 /// @param[in] attribute_name
10634 /// null-terminated name of the work item attribute
10635 ///
10636 /// @param[in] values_array
10637 /// array of integer values
10638 ///
10639 /// @param[in] length
10640 /// number of values to copy from values_array to the parameter
10641 ///
10643  HAPI_NodeId node_id,
10644  HAPI_PDG_WorkItemId work_item_id,
10645  const char * attribute_name,
10646  const int * values_array,
10647  int length );
10648 
10649 /// @brief Adds float data to a pending PDG work item attribute for the given node.
10650 ///
10651 /// @ingroup PDG
10652 ///
10653 /// @param[in] session
10654 /// The session of Houdini you are interacting with.
10655 /// See @ref HAPI_Sessions for more on sessions.
10656 /// Pass NULL to just use the default in-process session.
10657 /// <!-- default NULL -->
10658 ///
10659 /// @param[in] node_id
10660 /// The node id.
10661 ///
10662 /// @param[in] work_item_id
10663 /// The id of the pending work item returned by ::HAPI_CreateWorkItem()
10664 ///
10665 /// @param[in] attribute_name
10666 /// null-terminated name of the work item attribute
10667 ///
10668 /// @param[in] values_array
10669 /// array of float values
10670 ///
10671 /// @param[in] length
10672 /// number of values to copy from values_array to the parameter
10673 ///
10675  HAPI_NodeId node_id,
10676  HAPI_PDG_WorkItemId work_item_id,
10677  const char * attribute_name,
10678  const float * values_array,
10679  int length );
10680 
10681 /// @brief Adds integer data to a pending PDG work item attribute for the given node.
10682 ///
10683 /// @ingroup PDG
10684 ///
10685 /// @param[in] session
10686 /// The session of Houdini you are interacting with.
10687 /// See @ref HAPI_Sessions for more on sessions.
10688 /// Pass NULL to just use the default in-process session.
10689 /// <!-- default NULL -->
10690 ///
10691 /// @param[in] node_id
10692 /// The node id.
10693 ///
10694 /// @param[in] work_item_id
10695 /// The id of the created work item returned by HAPI_CreateWorkItem()
10696 ///
10697 /// @param[in] attribute_name
10698 /// null-terminated name of the work item attribute
10699 ///
10700 /// @param[in] data_index
10701 /// index of the string data member
10702 ///
10703 /// @param[in] value
10704 /// null-terminated string to copy to the work item data member
10705 ///
10707  HAPI_NodeId node_id,
10708  HAPI_PDG_WorkItemId work_item_id,
10709  const char * attribute_name,
10710  int data_index,
10711  const char * value );
10712 
10713 /// @brief Commits any pending work items.
10714 ///
10715 /// @ingroup PDG
10716 ///
10717 /// @param[in] session
10718 /// The session of Houdini you are interacting with.
10719 /// See @ref HAPI_Sessions for more on sessions.
10720 /// Pass NULL to just use the default in-process session.
10721 /// <!-- default NULL -->
10722 ///
10723 /// @param[in] node_id
10724 /// The node id for which the pending work items have been
10725 /// created but not yet injected.
10726 ///
10728  HAPI_NodeId node_id );
10729 
10730 /// @brief Gets the number of work items that are available on the given node.
10731 /// Should be used with ::HAPI_GetWorkItems.
10732 ///
10733 /// @ingroup PDG
10734 ///
10735 /// @param[in] session
10736 /// The session of Houdini you are interacting with.
10737 /// See @ref HAPI_Sessions for more on sessions.
10738 /// Pass NULL to just use the default in-process session.
10739 /// <!-- default NULL -->
10740 ///
10741 /// @param[in] node_id
10742 /// The node id.
10743 ///
10744 /// @param[out] num
10745 /// The number of work items.
10746 ///
10748  HAPI_NodeId node_id,
10749  int * num );
10750 
10751 /// @brief Gets the list of work item ids for the given node
10752 ///
10753 /// @ingroup PDG
10754 ///
10755 /// @param[in] session
10756 /// The session of Houdini you are interacting with.
10757 /// See @ref HAPI_Sessions for more on sessions.
10758 /// Pass NULL to just use the default in-process session.
10759 /// <!-- default NULL -->
10760 ///
10761 /// @param[in] node_id
10762 /// The node id.
10763 ///
10764 /// @param[out] work_item_ids_array
10765 /// buffer for resulting array of ::HAPI_PDG_WorkItemId
10766 ///
10767 /// @param[in] length
10768 /// The length of the @p work_item_ids buffer
10769 ///
10771  HAPI_NodeId node_id,
10772  int * work_item_ids_array,
10773  int length );
10774 
10775 /// @brief Gets the size of the work item attribute.
10776 /// It is the length of the array of data.
10777 ///
10778 /// @ingroup PDG
10779 ///
10780 /// @param[in] session
10781 /// The session of Houdini you are interacting with.
10782 /// See @ref HAPI_Sessions for more on sessions.
10783 /// Pass NULL to just use the default in-process session.
10784 /// <!-- default NULL -->
10785 ///
10786 /// @param[in] node_id
10787 /// The node id.
10788 ///
10789 /// @param[in] work_item_id
10790 /// The id of the work item
10791 ///
10792 /// @param[in] attribute_name
10793 /// null-terminated name of the work item attribute
10794 ///
10795 /// @param[out] length
10796 /// The length of the data member array
10797 ///
10799  HAPI_NodeId node_id,
10800  HAPI_PDG_WorkItemId work_item_id,
10801  const char * attribute_name,
10802  int * length );
10803 
10804 /// @brief Gets int data from a work item attribute.
10805 ///
10806 /// @ingroup PDG
10807 ///
10808 /// @param[in] session
10809 /// The session of Houdini you are interacting with.
10810 /// See @ref HAPI_Sessions for more on sessions.
10811 /// Pass NULL to just use the default in-process session.
10812 /// <!-- default NULL -->
10813 ///
10814 /// @param[in] node_id
10815 /// The node id.
10816 ///
10817 /// @param[in] work_item_id
10818 /// The id of the work_item
10819 ///
10820 /// @param[in] attribute_name
10821 /// null-terminated name of the work item attribute
10822 ///
10823 /// @param[out] data_array
10824 /// buffer of at least size length to copy the data into. The required
10825 /// length should be determined by ::HAPI_GetWorkItemDataLength().
10826 ///
10827 /// @param[in] length
10828 /// The length of @p data_array
10829 ///
10831  HAPI_NodeId node_id,
10832  HAPI_PDG_WorkItemId work_item_id,
10833  const char * attribute_name,
10834  int * data_array,
10835  int length );
10836 
10837 /// @brief Gets float data from a work item attribute.
10838 ///
10839 /// @ingroup PDG
10840 ///
10841 /// @param[in] session
10842 /// The session of Houdini you are interacting with.
10843 /// See @ref HAPI_Sessions for more on sessions.
10844 /// Pass NULL to just use the default in-process session.
10845 /// <!-- default NULL -->
10846 ///
10847 /// @param[in] node_id
10848 /// The node id.
10849 ///
10850 /// @param[in] work_item_id
10851 /// The id of the work_item
10852 ///
10853 /// @param[in] attribute_name
10854 /// null-terminated name of the work item attribute
10855 ///
10856 /// @param[out] data_array
10857 /// buffer of at least size length to copy the data into. The required
10858 /// length should be determined by ::HAPI_GetWorkItemDataLength().
10859 ///
10860 /// @param[in] length
10861 /// The length of the @p data_array
10862 ///
10864  HAPI_NodeId node_id,
10865  HAPI_PDG_WorkItemId work_item_id,
10866  const char * attribute_name,
10867  float * data_array,
10868  int length );
10869 
10870 /// @brief Gets string ids from a work item attribute.
10871 ///
10872 /// @ingroup PDG
10873 ///
10874 /// @param[in] session
10875 /// The session of Houdini you are interacting with.
10876 /// See @ref HAPI_Sessions for more on sessions.
10877 /// Pass NULL to just use the default in-process session.
10878 /// <!-- default NULL -->
10879 ///
10880 /// @param[in] node_id
10881 /// The node id.
10882 ///
10883 /// @param[in] work_item_id
10884 /// The id of the work item
10885 ///
10886 /// @param[in] attribute_name
10887 /// null-terminated name of the work item attribute
10888 ///
10889 /// @param[out] data_array
10890 /// buffer of at least size length to copy the data into. The required
10891 /// length should be determined by ::HAPI_GetWorkItemDataLength().
10892 /// The data is an array of ::HAPI_StringHandle which can be used with
10893 /// ::HAPI_GetString(). The string handles are valid until the
10894 /// next call to this function.
10895 ///
10896 /// @param[in] length
10897 /// The length of @p data_array
10898 ///
10900  HAPI_NodeId node_id,
10901  HAPI_PDG_WorkItemId work_item_id,
10902  const char * attribute_name,
10903  HAPI_StringHandle * data_array,
10904  int length );
10905 
10906 /// @brief Gets the info for work item output files.
10907 /// The number of work item results is found on the ::HAPI_PDG_WorkItemInfo
10908 /// returned by ::HAPI_GetWorkItemInfo()
10909 ///
10910 /// @ingroup PDG
10911 ///
10912 /// @param[in] session
10913 /// The session of Houdini you are interacting with.
10914 /// See @ref HAPI_Sessions for more on sessions.
10915 /// Pass NULL to just use the default in-process session.
10916 /// <!-- default NULL -->
10917 ///
10918 /// @param[in] node_id
10919 /// The node id.
10920 ///
10921 /// @param[in] work_item_id
10922 /// The id of the work item
10923 ///
10924 /// @param[out] resultinfo_array
10925 /// Buffer to fill with info structs. String handles are valid
10926 /// until the next call of this function.
10927 ///
10928 /// @param[in] resultinfo_count
10929 /// The length of @p resultinfo_array
10930 ///
10932  HAPI_NodeId node_id,
10933  HAPI_PDG_WorkItemId work_item_id,
10934  HAPI_PDG_WorkItemOutputFile * resultinfo_array,
10935  int resultinfo_count );
10936 
10937 /// @brief Dirties the given node. Cancels the cook if necessary and then
10938 /// deletes all workitems on the node.
10939 ///
10940 /// @ingroup PDG
10941 ///
10942 /// @param[in] session
10943 /// The session of Houdini you are interacting with.
10944 /// See @ref HAPI_Sessions for more on sessions.
10945 /// Pass NULL to just use the default in-process session.
10946 /// <!-- default NULL -->
10947 ///
10948 /// @param[in] node_id
10949 /// The node id.
10950 ///
10951 /// @param[in] clean_results
10952 /// Remove the results generated by the node.
10953 /// <!-- default 0 -->
10954 ///
10956  HAPI_NodeId node_id,
10957  HAPI_Bool clean_results );
10958 
10959 /// @brief Pause the PDG cooking operation.
10960 ///
10961 /// @ingroup PDG
10962 ///
10963 /// @param[in] session
10964 /// The session of Houdini you are interacting with.
10965 /// See @ref HAPI_Sessions for more on sessions.
10966 /// Pass NULL to just use the default in-process session.
10967 /// <!-- default NULL -->
10968 ///
10969 /// @param[in] graph_context_id
10970 /// The id of the graph context
10971 ///
10973  HAPI_PDG_GraphContextId graph_context_id );
10974 
10975 /// @brief Cancel the PDG cooking operation.
10976 ///
10977 /// @ingroup PDG
10978 ///
10979 /// @param[in] session
10980 /// The session of Houdini you are interacting with.
10981 /// See @ref HAPI_Sessions for more on sessions.
10982 /// Pass NULL to just use the default in-process session.
10983 /// <!-- default NULL -->
10984 ///
10985 /// @param[in] graph_context_id
10986 /// The id of the graph context
10987 ///
10989  HAPI_PDG_GraphContextId graph_context_id );
10990 
10991 #endif // __HAPI_h__
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_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:1769
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_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_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_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:503
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.
int16_t HAPI_Int16
Definition: HAPI_Common.h:140
Data for a PDG output file.
Definition: HAPI_Common.h:2015
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:174
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_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:180
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_SessionEnvIntType
Definition: HAPI_Common.h:846
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_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_GetTime(const HAPI_Session *session, float *time)
Gets the global time of the scene. All API calls deal with this time to cook.
HAPI_DECL HAPI_CreateInputCurveNode(const HAPI_Session *session, HAPI_NodeId *node_id, const char *name)
Helper for creating specifically creating a curve input geometry SOP. This will create a dummy OBJ no...
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)
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_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
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_CreateInputNode(const HAPI_Session *session, HAPI_NodeId *node_id, const char *name)
Creates a simple geometry SOP node that can accept geometry input. This will create a dummy OBJ node ...
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_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:751
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_GetImagePlaneCount(const HAPI_Session *session, HAPI_NodeId material_node_id, int *image_plane_count)
Get the number of image planes for the just rendered image.
HAPI_DECL HAPI_CreateHeightFieldInput(const HAPI_Session *session, HAPI_NodeId parent_node_id, const char *name, int xsize, int ysize, float voxelsize, HAPI_HeightFieldSampling sampling, HAPI_NodeId *heightfield_node_id, HAPI_NodeId *height_node_id, HAPI_NodeId *mask_node_id, HAPI_NodeId *merge_node_id)
Creates the required node hierarchy needed for heightfield inputs.
HAPI_DECL HAPI_CreateThriftSocketSession(HAPI_Session *session, const char *host_name, int port)
Creates a Thrift RPC session using a TCP socket as transport.
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:184
HAPI_DECL HAPI_SetCompositorOptions(const HAPI_Session *session, const HAPI_CompositorOptions *compositor_options)
Sets the global compositor options.
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:813
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)
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_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:1998
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_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)
HAPI_DECL HAPI_SetAttributeStringData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const char **data_array, int start, int length)
Set attribute string data.
HAPI_DECL HAPI_GetObjectInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ObjectInfo *object_info)
Get the object info on an OBJ node.
HAPI_DECL HAPI_GetAttributeIntData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, int *data_array, int start, int length)
Get attribute integer data.
HAPI_DECL HAPI_GetParmIntValue(const HAPI_Session *session, HAPI_NodeId node_id, const char *parm_name, int index, int *value)
Get single parm int value by name.
HAPI_DECL HAPI_SetViewport(const HAPI_Session *session, const HAPI_Viewport *viewport)
Set the HAPI_Viewport info for synchronizing viewport in SessionSync. When SessionSync is running...
HAPI_DECL HAPI_GetCookingTotalCount(const HAPI_Session *session, int *count)
Get total number of nodes that need to cook in the current session.
HAPI_DECL HAPI_GetNodePath(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_NodeId relative_to_node_id, HAPI_StringHandle *path)
Get the node absolute path in the Houdini node network or a relative path any other node...
HAPI_DECL HAPI_GetOutputGeoInfos(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_GeoInfo *geo_infos_array, int count)
Gets the geometry info structs (HAPI_GeoInfo) for a node's main geometry outputs. This method can onl...
HAPI_DECL HAPI_GetAttributeInt8Data(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, int stride, HAPI_Int8 *data_array, int start, int length)
Get attribute 8-bit integer data.
HAPI_DECL HAPI_GetAttributeFloat64ArrayData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, HAPI_AttributeInfo *attr_info, double *data_fixed_array, int data_fixed_length, int *sizes_fixed_array, int start, int sizes_fixed_length)
Get array attribute 64-bit float data. Each entry in an array attribute can have varying array length...
HAPI_DECL HAPI_ConvertMatrixToQuat(const HAPI_Session *session, const float *matrix, HAPI_RSTOrder rst_order, HAPI_Transform *transform_out)
Converts a 4x4 matrix into its TRS form.
HAPI_GetWorkitemDataLength(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId workitem_id, const char *data_name, int *length)
Gets the length of the workitem data member. It is the length of the array of data.
HAPI_DECL HAPI_GetParmTagName(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int tag_index, HAPI_StringHandle *tag_name)
Get the tag name on a parameter given an index.
Meta-data about an HDA, returned by HAPI_GetAssetInfo()
Definition: HAPI_Common.h:1116
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:553
HAPI_DECL HAPI_ResetSimulation(const HAPI_Session *session, HAPI_NodeId node_id)
Resets the simulation cache of the asset. This is very useful for assets that use dynamics...
HAPI_DECL HAPI_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_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_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:1550
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:488
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_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:158
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:211
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:1085
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.
Definition: core.h:760
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:764
Data associated with a PDG Event.
Definition: HAPI_Common.h:1972
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_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:167
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:1643
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
int HAPI_ErrorCodeBits
Definition: HAPI_Common.h:264
HAPI_DECL HAPI_SaveGeoToMemory(const HAPI_Session *session, HAPI_NodeId node_id, char *buffer, int length)
Saves the cached geometry to your buffer in memory, whose format and required size is identified by t...
HAPI_DECL HAPI_QueryNodeInput(const HAPI_Session *session, HAPI_NodeId node_to_query, int input_index, HAPI_NodeId *connected_node_id)
Query which node is connected to another node's input.
HAPI_DECL HAPI_RemoveMultiparmInstance(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, int instance_position)
Remove the instance of a multiparm given by instance_position.
HAPI_DECL HAPI_GetPDGEvents(const HAPI_Session *session, HAPI_PDG_GraphContextId graph_context_id, HAPI_PDG_EventInfo *event_array, int length, int *event_count, int *remaining_events)
Returns PDG events that have been collected. Calling this function will remove those events from the ...
HAPI_DECL HAPI_ParmHasTag(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmId parm_id, const char *tag_name, HAPI_Bool *has_tag)
See if a parameter has a specific tag.
HAPI_DECL HAPI_GetParmChoiceLists(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_ParmChoiceInfo *parm_choices_array, int start, int length)
Fill an array of HAPI_ParmChoiceInfo structs with parameter choice list information from the asset in...
HAPI_DECL HAPI_LoadHIPFile(const HAPI_Session *session, const char *file_name, HAPI_Bool cook_on_load)
Loads a .hip file into the main Houdini scene.
HAPI_DECL HAPI_GetAssetLibraryIds(const HAPI_Session *session, HAPI_AssetLibraryId *asset_library_ids_array, int start, int length)
Gets the HAPI_AssetLibraryId's for HDAs that are loaded in Houdini.
HAPI_DECL HAPI_CreateInProcessSession(HAPI_Session *session)
Creates a new in-process session. There can only be one such session per host process.
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
Meta-data for a Houdini Node.
Definition: HAPI_Common.h:1274
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:266
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_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.
Configuration options for Houdini's compositing context.
Definition: HAPI_Common.h:2080
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_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_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_HeightFieldSampling
Type of sampling for heightfield.
Definition: HAPI_Common.h:891
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...
GLuint const GLchar * name
Definition: glcorearb.h:786
int HAPI_ProcessId
Definition: HAPI_Common.h:150
HAPI_DECL HAPI_GetNodeInputName(const HAPI_Session *session, HAPI_NodeId node_id, int input_idx, HAPI_StringHandle *name)
Get the name of an node's input. This function will return a string handle for the name which will be...
HAPI_DECL HAPI_SetSessionSyncInfo(const HAPI_Session *session, const HAPI_SessionSyncInfo *session_sync_info)
Set the HAPI_SessionSyncInfo for synchronizing SessionSync state between Houdini and Houdini Engine i...
HAPI_DECL HAPI_GetMaterialInfo(const HAPI_Session *session, HAPI_NodeId material_node_id, HAPI_MaterialInfo *material_info)
Get the material info.
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:1175
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_GetStatus(const HAPI_Session *session, HAPI_StatusType status_type, int *status)
Gives back the status code for a specific status type.
HAPI_DECL HAPI_GetConnectionError(char *string_value, int length, HAPI_Bool clear)
Return the connection error message.
HAPI_DECL HAPI_SetAttributeUInt8UniqueData(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const char *name, const HAPI_AttributeInfo *attr_info, const HAPI_UInt8 *data_array, int data_length, int start_index, int num_indices)
Set multiple attribute unsigned 8-bit int data to the same unique value.
HAPI_DECL HAPI_GetCurveOrders(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, int *orders_array, int start, int length)
Retrieve the orders for each curve in the part if the curve has varying order.
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_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_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 attribute string array 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_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_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:1072
#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:1599
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:1057
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_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_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:142
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:1104
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)
HAPI_DECL HAPI_GetInstanceTransformsOnPart(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_RSTOrder rst_order, HAPI_Transform *transforms_array, int start, int length)
Fill an array of HAPI_Transform structs with the transforms of each instance of this instancer object...
HAPI_DECL HAPI_SetTime(const HAPI_Session *session, float time)
Sets the global time of the scene. All API calls will deal with this time to cook.
HAPI_DECL HAPI_CookPDGAllOutputs(const HAPI_Session *session, HAPI_NodeId cook_node_id, int generate_only, int blocking)
Starts a PDG cooking operation. This can be asynchronous. Progress can be checked with HAPI_GetPDGSta...
HAPI_DECL HAPI_GetComposedObjectList(const HAPI_Session *session, HAPI_NodeId parent_node_id, HAPI_ObjectInfo *object_infos_array, int start, int length)
Fill an array of HAPI_ObjectInfo structs.
HAPI_DECL HAPI_DirtyPDGNode(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_Bool clean_results)
Dirties the given node. Cancels the cook if necessary and then deletes all workitems on the node...
HAPI_DECL HAPI_SetWorkItemStringAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, int data_index, const char *value)
Adds integer data to a pending PDG work item attribute for the given node.
HAPI_DECL HAPI_GetCacheProperty(const HAPI_Session *session, const char *cache_name, HAPI_CacheProperty cache_property, int *property_value)
Lets you inspect specific properties of the different memory caches in the current Houdini context...
HAPI_DECL HAPI_SetCurveOrders(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const int *orders_array, int start, int length)
Set the orders for each curve in the part if the curve has varying order.
HAPI_DECL HAPI_BindCustomImplementation(HAPI_SessionType session_type, const char *dll_path)
Binds a new implementation DLL to one of the custom session slots.
HAPI_DECL HAPI_GetNodeCookResult(const HAPI_Session *session, char *string_value, int length)
Return the cook result string that was composed during a call to HAPI_GetNodeCookResultLength().
HAPI_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_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)
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:117
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_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:202
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:477
Data for a Box Part.
Definition: HAPI_Common.h:1953
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)
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_GetSupportedImageFileFormatCount(const HAPI_Session *session, int *file_format_count)
Get the number of supported texture file formats.
HAPI_DECL HAPI_GetParmIntValues(const HAPI_Session *session, HAPI_NodeId node_id, int *values_array, int start, int length)
Fill an array of parameter int values. This is more efficient than calling HAPI_GetParmIntValue() ind...
HAPI_DECL HAPI_IsInitialized(const HAPI_Session *session)
Check whether the runtime has been initialized yet using HAPI_Initialize(). Function will return HAPI...
HAPI_DECL HAPI_Interrupt(const HAPI_Session *session)
Interrupt a cook or load operation.
HAPI_DECL HAPI_GetGeoInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_GeoInfo *geo_info)
Get the geometry info struct (HAPI_GeoInfo) on a SOP node.
HAPI_DECL HAPI_GetHIPFileNodeIds(const HAPI_Session *session, HAPI_HIPFileId id, HAPI_NodeId *node_ids, int length)
Fills an array of HAPI_NodeId of nodes that were created as a result of loading the HIP file specifie...
HAPI_DECL HAPI_GetConnectionErrorLength(int *buffer_length)
Return the length of string buffer storing connection error message.
HAPI_DECL HAPI_GetHandleInfo(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_HandleInfo *handle_infos_array, int start, int length)
Fill an array of HAPI_HandleInfo structs with information about every exposed user manipulation handl...
HAPI_DECL HAPI_GetNextVolumeTile(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, HAPI_VolumeTileInfo *tile)
Iterate through a volume based on 8x8x8 sections of the volume Continue iterating through the value o...
HAPI_DECL HAPI_GetSessionEnvInt(const HAPI_Session *session, HAPI_SessionEnvIntType int_type, int *value)
Gives back a certain session-specific environment integers like current license type being used...
HAPI_DECL HAPI_GetNodeOutputName(const HAPI_Session *session, HAPI_NodeId node_id, int output_idx, HAPI_StringHandle *name)
Get the name of an node's output. This function will return a string handle for the name which will b...
HAPI_DECL HAPI_RenderCOPToImage(const HAPI_Session *session, HAPI_NodeId cop_node_id)
Render a single texture from a COP to an image for later extraction.
HAPI_DECL HAPI_SetCurveCounts(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PartId part_id, const int *counts_array, int start, int length)
Set the number of vertices for each curve in the part.
HAPI_DECL HAPI_GetWorkItemStringAttribute(const HAPI_Session *session, HAPI_NodeId node_id, HAPI_PDG_WorkItemId work_item_id, const char *attribute_name, HAPI_StringHandle *data_array, int length)
Gets string ids from a work item attribute.
HAPI_DECL HAPI_GetCookingCurrentCount(const HAPI_Session *session, int *count)
Get current number of nodes that have already cooked in the current session. Note that this is a very...
HAPI_DECL HAPI_GetComposedNodeCookResult(const HAPI_Session *session, char *string_value, int length)
Return cook result string message on a single node.
HAPI_DECL HAPI_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:541
Data for a Sphere Part.
Definition: HAPI_Common.h:1962
Definition: core.h:1131
A Transform with Quaternion rotation.
Definition: HAPI_Common.h:1045
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.
#define const
Definition: zconf.h:214
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:543
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...
int HAPI_NodeId
See HAPI_Nodes_Basics.
Definition: HAPI_Common.h:163
Describes an image format, used with HAPI_GetSupportedImageFileFormats()
Definition: HAPI_Common.h:1760
HAPI_CacheProperty
Identifies a memory cache.
Definition: HAPI_Common.h:858
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_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:1798
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:160
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)
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:733
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_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:138
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.
HAPI_DECL HAPI_CreateThriftNamedPipeSession(HAPI_Session *session, const char *pipe_name)
Creates a Thrift RPC session using a Windows named pipe or a Unix domain socket as transport...
Meta-data for a combo-box / choice parm.
Definition: HAPI_Common.h:1505
HAPI_CommitWorkitems(const HAPI_Session *session, HAPI_NodeId node_id)
Commits any pending workitems.
int HAPI_PartId
Definition: HAPI_Common.h:171
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:133