kiss-lang/lime
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a926ee70d9171656f5ac573e4fe89e339d7ed1b4
lime/project/src/media/openal/OpenALBindings.cpp
ACrazyTown a926ee70d9
Some checks failed
CI / flash-samples (push) Successful in 1m17s
Details
CI / docs (push) Failing after 1m18s
Details
CI / android (stable) (push) Failing after 3m26s
Details
CI / android (r28c) (push) Failing after 3m54s
Details
CI / linux (push) Failing after 7m19s
Details
CI / air-samples (4.0.5) (push) Has been cancelled
Details
CI / macos (push) Has been cancelled
Details
CI / windows (push) Has been cancelled
Details
CI / ios (push) Has been cancelled
Details
CI / package-haxelib (push) Has been cancelled
Details
CI / air-samples (4.1.5) (push) Has been cancelled
Details
CI / air-samples (4.2.5) (push) Has been cancelled
Details
CI / air-samples (4.3.6) (push) Has been cancelled
Details
CI / hashlink-samples (macos-13) (push) Has been cancelled
Details
CI / hashlink-samples (ubuntu-22.04) (push) Has been cancelled
Details
CI / hashlink-samples (windows-latest) (push) Has been cancelled
Details
CI / hashlinkc-samples (macos-13) (push) Has been cancelled
Details
CI / hashlinkc-samples (ubuntu-22.04) (push) Has been cancelled
Details
CI / hashlinkc-samples (windows-latest) (push) Has been cancelled
Details
CI / html5-samples (3.4.7) (push) Has been cancelled
Details
CI / html5-samples (4.0.5) (push) Has been cancelled
Details
CI / html5-samples (4.1.5) (push) Has been cancelled
Details
CI / html5-samples (4.2.5) (push) Has been cancelled
Details
CI / html5-samples (4.3.6) (push) Has been cancelled
Details
CI / neko-samples (3.4.7, macos-13) (push) Has been cancelled
Details
CI / neko-samples (3.4.7, ubuntu-22.04) (push) Has been cancelled
Details
CI / neko-samples (3.4.7, windows-latest) (push) Has been cancelled
Details
CI / neko-samples (4.2.5, macos-13) (push) Has been cancelled
Details
CI / neko-samples (4.2.5, ubuntu-22.04) (push) Has been cancelled
Details
CI / neko-samples (4.2.5, windows-latest) (push) Has been cancelled
Details
CI / notify (push) Has been cancelled
Details
Implement ALC.getStringList()
2025-11-16 11:14:36 -06:00

3939 lines
78 KiB
C++
Raw Blame History

