Scripting API for GeeXLab 0.41.0.0

syntax

num_leds = gh_asus_aura.get_gpu_light_ctrl_num_leds (
  light_ctrl_index
)

parameters

light_ctrl_index INTEGER light controller index in the range (0 … num_light_ctrl - 1)

return values

num_leds INTEGER number of LEDs

code sample

light_ctrl_index = 0
num_leds = gh_asus_aura.get_gpu_light_ctrl_num_leds(light_ctrl_index)

syntax

num_leds = gh_asus_aura.get_mb_light_ctrl_num_leds (
  light_ctrl_index
)

parameters

light_ctrl_index INTEGER light controller index in the range (0 … num_light_ctrl - 1)

return values

num_leds INTEGER number of LEDs

code sample

light_ctrl_index = 0
num_leds = gh_asus_aura.get_mb_light_ctrl_num_leds(light_ctrl_index)

syntax

num_light_ctrl = gh_asus_aura.get_num_gpu_light_ctrl()

parameters

none

return values

num_light_ctrl INTEGER number of light controllers

code sample

num_light_ctrl = gh_asus_aura.get_num_gpu_light_ctrl()

syntax

num_light_ctrl = gh_asus_aura.get_num_mb_light_ctrl()

parameters

none

return values

num_light_ctrl INTEGER number of light controllers

code sample

num_light_ctrl = gh_asus_aura.get_num_mb_light_ctrl()

syntax

gh_asus_aura.set_gpu_led_color (
  light_ctrl_index,
  led_index,
  r, g, b
)

parameters

light_ctrl_index INTEGER light controller index in the range (0 … num_light_ctrl - 1)
led_index INTEGER LED index in the range (0 … num_leds - 1)
r, g, b INTEGER RGB color in the range (0 … 255) per channel

return values

none

code sample

light_ctrl_index = 0
led_index = 0
r = 255
g = 0
b = 0
gh_asus_aura.set_gpu_led_color(light_ctrl_index, led_index, r, g, b)

syntax

gh_asus_aura.set_gpu_mode (
  light_ctrl_index,
  mode
)

parameters

light_ctrl_index INTEGER light controller index in the range (0 … num_light_ctrl - 1)
mode BOOLEAN 1 (software programming) or 0 (default)

return values

none

code sample

light_ctrl_index = 0
mode = 1
gh_asus_aura.set_gpu_mode(light_ctrl_index, mode)

syntax

gh_asus_aura.set_mb_led_color (
  light_ctrl_index,
  led_index,
  r, g, b
)

parameters

light_ctrl_index INTEGER light controller index in the range (0 … num_light_ctrl - 1)
led_index INTEGER LED index in the range (0 … num_leds - 1)
r, g, b INTEGER RGB color in the range (0 … 255) per channel

return values

none

code sample

light_ctrl_index = 0
led_index = 0
r = 255
g = 0
b = 0
gh_asus_aura.set_mb_led_color(light_ctrl_index, led_index, r, g, b)

syntax

gh_asus_aura.set_mb_mode (
  light_ctrl_index,
  mode
)

parameters

light_ctrl_index INTEGER light controller index in the range (0 … num_light_ctrl - 1)
mode BOOLEAN 1 (software programming) or 0 (default)

return values

none

code sample

light_ctrl_index = 0
mode = 1
gh_asus_aura.set_mb_mode(light_ctrl_index, mode)

syntax

sound_id = gh_audio.sound_create (
  filename,
  absolute_path,
  streaming
)

parameters

filename STRING audio filename
absolute_path BOOLEAN file path: 1 (absolute) or 0 (relative)
streaming BOOLEAN streaming: 1 (enabled) or 0 (disabled)

return values

sound_id ID sound identifier

code sample

filename = demo_dir .. "audio/sound01.mp3"
local is_absolute_path = 0
sound_id = gh_audio.sound_create(filename, is_absolute_path, 1)

syntax

sound_id = gh_audio.sound_create_from_buffer (
  buff_ptr,
  buff_size,
  streaming
)

parameters

buff_ptr POINTER pointer to the buffer
buff_size INTEGER size of the buffer in bytes
streaming BOOLEAN streaming: 1 (enabled) or 0 (disabled)

return values

sound_id ID sound identifier

code sample

buffer, buffer_size = gh_utils.file_buffer_create(audio_filename)
sound_id = gh_audio.sound_create_from_buffer(buffer, buffer_size, 0)
gh_utils.file_buffer_kill(buffer)

syntax

sound_id = gh_audio.sound_create_from_sqlite3_blob (
  db_id,
  column,
  streaming
)

parameters

db_id ID database identifier
column INTEGER index of the column
streaming BOOLEAN streaming: 1 (enabled) or 0 (disabled)

return values

sound_id ID sound identifier

code sample

sound_id = gh_audio.sound_create_from_sqlite3_blob_v1(db_id, column, 0)

syntax

sound_id = gh_audio.sound_create_from_zip (
  zip_filename,
  filename,
  streaming
)

parameters

zip_filename STRING absolute path of the zip file
filename STRING sound file in the zip archive
streaming BOOLEAN streaming: 1 (enabled) or 0 (disabled)

return values

sound_id ID sound identifier

code sample

zip_filename = demo_dir .. "data.zip"
sound_id = gh_audio.sound_create_from_zip(zip_filename, "audio/sound01.wav", 0)

syntax

sound_id = gh_audio.sound_create_v2 (
  sampling_rate,
  num_channels,
  duration_sec,
  bits_per_sample,
  frequency,
  generator_type,
  volume,
  time
)

parameters

sampling_rate INTEGER sampling rate
num_channels INTEGER number of channels
duration_sec INTEGER duration in seconds
bits_per_sample INTEGER bits per sample
frequency INTEGER frequency in Hz
generator_type ENUM( audio_fmod_generator_type ) type of sound generator (1 to 4)
volume REAL sound volume
time REAL time

return values

sound_id ID sound identifier

code sample

FMOD_GENERATOR_SINE_WAVE = 1
FMOD_GENERATOR_SAWTOOTH = 2
FMOD_GENERATOR_SQUARE = 3
FMOD_GENERATOR_WHITE_NOISE = 4

generator_type = FMOD_GENERATOR_SINE_WAVE

sound_id = gh_audio.sound_create_v2(sampling_rate, num_channels, duration_sec, bits_per_sample, frequency, generator_type, volume, time)

syntax

sound_id = gh_audio.sound_create_v3 (
  filename,
  streaming
)

parameters

filename STRING audio filename
streaming BOOLEAN streaming: 1 (enabled) or 0 (disabled)

return values

sound_id ID sound identifier

code sample

filename = demo_dir .. "audio/sound01.mp3"
streaming = 1
sound_id = gh_audio.sound_create_v3(filename, streaming)

syntax

duration = gh_audio.sound_get_duration_ms (
  sound_id
)

parameters

sound_id ID sound identifier

return values

duration INTEGER duration in milliseconds

code sample

duration = gh_audio.sound_get_duration_ms(sound_id)

syntax

open_state, percent_buffered = gh_audio.sound_get_open_state (
  sound_id
)

parameters

sound_id ID sound identifier

return values

open_state ENUM( audio_fmod_openstate ) state (0 to 7)
percent_buffered INTEGER percent buffered

code sample

-- Possible states
FMOD_OPENSTATE_READY = 0 -- Opened and ready to play.
FMOD_OPENSTATE_LOADING = 1 -- Initial load in progress.
FMOD_OPENSTATE_ERROR = 2 -- Failed to open - file not found, out of memory etc.
FMOD_OPENSTATE_CONNECTING = 3 -- Connecting to remote host (internet sounds only).
FMOD_OPENSTATE_BUFFERING = 4 -- Buffering data.
FMOD_OPENSTATE_SEEKING = 5 -- Seeking to subsound and re-flushing stream buffer.
FMOD_OPENSTATE_PLAYING = 6 -- Ready and playing, but not possible to release at this time without stalling the main thread.
FMOD_OPENSTATE_SETPOSITION = 7 -- Seeking within a stream to a different position.

open_state, percentbuffered = gh_audio.sound_get_open_state(sound_id)

syntax