#if defined (IPHONE) || defined (TVOS) || (defined (HX_MACOS) && !defined (LIME_OPENALSOFT))
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#define LIME_OPENAL_DELETION_DELAY 600
#include <time.h>
#else
#include "AL/al.h"
#include "AL/alc.h"
#ifdef LIME_OPENALSOFT
// TODO: Can we support EFX on macOS?
#include "AL/alext.h"
#endif
#endif
#include <system/CFFI.h>
#include <system/CFFIPointer.h>
#include <system/Mutex.h>
#include <utils/ArrayBufferView.h>
#include <list>
#include <map>
namespace lime {
#ifdef LIME_OPENAL_DELETION_DELAY
std::list<ALuint> alDeletedBuffer;
std::list<time_t> alDeletedBufferTime;
std::list<ALuint> alDeletedSource;
std::list<time_t> alDeletedSourceTime;
#endif
std::map<ALuint, void*> alObjects;
std::map<void*, void*> alcObjects;
Mutex al_gc_mutex;
#ifdef LIME_OPENALSOFT
void lime_al_delete_auxiliary_effect_slot (value aux);
HL_PRIM void HL_NAME(hl_al_delete_auxiliary_effect_slot) (HL_CFFIPointer* aux);
#endif
void lime_al_delete_buffer (value buffer);
void lime_al_delete_source (value source);
HL_PRIM void HL_NAME(hl_al_delete_buffer) (HL_CFFIPointer* buffer);
HL_PRIM void HL_NAME(hl_al_delete_source) (HL_CFFIPointer* source);
#ifdef LIME_OPENALSOFT
void lime_al_delete_effect (value effect);
void lime_al_delete_filter (value filter);
HL_PRIM void HL_NAME(hl_al_delete_effect) (HL_CFFIPointer* effect);
HL_PRIM void HL_NAME(hl_al_delete_filter) (HL_CFFIPointer* filter);
#endif
void gc_al_buffer (value buffer) {
lime_al_delete_buffer (buffer);
}
void hl_gc_al_buffer (HL_CFFIPointer* buffer) {
lime_hl_al_delete_buffer (buffer);
}
#ifdef LIME_OPENALSOFT
void gc_al_auxiliary_effect_slot (value aux) {
lime_al_delete_auxiliary_effect_slot (aux);
}
void hl_gc_al_auxiliary_effect_slot (HL_CFFIPointer* aux) {
lime_hl_al_delete_auxiliary_effect_slot (aux);
}
#endif
void gc_al_source (value source) {
lime_al_delete_source (source);
}
void hl_gc_al_source (HL_CFFIPointer* source) {
lime_hl_al_delete_source (source);
}
#ifdef LIME_OPENALSOFT
void gc_al_effect (value effect) {
lime_al_delete_effect (effect);
}
void hl_gc_al_effect (HL_CFFIPointer* effect) {
lime_hl_al_delete_effect (effect);
}
void gc_al_filter (value filter) {
lime_al_delete_filter (filter);
}
void hl_gc_al_filter (HL_CFFIPointer* filter) {
lime_hl_al_delete_filter (filter);
}
#endif
void gc_alc_object (value object) {
al_gc_mutex.Lock ();
alcObjects.erase (val_data (object));
al_gc_mutex.Unlock ();
}
void hl_gc_alc_object (HL_CFFIPointer* object) {
al_gc_mutex.Lock ();
alcObjects.erase (object->ptr);
al_gc_mutex.Unlock ();
}
/*This has been removed after updating to openal 1.20.0+ since the cleanup functions involved
* lead to deadlocking. See https://github.com/openfl/lime/issues/1803 for more info.
* Developers should use lime.system.System.exit() instead of Sys.exit() to clean up any system
* resources
*/
/*
void lime_al_atexit () {
ALCcontext* alcContext = alcGetCurrentContext ();
if (alcContext) {
ALCdevice* alcDevice = alcGetContextsDevice (alcContext);
alcMakeContextCurrent (0);
alcDestroyContext (alcContext);
if (alcDevice) {
alcCloseDevice (alcDevice);
}
}
}
*/
void lime_al_auxf (value aux, int param, float value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (aux);
alAuxiliaryEffectSlotf (id, param, value);
#endif
}
HL_PRIM void HL_NAME(hl_al_auxf) (HL_CFFIPointer* aux, int param, float value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)aux->ptr;
alAuxiliaryEffectSlotf (id, param, value);
#endif
}
void lime_al_auxfv (value aux, int param, value values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (aux);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALfloat *data = new ALfloat[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALfloat)val_float (val_array_i (values, i));
}
alAuxiliaryEffectSlotfv (id, param, data);
delete[] data;
}
#endif
}
HL_PRIM void HL_NAME(hl_al_auxfv) (HL_CFFIPointer* aux, int param, varray* values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)aux->ptr;
if (values) {
int size = values->size;
alAuxiliaryEffectSlotfv (id, param, hl_aptr (values, float));
}
#endif
}
void lime_al_auxi (value aux, int param, value val) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (aux);
ALuint data;
if (param == AL_EFFECTSLOT_EFFECT) {
data = (ALuint)(uintptr_t)val_data (val);
} else {
data = val_int (val);
}
alAuxiliaryEffectSloti (id, param, data);
#endif
}
HL_PRIM void HL_NAME(hl_al_auxi) (HL_CFFIPointer* aux, int param, vdynamic* val) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)aux->ptr;
ALuint data;
if (param == AL_EFFECTSLOT_EFFECT) {
data = (ALuint)(uintptr_t)((HL_CFFIPointer*)val)->ptr;
} else {
data = val->v.i;
}
alAuxiliaryEffectSloti (id, param, data);
#endif
}
void lime_al_auxiv (value aux, int param, value values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (aux);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALint* data = new ALint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALint)val_int (val_array_i (values, i));
}
alAuxiliaryEffectSlotiv (id, param, data);
delete[] data;
}
#endif
}
HL_PRIM void HL_NAME(hl_al_auxiv) (HL_CFFIPointer* aux, int param, varray* values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)aux->ptr;
if (values) {
alAuxiliaryEffectSlotiv (id, param, hl_aptr (values, int));
}
#endif
}
void lime_al_buffer_data (value buffer, int format, value data, int size, int freq) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ArrayBufferView bufferView (data);
alBufferData (id, format, bufferView.buffer->b, size, freq);
}
HL_PRIM void HL_NAME(hl_al_buffer_data) (HL_CFFIPointer* buffer, int format, ArrayBufferView* data, int size, int freq) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
alBufferData (id, format, data->buffer->b, size, freq);
}
void lime_al_buffer3f (value buffer, int param, float value1, float value2, float value3) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
alBuffer3f (id, param, value1, value2, value3);
}
HL_PRIM void HL_NAME(hl_al_buffer3f) (HL_CFFIPointer* buffer, int param, float value1, float value2, float value3) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
alBuffer3f (id, param, value1, value2, value3);
}
void lime_al_buffer3i (value buffer, int param, int value1, int value2, int value3) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
alBuffer3i (id, param, value1, value2, value3);
}
HL_PRIM void HL_NAME(hl_al_buffer3i) (HL_CFFIPointer* buffer, int param, int value1, int value2, int value3) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
alBuffer3i (id, param, value1, value2, value3);
}
void lime_al_bufferf (value buffer, int param, float value) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
alBufferf (id, param, value);
}
HL_PRIM void HL_NAME(hl_al_bufferf) (HL_CFFIPointer* buffer, int param, float value) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
alBufferf (id, param, value);
}
void lime_al_bufferfv (value buffer, int param, value values) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALfloat *data = new ALfloat[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALfloat)val_float (val_array_i (values, i));
}
alBufferfv (id, param, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_bufferfv) (HL_CFFIPointer* buffer, int param, varray* values) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
if (values) {
int size = values->size;
alBufferfv (id, param, hl_aptr (values, float));
}
}
void lime_al_bufferi (value buffer, int param, int value) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
alBufferi (id, param, value);
}
HL_PRIM void HL_NAME(hl_al_bufferi) (HL_CFFIPointer* buffer, int param, int value) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
alBufferi (id, param, value);
}
void lime_al_bufferiv (value buffer, int param, value values) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALint* data = new ALint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALint)val_int (val_array_i (values, i));
}
alBufferiv (id, param, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_bufferiv) (HL_CFFIPointer* buffer, int param, varray* values) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
if (values) {
alBufferiv (id, param, hl_aptr (values, int));
}
}
void lime_al_cleanup () {
#ifdef LIME_OPENAL_DELETION_DELAY
time_t currentTime = time (0);
ALuint deletedData;
time_t deletedTime;
std::list<ALuint>::const_iterator itSource = alDeletedSource.begin ();
std::list<time_t>::const_iterator itSourceTime = alDeletedSourceTime.begin ();
while (itSource != alDeletedSource.end ()) {
deletedTime = *itSourceTime;
if (difftime (currentTime, deletedTime) * 1000 > LIME_OPENAL_DELETION_DELAY) {
ALuint deletedData = *itSource;
alDeleteSources (1, &deletedData);
itSource = alDeletedSource.erase (itSource);
itSourceTime = alDeletedSourceTime.erase (itSourceTime);
} else {
++itSource;
++itSourceTime;
}
}
std::list<ALuint>::iterator itBuffer = alDeletedBuffer.begin ();
std::list<time_t>::iterator itBufferTime = alDeletedBufferTime.begin ();
while (itBuffer != alDeletedBuffer.end ()) {
deletedTime = *itBufferTime;
if (difftime (currentTime, deletedTime) * 1000 > LIME_OPENAL_DELETION_DELAY) {
ALuint deletedData = *itBuffer;
alDeleteBuffers (1, &deletedData);
itBuffer = alDeletedBuffer.erase (itBuffer);
itBufferTime = alDeletedBufferTime.erase (itBufferTime);
} else {
++itBuffer;
++itBufferTime;
}
}
#endif
}
HL_PRIM void HL_NAME(hl_al_cleanup) () {
lime_al_cleanup ();
}
void lime_al_delete_auxiliary_effect_slot (value aux) {
#ifdef LIME_OPENALSOFT
if (!val_is_null (aux)) {
al_gc_mutex.Lock ();
ALuint data = (ALuint)(uintptr_t)val_data (aux);
val_gc (aux, 0);
alDeleteAuxiliaryEffectSlots ((ALuint)1, &data);
alObjects.erase (data);
al_gc_mutex.Unlock ();
}
#endif
}
HL_PRIM void HL_NAME(hl_al_delete_auxiliary_effect_slot) (HL_CFFIPointer* aux) {
#ifdef LIME_OPENALSOFT
if (aux) {
al_gc_mutex.Lock ();
ALuint data = (ALuint)(uintptr_t)aux->ptr;
aux->finalizer = 0;
alDeleteAuxiliaryEffectSlots ((ALuint)1, &data);
alObjects.erase (data);
al_gc_mutex.Unlock ();
}
#endif
}
void lime_al_delete_buffer (value buffer) {
if (!val_is_null (buffer)) {
al_gc_mutex.Lock ();
ALuint data = (ALuint)(uintptr_t)val_data (buffer);
val_gc (buffer, 0);
#ifdef LIME_OPENAL_DELETION_DELAY
alDeletedBuffer.push_back (data);
alDeletedBufferTime.push_back (time (0));
#else
alDeleteBuffers ((ALuint)1, &data);
#endif
alObjects.erase (data);
al_gc_mutex.Unlock ();
}
}
HL_PRIM void HL_NAME(hl_al_delete_buffer) (HL_CFFIPointer* buffer) {
if (buffer) {
al_gc_mutex.Lock ();
ALuint data = (ALuint)(uintptr_t)buffer->ptr;
buffer->finalizer = 0;
#ifdef LIME_OPENAL_DELETION_DELAY
alDeletedBuffer.push_back (data);
alDeletedBufferTime.push_back (time (0));
#else
alDeleteBuffers ((ALuint)1, &data);
#endif
alObjects.erase (data);
al_gc_mutex.Unlock ();
}
}
void lime_al_delete_buffers (int n, value buffers) {
if (!val_is_null (buffers)) {
int size = val_array_size (buffers);
value buffer;
al_gc_mutex.Lock ();
#ifdef LIME_OPENAL_DELETION_DELAY
ALuint data;
for (int i = 0; i < size; ++i) {
buffer = val_array_i (buffers, i);
data = (ALuint)(uintptr_t)val_data (buffer);
alDeletedBuffer.push_back (data);
alDeletedBufferTime.push_back (time (0));
val_gc (buffer, 0);
alObjects.erase (data);
}
#else
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
buffer = val_array_i (buffers, i);
data[i] = (ALuint)(uintptr_t)val_data (buffer);
val_gc (buffer, 0);
alObjects.erase (data[i]);
}
alDeleteBuffers (n, data);
delete[] data;
#endif
al_gc_mutex.Unlock ();
}
}
HL_PRIM void HL_NAME(hl_al_delete_buffers) (int n, varray* buffers) {
if (buffers) {
int size = buffers->size;
HL_CFFIPointer** bufferData = hl_aptr (buffers, HL_CFFIPointer*);
HL_CFFIPointer* buffer;
al_gc_mutex.Lock ();
#ifdef LIME_OPENAL_DELETION_DELAY
ALuint data;
for (int i = 0; i < size; ++i) {
buffer = *bufferData++;
data = (ALuint)(uintptr_t)buffer->ptr;
alDeletedBuffer.push_back (data);
alDeletedBufferTime.push_back (time (0));
buffer->finalizer = 0;
alObjects.erase (data);
}
#else
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
buffer = *bufferData++;
data[i] = (ALuint)(uintptr_t)buffer->ptr;
buffer->finalizer = 0;
alObjects.erase (data[i]);
}
alDeleteBuffers (n, data);
delete[] data;
#endif
al_gc_mutex.Unlock ();
}
}
void lime_al_delete_effect (value effect) {
#ifdef LIME_OPENALSOFT
if (!val_is_null (effect)) {
ALuint data = (ALuint)(uintptr_t)val_data (effect);
alDeleteEffects (1, &data);
val_gc (effect, 0);
}
#endif
}
HL_PRIM void HL_NAME(hl_al_delete_effect) (HL_CFFIPointer* effect) {
#ifdef LIME_OPENALSOFT
if (effect) {
ALuint data = (ALuint)(uintptr_t)effect->ptr;
alDeleteEffects (1, &data);
effect->finalizer = 0;
}
#endif
}
void lime_al_delete_filter (value filter) {
#ifdef LIME_OPENALSOFT
if (!val_is_null (filter)) {
ALuint data = (ALuint)(uintptr_t)val_data (filter);
alDeleteFilters (1, &data);
val_gc (filter, 0);
}
#endif
}
HL_PRIM void HL_NAME(hl_al_delete_filter) (HL_CFFIPointer* filter) {
#ifdef LIME_OPENALSOFT
if (filter) {
ALuint data = (ALuint)(uintptr_t)filter->ptr;
alDeleteFilters (1, &data);
filter->finalizer = 0;
}
#endif
}
void lime_al_delete_source (value source) {
if (!val_is_null (source)) {
ALuint data = (ALuint)(uintptr_t)val_data (source);
val_gc (source, 0);
#ifdef LIME_OPENAL_DELETION_DELAY
al_gc_mutex.Lock ();
alSourcei (data, AL_BUFFER, 0);
alDeletedSource.push_back (data);
alDeletedSourceTime.push_back (time (0));
al_gc_mutex.Unlock ();
#else
alDeleteSources (1, &data);
#endif
}
}
HL_PRIM void HL_NAME(hl_al_delete_source) (HL_CFFIPointer* source) {
if (source) {
ALuint data = (ALuint)(uintptr_t)source->ptr;
source->finalizer = 0;
#ifdef LIME_OPENAL_DELETION_DELAY
al_gc_mutex.Lock ();
alSourcei (data, AL_BUFFER, 0);
alDeletedSource.push_back (data);
alDeletedSourceTime.push_back (time (0));
al_gc_mutex.Unlock ();
#else
alDeleteSources (1, &data);
#endif
}
}
void lime_al_delete_sources (int n, value sources) {
if (!val_is_null (sources)) {
int size = val_array_size (sources);
value source;
#ifdef LIME_OPENAL_DELETION_DELAY
al_gc_mutex.Lock ();
ALuint data;
for (int i = 0; i < size; ++i) {
source = val_array_i (sources, i);
data = (ALuint)(uintptr_t)val_data (source);
alSourcei (data, AL_BUFFER, 0);
alDeletedSource.push_back (data);
alDeletedSourceTime.push_back (time (0));
val_gc (source, 0);
}
al_gc_mutex.Unlock ();
#else
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
source = val_array_i (sources, i);
data[i] = (ALuint)(uintptr_t)val_data (source);
val_gc (source, 0);
}
alDeleteSources (n, data);
delete[] data;
#endif
}
}
HL_PRIM void HL_NAME(hl_al_delete_sources) (int n, varray* sources) {
if (sources) {
int size = sources->size;
HL_CFFIPointer** sourceData = hl_aptr (sources, HL_CFFIPointer*);
HL_CFFIPointer* source;
#ifdef LIME_OPENAL_DELETION_DELAY
al_gc_mutex.Lock ();
ALuint data;
for (int i = 0; i < size; ++i) {
source = *sourceData++;
data = (ALuint)(uintptr_t)source->ptr;
alSourcei (data, AL_BUFFER, 0);
alDeletedSource.push_back (data);
alDeletedSourceTime.push_back (time (0));
source->finalizer = 0;
}
al_gc_mutex.Unlock ();
#else
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
source = *sourceData++;
data[i] = (ALuint)(uintptr_t)source->ptr;
source->finalizer = 0;
}
alDeleteSources (n, data);
delete[] data;
#endif
}
}
void lime_al_disable (int capability) {
alDisable (capability);
}
HL_PRIM void HL_NAME(hl_al_disable) (int capability) {
alDisable (capability);
}
void lime_al_distance_model (int distanceModel) {
alDistanceModel (distanceModel);
}
HL_PRIM void HL_NAME(hl_al_distance_model) (int distanceModel) {
alDistanceModel (distanceModel);
}
void lime_al_doppler_factor (float factor) {
alDopplerFactor (factor);
}
HL_PRIM void HL_NAME(hl_al_doppler_factor) (float factor) {
alDopplerFactor (factor);
}
void lime_al_doppler_velocity (float velocity) {
alDopplerVelocity (velocity);
}
HL_PRIM void HL_NAME(hl_al_doppler_velocity) (float velocity) {
alDopplerVelocity (velocity);
}
void lime_al_effectf (value effect, int param, float value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (effect);
alEffectf (id, param, value);
#endif
}
HL_PRIM void HL_NAME(hl_al_effectf) (HL_CFFIPointer* effect, int param, float value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)effect->ptr;
alEffectf (id, param, value);
#endif
}
void lime_al_effectfv (value effect, int param, value values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (effect);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALfloat *data = new ALfloat[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALfloat)val_float (val_array_i (values, i));
}
alEffectfv (id, param, data);
delete[] data;
}
#endif
}
HL_PRIM void HL_NAME(hl_al_effectfv) (HL_CFFIPointer* effect, int param, varray* values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)effect->ptr;
if (values) {
int size = values->size;
alEffectfv (id, param, hl_aptr (values, float));
}
#endif
}
void lime_al_effecti (value effect, int param, int value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (effect);
alEffecti (id, param, value);
#endif
}
HL_PRIM void HL_NAME(hl_al_effecti) (HL_CFFIPointer* effect, int param, int value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)effect->ptr;
alEffecti (id, param, value);
#endif
}
void lime_al_effectiv (value effect, int param, value values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (effect);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALint* data = new ALint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALint)val_int (val_array_i (values, i));
}
alEffectiv (id, param, data);
delete[] data;
}
#endif
}
HL_PRIM void HL_NAME(hl_al_effectiv) (HL_CFFIPointer* effect, int param, varray* values) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)effect->ptr;
if (values) {
alEffectiv (id, param, hl_aptr (values, int));
}
#endif
}
void lime_al_enable (int capability) {
alEnable (capability);
}
HL_PRIM void HL_NAME(hl_al_enable) (int capability) {
alEnable (capability);
}
void lime_al_filteri (value filter, int param, value val) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (filter);
ALuint data;
data = val_int (val);
alFilteri (id, param, data);
#endif
}
HL_PRIM void HL_NAME(hl_al_filteri) (HL_CFFIPointer* filter, int param, int val) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)filter->ptr;
ALuint data;
data = val;
alFilteri (id, param, data);
#endif
}
void lime_al_filterf (value filter, int param, float value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (filter);
alFilterf (id, param, value);
#endif
}
HL_PRIM void HL_NAME(hl_al_filterf) (HL_CFFIPointer* filter, int param, float value) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)filter->ptr;
alFilterf (id, param, value);
#endif
}
value lime_al_gen_aux () {
#ifdef LIME_OPENALSOFT
ALuint aux;
alGenAuxiliaryEffectSlots ((ALuint)1, &aux);
return CFFIPointer ((void*)(uintptr_t)aux, gc_al_auxiliary_effect_slot);
#else
return alloc_null ();
#endif
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_al_gen_aux) () {
#ifdef LIME_OPENALSOFT
ALuint aux;
alGenAuxiliaryEffectSlots ((ALuint)1, &aux);
return HLCFFIPointer ((void*)(uintptr_t)aux, (hl_finalizer)hl_gc_al_auxiliary_effect_slot);
#else
return 0;
#endif
}
value lime_al_gen_buffer () {
alGetError ();
ALuint buffer = 0;
alGenBuffers ((ALuint)1, &buffer);
if (alGetError () == AL_NO_ERROR) {
al_gc_mutex.Lock ();
value ptr = CFFIPointer ((void*)(uintptr_t)buffer, gc_al_buffer);
alObjects[buffer] = ptr;
al_gc_mutex.Unlock ();
return ptr;
} else {
return alloc_null ();
}
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_al_gen_buffer) () {
alGetError ();
ALuint buffer = 0;
alGenBuffers ((ALuint)1, &buffer);
if (alGetError () == AL_NO_ERROR) {
al_gc_mutex.Lock ();
HL_CFFIPointer* ptr = HLCFFIPointer ((void*)(uintptr_t)buffer, (hl_finalizer)hl_gc_al_buffer);
alObjects[buffer] = ptr;
al_gc_mutex.Unlock ();
return ptr;
} else {
return 0;
}
}
value lime_al_gen_buffers (int n) {
alGetError ();
ALuint* buffers = new ALuint[n];
alGenBuffers (n, buffers);
if (alGetError () == AL_NO_ERROR) {
value result = alloc_array (n);
ALuint buffer;
value ptr;
al_gc_mutex.Lock ();
for (int i = 0; i < n; i++) {
buffer = buffers[i];
ptr = CFFIPointer ((void*)(uintptr_t)buffer, gc_al_buffer);
alObjects[buffer] = ptr;
val_array_set_i (result, i, ptr);
}
al_gc_mutex.Unlock ();
delete[] buffers;
return result;
} else {
delete[] buffers;
return alloc_null ();
}
}
HL_PRIM varray* HL_NAME(hl_al_gen_buffers) (int n) {
alGetError ();
ALuint* buffers = new ALuint[n];
alGenBuffers (n, buffers);
if (alGetError () == AL_NO_ERROR) {
varray* result = hl_alloc_array (&hlt_dyn, n);
HL_CFFIPointer** resultData = hl_aptr (result, HL_CFFIPointer*);
ALuint buffer;
HL_CFFIPointer* ptr;
al_gc_mutex.Lock ();
for (int i = 0; i < n; i++) {
buffer = buffers[i];
ptr = HLCFFIPointer ((void*)(uintptr_t)buffer, (hl_finalizer)hl_gc_al_buffer);
alObjects[buffer] = ptr;
*resultData++ = ptr;
}
al_gc_mutex.Unlock ();
delete[] buffers;
return result;
} else {
delete[] buffers;
return NULL;
}
}
value lime_al_gen_effect () {
alGetError ();
#ifdef LIME_OPENALSOFT
ALuint effect;
alGenEffects ((ALuint)1, &effect);
if (alGetError () == AL_NO_ERROR) {
return CFFIPointer ((void*)(uintptr_t)effect, gc_al_effect);
}
#endif
return alloc_null ();
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_al_gen_effect) () {
alGetError ();
#ifdef LIME_OPENALSOFT
ALuint effect;
alGenEffects ((ALuint)1, &effect);
if (alGetError () == AL_NO_ERROR) {
return HLCFFIPointer ((void*)(uintptr_t)effect, (hl_finalizer)hl_gc_al_effect);
}
#endif
return NULL;
}
value lime_al_gen_filter () {
alGetError ();
#ifdef LIME_OPENALSOFT
ALuint filter;
alGenFilters ((ALuint)1, &filter);
if (alGetError () == AL_NO_ERROR) {
return CFFIPointer ((void*)(uintptr_t)filter, gc_al_filter);
}
#endif
return alloc_null ();
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_al_gen_filter) () {
alGetError ();
#ifdef LIME_OPENALSOFT
ALuint filter;
alGenFilters ((ALuint)1, &filter);
if (alGetError () == AL_NO_ERROR) {
return HLCFFIPointer ((void*)(uintptr_t)filter, (hl_finalizer)hl_gc_al_filter);
}
#endif
return NULL;
}
value lime_al_gen_source () {
alGetError ();
ALuint source;
alGenSources ((ALuint)1, &source);
if (alGetError () == AL_NO_ERROR) {
return CFFIPointer ((void*)(uintptr_t)source, gc_al_source);
} else {
return alloc_null ();
}
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_al_gen_source) () {
alGetError ();
ALuint source;
alGenSources ((ALuint)1, &source);
if (alGetError () == AL_NO_ERROR) {
return HLCFFIPointer ((void*)(uintptr_t)source, (hl_finalizer)hl_gc_al_source);
} else {
return NULL;
}
}
value lime_al_gen_sources (int n) {
alGetError ();
ALuint* sources = new ALuint[n];
alGenSources (n, sources);
if (alGetError () == AL_NO_ERROR) {
value result = alloc_array (n);
for (int i = 0; i < n; i++) {
val_array_set_i (result, i, CFFIPointer ((void*)(uintptr_t)sources[i], gc_al_source));
}
delete[] sources;
return result;
} else {
delete[] sources;
return alloc_null ();
}
}
HL_PRIM varray* HL_NAME(hl_al_gen_sources) (int n) {
alGetError ();
ALuint* sources = new ALuint[n];
alGenSources (n, sources);
if (alGetError () == AL_NO_ERROR) {
varray* result = hl_alloc_array (&hlt_dyn, n);
HL_CFFIPointer** resultData = hl_aptr (result, HL_CFFIPointer*);
for (int i = 0; i < n; i++) {
*resultData++ = HLCFFIPointer ((void*)(uintptr_t)sources[i], (hl_finalizer)hl_gc_al_source);
}
delete[] sources;
return result;
} else {
delete[] sources;
return NULL;
}
}
bool lime_al_get_boolean (int param) {
return alGetBoolean (param);
}
HL_PRIM bool HL_NAME(hl_al_get_boolean) (int param) {
return alGetBoolean (param);
}
value lime_al_get_booleanv (int param, int count) {
ALboolean* values = new ALboolean[count];
alGetBooleanv (param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_bool (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_booleanv) (int param, int count) {
varray* result = hl_alloc_array (&hlt_bool, count);
alGetBooleanv (param, (ALboolean*)hl_aptr (result, bool));
return result;
}
value lime_al_get_buffer3f (value buffer, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ALfloat val1, val2, val3;
alGetBuffer3f (id, param, &val1, &val2, &val3);
value result = alloc_array (3);
val_array_set_i (result, 0, alloc_float (val1));
val_array_set_i (result, 1, alloc_float (val2));
val_array_set_i (result, 2, alloc_float (val3));
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_buffer3f) (HL_CFFIPointer* buffer, int param) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
varray* result = hl_alloc_array (&hlt_f32, 3);
alGetBuffer3f (id, param, &hl_aptr (result, float)[0], &hl_aptr (result, float)[1], &hl_aptr (result, float)[2]);
return result;
}
value lime_al_get_buffer3i (value buffer, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ALint val1, val2, val3;
alGetBuffer3i (id, param, &val1, &val2, &val3);
value result = alloc_array (3);
val_array_set_i (result, 0, alloc_int (val1));
val_array_set_i (result, 1, alloc_int (val2));
val_array_set_i (result, 2, alloc_int (val3));
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_buffer3i) (HL_CFFIPointer* buffer, int param) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
varray* result = hl_alloc_array (&hlt_i32, 3);
alGetBuffer3i (id, param, &hl_aptr (result, int)[0], &hl_aptr (result, int)[2], &hl_aptr (result, int)[3]);
return result;
}
float lime_al_get_bufferf (value buffer, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ALfloat data;
alGetBufferf (id, param, &data);
return data;
}
HL_PRIM float HL_NAME(hl_al_get_bufferf) (HL_CFFIPointer* buffer, int param) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
ALfloat data;
alGetBufferf (id, param, &data);
return data;
}
value lime_al_get_bufferfv (value buffer, int param, int count) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ALfloat* values = new ALfloat[count];
alGetBufferfv (id, param, values);
value result = alloc_array (count);
for (int i = 0; i < count; ++i) {
val_array_set_i (result, i, alloc_float (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_bufferfv) (HL_CFFIPointer* buffer, int param, int count) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
varray* result = hl_alloc_array (&hlt_f32, count);
alGetBufferfv (id, param, hl_aptr (result, float));
return result;
}
int lime_al_get_bufferi (value buffer, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ALint data;
alGetBufferi (id, param, &data);
return data;
}
HL_PRIM int HL_NAME(hl_al_get_bufferi) (HL_CFFIPointer* buffer, int param) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
ALint data;
alGetBufferi (id, param, &data);
return data;
}
value lime_al_get_bufferiv (value buffer, int param, int count) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
ALint* values = new ALint[count];
alGetBufferiv (id, param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_int (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_bufferiv) (HL_CFFIPointer* buffer, int param, int count) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
varray* result = hl_alloc_array (&hlt_i32, count);
alGetBufferiv (id, param, hl_aptr (result, int));
return result;
}
double lime_al_get_double (int param) {
return alGetDouble (param);
}
HL_PRIM double HL_NAME(hl_al_get_double) (int param) {
return alGetDouble (param);
}
value lime_al_get_doublev (int param, int count) {
ALdouble* values = new ALdouble[count];
alGetDoublev (param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_float (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_doublev) (int param, int count) {
varray* result = hl_alloc_array (&hlt_f64, count);
alGetDoublev (param, hl_aptr (result, double));
return result;
}
int lime_al_get_enum_value (HxString ename) {
return alGetEnumValue (ename.__s);
}
HL_PRIM int HL_NAME(hl_al_get_enum_value) (hl_vstring* ename) {
return alGetEnumValue (ename ? hl_to_utf8 (ename->bytes) : NULL);
}
int lime_al_get_error () {
return alGetError ();
}
HL_PRIM int HL_NAME(hl_al_get_error) () {
return alGetError ();
}
int lime_al_get_filteri (value filter, int param) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (filter);
ALint data;
alGetFilteri (id, param, &data);
return data;
#else
return 0;
#endif
}
HL_PRIM int HL_NAME(hl_al_get_filteri) (HL_CFFIPointer* filter, int param) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)filter->ptr;
ALint data;
alGetFilteri (id, param, &data);
return data;
#else
return 0;
#endif
}
float lime_al_get_float (int param) {
return alGetFloat (param);
}
HL_PRIM float HL_NAME(hl_al_get_float) (int param) {
return alGetFloat (param);
}
value lime_al_get_floatv (int param, int count) {
ALfloat* values = new ALfloat[count];
alGetFloatv (param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_float (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_floatv) (int param, int count) {
varray* result = hl_alloc_array (&hlt_f32, count);
alGetFloatv (param, hl_aptr (result, float));
return result;
}
int lime_al_get_integer (int param) {
return alGetInteger (param);
}
HL_PRIM int HL_NAME(hl_al_get_integer) (int param) {
return alGetInteger (param);
}
value lime_al_get_integerv (int param, int count) {
ALint* values = new ALint[count];
alGetIntegerv (param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_int (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_integerv) (int param, int count) {
varray* result = hl_alloc_array (&hlt_i32, count);
alGetIntegerv (param, hl_aptr (result, int));
return result;
}
value lime_al_get_listener3f (int param) {
ALfloat val1, val2, val3;
alGetListener3f (param, &val1, &val2, &val3);
value result = alloc_array (3);
val_array_set_i (result, 0, alloc_float (val1));
val_array_set_i (result, 1, alloc_float (val2));
val_array_set_i (result, 2, alloc_float (val3));
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_listener3f) (int param) {
varray* result = hl_alloc_array (&hlt_f32, 3);
alGetListener3f (param, &hl_aptr (result, float)[0], &hl_aptr (result, float)[2], &hl_aptr (result, float)[3]);
return result;
}
value lime_al_get_listener3i (int param) {
ALint val1, val2, val3;
alGetListener3i (param, &val1, &val2, &val3);
value result = alloc_array (3);
val_array_set_i (result, 0, alloc_int (val1));
val_array_set_i (result, 1, alloc_int (val2));
val_array_set_i (result, 2, alloc_int (val3));
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_listener3i) (int param) {
varray* result = hl_alloc_array (&hlt_i32, 3);
alGetListener3i (param, &hl_aptr (result, int)[0], &hl_aptr (result, int)[2], &hl_aptr (result, int)[3]);
return result;
}
float lime_al_get_listenerf (int param) {
ALfloat data;
alGetListenerf (param, &data);
return data;
}
HL_PRIM float HL_NAME(hl_al_get_listenerf) (int param) {
ALfloat data;
alGetListenerf (param, &data);
return data;
}
value lime_al_get_listenerfv (int param, int count) {
ALfloat* values = new ALfloat[count];
alGetListenerfv (param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_float (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_listenerfv) (int param, int count) {
varray* result = hl_alloc_array (&hlt_f32, count);
alGetListenerfv (param, hl_aptr (result, float));
return result;
}
int lime_al_get_listeneri (int param) {
ALint data;
alGetListeneri (param, &data);
return data;
}
HL_PRIM int HL_NAME(hl_al_get_listeneri) (int param) {
ALint data;
alGetListeneri (param, &data);
return data;
}
value lime_al_get_listeneriv (int param, int count) {
ALint* values = new ALint[count];
alGetListeneriv (param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_int (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_listeneriv) (int param, int count) {
varray* result = hl_alloc_array (&hlt_i32, count);
alGetListeneriv (param, hl_aptr (result, int));
return result;
}
double lime_al_get_proc_address (HxString fname) {
return (uintptr_t)alGetProcAddress (fname.__s);
}
HL_PRIM double HL_NAME(hl_al_get_proc_address) (hl_vstring* fname) {
return (uintptr_t)alGetProcAddress (fname ? hl_to_utf8 (fname->bytes) : NULL);
}
value lime_al_get_source3f (value source, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALfloat val1, val2, val3;
alGetSource3f (id, param, &val1, &val2, &val3);
value result = alloc_array (3);
val_array_set_i (result, 0, alloc_float (val1));
val_array_set_i (result, 1, alloc_float (val2));
val_array_set_i (result, 2, alloc_float (val3));
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_source3f) (HL_CFFIPointer* source, int param) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
varray* result = hl_alloc_array (&hlt_f32, 3);
alGetSource3f (id, param, &hl_aptr (result, float)[0], &hl_aptr (result, float)[2], &hl_aptr (result, float)[3]);
return result;
}
value lime_al_get_source3i (value source, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALint val1, val2, val3;
alGetSource3i (id, param, &val1, &val2, &val3);
value result = alloc_array (3);
val_array_set_i (result, 1, alloc_int (val1));
val_array_set_i (result, 2, alloc_int (val2));
val_array_set_i (result, 3, alloc_int (val3));
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_source3i) (HL_CFFIPointer* source, int param) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
varray* result = hl_alloc_array (&hlt_i32, 3);
alGetSource3i (id, param, &hl_aptr (result, int)[0], &hl_aptr (result, int)[2], &hl_aptr (result, int)[3]);
return result;
}
float lime_al_get_sourcef (value source, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALfloat data;
alGetSourcef (id, param, &data);
return data;
}
HL_PRIM float HL_NAME(hl_al_get_sourcef) (HL_CFFIPointer* source, int param) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
ALfloat data;
alGetSourcef (id, param, &data);
return data;
}
value lime_al_get_sourcefv (value source, int param, int count) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALfloat* values = new ALfloat[count];
alGetSourcefv (id, param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_float (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_sourcefv) (HL_CFFIPointer* source, int param, int count) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
varray* result = hl_alloc_array (&hlt_f32, count);
alGetSourcefv (id, param, hl_aptr (result, float));
return result;
}
value lime_al_get_sourcei (value source, int param) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALint data;
alGetSourcei (id, param, &data);
if (param == AL_BUFFER) {
if (alObjects.count (data) > 0) {
return (value)alObjects[data];
} else {
al_gc_mutex.Lock ();
value ptr = CFFIPointer ((void*)(uintptr_t)data, gc_al_buffer);
alObjects[data] = ptr;
al_gc_mutex.Unlock ();
return ptr;
}
} else {
return alloc_int (data);
}
}
HL_PRIM vdynamic* HL_NAME(hl_al_get_sourcei) (HL_CFFIPointer* source, int param) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
ALint data;
alGetSourcei (id, param, &data);
if (param == AL_BUFFER) {
if (alObjects.count (data) > 0) {
return (vdynamic*)alObjects[data];
} else {
al_gc_mutex.Lock ();
HL_CFFIPointer* ptr = HLCFFIPointer ((void*)(uintptr_t)data, (hl_finalizer)hl_gc_al_buffer);
alObjects[data] = ptr;
al_gc_mutex.Unlock ();
return (vdynamic*)ptr;
}
} else {
vdynamic* result = hl_alloc_dynamic (&hlt_i32);
result->v.i = data;
return result;
}
}
value lime_al_get_sourceiv (value source, int param, int count) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALint* values = new ALint[count];
alGetSourceiv (id, param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_int (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_get_sourceiv) (HL_CFFIPointer* source, int param, int count) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
varray* result = hl_alloc_array (&hlt_i32, count);
alGetSourceiv (id, param, hl_aptr (result, int));
return result;
}
value lime_al_get_string (int param) {
const char* result = alGetString (param);
return result ? alloc_string (result) : alloc_null ();
}
HL_PRIM vbyte* HL_NAME(hl_al_get_string) (int param) {
const char* result = alGetString (param);
int length = strlen (result);
char* _result = (char*)malloc (length + 1);
strcpy (_result, result);
return (vbyte*)_result;
}
bool lime_al_is_aux (value aux) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (aux);
return alIsAuxiliaryEffectSlot (id);
#else
return false;
#endif
}
HL_PRIM bool HL_NAME(hl_al_is_aux) (HL_CFFIPointer* aux) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)aux->ptr;
return alIsAuxiliaryEffectSlot (id);
#else
return false;
#endif
}
bool lime_al_is_buffer (value buffer) {
ALuint id = (ALuint)(uintptr_t)val_data (buffer);
return alIsBuffer (id);
}
HL_PRIM bool HL_NAME(hl_al_is_buffer) (HL_CFFIPointer* buffer) {
ALuint id = (ALuint)(uintptr_t)buffer->ptr;
return alIsBuffer (id);
}
bool lime_al_is_effect (value effect) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (effect);
return alIsEffect (id);
#else
return false;
#endif
}
HL_PRIM bool HL_NAME(hl_al_is_effect) (HL_CFFIPointer* effect) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)effect->ptr;
return alIsEffect (id);
#else
return false;
#endif
}
bool lime_al_is_enabled (int capability) {
return alIsEnabled (capability);
}
HL_PRIM bool HL_NAME(hl_al_is_enabled) (int capability) {
return alIsEnabled (capability);
}
bool lime_al_is_extension_present (HxString extname) {
#ifdef LIME_OPENALSOFT
return alIsExtensionPresent (extname.__s);
#else
return false;
#endif
}
HL_PRIM bool HL_NAME(hl_al_is_extension_present) (hl_vstring* extname) {
#ifdef LIME_OPENALSOFT
return alIsExtensionPresent (extname ? hl_to_utf8 (extname->bytes) : NULL);
#else
return false;
#endif
}
bool lime_al_is_filter (value filter) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (filter);
return alIsSource (id);
#else
return false;
#endif
}
HL_PRIM bool HL_NAME(hl_al_is_filter) (HL_CFFIPointer* filter) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)filter->ptr;
return alIsSource (id);
#else
return false;
#endif
}
bool lime_al_is_source (value source) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
return alIsSource (id);
}
HL_PRIM bool HL_NAME(hl_al_is_source) (HL_CFFIPointer* source) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
return alIsSource (id);
}
void lime_al_listener3f (int param, float value1, float value2, float value3) {
alListener3f (param, value1, value2, value3);
}
HL_PRIM void HL_NAME(hl_al_listener3f) (int param, float value1, float value2, float value3) {
alListener3f (param, value1, value2, value3);
}
void lime_al_listener3i (int param, int value1, int value2, int value3) {
alListener3i (param, value1, value2, value3);
}
HL_PRIM void HL_NAME(hl_al_listener3i) (int param, int value1, int value2, int value3) {
alListener3i (param, value1, value2, value3);
}
void lime_al_listenerf (int param, float value1) {
alListenerf (param, value1);
}
HL_PRIM void HL_NAME(hl_al_listenerf) (int param, float value1) {
alListenerf (param, value1);
}
void lime_al_listenerfv (int param, value values) {
if (!val_is_null (values)) {
int size = val_array_size (values);
ALfloat *data = new ALfloat[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALfloat)val_float (val_array_i (values, i));
}
alListenerfv (param, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_listenerfv) (int param, varray* values) {
if (values) {
int size = values->size;
alListenerfv (param, hl_aptr (values, float));
}
}
void lime_al_listeneri (int param, int value1) {
alListeneri (param, value1);
}
HL_PRIM void HL_NAME(hl_al_listeneri) (int param, int value1) {
alListeneri (param, value1);
}
void lime_al_listeneriv (int param, value values) {
if (!val_is_null (values)) {
int size = val_array_size (values);
ALint* data = new ALint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALint)val_int (val_array_i (values, i));
}
alListeneriv (param, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_listeneriv) (int param, varray* values) {
if (values) {
int size = values->size;
alListeneriv (param, hl_aptr (values, int));
}
}
void lime_al_remove_direct_filter (value source) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSourcei (id, AL_DIRECT_FILTER, AL_FILTER_NULL);
#endif
}
HL_PRIM void HL_NAME(hl_al_remove_direct_filter) (HL_CFFIPointer* source) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSourcei (id, AL_DIRECT_FILTER, AL_FILTER_NULL);
#endif
}
void lime_al_remove_send (value source, int index) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSource3i (id, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, index, 0);
#endif
}
HL_PRIM void HL_NAME(hl_al_remove_send) (HL_CFFIPointer* source, int index) {
#ifdef LIME_OPENALSOFT
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSource3i (id, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, index, 0);
#endif
}
void lime_al_source_pause (value source) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSourcePause (id);
}
HL_PRIM void HL_NAME(hl_al_source_pause) (HL_CFFIPointer* source) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSourcePause (id);
}
void lime_al_source_pausev (int n, value sources) {
if (!val_is_null (sources)) {
int size = val_array_size (sources);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)val_data (val_array_i (sources, i));
}
alSourcePausev (n, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_source_pausev) (int n, varray* sources) {
if (sources) {
int size = sources->size;
HL_CFFIPointer** sourcesData = hl_aptr (sources, HL_CFFIPointer*);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)(*sourcesData++)->ptr;
}
alSourcePausev (n, data);
delete[] data;
}
}
void lime_al_source_play (value source) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSourcePlay (id);
}
HL_PRIM void HL_NAME(hl_al_source_play) (HL_CFFIPointer* source) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSourcePlay (id);
}
void lime_al_source_playv (int n, value sources) {
if (!val_is_null (sources)) {
int size = val_array_size (sources);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)val_data (val_array_i (sources, i));
}
alSourcePlayv (n, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_source_playv) (int n, varray* sources) {
if (sources) {
int size = sources->size;
HL_CFFIPointer** sourcesData = hl_aptr (sources, HL_CFFIPointer*);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)(*sourcesData++)->ptr;
}
alSourcePlayv (n, data);
delete[] data;
}
}
void lime_al_source_queue_buffers (value source, int nb, value buffers) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
if (!val_is_null (buffers)) {
int size = val_array_size (buffers);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)val_data (val_array_i (buffers, i));
}
alSourceQueueBuffers (id, nb, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_source_queue_buffers) (HL_CFFIPointer* source, int nb, varray* buffers) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
if (buffers) {
int size = buffers->size;
HL_CFFIPointer** buffersData = hl_aptr (buffers, HL_CFFIPointer*);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)(*buffersData++)->ptr;
}
alSourceQueueBuffers (id, nb, data);
delete[] data;
}
}
void lime_al_source_rewind (value source) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSourceRewind (id);
}
HL_PRIM void HL_NAME(hl_al_source_rewind) (HL_CFFIPointer* source) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSourceRewind (id);
}
void lime_al_source_rewindv (int n, value sources) {
if (!val_is_null (sources)) {
int size = val_array_size (sources);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)val_data (val_array_i (sources, i));
}
alSourceRewindv (n, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_source_rewindv) (int n, varray* sources) {
if (sources) {
int size = sources->size;
HL_CFFIPointer** sourcesData = hl_aptr (sources, HL_CFFIPointer*);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)(*sourcesData++)->ptr;
}
alSourceRewindv (n, data);
delete[] data;
}
}
void lime_al_source_stop (value source) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSourceStop (id);
}
HL_PRIM void HL_NAME(hl_al_source_stop) (HL_CFFIPointer* source) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSourceStop (id);
}
void lime_al_source_stopv (int n, value sources) {
if (!val_is_null (sources)) {
int size = val_array_size (sources);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)val_data (val_array_i (sources, i));
}
alSourceStopv (n, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_source_stopv) (int n, varray* sources) {
if (sources) {
int size = sources->size;
HL_CFFIPointer** sourcesData = hl_aptr (sources, HL_CFFIPointer*);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)(uintptr_t)(*sourcesData++)->ptr;
}
alSourceStopv (n, data);
delete[] data;
}
}
value lime_al_source_unqueue_buffers (value source, int nb) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALuint* buffers = new ALuint[nb];
alSourceUnqueueBuffers (id, nb, buffers);
value result = alloc_array (nb);
ALuint buffer;
value ptr;
for (int i = 0; i < nb; i++) {
buffer = buffers[i];
if (alObjects.count (buffer) > 0) {
ptr = (value)alObjects[buffer];
} else {
al_gc_mutex.Lock ();
ptr = CFFIPointer ((void*)(uintptr_t)buffer, gc_al_buffer);
alObjects[buffer] = ptr;
al_gc_mutex.Unlock ();
}
val_array_set_i (result, i, ptr);
}
delete[] buffers;
return result;
}
HL_PRIM varray* HL_NAME(hl_al_source_unqueue_buffers) (HL_CFFIPointer* source, int nb) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
ALuint* buffers = new ALuint[nb];
alSourceUnqueueBuffers (id, nb, buffers);
varray* result = hl_alloc_array (&hlt_dyn, nb);
HL_CFFIPointer** resultData = hl_aptr (result, HL_CFFIPointer*);
ALuint buffer;
HL_CFFIPointer* ptr;
for (int i = 0; i < nb; i++) {
buffer = buffers[i];
if (alObjects.count (buffer) > 0) {
ptr = (HL_CFFIPointer*)alObjects[buffer];
} else {
al_gc_mutex.Lock ();
ptr = HLCFFIPointer ((void*)(uintptr_t)buffer, (hl_finalizer)hl_gc_al_buffer);
alObjects[buffer] = ptr;
al_gc_mutex.Unlock ();
}
*resultData++ = ptr;
}
delete[] buffers;
return result;
}
void lime_al_source3f (value source, int param, float value1, float value2, float value3) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSource3f (id, param, value1, value2, value3);
}
HL_PRIM void HL_NAME(hl_al_source3f) (HL_CFFIPointer* source, int param, float value1, float value2, float value3) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSource3f (id, param, value1, value2, value3);
}
void lime_al_source3i (value source, int param, value value1, int value2, int value3) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALuint data1;
#ifdef LIME_OPENALSOFT
if (param == AL_AUXILIARY_SEND_FILTER) {
data1 = (ALuint)(uintptr_t)val_data (value1);
} else {
data1 = val_int (value1);
}
#else
data1 = val_int (value1);
#endif
alSource3i (id, param, data1, value2, value3);
}
HL_PRIM void HL_NAME(hl_al_source3i) (HL_CFFIPointer* source, int param, vdynamic* value1, int value2, int value3) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
ALuint data1;
#ifdef LIME_OPENALSOFT
if (param == AL_AUXILIARY_SEND_FILTER) {
data1 = (ALuint)(uintptr_t)((HL_CFFIPointer*)value1)->ptr;
} else {
data1 = value1->v.i;
}
#else
data1 = value1->v.i;
#endif
alSource3i (id, param, data1, value2, value3);
}
void lime_al_sourcef (value source, int param, float value) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
alSourcef (id, param, value);
}
HL_PRIM void HL_NAME(hl_al_sourcef) (HL_CFFIPointer* source, int param, float value) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
alSourcef (id, param, value);
}
void lime_al_sourcefv (value source, int param, value values) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALfloat *data = new ALfloat[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALfloat)val_float (val_array_i (values, i));
}
alSourcefv (id, param, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_sourcefv) (HL_CFFIPointer* source, int param, varray* values) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
if (values) {
int size = values->size;
alSourcefv (id, param, hl_aptr (values, float));
}
}
void lime_al_sourcei (value source, int param, value val) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
ALuint data = 0;
if (!val_is_null (val)) {
#ifdef LIME_OPENALSOFT
if (param == AL_BUFFER || param == AL_DIRECT_FILTER) {
data = (ALuint)(uintptr_t)val_data (val);
} else {
data = val_int (val);
}
#else
if (param == AL_BUFFER) {
data = (ALuint)(uintptr_t)val_data (val);
} else {
data = val_int (val);
}
#endif
}
alSourcei (id, param, data);
}
HL_PRIM void HL_NAME(hl_al_sourcei) (HL_CFFIPointer* source, int param, vdynamic* val) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
ALuint data = 0;
if (val) {
#ifdef LIME_OPENALSOFT
if (param == AL_BUFFER || param == AL_DIRECT_FILTER) {
data = (ALuint)(uintptr_t)((HL_CFFIPointer*)val)->ptr;
} else {
data = val->v.i;
}
#else
if (param == AL_BUFFER) {
data = (ALuint)(uintptr_t)((HL_CFFIPointer*)val)->ptr;
} else {
data = val->v.i;
}
#endif
}
alSourcei (id, param, data);
}
void lime_al_sourceiv (value source, int param, value values) {
ALuint id = (ALuint)(uintptr_t)val_data (source);
if (!val_is_null (values)) {
int size = val_array_size (values);
ALint* data = new ALint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALint)val_int (val_array_i (values, i));
}
alSourceiv (id, param, data);
delete[] data;
}
}
HL_PRIM void HL_NAME(hl_al_sourceiv) (HL_CFFIPointer* source, int param, varray* values) {
ALuint id = (ALuint)(uintptr_t)source->ptr;
if (values) {
int size = values->size;
alSourceiv (id, param, hl_aptr (values, int));
}
}
void lime_al_speed_of_sound (float speed) {
alSpeedOfSound (speed);
}
HL_PRIM void HL_NAME(hl_al_speed_of_sound) (float speed) {
alSpeedOfSound (speed);
}
bool lime_alc_close_device (value device) {
al_gc_mutex.Lock ();
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
alcObjects.erase (alcDevice);
al_gc_mutex.Unlock ();
return alcCloseDevice (alcDevice);
}
HL_PRIM bool HL_NAME(hl_alc_close_device) (HL_CFFIPointer* device) {
al_gc_mutex.Lock ();
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
alcObjects.erase (alcDevice);
al_gc_mutex.Unlock ();
return alcCloseDevice (alcDevice);
}
value lime_alc_create_context (value device, value attrlist) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
ALCint* list = NULL;
if (!val_is_null (attrlist)) {
int size = val_array_size (attrlist);
list = new ALCint[size];
for (int i = 0; i < size; ++i) {
list[i] = (ALCint)val_int (val_array_i (attrlist, i));
}
}
ALCcontext* alcContext = alcCreateContext (alcDevice, list);
if (list != NULL) {
delete[] list;
}
al_gc_mutex.Lock ();
value object = CFFIPointer (alcContext, gc_alc_object);
alcObjects[alcContext] = object;
al_gc_mutex.Unlock ();
return object;
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_alc_create_context) (HL_CFFIPointer* device, varray* attrlist) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
ALCcontext* alcContext = alcCreateContext (alcDevice, attrlist ? hl_aptr (attrlist, int) : NULL);
al_gc_mutex.Lock ();
HL_CFFIPointer* object = HLCFFIPointer (alcContext, (hl_finalizer)hl_gc_alc_object);
alcObjects[alcContext] = object;
al_gc_mutex.Unlock ();
return object;
}
void lime_alc_destroy_context (value context) {
al_gc_mutex.Lock ();
ALCcontext* alcContext = (ALCcontext*)val_data (context);
if (alcObjects.find (alcContext) != alcObjects.end ()) {
alcObjects.erase (alcContext);
}
if (alcContext == alcGetCurrentContext ()) {
alcMakeContextCurrent (0);
}
alcDestroyContext (alcContext);
al_gc_mutex.Unlock ();
}
HL_PRIM void HL_NAME(hl_alc_destroy_context) (HL_CFFIPointer* context) {
al_gc_mutex.Lock ();
ALCcontext* alcContext = (ALCcontext*)context->ptr;
if (alcObjects.find (alcContext) != alcObjects.end ()) {
alcObjects.erase (alcContext);
}
if (alcContext == alcGetCurrentContext ()) {
alcMakeContextCurrent (0);
}
alcDestroyContext (alcContext);
al_gc_mutex.Unlock ();
}
value lime_alc_get_contexts_device (value context) {
ALCcontext* alcContext = (ALCcontext*)val_data (context);
ALCdevice* alcDevice = alcGetContextsDevice (alcContext);
value result;
al_gc_mutex.Lock ();
if (alcObjects.find (alcDevice) != alcObjects.end ()) {
result = (value)alcObjects[alcDevice];
} else {
value object = CFFIPointer (alcDevice, gc_alc_object);
alcObjects[alcDevice] = object;
result = object;
}
al_gc_mutex.Unlock ();
return result;
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_alc_get_contexts_device) (HL_CFFIPointer* context) {
ALCcontext* alcContext = (ALCcontext*)context->ptr;
ALCdevice* alcDevice = alcGetContextsDevice (alcContext);
HL_CFFIPointer* result;
al_gc_mutex.Lock ();
if (alcObjects.find (alcDevice) != alcObjects.end ()) {
result = (HL_CFFIPointer*)alcObjects[alcDevice];
} else {
HL_CFFIPointer* object = HLCFFIPointer (alcDevice, (hl_finalizer)hl_gc_alc_object);
alcObjects[alcDevice] = object;
result = object;
}
al_gc_mutex.Unlock ();
return result;
}
value lime_alc_get_current_context () {
ALCcontext* alcContext = alcGetCurrentContext ();
value result;
al_gc_mutex.Lock ();
if (alcObjects.find (alcContext) != alcObjects.end ()) {
result = (value)alcObjects[alcContext];
} else {
value object = CFFIPointer (alcContext, gc_alc_object);
alcObjects[alcContext] = object;
result = object;
}
al_gc_mutex.Unlock ();
return result;
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_alc_get_current_context) () {
ALCcontext* alcContext = alcGetCurrentContext ();
HL_CFFIPointer* result;
al_gc_mutex.Lock ();
if (alcObjects.find (alcContext) != alcObjects.end ()) {
result = (HL_CFFIPointer*)alcObjects[alcContext];
} else {
HL_CFFIPointer* object = HLCFFIPointer (alcContext, (hl_finalizer)hl_gc_alc_object);
alcObjects[alcContext] = object;
result = object;
}
al_gc_mutex.Unlock ();
return result;
}
int lime_alc_get_error (value device) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
return alcGetError (alcDevice);
}
HL_PRIM int HL_NAME(hl_alc_get_error) (HL_CFFIPointer* device) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
return alcGetError (alcDevice);
}
value lime_alc_get_integerv (value device, int param, int size) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
ALCint* values = new ALCint[size];
alcGetIntegerv (alcDevice, param, size, values);
value result = alloc_array (size);
for (int i = 0; i < size; i++) {
val_array_set_i (result, i, alloc_int (values[i]));
}
delete[] values;
return result;
}
HL_PRIM varray* HL_NAME(hl_alc_get_integerv) (HL_CFFIPointer* device, int param, int size) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
varray* result = hl_alloc_array (&hlt_i32, size);
alcGetIntegerv (alcDevice, param, size, hl_aptr (result, int));
return result;
}
value lime_alc_get_string (value device, int param) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
const char* result = alcGetString (alcDevice, param);
return result ? alloc_string (result) : alloc_null ();
}
HL_PRIM vbyte* HL_NAME(hl_alc_get_string) (HL_CFFIPointer* device, int param) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
const char* result = alcGetString (alcDevice, param);
int length = strlen (result);
char* _result = (char*)malloc (length + 1);
strcpy (_result, result);
return (vbyte*)_result;
}
value lime_alc_get_string_list (value device, int param) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
const char* result = alcGetString (alcDevice, param);
if (!result || *result == '\0') {
return alloc_null ();
}
value list = alloc_array (0);
while (*result != '\0') {
val_array_push (list, alloc_string (result));
result += strlen (result) + 1;
}
return list;
}
HL_PRIM varray* HL_NAME(hl_alc_get_string_list) (HL_CFFIPointer* device, int param) {
ALCdevice* alcDevice = device ? (ALCdevice*)device->ptr : 0;
const char* result = alcGetString(alcDevice, param);
if (!result || *result == '\0') {
return 0;
}
int count = 0;
const char* temp = result;
while (*temp != '\0') {
count++;
temp += strlen (temp) + 1;
}
varray* list = hl_alloc_array (&hlt_bytes, count);
vbyte** listData = hl_aptr (list, vbyte*);
while (*result != '\0') {
int length = strlen (result) + 1;
char* _result = (char*)malloc (length);
strcpy (_result, result);
*listData = (vbyte*)_result;
listData++;
result += length;
}
return list;
}
bool lime_alc_make_context_current (value context) {
ALCcontext* alcContext = (ALCcontext*)val_data (context);
return alcMakeContextCurrent (alcContext);
}
HL_PRIM bool HL_NAME(hl_alc_make_context_current) (HL_CFFIPointer* context) {
ALCcontext* alcContext = context ? (ALCcontext*)context->ptr : 0;
return alcMakeContextCurrent (alcContext);
}
value lime_alc_open_device (HxString devicename) {
ALCdevice* alcDevice = alcOpenDevice (devicename.__s);
//TODO: Can we work out our own cleanup for openal?
//atexit (lime_al_atexit);
value ptr = CFFIPointer (alcDevice, gc_alc_object);
alcObjects[alcDevice] = ptr;
return ptr;
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_alc_open_device) (hl_vstring* devicename) {
ALCdevice* alcDevice = alcOpenDevice (devicename ? (char*)hl_to_utf8 ((const uchar*)devicename->bytes) : 0);
//TODO: Can we work out our own cleanup for openal?
//atexit (lime_al_atexit);
HL_CFFIPointer* ptr = HLCFFIPointer (alcDevice, (hl_finalizer)hl_gc_alc_object);
alcObjects[alcDevice] = ptr;
return ptr;
}
void lime_alc_pause_device (value device) {
#ifdef LIME_OPENALSOFT
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
alcDevicePauseSOFT (alcDevice);
#endif
}
HL_PRIM void HL_NAME(hl_alc_pause_device) (HL_CFFIPointer* device) {
#ifdef LIME_OPENALSOFT
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
alcDevicePauseSOFT (alcDevice);
#endif
}
void lime_alc_process_context (value context) {
ALCcontext* alcContext = (ALCcontext*)val_data (context);
alcProcessContext (alcContext);
}
HL_PRIM void HL_NAME(hl_alc_process_context) (HL_CFFIPointer* context) {
ALCcontext* alcContext = (ALCcontext*)context->ptr;
alcProcessContext (alcContext);
}
void lime_alc_resume_device (value device) {
#ifdef LIME_OPENALSOFT
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
alcDeviceResumeSOFT (alcDevice);
#endif
}
HL_PRIM void HL_NAME(hl_alc_resume_device) (HL_CFFIPointer* device) {
#ifdef LIME_OPENALSOFT
ALCdevice* alcDevice = device ? (ALCdevice*)device->ptr : NULL;
alcDeviceResumeSOFT (alcDevice);
#endif
}
void lime_alc_suspend_context (value context) {
ALCcontext* alcContext = (ALCcontext*)val_data (context);
alcSuspendContext (alcContext);
}
HL_PRIM void HL_NAME(hl_alc_suspend_context) (HL_CFFIPointer* context) {
ALCcontext* alcContext = context ? (ALCcontext*)context->ptr : NULL;
alcSuspendContext (alcContext);
}
value lime_alc_capture_open_device (HxString devicename, int frequency, int format, int buffersize) {
ALCdevice* alcDevice = alcCaptureOpenDevice (devicename.__s, frequency, format, buffersize);
value ptr = CFFIPointer (alcDevice, gc_alc_object);
alcObjects[alcDevice] = ptr;
return ptr;
}
HL_PRIM HL_CFFIPointer* HL_NAME(hl_alc_capture_open_device) (hl_vstring* devicename, int frequency, int format, int buffersize) {
ALCdevice* alcDevice = alcCaptureOpenDevice (devicename ? (char*)hl_to_utf8 ((const uchar*)devicename->bytes) : 0, frequency, format, buffersize);
HL_CFFIPointer* ptr = HLCFFIPointer (alcDevice, (hl_finalizer)hl_gc_alc_object);
alcObjects[alcDevice] = ptr;
return ptr;
}
bool lime_alc_capture_close_device (value device) {
al_gc_mutex.Lock ();
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
alcObjects.erase (alcDevice);
al_gc_mutex.Unlock ();
return alcCaptureCloseDevice (alcDevice);
}
HL_PRIM bool HL_NAME(hl_alc_capture_close_device) (HL_CFFIPointer* device) {
al_gc_mutex.Lock ();
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
alcObjects.erase (alcDevice);
al_gc_mutex.Unlock ();
return alcCaptureCloseDevice (alcDevice);
}
void lime_alc_capture_start (value device) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
alcCaptureStart (alcDevice);
}
HL_PRIM void HL_NAME(hl_alc_capture_start) (HL_CFFIPointer* device) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
alcCaptureStart (alcDevice);
}
void lime_alc_capture_stop (value device) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
alcCaptureStop (alcDevice);
}
HL_PRIM void HL_NAME(hl_alc_capture_stop) (HL_CFFIPointer* device) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
alcCaptureStop (alcDevice);
}
void lime_alc_capture_samples (value device, value buffer, int samples) {
ALCdevice* alcDevice = (ALCdevice*)val_data (device);
Bytes bytes (buffer);
alcCaptureSamples (alcDevice, bytes.b, samples);
}
HL_PRIM void HL_NAME(hl_alc_capture_samples) (HL_CFFIPointer* device, Bytes* buffer, int samples) {
ALCdevice* alcDevice = (ALCdevice*)device->ptr;
alcCaptureSamples (alcDevice, buffer->b, samples);
}
DEFINE_PRIME3v (lime_al_auxf);
DEFINE_PRIME3v (lime_al_auxfv);
DEFINE_PRIME3v (lime_al_auxi);
DEFINE_PRIME3v (lime_al_auxiv);
DEFINE_PRIME5v (lime_al_buffer_data);
DEFINE_PRIME5v (lime_al_buffer3f);
DEFINE_PRIME5v (lime_al_buffer3i);
DEFINE_PRIME3v (lime_al_bufferf);
DEFINE_PRIME3v (lime_al_bufferfv);
DEFINE_PRIME3v (lime_al_bufferi);
DEFINE_PRIME3v (lime_al_bufferiv);
DEFINE_PRIME0v (lime_al_cleanup);
DEFINE_PRIME1v (lime_al_delete_auxiliary_effect_slot);
DEFINE_PRIME1v (lime_al_delete_buffer);
DEFINE_PRIME2v (lime_al_delete_buffers);
DEFINE_PRIME1v (lime_al_delete_effect);
DEFINE_PRIME1v (lime_al_delete_filter);
DEFINE_PRIME1v (lime_al_delete_source);
DEFINE_PRIME2v (lime_al_delete_sources);
DEFINE_PRIME1v (lime_al_disable);
DEFINE_PRIME1v (lime_al_distance_model);
DEFINE_PRIME1v (lime_al_doppler_factor);
DEFINE_PRIME1v (lime_al_doppler_velocity);
DEFINE_PRIME3v (lime_al_effectf);
DEFINE_PRIME3v (lime_al_effectfv);
DEFINE_PRIME3v (lime_al_effecti);
DEFINE_PRIME3v (lime_al_effectiv);
DEFINE_PRIME1v (lime_al_enable);
DEFINE_PRIME3v (lime_al_filteri);
DEFINE_PRIME3v (lime_al_filterf);
DEFINE_PRIME0 (lime_al_gen_aux);
DEFINE_PRIME0 (lime_al_gen_buffer);
DEFINE_PRIME1 (lime_al_gen_buffers);
DEFINE_PRIME0 (lime_al_gen_effect);
DEFINE_PRIME0 (lime_al_gen_filter);
DEFINE_PRIME0 (lime_al_gen_source);
DEFINE_PRIME1 (lime_al_gen_sources);
DEFINE_PRIME1 (lime_al_get_boolean);
DEFINE_PRIME2 (lime_al_get_booleanv);
DEFINE_PRIME2 (lime_al_get_buffer3f);
DEFINE_PRIME2 (lime_al_get_buffer3i);
DEFINE_PRIME2 (lime_al_get_bufferf);
DEFINE_PRIME3 (lime_al_get_bufferfv);
DEFINE_PRIME2 (lime_al_get_bufferi);
DEFINE_PRIME3 (lime_al_get_bufferiv);
DEFINE_PRIME1 (lime_al_get_double);
DEFINE_PRIME2 (lime_al_get_doublev);
DEFINE_PRIME1 (lime_al_get_enum_value);
DEFINE_PRIME0 (lime_al_get_error);
DEFINE_PRIME2 (lime_al_get_filteri);
DEFINE_PRIME1 (lime_al_get_float);
DEFINE_PRIME2 (lime_al_get_floatv);
DEFINE_PRIME1 (lime_al_get_integer);
DEFINE_PRIME2 (lime_al_get_integerv);
DEFINE_PRIME1 (lime_al_get_listener3f);
DEFINE_PRIME1 (lime_al_get_listener3i);
DEFINE_PRIME1 (lime_al_get_listenerf);
DEFINE_PRIME2 (lime_al_get_listenerfv);
DEFINE_PRIME1 (lime_al_get_listeneri);
DEFINE_PRIME2 (lime_al_get_listeneriv);
DEFINE_PRIME1 (lime_al_get_proc_address);
DEFINE_PRIME2 (lime_al_get_source3f);
DEFINE_PRIME2 (lime_al_get_source3i);
DEFINE_PRIME2 (lime_al_get_sourcef);
DEFINE_PRIME3 (lime_al_get_sourcefv);
DEFINE_PRIME2 (lime_al_get_sourcei);
DEFINE_PRIME3 (lime_al_get_sourceiv);
DEFINE_PRIME1 (lime_al_get_string);
DEFINE_PRIME1 (lime_al_is_aux);
DEFINE_PRIME1 (lime_al_is_buffer);
DEFINE_PRIME1 (lime_al_is_effect);
DEFINE_PRIME1 (lime_al_is_enabled);
DEFINE_PRIME1 (lime_al_is_extension_present);
DEFINE_PRIME1 (lime_al_is_filter);
DEFINE_PRIME1 (lime_al_is_source);
DEFINE_PRIME4v (lime_al_listener3f);
DEFINE_PRIME4v (lime_al_listener3i);
DEFINE_PRIME2v (lime_al_listenerf);
DEFINE_PRIME2v (lime_al_listenerfv);
DEFINE_PRIME2v (lime_al_listeneri);
DEFINE_PRIME2v (lime_al_listeneriv);
DEFINE_PRIME1v (lime_al_remove_direct_filter);
DEFINE_PRIME2v (lime_al_remove_send);
DEFINE_PRIME1v (lime_al_source_pause);
DEFINE_PRIME2v (lime_al_source_pausev);
DEFINE_PRIME1v (lime_al_source_play);
DEFINE_PRIME2v (lime_al_source_playv);
DEFINE_PRIME3v (lime_al_source_queue_buffers);
DEFINE_PRIME1v (lime_al_source_rewind);
DEFINE_PRIME2v (lime_al_source_rewindv);
DEFINE_PRIME1v (lime_al_source_stop);
DEFINE_PRIME2v (lime_al_source_stopv);
DEFINE_PRIME2 (lime_al_source_unqueue_buffers);
DEFINE_PRIME5v (lime_al_source3f);
DEFINE_PRIME5v (lime_al_source3i);
DEFINE_PRIME3v (lime_al_sourcef);
DEFINE_PRIME3v (lime_al_sourcefv);
DEFINE_PRIME3v (lime_al_sourcei);
DEFINE_PRIME3v (lime_al_sourceiv);
DEFINE_PRIME1v (lime_al_speed_of_sound);
DEFINE_PRIME2 (lime_alc_create_context);
DEFINE_PRIME1 (lime_alc_close_device);
DEFINE_PRIME1v (lime_alc_destroy_context);
DEFINE_PRIME1 (lime_alc_get_contexts_device);
DEFINE_PRIME0 (lime_alc_get_current_context);
DEFINE_PRIME1 (lime_alc_get_error);
DEFINE_PRIME3 (lime_alc_get_integerv);
DEFINE_PRIME2 (lime_alc_get_string);
DEFINE_PRIME2 (lime_alc_get_string_list);
DEFINE_PRIME1 (lime_alc_make_context_current);
DEFINE_PRIME1 (lime_alc_open_device);
DEFINE_PRIME1v (lime_alc_pause_device);
DEFINE_PRIME1v (lime_alc_process_context);
DEFINE_PRIME1v (lime_alc_resume_device);
DEFINE_PRIME1v (lime_alc_suspend_context);
DEFINE_PRIME4 (lime_alc_capture_open_device);
DEFINE_PRIME1 (lime_alc_capture_close_device);
DEFINE_PRIME1v (lime_alc_capture_start);
DEFINE_PRIME1v (lime_alc_capture_stop);
DEFINE_PRIME3v (lime_alc_capture_samples);
#define _TBYTES _OBJ (_I32 _BYTES)
#define _TCFFIPOINTER _DYN
#define _TDEVICE _ABSTRACT (alc_device)
#define _TCONTEXT _ABSTRACT (alc_context)
#define _TARRAYBUFFER _TBYTES
#define _TARRAYBUFFERVIEW _OBJ (_I32 _TARRAYBUFFER _I32 _I32 _I32 _I32)
DEFINE_HL_PRIM (_VOID, hl_al_auxf, _TCFFIPOINTER _I32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_auxfv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_auxi, _TCFFIPOINTER _I32 _DYN);
DEFINE_HL_PRIM (_VOID, hl_al_auxiv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_buffer_data, _TCFFIPOINTER _I32 _TARRAYBUFFERVIEW _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_buffer3f, _TCFFIPOINTER _I32 _F32 _F32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_buffer3i, _TCFFIPOINTER _I32 _I32 _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_bufferf, _TCFFIPOINTER _I32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_bufferfv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_bufferi, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_bufferiv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_cleanup, _NO_ARG);
DEFINE_HL_PRIM (_VOID, hl_al_delete_auxiliary_effect_slot, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_delete_buffer, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_delete_buffers, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_delete_effect, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_delete_filter, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_delete_source, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_delete_sources, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_disable, _I32);
DEFINE_HL_PRIM (_VOID, hl_al_distance_model, _I32);
DEFINE_HL_PRIM (_VOID, hl_al_doppler_factor, _F32);
DEFINE_HL_PRIM (_VOID, hl_al_doppler_velocity, _F32);
DEFINE_HL_PRIM (_VOID, hl_al_effectf, _TCFFIPOINTER _I32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_effectfv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_effecti, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_effectiv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_enable, _I32);
DEFINE_HL_PRIM (_VOID, hl_al_filteri, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_filterf, _TCFFIPOINTER _I32 _F32);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_al_gen_aux, _NO_ARG);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_al_gen_buffer, _NO_ARG);
DEFINE_HL_PRIM (_ARR, hl_al_gen_buffers, _I32);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_al_gen_effect, _NO_ARG);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_al_gen_filter, _NO_ARG);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_al_gen_source, _NO_ARG);
DEFINE_HL_PRIM (_ARR, hl_al_gen_sources, _I32);
DEFINE_HL_PRIM (_BOOL, hl_al_get_boolean, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_booleanv, _I32 _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_buffer3f, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_buffer3i, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_F32, hl_al_get_bufferf, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_bufferfv, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_I32, hl_al_get_bufferi, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_bufferiv, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_F64, hl_al_get_double, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_doublev, _I32 _I32);
DEFINE_HL_PRIM (_I32, hl_al_get_enum_value, _STRING);
DEFINE_HL_PRIM (_I32, hl_al_get_error, _NO_ARG);
DEFINE_HL_PRIM (_I32, hl_al_get_filteri, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_F32, hl_al_get_float, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_floatv, _I32 _I32);
DEFINE_HL_PRIM (_I32, hl_al_get_integer, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_integerv, _I32 _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_listener3f, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_listener3i, _I32);
DEFINE_HL_PRIM (_F32, hl_al_get_listenerf, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_listenerfv, _I32 _I32);
DEFINE_HL_PRIM (_I32, hl_al_get_listeneri, _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_listeneriv, _I32 _I32);
DEFINE_HL_PRIM (_F64, hl_al_get_proc_address, _STRING);
DEFINE_HL_PRIM (_ARR, hl_al_get_source3f, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_source3i, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_F32, hl_al_get_sourcef, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_sourcefv, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_DYN, hl_al_get_sourcei, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_al_get_sourceiv, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_BYTES, hl_al_get_string, _I32);
DEFINE_HL_PRIM (_BOOL, hl_al_is_aux, _TCFFIPOINTER);
DEFINE_HL_PRIM (_BOOL, hl_al_is_buffer, _TCFFIPOINTER);
DEFINE_HL_PRIM (_BOOL, hl_al_is_effect, _TCFFIPOINTER);
DEFINE_HL_PRIM (_BOOL, hl_al_is_enabled, _I32);
DEFINE_HL_PRIM (_BOOL, hl_al_is_extension_present, _STRING);
DEFINE_HL_PRIM (_BOOL, hl_al_is_filter, _TCFFIPOINTER);
DEFINE_HL_PRIM (_BOOL, hl_al_is_source, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_listener3f, _I32 _F32 _F32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_listener3i, _I32 _I32 _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_listenerf, _I32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_listenerfv, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_listeneri, _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_listeneriv, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_remove_direct_filter, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_remove_send, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_VOID, hl_al_source_pause, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_source_pausev, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_source_play, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_source_playv, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_source_queue_buffers, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_source_rewind, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_source_rewindv, _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_source_stop, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_al_source_stopv, _I32 _ARR);
DEFINE_HL_PRIM (_ARR, hl_al_source_unqueue_buffers, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_VOID, hl_al_source3f, _TCFFIPOINTER _I32 _F32 _F32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_source3i, _TCFFIPOINTER _I32 _DYN _I32 _I32);
DEFINE_HL_PRIM (_VOID, hl_al_sourcef, _TCFFIPOINTER _I32 _F32);
DEFINE_HL_PRIM (_VOID, hl_al_sourcefv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_sourcei, _TCFFIPOINTER _I32 _DYN);
DEFINE_HL_PRIM (_VOID, hl_al_sourceiv, _TCFFIPOINTER _I32 _ARR);
DEFINE_HL_PRIM (_VOID, hl_al_speed_of_sound, _F32);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_alc_create_context, _TCFFIPOINTER _ARR);
DEFINE_HL_PRIM (_BOOL, hl_alc_close_device, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_destroy_context, _TCFFIPOINTER);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_alc_get_contexts_device, _TCFFIPOINTER);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_alc_get_current_context, _NO_ARG);
DEFINE_HL_PRIM (_I32, hl_alc_get_error, _TCFFIPOINTER);
DEFINE_HL_PRIM (_ARR, hl_alc_get_integerv, _TCFFIPOINTER _I32 _I32);
DEFINE_HL_PRIM (_BYTES, hl_alc_get_string, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_ARR, hl_alc_get_string_list, _TCFFIPOINTER _I32);
DEFINE_HL_PRIM (_BOOL, hl_alc_make_context_current, _TCFFIPOINTER);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_alc_open_device, _STRING);
DEFINE_HL_PRIM (_VOID, hl_alc_pause_device, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_process_context, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_resume_device, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_suspend_context, _TCFFIPOINTER);
DEFINE_HL_PRIM (_TCFFIPOINTER, hl_alc_capture_open_device, _STRING _I32 _I32 _I32);
DEFINE_HL_PRIM (_BOOL, hl_alc_capture_close_device, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_capture_start, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_capture_stop, _TCFFIPOINTER);
DEFINE_HL_PRIM (_VOID, hl_alc_capture_samples, _TCFFIPOINTER _TBYTES _I32);
}
extern "C" int lime_openal_register_prims () {
return 0;
}
Reference in New Issue View Git Blame Copy Permalink