position = gh_audio.sound_get_position_ms (
  sound_id,
  channel
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance

return values

position INTEGER current position in milliseconds

code sample

position = gh_audio.sound_get_position_ms(sound_id, channel)

syntax

volume = gh_audio.sound_get_volume (
  sound_id,
  channel
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance

return values

volume REAL volume from 0.0 to 1.0

code sample

volume = gh_audio.sound_get_volume(sound_id, channel)

syntax

is_playing = gh_audio.sound_is_playing (
  sound_id,
  channel
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance

return values

is_playing BOOLEAN playing state: 1 (true) or 0 (false)

code sample

is_playing = gh_audio.sound_is_playing(sound_id, channel)

syntax

gh_audio.sound_kill (
  sound_id
)

parameters

sound_id ID sound identifier

return values

none

code sample

gh_audio.sound_kill(sound_id)

syntax

channel = gh_audio.sound_play (
  sound_id
)

parameters

sound_id ID sound identifier

return values

channel INTEGER sound instance

code sample

channel = gh_audio.sound_play(sound_id)

syntax

gh_audio.sound_set_loop_state (
  sound_id,
  state
)

parameters

sound_id ID sound identifier
state BOOLEAN 1 (enabled) or 0 (disabled)

return values

none

code sample

gh_audio.sound_set_loop_state(sound_id, 1)

syntax

gh_audio.sound_set_paused (
  sound_id,
  channel,
  state
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance
state BOOLEAN paused: 1 (true) or 0 (false)

return values

none

code sample

gh_audio.sound_set_paused(sound_id, channel, 1)

syntax

gh_audio.sound_set_volume (
  sound_id,
  channel,
  volume
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance
volume REAL volume from 0.0 to 1.0

return values

none

code sample

gh_audio.sound_set_volume(sound_id, channel, 0.5)

syntax

num_entries = gh_audio.sound_spectrum_get_num_values (
  sound_id,
  channel
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance

return values

num_entries INTEGER number of entries

code sample

num_values = gh_audio.sound_spectrum_get_num_values(sound_id, channel)

syntax

value = gh_audio.sound_spectrum_get_value (
  sound_id,
  channel,
  value_index
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance
value_index INTEGER entry index (from 0 to num_values-1)

return values

value REAL value

code sample

local value = gh_audio.sound_spectrum_get_value(sound_id, channel, value_index)

syntax

gh_audio.sound_spectrum_read (
  sound_id,
  channel
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance

return values

none

code sample

gh_audio.sound_spectrum_read(sound_id, channel)

syntax

gh_audio.sound_spectrum_read_v2 (
  sound_id,
  channel,
  fft_window_type
)

parameters

sound_id ID sound identifier
channel INTEGER sound instance
fft_window_type ENUM( audio_fft_window_type ) FFT window type - Default value: window_hamming

return values

none

code sample

-- Possible window types:
"window_rect"
"window_triangle"
"window_hamming" -- Default value
"window_hanning"
"window_blackman"
"window_blackmanharris"

fft_window_type =  "window_hamming"
gh_audio.sound_spectrum_read_v2(sound_id, channel, fft_window_type)

syntax

gh_audio.sound_update_audio_data_params (
  sound_id,
  sampling_rate,
  num_channels,
  duration_sec,
  bits_per_sample,
  frequency,
  generator_type,
  volume,
  time
)

parameters

sound_id ID sound identifier
sampling_rate INTEGER sampling rate
num_channels INTEGER number of channels
duration_sec INTEGER duration in seconds
bits_per_sample INTEGER bits per sample
frequency INTEGER frequency in Hz
generator_type ENUM( audio_fmod_generator_type ) type of sound generator (1 to 4)
volume REAL sound volume
time REAL time

return values

none

code sample

FMOD_GENERATOR_SINE_WAVE = 1
FMOD_GENERATOR_SAWTOOTH = 2
FMOD_GENERATOR_SQUARE = 3
FMOD_GENERATOR_WHITE_NOISE = 4

generator_type = FMOD_GENERATOR_SINE_WAVE

gh_audio.sound_update_audio_data_params(sound_id, sampling_rate, num_channels, duration_sec, bits_per_sample, frequency, generator_type, volume, time)

syntax

gh_audio.update()

parameters

none

return values

none

code sample

gh_audio.update()

syntax

gh_av.decoder_close (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

none

code sample

gh_av.decoder_close(av_id)

syntax

av_id = gh_av.decoder_open (
  filename,
  loop_mode
)

parameters

filename STRING audio filename
loop_mode BOOLEAN looping: 1 (true) or 0 (false)

return values

av_id ID audio-video object identifier

code sample

av_id = gh_av.decoder_open(filename, 1)

syntax

video_codec, audio_codec = gh_av.get_codec_name (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

video_codec, audio_codec STRING codec names

code sample

video_codec, audio_codec = gh_av.get_codec_name(av_id)

syntax

duration = gh_av.get_duration (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

duration REAL duration in seconds

code sample

duration = gh_av.get_duration(av_id)

syntax

elapsed_time = gh_av.get_elapsed_time (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

elapsed_time REAL elapsed time in seconds since the start of playing

code sample

elapsed_time = gh_av.get_elapsed_time(av_id)

syntax

video_frames, audio_frames = gh_av.get_num_frames (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

video_frames, audio_frames INTEGER number of frames

code sample

video_frames, audio_frames = gh_av.get_num_frames(av_id)

syntax

video_index, audio_index = gh_av.get_streams_index (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

video_index, audio_index INTEGER video and audio streams indices: -1 if the stream is not present and >= 0 if the stream is present

code sample

audio, video = gh_av.get_streams_index(av_id)

syntax

gh_av.pause (
  av_id,
  state
)

parameters

av_id ID audio-video object identifier
state BOOLEAN pause: 1 (true) or 0 (false)

return values

none

code sample

gh_av.pause(av_id, 1)

syntax

gh_av.process_frame (
  av_id,
  process_video,
  process_audio
)

parameters

av_id ID audio-video object identifier
process_video BOOLEAN video stream processing: 1 (enabled) or 0 (disabled)
process_audio BOOLEAN audio stream processing: 1 (enabled) or 0 (disabled)

return values

none

code sample

gh_av.process_frame(av_id, 1, 1)

syntax

gh_av.reset_streams (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

none

code sample

gh_av.reset_streams(av_id)

syntax

ret = gh_av.seek_frame_time (
  av_id,
  frame_time_sec
)

parameters

av_id ID audio-video object identifier
frame_time_sec INTEGER frame time in seconds

return values

ret BOOLEAN return code: 1 (success) or 0 (error)

code sample

"Seek the frame 20 sec before the end of the video"
frame_time_sec = video_duration_sec - 20
ret = gh_av.seek_frame_time(av_id, frame_time_sec)

syntax

gh_av.set_option_1i (
  name,
  x
)

parameters

name STRING name of the option
x INTEGER value

return values

none

code sample

# Possible options:
# "num_video_threads"
# "num_audio_threads"

gh_av.set_option_1i("num_video_threads", 4)

syntax

gh_av.set_option_str (
  name,
  x
)

parameters

name STRING name of the option
x STRING value

return values

none

code sample

# Possible options:
# "hw_device" 
#  - possible values: "cuda"

# "video_pixel_fmt"
#  - possible values: "yuv420p" and "rgb24"

gh_av.set_option_str("hw_device", "cuda")

syntax

gh_av.set_volume (
  av_id,
  volume
)

parameters

av_id ID audio-video object identifier
volume REAL volume from 0.0 to 1.0

return values

none

code sample

gh_av.set_volume(av_id, 0.7)

syntax

gh_av.start_audio_video_processing (
  av_id,
  process_video,
  process_audio
)

parameters

av_id ID audio-video object identifier
process_video BOOLEAN video stream processing: 1 (enabled) or 0 (disabled)
process_audio BOOLEAN audio stream processing: 1 (enabled) or 0 (disabled)

return values

none

code sample

gh_av.start_audio_video_processing(av_id, 1, 1)

syntax

gh_av.stop_audio_video_processing (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

none

code sample

gh_av.stop_audio_video_processing(av_id)

syntax

width, height = gh_av.video_get_resolution (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

width, height INTEGER resolution

code sample

duration = gh_av.video_get_resolution(av_id)

syntax

tex_id = gh_av.video_init_texture (
  av_id,
  pf
)

parameters

av_id ID audio-video object identifier
pf INTEGER pixel format

return values

tex_id ID texture identifier

code sample

tex_id = gh_av.video_init_texture(av_id, pf) -- DEPRECATED

syntax

gh_av.video_init_texture_rgb24 (
  av_id
)

parameters

av_id ID audio-video object identifier

return values

none

code sample

tex_id = gh_av.video_init_texture_rgb24(av_id)

syntax

gh_av.video_init_texture_yuv420 (
  av_id,
  texY, texU, texV
)

parameters

av_id ID audio-video object identifier
texY, texU, texV ID the three texture identifiers

return values

none

code sample

texY, texU, texV = gh_av.video_init_texture_rgb24(av_id)

syntax

gh_av.video_update_texture (
  av_id,
  tex_id
)

parameters

av_id ID audio-video object identifier
tex_id ID texture identifier

return values

none

code sample

gh_av.video_update_texture(av_id, tex_id) -- DEPRECATED

syntax

gh_av.video_update_texture_rgb24 (
  av_id,
  tex_id
)

parameters

av_id ID audio-video object identifier
tex_id ID texture identifier

return values

none

code sample

gh_av.video_update_texture_rgb24(av_id, tex_id)

syntax

gh_av.video_update_texture_yuv420 (
  av_id,
  texY_DUP1,
  tuY,
  texU,
  tuU,
  texY_DUP2,
  tuV
)

parameters

av_id ID audio-video object identifier
texY_DUP1 ID texture identifier
tuY INTEGER texture unit for texY
texU ID texture identifier
tuU INTEGER texture unit for texU
texY_DUP2 ID texture identifier
tuV INTEGER texture unit for texV

return values

none

code sample

tuY = 0			
tuU = 1			
tuV = 2			
gh_av.video_update_texture_yuv420(av_id, texY, tuY, texU, tuU, texV, tuV)

syntax

gh_box2d.actor_add_vertices (
  aid,
  x, y
)

parameters

aid ID actor identifier
x, y REAL vertex 2D position

return values

none

code sample

b2_triangle = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_add_vertices(b2_triangle, -1,-1)
gh_box2d.actor_add_vertices(b2_triangle,  0, 1)
gh_box2d.actor_add_vertices(b2_triangle,  1,-1)
gh_box2d.actor_polygon_build(b2_triangle)

syntax

gh_box2d.actor_apply_force (
  aid,
  force_x, force_y,
  point_x, point_y,
  wake
)

parameters

aid ID actor identifier
force_x, force_y REAL force in Newtons (N)
point_x, point_y REAL world point
wake INTEGER wake up the actor (1 or 0)

return values

none

code sample

gh_box2d.actor_apply_force(aid, force_x, force_y, point_x, point_y, wake)

syntax

gh_box2d.actor_apply_force_to_center (
  aid,
  force_x, force_y,
  wake
)

parameters

aid ID actor identifier
force_x, force_y REAL force in Newtons (N)
wake INTEGER wake up the actor (1 or 0)

return values

none

code sample

gh_box2d.actor_apply_force_to_center(aid, force_x, force_y, wake)

syntax

gh_box2d.actor_apply_linear_impulse (
  aid,
  impulse_x, impulse_y,
  point_x, point_y,
  wake
)

parameters

aid ID actor identifier
impulse_x, impulse_y REAL impulse in N-seconds or kg-m/s
point_x, point_y REAL world point
wake INTEGER wake up the actor (1 or 0)

return values

none

code sample

gh_box2d.actor_apply_linear_impulse(aid, impulse_x, impulse_y, point_x, point_y, wake)

syntax

gh_box2d.actor_apply_linear_impulse_to_center (
  aid,
  impulse_x, impulse_y,
  wake
)

parameters

aid ID actor identifier
impulse_x, impulse_y REAL impulse in N-seconds or kg-m/s
wake INTEGER wake up the actor (1 or 0)

return values

none

code sample

gh_box2d.actor_apply_linear_impulse_to_center(aid, impulse_x, impulse_y, wake)

syntax

gh_box2d.actor_apply_torque (
  aid,
  torque,
  wake
)

parameters

aid ID actor identifier
torque REAL torque in N-m
wake INTEGER wake up the actor (1 or 0)

return values

none

code sample

gh_box2d.actor_apply_torque(aid, torque, wake)

syntax

gh_box2d.actor_apply_transform (
  aid,
  object_id
)

parameters

aid ID actor identifier
object_id ID object identifier

return values

none

code sample

gh_box2d.actor_apply_transform(aid, mesh_id)

syntax

gh_box2d.actor_box_build (
  aid
)

parameters

aid ID actor identifier

return values

none

code sample

b2_box = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_box_set_size(b2_box, 2.0, 2.0)
gh_box2d.actor_box_build(b2_box)

syntax

gh_box2d.actor_box_set_size (
  aid,
  w, h
)

parameters

aid ID actor identifier
w, h REAL width and height

return values

none

code sample

b2_box = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_box_set_size(b2_box, 2.0, 2.0)
gh_box2d.actor_box_build(b2_box)

syntax

gh_box2d.actor_chain_build (
  aid
)

parameters

aid ID actor identifier

return values

none

code sample

b2_chain = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_add_vertices(b2_chain, 1, 1)
gh_box2d.actor_add_vertices(b2_chain,  0, -1)
gh_box2d.actor_add_vertices(b2_chain,  -1, -1)
gh_box2d.actor_add_vertices(b2_chain,  -2, 1)
gh_box2d.actor_chain_build(b2_chain)

syntax

gh_box2d.actor_circle_build (
  aid
)

parameters

aid ID actor identifier

return values

none

code sample

b2_circle = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_circle_set_radius(b2_circle, 2.0, 2.0)
gh_box2d.actor_box_actor_circle_buildbuild(b2_circle)

syntax

gh_box2d.actor_circle_set_radius (
  aid,
  r
)

parameters

aid ID actor identifier
r REAL radius

return values

none

code sample

b2_circle = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_circle_set_radius(b2_circle, 2.0, 2.0)
gh_box2d.actor_box_actor_circle_buildbuild(b2_circle)

syntax

contact_actor_id, cx, cy = gh_box2d.actor_get_contact_actor (
  actor_id,
  contact_index
)

parameters

actor_id ID actor identifier
contact_index INTEGER contact index from [0; num_contacts] - call actor_read_contacts() for num_contacts.

return values

contact_actor_id ID ID of the actor in contact
cx, cy REAL position of the contact

code sample

num_contacts, x, y = gh_box2d.actor_read_contacts(actor_id)
for i=0, num_contacts-1 do
  contact_actor_id, cx, cy = gh_box2d.actor_get_contact_actor(actor_id, i)
	...
end

syntax

x, y, angle = gh_box2d.actor_get_transform (
  aid
)

parameters

aid ID actor identifier

return values

x, y REAL actor position
angle REAL actor orientation in radians

code sample

x, y, angle = gh_box2d.actor_get_transform(aid)

syntax

state = gh_box2d.actor_is_awake (
  aid
)

parameters

aid ID actor identifier

return values

state BOOLEAN disabled (0) or enabled (1)

code sample

state = gh_box2d.actor_is_awake(aid)

syntax

gh_box2d.actor_polygon_build (
  aid,
  x, y
)

parameters

aid ID actor identifier
x, y REAL vertex 2D position

return values

none

code sample

b2_triangle = gh_box2d.world_create_actor(b2_world, -3, 10,  "dynamic")
gh_box2d.actor_add_vertices(b2_triangle, -1,-1)
gh_box2d.actor_add_vertices(b2_triangle,  0, 1)
gh_box2d.actor_add_vertices(b2_triangle,  1,-1)
gh_box2d.actor_polygon_build(b2_triangle)

syntax

ret, hit_point_x, hit_point_y = gh_box2d.actor_raycast (
  aid,
  x0, y0,
  x1, y1
)

parameters

aid ID actor identifier
x0, y0 REAL ray start
x1, y1 REAL ray end

return values

ret INTEGER 1 if intersection found, 0 otherwise.
hit_point_x, hit_point_y REAL coordinates of the hit point.

code sample

ret, hit_point_x, hit_point_y = gh_box2d.actor_raycast(aid, x0, y0, x1, y1)

syntax

num_contacts, x, y = gh_box2d.actor_read_contacts (
  aid
)

parameters

aid ID actor identifier

return values

num_contacts INTEGER number of contacts
x, y REAL position of the first contact

code sample

num_contacts, x, y = gh_box2d.actor_read_contacts(aid)

syntax

gh_box2d.actor_set_awake (
  aid,
  state
)

parameters

aid ID actor identifier
state BOOLEAN disabled (0) or enabled (1)

return values

none

code sample

gh_box2d.actor_set_awake(aid, state)

syntax

gh_box2d.actor_set_ccd (
  aid,
  state
)

parameters

aid ID actor identifier
state BOOLEAN disabled (0) or enabled (1)

return values

none

code sample

gh_box2d.actor_set_ccd(aid, state)

syntax

gh_box2d.actor_set_damping (
  aid,
  linear,
  angular
)

parameters

aid ID actor identifier
linear REAL linear damping
angular REAL angular damping

return values

none

code sample

gh_box2d.actor_set_damping(aid, linear, angular)

syntax

gh_box2d.actor_set_density (
  aid,
  x
)

parameters

aid ID actor identifier
x REAL density

return values

none

code sample

gh_box2d.actor_set_density(aid, x)

syntax

gh_box2d.actor_set_enabled (
  aid,
  state
)

parameters

aid ID actor identifier
state BOOLEAN disabled (0) or enabled (1)

return values

none

code sample

gh_box2d.actor_set_enabled(aid, state)

syntax

gh_box2d.actor_set_friction (
  aid,
  x
)

parameters

aid ID actor identifier
x REAL friction

return values

none

code sample

gh_box2d.actor_set_friction(aid, x)

syntax

gh_box2d.actor_set_linear_angular (
  aid,
  x
)

parameters

aid ID actor identifier
x REAL angular velocity

return values

none

code sample

gh_box2d.actor_set_linear_angular(aid, x)

syntax

gh_box2d.actor_set_linear_velocity (
  aid,
  x, y
)

parameters

aid ID actor identifier
x, y REAL linear velocity along X and Y axis

return values

none

code sample

gh_box2d.actor_set_linear_velocity(aid, x, y)

syntax

gh_box2d.actor_set_restitution (
  aid,
  x
)

parameters

aid ID actor identifier
x REAL restitution

return values

none

code sample

gh_box2d.actor_set_restitution(aid, x)

syntax

gh_box2d.actor_set_sleeping_allowed (
  aid,
  state
)

parameters

aid ID actor identifier
state BOOLEAN disabled (0) or enabled (1)

return values

none

code sample

gh_box2d.actor_set_sleeping_allowed(aid, state)

syntax

gh_box2d.actor_set_transform (
  aid,
  x, y,
  angle
)

parameters

aid ID actor identifier
x, y REAL actor position
angle REAL actor orientation in radians

return values

none

code sample

gh_box2d.actor_set_transform(aid, x, y, angle)

syntax

major, minor, revision = gh_box2d.get_version()

parameters

none

return values

major, minor, revision INTEGER version

code sample

major, minor, revision = gh_box2d.get_version()

syntax

ret = gh_box2d.init()

parameters

none

return values

ret BOOLEAN return code: 1 (success) or 0 (error)

code sample

ret = gh_box2d.init()

syntax

stiffness, damping = gh_box2d.joint_distance_compute_linear_stiffness (
  wid,
  frequency_hz,
  damping_ratio
)

parameters

wid ID world identifier
frequency_hz REAL frequency in Hertz
damping_ratio REAL non-dimensional value, typically between 0 and 1

return values

stiffness, damping REAL stiffness and damping

code sample

frequency_hz = 4.0			
damping_ratio = 0.5
stiffness, damping = gh_box2d.joint_distance_compute_linear_stiffness(jid, frequency_hz, damping_ratio)

syntax

gh_box2d.joint_distance_set_damping (
  wid,
  damping
)

parameters

wid ID world identifier
damping REAL damping value

return values

none

code sample

gh_box2d.joint_distance_set_damping(jid, damping)

syntax

gh_box2d.joint_distance_set_stiffness (
  wid,
  stiffness
)

parameters

wid ID world identifier
stiffness REAL stiffness value

return values

none

code sample

gh_box2d.joint_distance_set_stiffness(jid, stiffness)

syntax

ret = gh_box2d.terminate()

parameters

none

return values

ret BOOLEAN return code: 1 (success) or 0 (error)

code sample

ret = gh_box2d.terminate()

syntax

gh_box2d.world_clear_forces (
  wid
)

parameters

wid ID world identifier

return values

none

code sample

gh_box2d.world_clear_forces(wid)

syntax

aid = gh_box2d.world_create_actor (
  wid,
  posx, posy,
  body_type
)

parameters

wid ID world identifier
posx, posy REAL initial position
body_type STRING body type: static, kinematic or dynamic

return values

aid ID actor identifier

code sample

body_type = "dynamic"			
aid = gh_box2d.world_create_actor(wid, posx, posy, body_type)
gh_box2d.actor_circle_set_radius(aid, 2.0)
gh_box2d.actor_circle_build(aid)

syntax

aid = gh_box2d.world_create_actor_box (
  wid,
  posx, posy,
  width, height,
  body_type,
  density,
  friction,
  restitution
)

parameters

wid ID world identifier
posx, posy REAL initial position
width, height REAL box size
body_type STRING body type: static, kinematic or dynamic
density REAL density - mass will be computed later based on the volume and density.
friction REAL friction
restitution REAL restitution

return values

aid ID actor identifier

code sample

body_type = "dynamic"			
density = 10.0
friction = 0.1
restitution = 0.4
aid = gh_box2d.world_create_actor_box(wid, posx, posy, width, height, body_type, density, friction, restitution)

syntax

aid = gh_box2d.world_create_actor_circle (
  wid,
  posx, posy,
  radius,
  body_type,
  density,
  friction,
  restitution
)

parameters

wid ID world identifier
posx, posy REAL initial position
radius REAL disc radius
body_type STRING body type: static, kinematic or dynamic
density REAL density - mass will be computed later based on the volume and density.
friction REAL friction
restitution REAL restitution

return values

aid ID actor identifier

code sample

body_type = "dynamic"			
density = 10.0
friction = 0.1
restitution = 0.4
aid = gh_box2d.world_create_actor_circle(wid, posx, posy, radius, body_type, density, friction, restitution)

syntax

jid = gh_box2d.world_create_joint_distance (
  wid,
  a,
  b,
  anchor_a_x, anchor_a_y,
  anchor_b_x, anchor_b_y
)

parameters

wid ID world identifier
a ID actor A
b ID actor B
anchor_a_x, anchor_a_y REAL anchor point in actor A
anchor_b_x, anchor_b_y REAL anchor point in actor B

return values

jid ID joint identifier

code sample

jid = gh_box2d.world_create_joint_distance(wid, a, b, anchor_a_x, anchor_a_y, anchor_b_x, anchor_b_y)

syntax

wid = gh_box2d.world_init()

parameters

none

return values

wid ID world identifier

code sample

wid = gh_box2d.world_init()

syntax

gh_box2d.world_kill_actor (
  wid,
  aid
)

parameters

wid ID world identifier
aid ID actor identifier

return values

none

code sample

gh_box2d.world_kill_actor(wid, aid)

syntax

gh_box2d.world_kill_joint (
  wid,
  jid
)

parameters

wid ID world identifier
jid ID joint identifier

return values

none

code sample

gh_box2d.world_kill_joint(wid, jid)

syntax

gh_box2d.world_set_auto_clear_forces (
  wid,
  state
)

parameters

wid ID world identifier
state BOOLEAN disables (0) or enabled (1)

return values

none

code sample

state = 0
gh_box2d.world_set_auto_clear_forces(wid, state)

syntax

gh_box2d.world_set_gravity (
  wid,
  x, y
)

parameters

wid ID world identifier
x, y REAL gravity vector

return values

none

code sample

gh_box2d.world_set_gravity(wid, 0, -10)

syntax

gh_box2d.world_step_simulation (
  wid,
  time_step,
  velocity_iterations,
  position_iterations
)

parameters

wid ID world identifier
time_step REAL time step between two frames
velocity_iterations INTEGER number of solver iterations for velocity
position_iterations INTEGER number of solver iterations for position

return values

none

code sample

dt = 1.0/60.0			
velocity_iterations = 8
position_iterations = 4
gh_box2d.world_step_simulation(wid, dt, velocity_iterations, position_iterations)

syntax

gh_box2d.world_terminate (
  wid
)

parameters

wid ID world identifier

return values

none

code sample

gh_box2d.world_terminate(wid)

syntax

gh_bullet3.actor_apply_central_force (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL force

return values

none

code sample

gh_bullet3.actor_apply_central_force(actor_id, x, y, z)

syntax

gh_bullet3.actor_apply_central_impulse (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL force

return values

none

code sample

gh_bullet3.actor_apply_central_impulse(actor_id, x, y, z)

syntax

gh_bullet3.actor_apply_torque (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL torque

return values

none

code sample

gh_bullet3.actor_apply_torque(actor_id, x, y, z)

syntax

gh_bullet3.actor_apply_transform (
  actor_id,
  o3d_id
)

parameters

actor_id ID actor identifier
o3d_id ID 3d object identifier

return values

none

code sample

gh_bullet3.actor_apply_transform(actor_id, o3d_id)

syntax

gh_bullet3.actor_clear_forces (
  actor_id
)

parameters

actor_id ID actor identifier

return values

none

code sample

gh_bullet3.actor_clear_forces(actor_id)

syntax

actor_id = gh_bullet3.actor_create_box (
  w, h, d,
  x, y, z,
  mass,
  mat_id
)

parameters

w, h, d REAL dimensions of the box
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_box(w, h, d, x, y, z, mass, mat_id)

syntax

actor_id = gh_bullet3.actor_create_box_v2 (
  w, h, d,
  x, y, z,
  mass,
  ix, iy, iz,
  mat_id
)

parameters

w, h, d REAL dimensions of the box
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
ix, iy, iz REAL initial local inertia
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_box_v2(w, h, d, x, y, z, mass, ix, iy, iz, mat_id)

syntax

actor_id = gh_bullet3.actor_create_cylinder (
  main_axis,
  height,
  radius,
  x, y, z,
  mass,
  mat_id
)

parameters

main_axis ENUM( along_axis ) direction of the main axis: 0 (along X axis), 1 (along Y axis) or 2 (along Z axis)
height REAL cylinder height
radius REAL cylinder radius
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_cylinder(central_axis, height, radius, x, y, z, mass, mat_id)

syntax

actor_id = gh_bullet3.actor_create_cylinder_v2 (
  main_axis,
  height,
  radius,
  x, y, z,
  mass,
  ix, iy, iz,
  mat_id
)

parameters

main_axis ENUM( along_axis ) direction of the main axis: 0 (along X axis), 1 (along Y axis) or 2 (along Z axis)
height REAL cylinder height
radius REAL cylinder radius
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
ix, iy, iz REAL initial local inertia
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_cylinder_v2(central_axis, height, radius, x, y, z, mass, ix, iy, iz, mat_id)

syntax

actor_id = gh_bullet3.actor_create_mesh (
  mesh_id,
  convex,
  x, y, z,
  mass,
  mat_id
)

parameters

mesh_id ID mesh identifier
convex BOOLEAN convex mesh: 1 (yes) or 0 (no)
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_mesh(mesh_id, convex, x, y, z, mass, mat_id)

syntax

actor_id = gh_bullet3.actor_create_mesh_v2 (
  mesh_id,
  convex,
  x, y, z,
  mass,
  ix, iy, iz,
  mat_id
)

parameters

mesh_id ID mesh identifier
convex BOOLEAN convex mesh: 1 (yes) or 0 (no)
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
ix, iy, iz REAL initial local inertia
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_mesh_v2(mesh_id, convex, x, y, z, mass, ix, iy, iz, mat_id)

syntax

actor_id = gh_bullet3.actor_create_sphere (
  radius,
  x, y, z,
  mass,
  mat_id
)

parameters

radius REAL sphere radius
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_sphere(radius, x, y, z, mass, mat_id)

syntax

actor_id = gh_bullet3.actor_create_sphere_v2 (
  radius,
  x, y, z,
  mass,
  ix, iy, iz,
  mat_id
)

parameters

radius REAL sphere radius
x, y, z REAL initial position of the actor
mass REAL mass (set the mass = 0 for a kinematic actor)
ix, iy, iz REAL initial local inertia
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

actor_id = gh_bullet3.actor_create_sphere_v2(radius, x, y, z, mass, ix, iy, iz, mat_id)

syntax

actor_id = gh_bullet3.actor_create_static_plane (
  nx, ny, nz, d,
  mat_id
)

parameters

nx, ny, nz, d REAL plane equation
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

nx = 0
ny = 1
nz = 0
d = 0
actor_id = gh_bullet3.actor_create_static_plane(nx, ny, nz, d, mat_id)

syntax

actor_id = gh_bullet3.actor_create_static_plane_v2 (
  nx, ny, nz,
  px, py, pz,
  mat_id
)

parameters

nx, ny, nz REAL plane normal vector
px, py, pz REAL plane position
mat_id ID material identifier

return values

actor_id ID actor identifier

code sample

nx = 1
ny = 0
nz = 0
px = 5
py = 0
pz = 0
actor_id = gh_bullet3.actor_create_static_plane_v2(nx, ny, nz, px, py, pz, mat_id)

syntax

state = gh_bullet3.actor_get_activation_state (
  actor_id
)

parameters

actor_id ID actor identifier

return values

state INTEGER activation state (0 or 1)

code sample

state = gh_bullet3.actor_get_activation_state(actor_id)

syntax

s = gh_bullet3.actor_get_angular_speed2 (
  actor_id
)

parameters

actor_id ID actor identifier

return values

s REAL squared speed

code sample

s = gh_bullet3.actor_get_angular_speed2(actor_id)

syntax

x, y, z = gh_bullet3.actor_get_angular_velocity (
  actor_id
)

parameters

actor_id ID actor identifier

return values

x, y, z REAL velocity vector

code sample

x, y, z= gh_bullet3.actor_get_angular_velocity(actor_id)

syntax

contact_actor_id = gh_bullet3.actor_get_contact_actor (
  actor_id,
  contact_index
)

parameters

actor_id ID actor identifier
contact_index INTEGER contact index

return values

contact_actor_id ID ID of the actor in contact

code sample

num_contacts, x, y, z = gh_bullet3.actor_get_contact_info(actor_id)
for i=0, num_contacts-1 do
  contact_actor_id = gh_bullet3.actor_get_contact_actor(actor_id, i)
	...
end

syntax

num_contacts = gh_bullet3.actor_get_contact_info (
  actor_id,
  px, py, pz
)

parameters

actor_id ID actor identifier
px, py, pz REAL position of the first contact

return values

num_contacts INTEGER number of contacts

code sample

num_contacts, px, py, pz = gh_bullet3.actor_get_contact_info(actor_id)

syntax

s = gh_bullet3.actor_get_linear_speed2 (
  actor_id
)

parameters

actor_id ID actor identifier

return values

s REAL squared speed

code sample

s = gh_bullet3.actor_get_linear_speed2(actor_id)

syntax

x, y, z = gh_bullet3.actor_get_linear_velocity (
  actor_id
)

parameters

actor_id ID actor identifier

return values

x, y, z REAL velocity vector

code sample

x, y, z= gh_bullet3.actor_get_linear_velocity(actor_id)

syntax

qx, qy, qz, qw = gh_bullet3.actor_get_orientation (
  actor_id
)

parameters

actor_id ID actor identifier

return values

qx, qy, qz, qw REAL orientation quaternion

code sample

qx, qy, qz, qw = gh_bullet3.actor_get_orientation(actor_id)

syntax

x, y, z = gh_bullet3.actor_get_position (
  actor_id
)

parameters

actor_id ID actor identifier

return values

x, y, z REAL 3D position

code sample

x, y, z = gh_bullet3.actor_get_position(actor_id)

syntax

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_bullet3.actor_get_transform_mat16 (
  actor_id
)

parameters

actor_id ID actor identifier

return values

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

code sample

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_bullet3.actor_get_transform_mat16(actor_id)

syntax

px, py, pz, qx, qy, qz, qw = gh_bullet3.actor_get_transform_pos_qrot (
  actor_id
)

parameters

actor_id ID actor identifier

return values

px, py, pz REAL position
qx, qy, qz, qw REAL rotation quaternion

code sample

px, py, pz, qx, qy, qz, qw = gh_bullet3.actor_get_transform_pos_qrot(actor_id)

syntax

gh_bullet3.actor_kill (
  actor_id
)

parameters

actor_id ID actor identifier

return values

none

code sample

gh_bullet3.actor_kill(actor_id)

syntax

gh_bullet3.actor_set_3d_object (
  actor_id,
  o3d_id
)

parameters

actor_id ID actor identifier
o3d_id ID 3d object identifier

return values

none

code sample

gh_bullet3.actor_set_3d_object(actor_id, o3d_id)

syntax

gh_bullet3.actor_set_activation_state (
  actor_id,
  state
)

parameters

actor_id ID actor identifier
state INTEGER activation state (0 or 1)

return values

none

code sample

gh_bullet3.actor_set_activation_state(actor_id, state)

syntax

gh_bullet3.actor_set_angular_factor (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL XX factor

return values

none

code sample

gh_bullet3.actor_set_angular_factor(actor_id, x, y, z)

syntax

gh_bullet3.actor_set_angular_velocity (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL velocity vector

return values

none

code sample

gh_bullet3.actor_set_angular_velocity(actor_id, x, y, z)

syntax

gh_bullet3.actor_set_ccd_params (
  actor_id,
  motion_threshold,
  swept_sphere_radius
)

parameters

actor_id ID actor identifier
motion_threshold REAL CCD is not performed if the motion (in one step) is less then motion_threshold
swept_sphere_radius REAL swept sphere radius (0.0 by default)

return values

none

code sample

gh_bullet3.actor_set_ccd_params(actor_id, motion_threshold, swept_sphere_radius)

syntax

gh_bullet3.actor_set_collision_margin (
  actor_id,
  margin
)

parameters

actor_id ID actor identifier
margin REAL collision margin

return values

none

code sample

gh_bullet3.actor_set_collision_margin(actor_id, margin)

syntax

gh_bullet3.actor_set_damping (
  actor_id,
  linear,
  angular
)

parameters

actor_id ID actor identifier
linear REAL linear damping
angular REAL angular damping

return values

none

code sample

gh_bullet3.actor_set_damping(actor_id, linear, angular)

syntax

gh_bullet3.actor_set_gravity (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL gravity vector

return values

none

code sample

gh_bullet3.actor_set_gravity(actor_id, x, y, z)

syntax

gh_bullet3.actor_set_linear_factor (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL XX factor

return values

none

code sample

gh_bullet3.actor_set_linear_factor(actor_id, x, y, z)

syntax

gh_bullet3.actor_set_linear_velocity (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL velocity vector

return values

none

code sample

gh_bullet3.actor_set_linear_velocity(actor_id, x, y, z)

syntax

gh_bullet3.actor_set_material (
  actor_id,
  mat_id
)

parameters

actor_id ID actor identifier
mat_id ID material identifier

return values

none

code sample

gh_bullet3.actor_set_material(actor_id, mid)

syntax

gh_bullet3.actor_set_orientation (
  actor_id,
  qx, qy, qz, qw
)

parameters

actor_id ID actor identifier
qx, qy, qz, qw REAL orientation quaternion

return values

none

code sample

gh_bullet3.actor_set_orientation(actor_id, qx, qy, qz, qw)

syntax

gh_bullet3.actor_set_position (
  actor_id,
  x, y, z
)

parameters

actor_id ID actor identifier
x, y, z REAL 3d position

return values

none

code sample

gh_bullet3.actor_set_position(actor_id, x, y, z)

syntax

gh_bullet3.actor_set_sleeping_thresholds (
  actor_id,
  linear,
  angular
)

parameters

actor_id ID actor identifier
linear REAL linear sleeping threshold
angular REAL angular sleeping threshold

return values

none

code sample

gh_bullet3.actor_set_sleeping_thresholds(actor_id, linear, angular)

syntax

gh_bullet3.actor_update_mass (
  actor_id,
  mass
)

parameters

actor_id ID actor identifier
mass REAL mass

return values

none

code sample

gh_bullet3.actor_update_mass(actor_id, mass)

syntax

version = gh_bullet3.get_version()

parameters

none

return values

version INTEGER API version

code sample

version = gh_bullet3.get_version()

syntax

ret = gh_bullet3.init()

parameters

none

return values

ret BOOLEAN return code: 1 (success) or 0 (error)

code sample

ret = gh_bullet3.init()

syntax

mat_id = gh_bullet3.material_create (
  restitution,
  friction
)

parameters

restitution REAL restitution factor
friction REAL friction factor

return values

mat_id ID material identifier

code sample

mat_id = gh_bullet3.material_create(restitution, friction)

syntax

gh_bullet3.material_kill (
  mat_id
)

parameters

mat_id ID material identifier

return values

none

code sample

gh_bullet3.material_kill(mat_id)

syntax

gh_bullet3.material_update (
  mat_id,
  friction,
  restitution
)

parameters

mat_id ID material identifier
friction REAL friction
restitution REAL resilience / restitution

return values

none

code sample

restitution = 0.9
friction = 0.5

gh_bullet3.material_update(mat_id, restitution, friction)

-- now update the material for a particular actor
gh_bullet3.actor_set_material(actor_id, mat_id)

syntax

gh_bullet3.scene_add_actor (
  scene_id,
  actor_id
)

parameters

scene_id ID scene identifier
actor_id ID actor identifier

return values

none

code sample

gh_bullet3.scene_add_actor(scene_id, actor_id)

syntax

num_contacts = gh_bullet3.scene_check_contacts (
  scene_id
)

parameters

scene_id ID scene identifier

return values

num_contacts INTEGER number of contacts

code sample

num_contacts = gh_bullet3.scene_check_contacts(scene_id)

syntax

scene_id = gh_bullet3.scene_create()

parameters

none

return values

scene_id ID scene identifier

code sample

scene_id = gh_bullet3.scene_create()

syntax

scene_id = gh_bullet3.scene_create_sap (
  min_x, min_y, min_z,
  max_x, max_y, max_z
)

parameters

min_x, min_y, min_z REAL world dimensions (minimal AABB values)
max_x, max_y, max_z REAL world dimensions (maximal AABB values)

return values

scene_id ID scene identifier

code sample

scene_id = gh_bullet3.scene_create_sap(x0, y0, z0,  x1, x1, z1)

syntax

gh_bullet3.scene_kill (
  scene_id
)

parameters

scene_id ID scene identifier

return values

none

code sample

gh_bullet3.scene_kill(scene_id)

syntax

gh_bullet3.scene_remove_actor (
  scene_id,
  actor_id
)

parameters

scene_id ID scene identifier
actor_id ID actor identifier

return values

none

code sample

gh_bullet3.scene_remove_actor(scene_id, actor_id)

syntax

gh_bullet3.scene_reset_all_contacts (
  scene_id
)

parameters

scene_id ID scene identifier

return values

none

code sample

gh_bullet3.scene_reset_all_contacts(scene_id)

syntax

gh_bullet3.scene_set_gravity (
  scene_id,
  x, y, z
)

parameters

scene_id ID scene identifier
x, y, z REAL gravity vector

return values

none

code sample

gh_bullet3.scene_set_gravity(scene_id, x, y, z)

syntax

gh_bullet3.scene_set_solver_num_iterations (
  scene_id,
  num_iterations
)

parameters

scene_id ID scene identifier
num_iterations INTEGER number of iterations - default value is 10.

return values

none

code sample

gh_bullet3.scene_set_solver_num_iterations(scene_id, iterations)

syntax

gh_bullet3.scene_step_simulation (
  scene_id,
  time_step,
  max_sub_steps,
  fixed_time_step
)

parameters

scene_id ID scene identifier
time_step REAL time step between two frames
max_sub_steps INTEGER number of sub steps
fixed_time_step REAL fixed time step - default value: 1.0/60.0

return values

none

code sample

gh_bullet3.scene_step_simulation(scene_id, dt, max_sub_steps, 1.0/60.0)

syntax

gh_bullet3.scene_sync_3d_objects (
  scene_id
)

parameters

scene_id ID scene identifier

return values

none

code sample

gh_bullet3.scene_sync_3d_objects(scene_id)

syntax

ret = gh_bullet3.terminate()

parameters

none

return values

ret BOOLEAN return code: 1 (success) or 0 (error)

code sample

ret = gh_bullet3.terminate()

syntax

gh_camera.bind (
  cam_id
)

parameters

cam_id ID camera identifier

return values

none

code sample

gh_camera.bind(camera)

syntax

gh_camera.bind_v2 (
  cam_id,
  update_viewport,
  update_scissor,
  update_proj_mat,
  update_view_mat,
  update_fixed_pipeline
)

parameters

cam_id ID camera identifier
update_viewport BOOLEAN updates the viewport: 1 (true) or 0 (false)
update_scissor BOOLEAN updates the scissor rectangle (same size than the viewport): 1 (true) or 0 (false)
update_proj_mat BOOLEAN updates the projection matrix: 1 (true) or 0 (false)
update_view_mat BOOLEAN updates the view matrix: 1 (true) or 0 (false)
update_fixed_pipeline BOOLEAN updates the fixed pipeline (so you will have access to gl_ModelViewProjectionMatrix in a vertex shader for example): 1 (true) or 0 (false)

return values

none

code sample

local update_viewport = 1
local update_scissor = 0
local update_proj_mat = 1
local update_view_mat = 1
local update_fixed_pipeline = 0

gh_camera.bind_v2(cam_id, update_viewport, update_scissor, update_proj_mat, update_view_mat, update_fixed_pipeline)

syntax

cam_id = gh_camera.create_ortho (
  left,
  right,
  bottom,
  top,
  znear,
  zfar
)

parameters

left REAL left clipping plane
right REAL right clipping plane
bottom REAL bottom clipping plane
top REAL top clipping plane
znear REAL near clipping plane
zfar REAL far clipping plane

return values

cam_id ID camera identifier

code sample

w = screen_width
h = screen_height
cam_id = gh_camera.create_ortho(-w/2, w/2, -h/2, h/2, -1.0, 1.0)

syntax

cam_id = gh_camera.create_orthographic()

parameters

none

return values

cam_id ID camera identifier

code sample

cam_id = gh_camera.create_orthographic()

syntax

cam_id = gh_camera.create_persp (
  fov,
  aspect,
  znear,
  zfar
)

parameters

fov REAL field of view in degres
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

cam_id ID camera identifier

code sample

cam_id = gh_camera.create_persp(60, 1.333, 0.1, 1000.0)

syntax

cam_id = gh_camera.create_persp_v2 (
  fov,
  is_vertical_fov,
  aspect,
  znear,
  zfar
)

parameters

fov REAL field of view in degres
is_vertical_fov BOOLEAN 1 (vertical fov) or 0 (horizontal fov)
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

cam_id ID camera identifier

code sample

cam_id = gh_camera.create_persp_v2(60, 1, 1.333, 0.1, 1000.0)

syntax

cam_id = gh_camera.create_persp_v3 (
  fov_x,
  fov_y,
  aspect,
  znear,
  zfar
)

parameters

fov_x REAL horizontal field of view in degres
fov_y REAL vertical field of view in degres
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

cam_id ID camera identifier

code sample

cam_id = gh_camera.create_persp_v3(60, 70, 1.333, 0.1, 1000.0)

syntax

cam_id = gh_camera.create_perspective (
  pos_x, pos_y, pos_z,
  lookat_x, lookat_y, lookat_z
)

parameters

pos_x, pos_y, pos_z REAL position of the camera
lookat_x, lookat_y, lookat_z REAL look at point of the camera

return values

cam_id ID camera identifier

code sample

cam_id = gh_camera.create_perspective(0, 20, 0, 0, 0, 0)

syntax

cam_id = gh_camera.create_perspective_vk (
  fov,
  aspect,
  znear,
  zfar
)

parameters

fov REAL field of view in degres
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

cam_id ID camera identifier

code sample

cam_id = gh_camera.create_perspective_vk(60.0, winW/winH, 1.0, 1000.0)

syntax

collision = gh_camera.frustum_check_object_aa_box (
  cam_id,
  obj_id
)

parameters

cam_id ID camera identifier
obj_id ID object identifier

return values

collision BOOLEAN collision: 1 (true) or 0 (false)

code sample

collision = gh_camera.frustum_check_object_aa_box(cam_id, obj_id)

syntax

collision = gh_camera.frustum_check_object_sphere (
  cam_id,
  obj_id
)

parameters

cam_id ID camera identifier
obj_id ID object identifier

return values

collision BOOLEAN collision: 1 (true) or 0 (false)

code sample

collision = gh_camera.frustum_check_object_sphere(cam_id, obj_id)

syntax

collision = gh_camera.frustum_check_point (
  cam_id,
  x, y, z
)

parameters

cam_id ID camera identifier
x, y, z REAL position of the point

return values

collision BOOLEAN collision: 1 (true) or 0 (false)

code sample

collision = gh_camera.frustum_check_point(cam_id, x, y, z)

syntax

collision = gh_camera.frustum_check_sphere (
  cam_id,
  x, y, z
)

parameters

cam_id ID camera identifier
x, y, z REAL position of the sphere center

return values

collision BOOLEAN collision: 1 (true) or 0 (false)

code sample

collision = gh_camera.frustum_check_sphere(cam_id, radius, x, y, z)

syntax

gh_camera.frustum_update (
  cam_id
)

parameters

cam_id ID camera identifier

return values

none

code sample

gh_camera.frustum_update(cam_id)

syntax

pitch, yaw, roll = gh_camera.get_euler_angles (
  cam_id
)

parameters

cam_id ID camera identifier

return values

pitch, yaw, roll REAL Euler's angles in degrees

code sample

pitch, yaw, roll = gh_camera.get_euler_angles(cam_id)

syntax

fov = gh_camera.get_fov (
  cam_id
)

parameters

cam_id ID camera identifier

return values

fov REAL vertical field of view in degrees

code sample

fov = gh_camera.get_fov(cam_id)

syntax

x, y, z = gh_camera.get_position (
  cam_id
)

parameters

cam_id ID camera identifier

return values

x, y, z REAL position

code sample

x, y, z = gh_camera.get_position(cam_id)

syntax

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_camera.get_projection_matrix (
  cam_id
)

parameters

cam_id ID camera identifier

return values

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

code sample

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_camera.get_projection_matrix(cam_id)

syntax

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_camera.get_projection_matrix_4x4 (
  cam_id
)

parameters

cam_id ID camera identifier

return values

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

code sample

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_camera.get_projection_matrix_4x4(cam_id)

syntax

x, y, z = gh_camera.get_up_vector (
  cam_id
)

parameters

cam_id ID camera identifier

return values

x, y, z REAL up vector

code sample

x, y, z = gh_camera.get_up_vector(cam_id)

syntax

x, y, z = gh_camera.get_view (
  cam_id
)

parameters

cam_id ID camera identifier

return values

x, y, z REAL view vector

code sample

x, y, z = gh_camera.get_view(cam_id)

syntax

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_camera.get_view_matrix (
  cam_id
)

parameters

cam_id ID camera identifier

return values

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

code sample

m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 = gh_camera.get_view_matrix(cam_id)

syntax

x, y, z, w = gh_camera.get_view_quaternion (
  cam_id
)

parameters

cam_id ID camera identifier

return values

x, y, z, w REAL view quaternion

code sample

x, y, z, w = gh_camera.get_view_quaternion(cam_id)

syntax

gh_camera.load_gl2_matrix (
  cam_id,
  load_proj_mat,
  load_view_mat,
  object_id
)

parameters

cam_id ID camera identifier
load_proj_mat BOOLEAN load the projection matrix (0 or 1)
load_view_mat BOOLEAN load the view matrix (0 or 1)
object_id ID object identifier

return values

none

code sample

load_proj_mat = 1			
load_view_mat = 1
gh_camera.load_gl2_matrix(cam_id, load_proj_mat, load_view_mat, object_id)

syntax

gh_camera.reset_reflection_matrix (
  cam_id
)

parameters

cam_id ID camera identifier

return values

none

code sample

gh_camera.reset_reflection_matrix(cam_id)

syntax

gh_camera.set_fov (
  cam_id,
  fov
)

parameters

cam_id ID camera identifier
fov REAL vertical field of view in degrees

return values

none

code sample

gh_camera.set_fov(cam_id, 90)

syntax

gh_camera.set_lookat (
  cam_id,
  x, y, z,
  lookat_mode
)

parameters

cam_id ID camera identifier
x, y, z REAL the target
lookat_mode REAL 1: the target is a point (3D position) or 0: the target is a direction (3D vector)

return values

none

code sample

-- Look at the center of the scene:
gh_camera.set_lookat(cam_id, 0, 0, 0, 1)

syntax

gh_camera.set_orientation_cubemap (
  cam_id,
  face
)

parameters

cam_id ID camera identifier
face INTEGER cubemap face (0 to 5)

return values

none

code sample

for face = 0, 5 do
    gh_camera.set_orientation_cubemap(cam_id, face)
    ...
end

syntax

gh_camera.set_pitch (
  cam_id,
  pitch
)

parameters

cam_id ID camera identifier
pitch REAL pitch in degrees

return values

none

code sample

gh_camera.set_pitch(cam_id, pitch)

syntax

gh_camera.set_position (
  cam_id,
  x, y, z
)

parameters

cam_id ID camera identifier
x, y, z REAL 3D position of the camera

return values

none

code sample

gh_camera.set_position(cam_id, 0, 10, 20)

syntax

gh_camera.set_projection_matrix (
  cam_id,
  m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15
)

parameters

cam_id ID camera identifier
m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

return values

none

code sample

gh_camera.set_projection_matrix(cam_id, m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15)

syntax

gh_camera.set_reflection_matrix_v1 (
  cam_id,
  px, py, pz,
  nx, ny, nz,
  y
)

parameters

cam_id ID camera identifier
px, py, pz REAL mirror plane position
nx, ny, nz REAL mirror plane normal
y REAL y offset - default: 0

return values

none

code sample

gh_camera.set_reflection_matrix_v1(cam_id, 0, 10, 0, 0, 0, 1)

syntax

gh_camera.set_reflection_matrix_v2 (
  cam_id,
  a, b, c, d
)

parameters

cam_id ID camera identifier
a, b, c, d REAL mirror plane equation

return values

none

code sample

a, b, c, d = gh_object.get_plane_equation(mirror_plane)

gh_camera.set_reflection_matrix_v2(cam_id, a, b, c, d)

syntax

gh_camera.set_reflection_matrix_v3 (
  cam_id,
  m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15
)

parameters

cam_id ID camera identifier
m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

return values

none

code sample

gh_camera.set_reflection_matrix_v3(cam_id, m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15)

syntax

gh_camera.set_roll (
  cam_id,
  roll
)

parameters

cam_id ID camera identifier
roll REAL roll in degrees

return values

none

code sample

gh_camera.set_roll(cam_id, roll)

syntax

gh_camera.set_up_vec (
  cam_id,
  x, y, z
)

parameters

cam_id ID camera identifier
x, y, z REAL direction of the up vector

return values

none

code sample

-- The up vector is the unit Y axis.
gh_camera.set_up_vec(cam_id, 0, 1, 0)

syntax

gh_camera.set_view_matrix (
  cam_id,
  m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15
)

parameters

cam_id ID camera identifier
m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15 REAL the 16 floats that make the 4x4 matrix

return values

none

code sample

gh_camera.set_view_matrix(cam_id, m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15)

syntax

gh_camera.set_viewport (
  cam_id,
  x,
  y,
  width,
  height
)

parameters

cam_id ID camera identifier
x INTEGER x offset - default: 0
y INTEGER y offset - default: 0
width INTEGER width of the viewport
height INTEGER height of the viewport

return values

none

code sample

gh_camera.set_viewport(cam_id, 0, 0, screen_width, screen_height)

syntax

gh_camera.set_yaw (
  cam_id,
  yaw
)

parameters

cam_id ID camera identifier
yaw REAL yaw in degrees

return values

none

code sample

gh_camera.set_yaw(cam_id, yaw)

syntax

gh_camera.update_ortho (
  cam_id,
  left,
  right,
  bottom,
  top,
  znear,
  zfar
)

parameters

cam_id ID camera identifier
left REAL left clipping plane
right REAL right clipping plane
bottom REAL bottom clipping plane
top REAL top clipping plane
znear REAL near clipping plane
zfar REAL far clipping plane

return values

none

code sample

w = screen_width
h = screen_height

gh_camera.update_ortho(cam_id, -w/2, w/2, -h/2, h/2, 1.0, -1.0)

syntax

gh_camera.update_persp (
  cam_id,
  fov,
  aspect,
  znear,
  zfar
)

parameters

cam_id ID camera identifier
fov REAL field of view in degres
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

none

code sample

gh_camera.update_persp(cam_id, 60, 1.333, 0.1, 1000.0)

syntax

gh_camera.update_persp_v2 (
  cam_id,
  fov,
  is_vertical_fov,
  aspect,
  znear,
  zfar
)

parameters

cam_id ID camera identifier
fov REAL field of view in degres
is_vertical_fov BOOLEAN 1 (vertical fov) or 0 (horizontal fov)
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

none

code sample

local is_vertical_fov = 1
gh_camera.update_persp_v2(cam_id, 60, is_vertical_fov, 1.333, 0.1, 1000.0)

syntax

gh_camera.update_perspective_vk (
  cam_id,
  fov,
  aspect,
  znear,
  zfar
)

parameters

cam_id ID camera identifier
fov REAL field of view in degres
aspect REAL aspect ratio (usually screen_width / screen_height)
znear REAL near clipping plane
zfar REAL far clipping plane

return values

none

code sample

gh_camera.update_perspective_vk(cam_id, 60.0, winW/winH, 1.0, 1000.0)

syntax

x = gh_cuda.device_get_attribute_1i (
  dev_index,
  attr_name
)

parameters

dev_index INTEGER device index
attr_name ENUM( cuda_1i ) attribute name

return values

x INTEGER attribute value

code sample

--[[
"simd_width"
"mem_pitch"
"registers_per_block"
"texture_align"
"core_clock_rate"
"mem_clock_rate"
"mem_bus_width"
"mem_bandwidth_gbs"
"pci_bus_id"
"l2_cache_size"
"async_count"
"total_constant_memory"
"shared_mem_per_block"
"max_shared_mem_per_sm"
"max_threads_per_block"
"max_threads_per_sm"
"warp_size"
"multiprocessor_count"
"cuda_cores_per_sm"
"cuda_cores"
--]]

attribute = "multiprocessor_count"
x = gh_cuda.device_get_attribute_1i(0, attribute)

syntax

x, y = gh_cuda.device_get_attribute_2i (
  dev_index,
  attr_name
)

parameters

dev_index INTEGER device index
attr_name ENUM( cuda_2i ) attribute name

return values

x, y INTEGER attribute value

code sample

attribute = "compute_capability"
x, y = gh_cuda.device_get_attribute_2i(0, attribute)

syntax

x, y, z = gh_cuda.device_get_attribute_3i (
  dev_index,
  attr_name
)

parameters

dev_index INTEGER device index
attr_name ENUM( cuda_3i ) attribute name

return values

x, y, z INTEGER attribute value

code sample

-- "max_threads_dim"
-- "max_grid_size"
-- "max_block_dim"

attribute = "max_threads_dim"
x, y, z = gh_cuda.device_get_attribute_3i(0, attribute)

syntax

dev_name = gh_cuda.device_get_name (
  dev_index
)

parameters

dev_index INTEGER device index

return values

dev_name STRING name the CUDA device

code sample

name = gh_cuda.device_get_name(0)

syntax

pci_bus_id_str = gh_cuda.device_get_pci_bus_id_string (
  dev_index
)

parameters

dev_index INTEGER device index

return values

pci_bus_id_str STRING PCI bus ID string

code sample

pci_bus_id_str = gh_cuda.device_get_pci_bus_id_string(0)

syntax

total_memory = gh_cuda.device_get_total_memory (
  dev_index
)

parameters

dev_index INTEGER device index

return values

total_memory INTEGER memory amount in bytes

code sample

total_memory = gh_cuda.device_get_total_memory(0)

syntax

version = gh_cuda.get_driver_version()

parameters

none

return values

version INTEGER version

code sample

version = gh_cuda.get_driver_version()

syntax

num_devices = gh_cuda.get_num_devices()

parameters

none

return values

num_devices INTEGER number of CUDA devices

code sample

num_devices = gh_cuda.get_num_devices()

syntax

num_cores_per_sm = gh_cuda.sm_version_to_num_cores (
  cc_major,
  cc_minor
)

parameters

cc_major INTEGER major version of compute capability
cc_minor INTEGER minor version of compute capability

return values

num_cores_per_sm INTEGER number of cores per SM

code sample

num_cores_per_sm = gh_cuda.sm_version_to_num_cores(6, 0)

syntax

dev_name = gh_flex.get_compute_device_name()

parameters

none

return values

dev_name STRING device name

code sample

gpu = gh_flex.get_compute_device_name()

syntax

v = gh_flex.get_version()

parameters

none

return values

v INTEGER version

code sample

v = gh_flex.get_version()

syntax

gh_flex.make_phase (
  group,
  particle_flags,
  shape_channels
)

parameters

group INTEGER particle group
particle_flags ENUM( flex_particle_flags ) flags
shape_channels ENUM( flex_particle_flags ) channels for collisions

return values

none

code sample

-- Flags / options
--
eNvFlexPhaseSelfCollide	= 1048576 -- If set this particle will interact with particles of the same group
eNvFlexPhaseSelfCollideFilter	= 2097152 -- If set this particle will ignore collisions with particles closer than the radius in the rest pose, this flag should not be specified unless valid rest positions have been specified using NvFlexSetRestParticles()
eNvFlexPhaseFluid	= 4194304 -- If set this particle will generate fluid density constraints for its overlapping neighbors
eNvFlexPhaseGroupMask = 1048575 -- Bits [ 0, 19] represent the particle group for controlling collisions
eNvFlexPhaseFlagsMask	= 15728640 -- Bits [20, 23] hold flags about how the particle behave
eNvFlexPhaseShapeChannelMask = 2130706432 -- Bits [24, 30] hold flags representing what shape collision channels particles will collide with, see NvFlexMakeShapeFlags() (highest bit reserved for now)
eNvFlexPhaseShapeChannel0	= 16777216 -- Particle will collide with shapes 
with channel 0 set (see NvFlexMakeShapeFlags())
eNvFlexPhaseShapeChannel1 = 33554432

group = 0
particle_flags = eNvFlexPhaseSelfCollide
shape_channels = eNvFlexPhaseShapeChannelMask

phase = gh_flex.make_phase(group, particle_flags, shape_channels)

syntax

gh_flex.particles_copy_position_to_vb_fast (
  particles_id,
  vb_id,
  num_particles
)

parameters

particles_id ID particle set identifier
vb_id ID rendering vertex buffer identifier
num_particles INTEGER number of particles

return values

none

code sample

gh_flex.particles_copy_position_to_vb_fast(particles_id, vb_id, num_vertices)

syntax

gh_flex.particles_copy_to_vb (
  particles_id,
  particle_attrib,
  vb_id,
  num_particles,
  vb_start_offset_bytes,
  vb_position_stride_bytes,
  update_color_alpha,
  dt
)

parameters

particles_id ID particle set identifier
particle_attrib ENUM( flex_particle_attrib_name ) particle attribute
vb_id ID rendering vertex buffer identifier
num_particles INTEGER number of particles
vb_start_offset_bytes INTEGER start offset in bytes in the vertex buffer
vb_position_stride_bytes INTEGER size of a vertex in bytes in the vertex buffer. In code samples, the vertex is {vec4 position + vec4 color}. The size is then 32 bytes.
update_color_alpha BOOLEAN updates the alpha value of the color by decreasing it with time step (alpha = alpha - dt): 1 (true) or 0 (false)
dt REAL time step for updating the alpha value

return values

none

code sample

local vb_start_offset_bytes = 0
local vb_position_stride_bytes = 32
local update_color_alpha = 0
local dt = 0.016

gh_flex.particles_copy_to_vb(particles_id, "position", vb_id, num_vertices, vb_start_offset_bytes, vb_position_stride_bytes, update_color_alpha, dt)

-- particles_copy_to_vb() replaces the following code:
--
--[[
function point(buffer_ptr, index, x, y, z, r, g, b, a)
    -- Position
    local buffer_offset_bytes = index * vertex_size
    gh_utils.buffer_write_4f(buffer_ptr, buffer_offset_bytes, x, y, z, 1.0)

    -- Color
    buffer_offset_bytes = buffer_offset_bytes + attrib_size
    gh_utils.buffer_write_4f(buffer_ptr, buffer_offset_bytes, r, g, b, a)
end

gh_flex.particles_map_position(particles_id)
vb_buffer_ptr, bufsize = gh_vb.map(vb_id, "GL_WRITE_ONLY")

for i = 0, num_vertices - 1 do
    x, y, z, w = gh_flex.particles_get_position(particles_id, i)
    local alpha = particles[i+1].a
    if (update_color_alpha == 1) then
        alpha = alpha - dt
        if (alpha < 0) then
            alpha = 0
        end
    end
    particles[i+1].a = alpha
    point(vb_buffer_ptr, i, x, y, z, 1, 1, 1, alpha)
end

gh_vb.unmap(vb_id)
gh_flex.particles_unmap_position(particles_id)
--]]

syntax

particles_id = gh_flex.particles_create (
  num_particles
)

parameters

num_particles INTEGER number of particles in the set

return values

particles_id ID particle set identifier

code sample

num_particles = 1000
particles_id = gh_flex.particles_create(num_particles)

syntax

phase = gh_flex.particles_get_phase (
  particles_id,
  particle_index
)

parameters

particles_id ID particle set identifier
particle_index INTEGER particle index

return values

phase INTEGER value of the phase

code sample

phase = gh_flex.particles_get_phase(particles_id, particle_index)

syntax

x, y, z, w = gh_flex.particles_get_position (
  particles_id,
  particle_index
)

parameters

particles_id ID particle set identifier
particle_index INTEGER particle index

return values

x, y, z, w REAL 3D position

code sample

x, y, z, w = gh_flex.particles_get_position(particles_id, particle_index)

syntax

x, y, z = gh_flex.particles_get_velocity (
  particles_id,
  particle_index
)

parameters

particles_id ID particle set identifier
particle_index INTEGER particle index

return values

x, y, z REAL velocity vector

code sample

x, y, z = gh_flex.particles_get_velocity(particles_id, index)

syntax

gh_flex.particles_kill (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_kill(particles_id)

syntax

gh_flex.particles_map_active_indices (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_map_active_indices(particles_id)

syntax

gh_flex.particles_map_phase (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_map_phase(particles_id)

syntax

gh_flex.particles_map_position (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_map_position(particles_id)

syntax

gh_flex.particles_map_velocity (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_map_velocity(particles_id)

syntax

gh_flex.particles_set_active_index (
  particles_id,
  index,
  particle_index
)

parameters

particles_id ID particle set identifier
index INTEGER index in the active buffer
particle_index INTEGER particle index

return values

none

code sample

-- All the following code can be replaced by one call to particles_update_active()

-- Usually particles_set_active_index() is used as follows:
--

gh_flex.particles_map_active_indices(particles_id)

for i = 0, num_particles - 1 do
    gh_flex.particles_set_active_index(particles_id, i, i)
end

gh_flex.particles_unmap_active_indices(particles_id)
gh_flex.particles_set_num_active_indices(particles_id, num_particles)

-- Upload to GPU
gh_flex.solver_write_particles(solver_id, particles_id)

syntax

gh_flex.particles_set_num_active_indices (
  particles_id,
  num_active
)

parameters

particles_id ID particle set identifier
num_active INTEGER number of active particles

return values

none

code sample

gh_flex.particles_set_num_active_indices(particles_id, num_active)

syntax

gh_flex.particles_set_phase (
  particles_id,
  particle_index,
  phase
)

parameters

particles_id ID particle set identifier
particle_index INTEGER particle index
phase INTEGER particle phase

return values

none

code sample

gh_flex.particles_map_position(particles_id)
gh_flex.particles_map_velocity(particles_id)
gh_flex.particles_map_phase(particles_id)

phase = gh_flex.make_phase(...)

for i = 0, num_particles - 1 do
    x = random(...)
    y = random(...)
    z = random(...)

    -- Mass = 1.0
    w = 1.0
    gh_flex.particles_set_position(particles_id, i, x, y, z, w)

    -- Initial velocity is zero
    gh_flex.particles_set_velocity(particles_id, i, 0.0, 0.0, 0.0)
    gh_flex.particles_set_phase(particles_id, i, phase)
end

gh_flex.particles_unmap_phase(particles_id)
gh_flex.particles_unmap_velocity(particles_id)
gh_flex.particles_unmap_position(particles_id)

-- Upload to GPU
gh_flex.solver_write_particles(solver_id, particles_id)

syntax

gh_flex.particles_set_position (
  particles_id,
  particle_index,
  x, y, z, w
)

parameters

particles_id ID particle set identifier
particle_index INTEGER particle index
x, y, z, w REAL particle position - w holds the inverse of the mass: w=1.0/mass.

return values

none

code sample

gh_flex.particles_map_position(particles_id)

for i = 0, num_particles - 1 do
    x = random(...)
    y = random(...)
    z = random(...)

    -- Mass = 1.0
    w = 1.0
    gh_flex.particles_set_position(particles_id, i, x, y, z, w)
end

gh_flex.particles_unmap_position(particles_id)

-- Upload to GPU
gh_flex.solver_write_particles(solver_id, particles_id)

syntax

gh_flex.particles_set_velocity (
  particles_id,
  particle_index,
  x, y, z
)

parameters

particles_id ID particle set identifier
particle_index INTEGER particle index
x, y, z REAL particle velocity

return values

none

code sample

gh_flex.particles_map_position(particles_id)
gh_flex.particles_map_velocity(particles_id)

for i = 0, num_particles - 1 do
    x = random(...)
    y = random(...)
    z = random(...)

    -- Mass = 1.0
    w = 1.0
    gh_flex.particles_set_position(particles_id, i, x, y, z, w)

    -- Initial velocity is zero.
    gh_flex.particles_set_velocity(particles_id, i, 0.0, 0.0, 0.0)
end

gh_flex.particles_unmap_velocity(particles_id)
gh_flex.particles_unmap_position(particles_id)

-- Upload to GPU
gh_flex.solver_write_particles(solver_id, particles_id)

syntax

gh_flex.particles_unmap_active_indices (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_unmap_active_indices(particles_id)

syntax

gh_flex.particles_unmap_phase (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_unmap_phase(particles_id)

syntax

gh_flex.particles_unmap_position (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_unmap_position(particles_id)

syntax

gh_flex.particles_unmap_velocity (
  particles_id
)

parameters

particles_id ID particle set identifier

return values

none

code sample

gh_flex.particles_unmap_velocity(particles_id)

syntax

gh_flex.particles_update_active (
  particles_id,
  num_active_particles
)

parameters

particles_id ID particle set identifier
num_active_particles INTEGER number of active particles

return values

none

code sample

gh_flex.particles_update_active(particles_id, num_active_particles)

-- particles_update_active() replaces the following code:
--
--[[
gh_flex.particles_set_num_active_indices(particles_id, num_vertices)
gh_flex.particles_map_active_indices(particles_id)

for i = 0, num_vertices - 1 do
    gh_flex.particles_set_active_index(particles_id, i, i)
end

gh_flex.particles_unmap_active_indices(particles_id)
--]]

syntax

gh_flex.set_device_index (
  i
)

parameters

i INTEGER device index

return values

none

code sample

gh_flex.set_device_index(-1)

syntax

shapes_id = gh_flex.shapes_create (
  num_shapes
)

parameters

num_shapes INTEGER number of shapes in the set

return values

shapes_id ID shapes set identifier

code sample

num_shapes = 2
shapes_id = gh_flex.shapes_create(num_shapes)

syntax

gh_flex.shapes_kill (
  shapes_id
)

parameters

shapes_id ID shapes set identifier

return values

none

code sample

gh_flex.shapes_kill(shapes_id)

syntax

gh_flex.shapes_map (
  shapes_id
)

parameters

shapes_id ID shapes set identifier

return values

none

code sample

gh_flex.shapes_map(shapes_id)

syntax

gh_flex.shapes_set_box (
  shapes_id,
  shape_index,
  shape_channels,
  width, height, depth,
  x, y, z,
  qx, qy, qz, qw
)

parameters

shapes_id ID shapes set identifier
shape_index INTEGER index of the shape between 0 ; num_shapes-1
shape_channels ENUM( flex_particle_flags ) channels for collisions
width, height, depth REAL box size
x, y, z REAL box position
qx, qy, qz, qw REAL box orientation (quaternion)

return values

none

code sample

gh_flex.shapes_map(shapes_id)
shape_index = 0
shape_channels = eNvFlexPhaseShapeChannel0
width = 2.0
height = 2.0
depth = 2.0
gh_flex.shapes_set_box(shapes_id, shape_index, shape_channels,  width, height, depth,  0.0, 1.0, 0.0,  0.0, 0.0, 0.0, 1.0)
gh_flex.shapes_unmap(shapes_id)

syntax

gh_flex.shapes_set_box_v2 (
  shapes_id,
  shape_index,
  shape_channels,
  width, height, depth,
  x, y, z,
  pitch, yaw, roll
)

parameters

shapes_id ID shapes set identifier
shape_index INTEGER index of the shape between 0 ; num_shapes-1
shape_channels ENUM( flex_particle_flags ) channels for collisions
width, height, depth REAL box size
x, y, z REAL box position
pitch, yaw, roll REAL box orientation (Euler's angles)

return values

none

code sample

gh_flex.shapes_map(shapes_id)

shape_index = 0
shape_channels = eNvFlexPhaseShapeChannel0
width = 2.0
height = 2.0
depth = 2.0

gh_flex.shapes_set_box_v2(shapes_id, shape_index, shape_channels,  width, height, depth,  0.0, 1.0, 0.0,  0.0, 0.0, 0.0)

gh_flex.shapes_unmap(shapes_id)

syntax

gh_flex.shapes_set_mesh (
  shapes_id,
  shape_index,
  shape_channels,
  mesh_id,
  x, y, z,
  qx, qy, qz, qw
)

parameters

shapes_id ID shapes set identifier
shape_index INTEGER index of the shape between 0 ; num_shapes-1
shape_channels ENUM( flex_particle_flags ) channels for collisions
mesh_id ID mesh identifier
x, y, z REAL mesh position
qx, qy, qz, qw REAL mesh orientation (quaternion)

return values

none

code sample

gh_flex.shapes_map(shapes_id)

shape_index = 0
shape_channels = eNvFlexPhaseShapeChannel0
mesh_id = gh_mesh.create_torus(2.0, 0.4, 20)

gh_flex.shapes_set_mesh(shapes_id, shape_index, shape_channels,  mesh_id,  0.0, 2.0, 0.0,  0.0, 0.0, 0.0, 1.0)

gh_flex.shapes_unmap(shapes_id)

syntax

gh_flex.shapes_set_mesh_v2 (
  shapes_id,
  shape_index,
  shape_channels,
  mesh_id,
  x, y, z,
  pitch, yaw, roll
)

parameters

shapes_id ID shapes set identifier
shape_index INTEGER index of the shape between 0 ; num_shapes-1
shape_channels ENUM( flex_particle_flags ) channels for collisions
mesh_id ID mesh identifier
x, y, z REAL mesh position
pitch, yaw, roll REAL box orientation (Euler's angles)

return values

none

code sample

gh_flex.shapes_map(shapes_id)

shape_index = 0
shape_channels = eNvFlexPhaseShapeChannel0
mesh_id = gh_mesh.create_torus(2.0, 0.4, 20)

gh_flex.shapes_set_mesh_v2(shapes_id, shape_index, shape_channels,  mesh_id,  0.0, 2.0, 0.0,  0.0, 0.0, 0.0)

gh_flex.shapes_unmap(shapes_id)

syntax

gh_flex.shapes_set_sphere (
  shapes_id,
  shape_index,
  shape_channels,
  radius,
  x, y, z
)

parameters

shapes_id ID shapes set identifier
shape_index INTEGER index of the shape between 0 ; num_shapes-1
shape_channels ENUM( flex_particle_flags ) channels for collisions
radius REAL sphere radius
x, y, z REAL sphere position

return values

none

code sample

gh_flex.shapes_map(shapes_id)

shape_index = 0
shape_channels = eNvFlexPhaseShapeChannel0
radius = 2.0

gh_flex.shapes_set_sphere(shapes_id, shape_index, shape_channels, radius, 0.0, 3.0, 0.0)

gh_flex.shapes_unmap(shapes_id)

syntax

gh_flex.shapes_unmap (
  shapes_id
)

parameters

shapes_id ID shapes set identifier

return values

none

code sample

gh_flex.shapes_unmap(shapes_id)

syntax

solver_id = gh_flex.solver_create (
  max_particles
)

parameters

max_particles INTEGER max number of particles managed by the solver

return values

solver_id ID solver identifier

code sample

max_particles = 1000
solver_id = gh_flex.solver_create(max_particles)

syntax

gh_flex.solver_kill (
  solver_id
)

parameters

solver_id ID solver identifier

return values

none

code sample

gh_flex.solver_kill(solver_id)

syntax

gh_flex.solver_set_num_active_particles (
  solver_id,
  num_active_particles
)

parameters

solver_id ID solver identifier
num_active_particles INTEGER shapes identifier

return values

none

code sample

gh_flex.solver_set_num_active_particles(solver_id, num_active_particles)

syntax

gh_flex.solver_set_param_1f (
  solver_id,
  param_name,
  x
)

parameters

solver_id ID solver identifier
param_name ENUM( flex_solver_param_1f ) param name
x REAL value

return values

none

code sample

params = [[
float radius;						//!< The maximum interaction radius for particles
float solidRestDistance;			//!< The distance non-fluid particles attempt to maintain from each other, must be in the range (0, radius]
float fluidRestDistance;			//!< The distance fluid particles are spaced at the rest density, must be in the range (0, radius], for fluids this should generally be 50-70% of mRadius, for rigids this can simply be the same as the particle radius
// common params
float dynamicFriction;				//!< Coefficient of friction used when colliding against shapes
float staticFriction;				//!< Coefficient of static friction used when colliding against shapes
float particleFriction;				//!< Coefficient of friction used when colliding particles
float restitution;					//!< Coefficient of restitution used when colliding against shapes, particle collisions are always inelastic
float adhesion;						//!< Controls how strongly particles stick to surfaces they hit, default 0.0, range [0.0, +inf]
float sleepThreshold;				//!< Particles with a velocity magnitude < this threshold will be considered fixed
float maxSpeed;						//!< The magnitude of particle velocity will be clamped to this value at the end of each step
float maxAcceleration;				//!< The magnitude of particle acceleration will be clamped to this value at the end of each step (limits max velocity change per-second), useful to avoid popping due to large interpenetrations
float shockPropagation;				//!< Artificially decrease the mass of particles based on height from a fixed reference point, this makes stacks and piles converge faster
float dissipation;					//!< Damps particle velocity based on how many particle contacts it has
float damping;						//!< Viscous drag force, applies a force proportional, and opposite to the particle velocity
// cloth params
float drag;							//!< Drag force applied to particles belonging to dynamic triangles, proportional to velocity^2*area in the negative velocity direction
float lift;							//!< Lift force applied to particles belonging to dynamic triangles, proportional to velocity^2*area in the direction perpendicular to velocity and (if possible), parallel to the plane normal
// fluid params
float cohesion;						//!< Control how strongly particles hold each other together, default: 0.025, range [0.0, +inf]
float surfaceTension;				//!< Controls how strongly particles attempt to minimize surface area, default: 0.0, range: [0.0, +inf]
float viscosity;					//!< Smoothes particle velocities using XSPH viscosity
float vorticityConfinement;			//!< Increases vorticity by applying rotational forces to particles
float anisotropyScale;				//!< Control how much anisotropy is present in resulting ellipsoids for rendering, if zero then anisotropy will not be calculated, see NvFlexGetAnisotropy()
float anisotropyMin;				//!< Clamp the anisotropy scale to this fraction of the radius
float anisotropyMax;				//!< Clamp the anisotropy scale to this fraction of the radius
float smoothing;					//!< Control the strength of Laplacian smoothing in particles for rendering, if zero then smoothed positions will not be calculated, see NvFlexGetSmoothParticles()
float solidPressure;				//!< Add pressure from solid surfaces to particles
float freeSurfaceDrag;				//!< Drag force applied to boundary fluid particles
float buoyancy;						//!< Gravity is scaled by this value for fluid particles
// diffuse params
float diffuseThreshold;				//!< Particles with kinetic energy + divergence above this threshold will spawn new diffuse particles
float diffuseBuoyancy;				//!< Scales force opposing gravity that diffuse particles receive
float diffuseDrag;					//!< Scales force diffuse particles receive in direction of neighbor fluid particles
float diffuseLifetime;				//!< Time in seconds that a diffuse particle will live for after being spawned, particles will be spawned with a random lifetime in the range [0, diffuseLifetime]
// collision params
float collisionDistance;			//!< Distance particles maintain against shapes, note that for robust collision against triangle meshes this distance should be greater than zero
float particleCollisionMargin;		//!< Increases the radius used during neighbor finding, this is useful if particles are expected to move significantly during a single step to ensure contacts aren't missed on subsequent iterations
float shapeCollisionMargin;			//!< Increases the radius used during contact finding against kinematic shapes
float relaxationFactor;				//!< Control the convergence rate of the parallel solver, default: 1, values greater than 1 may lead to instability
]]

gh_flex.solver_set_param_1f(solver_id, "radius", 0.1)
gh_flex.solver_set_param_1f(solver_id, "dynamicFriction", 0.15)

syntax

gh_flex.solver_set_param_1i (
  solver_id,
  param_name,
  x
)

parameters

solver_id ID solver identifier
param_name ENUM( flex_solver_param_1i ) param name
x INTEGER value

return values

none

code sample

params = [[
int numIterations;					//!< Number of solver iterations to perform per-substep
int diffuseBallistic;				//!< The number of neighbors below which a diffuse particle is considered ballistic
int numPlanes;						//!< Num collision planes
]]

gh_flex.solver_set_param_1i(solver_id, "numIterations", 2)

syntax

gh_flex.solver_set_param_3f (
  solver_id,
  param_name,
  x, y, z
)

parameters

solver_id ID solver identifier
param_name ENUM( flex_solver_param_3f ) param name
x, y, z REAL value

return values

none

code sample

params = [[
float gravity[3];					//!< Constant acceleration applied to all particles
// cloth params
float wind[3];						//!< Constant acceleration applied to particles that belong to dynamic triangles, drag needs to be > 0 for wind to affect triangles
]]

gh_flex.solver_set_param_1f(solver_id, "gravity", 0.0, -10.0, 0.0)

syntax

gh_flex.solver_set_param_collision_plane (
  solver_id,
  plane_index,
  a, b, c, d
)

parameters

solver_id ID solver identifier
plane_index INTEGER index of the plane: 0 to 7 (8 planes)
a, b, c, d REAL plane equation: ax + by + cz + d = 0

return values

none

code sample

gh_flex.solver_set_param_1i(solver_id, "numPlanes", 1)

plane_index = 0
gh_flex.solver_set_param_collision_plane(solver_id, plane_index, 0.0, 1.0, 0.0, 0.0)

syntax

gh_flex.solver_update (
  solver_id,
  dt,
  substeps
)

parameters

solver_id ID solver identifier
dt REAL time step
substeps INTEGER number of simulation substeps

return values

none

code sample

substeps = 2
gh_flex.solver_update(solver_id, dt, substeps)

syntax

gh_flex.solver_update_params (
  solver_id
)

parameters

solver_id ID solver identifier

return values

none

code sample

gh_flex.solver_update_params(solver_id)

syntax

gh_flex.solver_write_particles (
  solver_id,
  particles_id
)

parameters

solver_id ID solver identifier
particles_id ID particles identifier

return values

none

code sample

num_particles = 1000

particles_id = gh_flex.particles_create(num_particles)
...
gh_flex.solver_write_particles(solver_id, particles_id)

syntax

gh_flex.solver_write_shapes (
  solver_id,
  shapes_id
)

parameters

solver_id ID solver identifier
shapes_id ID shapes identifier

return values

none

code sample

num_shapes = 2

shapes_id = gh_flex.shapes_create(num_shapes)
...
gh_flex.solver_write_shapes(solver_id, shapes_id)

syntax

state = gh_flex.start()

parameters

none

return values

state BOOLEAN 1 (success) or 0 (error)

code sample

flex_ok = gh_flex.start()

if (flex_ok == 0) then
    -- error
end

syntax

state = gh_flex.stop()

parameters

none

return values

state BOOLEAN 1 (success) or 0 (error)

code sample

state = gh_flex.stop()

syntax

gh_font.build_texture (
  font_id,
  tex_unit
)

parameters

font_id ID font identifier
tex_unit INTEGER texture unit

return values

none

code sample

gh_font.build_texture(font_id, 0)

syntax

gh_font.clear (
  font_id
)

parameters

font_id ID font identifier

return values

none

code sample

gh_font.clear(font_id)
gh_font.text_2d(font_id, x, y, r, g, b, a, "Hello!")
gh_font.update(font_id, 0)
gh_font.render(font_id)

syntax

font_id = gh_font.create (
  font_filename,
  font_height,
  font_tex_width,
  font_texture_height
)

parameters

font_filename STRING absolute path of the TTF/OTF file
font_height INTEGER height of the font
font_tex_width INTEGER width in pixels of the texture font
font_texture_height INTEGER height in pixels of the texture font

return values

font_id ID font identifier

code sample

local demo_dir = gh_utils.get_demo_dir()
font_id = gh_font.create(demo_dir .. "./data/kool.ttf", 24, 512, 512)

syntax

font_id = gh_font.create_from_buffer (
  buff_ptr,
  buff_size,
  font_height,
  font_tex_width,
  font_texture_height,
  char_offset_start,
  num_chars
)

parameters

buff_ptr POINTER pointer to the buffer
buff_size INTEGER size of the buffer in bytes
font_height INTEGER height of the font
font_tex_width INTEGER width in pixels of the texture font
font_texture_height INTEGER height in pixels of the texture font
char_offset_start INTEGER start char offset (0 … 254). Default value: 32
num_chars INTEGER number of chars in the texture. Default value: 256

return values

font_id ID font identifier

code sample

local demo_dir = gh_utils.get_demo_dir()
filename = demo_dir .. "assets/arial.ttf"
buffer, buffer_size = gh_utils.file_buffer_create(filename)

font_id = gh_font.create_from_buffer(buffer, buffer_size, 24, 512, 512, 32, 256)

gh_utils.file_buffer_kill(buffer)

syntax

font_id = gh_font.create_from_sqlite3_blob (
  db_id,
  column,
  font_height,
  font_tex_width,
  font_texture_height,
  char_offset_start,
  num_chars
)

parameters

db_id ID database identifier
column INTEGER index of the column
font_height INTEGER height of the font
font_tex_width INTEGER width in pixels of the texture font
font_texture_height INTEGER height in pixels of the texture font
char_offset_start INTEGER start char offset (0 … 254). Default value: 32
num_chars INTEGER number of chars in the texture. Default value: 256

return values

font_id ID font identifier

code sample

font_id = gh_font.create_from_sqlite3_blob(db_id, column, 24, 512, 512, 32, 256)

syntax

font_id = gh_font.create_from_zip (
  zip_filename,
  filename,
  font_height,
  font_tex_width,
  font_texture_height,
  char_offset_start,
  num_chars
)

parameters

zip_filename STRING absolute path of the zip file
filename STRING font file in the zip archive
font_height INTEGER height of the font
font_tex_width INTEGER width in pixels of the texture font
font_texture_height INTEGER height in pixels of the texture font
char_offset_start INTEGER start char offset (0 … 254). Default value: 32
num_chars INTEGER number of chars in the texture. Default value: 256

return values

font_id ID font identifier

code sample

zip_filename = demo_dir .. "data.zip"
font_id = gh_font.create_from_zip_v1(zip_filename, "fonts/arial.ttf", 24, 512, 512, 32, 256)

syntax

font_id = gh_font.create_v2 (
  font_name,
  font_height,
  font_tex_width,
  font_texture_height
)

parameters

font_name ENUM( builtin_font ) the name of the built-in TTF font (see name in the code snippet)
font_height INTEGER height of the font
font_tex_width INTEGER width in pixels of the texture font
font_texture_height INTEGER height in pixels of the texture font

return values

font_id ID font identifier

code sample

local built_in_fonts = {"roboto_bold", "roboto_medium", "roboto_medium_italic", "technott", "hacked", "top_secret", "timeless_bold", "vcr_osd_mono1"}

font_id = gh_font.create_v2(built_in_fonts[1], 24, 512, 512)

syntax

font_id = gh_font.create_v3 (
  font_filename,
  font_height,
  font_tex_width,
  font_texture_height,
  char_offset_start,
  num_chars
)

parameters

font_filename STRING absolute path of the TTF/OTF file
font_height INTEGER height of the font
font_tex_width INTEGER width in pixels of the texture font
font_texture_height INTEGER height in pixels of the texture font
char_offset_start INTEGER offset of the first character (default: 32)
num_chars INTEGER number of characters (default: 256)

return values

font_id ID font identifier

code sample

char_offset_start = 32
num_chars = 256
font_id = gh_font.create(demo_dir .. "data/kool.ttf", 24, 512, 512, char_offset_start, num_chars)

syntax

num_strings = gh_font.get_num_strings (
  font_id
)

parameters

font_id ID font identifier

return values

num_strings INTEGER number of strings

code sample

num_strings = gh_font.get_num_strings(font_id)

syntax

num_chars = gh_font.get_string_num_chars (
  font_id,
  string_index
)

parameters

font_id ID font identifier
string_index INTEGER string index

return values

num_chars INTEGER number of characters

code sample

num_chars = gh_font.get_string_num_chars(font_id, string_index)

syntax

width = gh_font.get_text_width (
  font_id,
  text
)

parameters

font_id ID font identifier
text STRING text

return values

width INTEGER width of the text

code sample

text_width = gh_font.get_text_width(font_id, "Hello!")

syntax

width = gh_font.get_text_width_w (
  font_id,
  text
)

parameters

font_id ID font identifier
text STRING text

return values

width INTEGER width of the text

code sample

text_width = gh_font.get_text_width_w(font_id, "Hello!")

syntax

font_tex_id = gh_font.get_texture (
  font_id
)

parameters

font_id ID font identifier

return values

font_tex_id ID font texture identifier

code sample

font_tex = gh_font.get_texture(font_id)
...
gh_texture.bind(font_tex, 0)

syntax

gh_font.render (
  font_id
)

parameters

font_id ID font identifier

return values

none

code sample

gh_font.render(font_id)

syntax

gh_font.set_scale (
  font_id,
  scale
)

parameters

font_id ID font identifier
scale REAL scale factor (default: 1.0)

return values

none

code sample

gh_font.set_scale(font_id, 2.0)

syntax

gh_font.set_string_char_color_factor (
  font_id,
  string_index,
  char_index,
  r, g, b, a
)

parameters

font_id ID font identifier
string_index INTEGER string index
char_index INTEGER character index
r, g, b, a REAL color factor

return values

none

code sample

gh_font.set_string_char_color_factor(font_id, string_index, char_index, r, g, b, a)

syntax

gh_font.set_string_char_position_offset (
  font_id,
  string_index,
  char_index,
  x, y, z
)

parameters

font_id ID font identifier
string_index INTEGER string index
char_index INTEGER character index
x, y, z REAL offset vector

return values

none

code sample

gh_font.set_string_char_position_offset(font_id, string_index, char_index, x, y, z)

syntax

gh_font.text_2d (
  font_id,
  x, y,
  r, g, b, a,
  text
)

parameters

font_id ID font identifier
x, y REAL start position of the text
r, g, b, a REAL RGBA text color
text STRING text

return values

none

code sample

gh_font.text_2d(font_id, x, y, r, g, b, a, "Hello!")

syntax

gh_font.text_2d_v2 (
  font_id,
  r, g, b, a,
  text
)

parameters

font_id ID font identifier
r, g, b, a REAL RGBA text color
text STRING text

return values

none

code sample

gh_font.text_2d(font_id, x, y, r, g, b, a, "Hello...")
gh_font.text_2d_v2(font_id, r, g, b, a, " from GeeXLab!")

syntax

gh_font.text_3d (
  font_id,
  x, y, z,
  r, g, b, a
)

parameters

font_id ID font identifier
x, y, z REAL start position of the text
r, g, b, a REAL RGBA text color

return values

none

code sample

gh_font.text_3d(font_id, x, y, z, r, g, b, a, "Hello!")

syntax

gh_font.update (
  font_id,
  mapped_gpu_memory
)

parameters

font_id ID font identifier
mapped_gpu_memory BOOLEAN GPU memory mapping for direct updating: 1 (enabled) or 0 (disabled)

return values

none

code sample

gh_font.clear(font_id)
gh_font.text_2d(font_id, x, y, r, g, b, a, "Hello!")
gh_font.update(font_id, 0)
gh_font.render(font_id)

syntax

gh_font.update_texture_2d_array_layer (
  font_id,
  texarray_id,
  layer
)

parameters

font_id ID font identifier
texarray_id ID texture array identifier
layer INTEGER index of the layer in the texture array

return values

none

code sample

layer = 0
gh_font.update_texture_2d_array_layer(font_id, texarray_id, layer)

syntax

gh_font.wtext_2d (
  font_id,
  x, y,
  r, g, b, a,
  text
)

parameters

font_id ID font identifier
x, y REAL start position of the text
r, g, b, a REAL RGBA text color
text STRING text

return values

none

code sample

gh_font.wtext_2d(font_id, x, y, r, g, b, a, "Hello!")

syntax

gh_font.wtext_2d_v2 (
  font_id,
  r, g, b, a,
  text
)

parameters

font_id ID font identifier
r, g, b, a REAL RGBA text color
text STRING text

return values

none

code sample

gh_font.wtext_2d(font_id, x, y, r, g, b, a, "Hello...")
gh_font.wtext_2d_v2(font_id, r, g, b, a, " from GeeXLab!")

syntax

num_cus, num_wgps, num_rops, core_clock, mem_clock = gh_gml.amd_ags_get_gpu_info (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

num_cus INTEGER number of compute units
num_wgps INTEGER number of RDNA work group processors
num_rops INTEGER number of render output units
core_clock INTEGER core clock speed at 100% power in MHz
mem_clock INTEGER memory clock speed at 100% power in MHz

code sample

num_cus, num_wgps, num_rops, core_clock, mem_clock = gh_gml.amd_ags_get_gpu_info(gpu_index)

syntax

ver = gh_gml.amd_get_overdrive_version (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

ver INTEGER overdrive version

code sample

ver = gh_gml.amd_get_overdrive_version(gpu_index)

syntax

asic, soc = gh_gml.amd_get_power_rdna (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

asic, soc INTEGER power: ASIC and SoC

code sample

asic, soc = gh_gml.amd_get_power_rdna(gpu_index)

syntax

gpu, mem, hotstop = gh_gml.amd_get_temperatures_rdna (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

gpu, mem, hotstop INTEGER temperature of GPU, memory and hotstop/junction

code sample

gpu, mem, hotstop = gh_gml.amd_get_temperatures_rdna(gpu_index)

syntax

illum_value = gh_gml.geforce_logo_get_illumination (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

illum_value REAL logo illumination value

code sample

illum_value = gh_gml.geforce_logo_get_illumination(0)

syntax

is_supported = gh_gml.geforce_logo_is_illumination_supported (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

is_supported BOOLEAN supported: 1 (true) or 0 (false)

code sample

is_supported = gh_gml.geforce_logo_is_illumination_supported(0)

syntax

gh_gml.geforce_logo_set_illumination (
  gpu_index,
  illum_value
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)
illum_value REAL logo illumination value

return values

none

code sample

gh_gml.geforce_logo_set_illumination(0, illum_value)

syntax

power, temperature, voltage, overvoltage = gh_gml.get_all_limiting_policies (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

power, temperature, voltage, overvoltage BOOLEAN limited: 1 (true) or 0 (false)

code sample

power, temperature, voltage, overvoltage = gh_gml.get_all_limiting_policies(0)

if (temperature == 1) then
    print("Limiting policy: temperature")
end

syntax

core_clock, mem_clock = gh_gml.get_clocks (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

core_clock, mem_clock INTEGER clock speeds

code sample

core_clock, mem_clock = gh_gml.get_clocks(0)

syntax

percent, rpm = gh_gml.get_fan_speed (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

percent, rpm INTEGER speed in percent and RPM

code sample

percent, rpm = gh_gml.get_fan_speed(0)

syntax

arch = gh_gml.get_gpu_architecture (
  gpu_index
)

parameters

gpu_index INTEGER index of the GPU in the range (0 … num_gpus - 1)

return values

arch STRING architecture

code sample