Initial release: RadiantWave v1.0

2026-03-12 08:05:10 -05:00
commit 403ec4db89
555 changed files with 437856 additions and 0 deletions
@@ -0,0 +1,359 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+static Sint64 RWsize(SDL_RWops *ctx)
+{
+	return ctx->size(ctx);
+}
+
+static Sint64 RWseek(SDL_RWops *ctx, Sint64 offset, int whence)
+{
+	return ctx->seek(ctx, offset, whence);
+}
+
+static size_t RWread(SDL_RWops *ctx, void *ptr, size_t size, size_t maxnum)
+{
+	return ctx->read(ctx, ptr, size, maxnum);
+}
+
+static size_t RWwrite(SDL_RWops *ctx, void *ptr, size_t size, size_t num)
+{
+	return ctx->write(ctx, ptr, size, num);
+}
+
+static int RWclose(SDL_RWops *ctx)
+{
+	return ctx->close(ctx);
+}
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_LoadFile_RW is not supported before SDL 2.0.6")
+#endif
+
+static void * SDL_LoadFile_RW(SDL_RWops * src, size_t *datasize, int freesrc)
+{
+	return 0;
+}
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"unsafe"
+)
+
+// RWops types
+const (
+	RWOPS_UNKNOWN   = 0 // unknown stream type
+	RWOPS_WINFILE   = 1 // win32 file
+	RWOPS_STDFILE   = 2 // stdio file
+	RWOPS_JNIFILE   = 3 // android asset
+	RWOPS_MEMORY    = 4 // memory stream
+	RWOPS_MEMORY_RO = 5 // read-only memory stream
+)
+
+// RWops seek from
+const (
+	RW_SEEK_SET = C.RW_SEEK_SET // seek from the beginning of data
+	RW_SEEK_CUR = C.RW_SEEK_CUR // seek relative to current read point
+	RW_SEEK_END = C.RW_SEEK_END // seek relative to the end of data
+)
+
+// RWops provides an abstract interface to stream I/O. Applications can generally ignore the specifics of this structure's internals and treat them as opaque pointers. The details are important to lower-level code that might need to implement one of these, however.
+// (https://wiki.libsdl.org/SDL_RWops)
+type RWops C.SDL_RWops
+
+func (rwops *RWops) cptr() *C.SDL_RWops {
+	return (*C.SDL_RWops)(rwops)
+}
+
+// RWFromFile creates a new RWops structure for reading from and/or writing to a named file.
+// (https://wiki.libsdl.org/SDL_RWFromFile)
+func RWFromFile(file, mode string) *RWops {
+	_file := C.CString(file)
+	_mode := C.CString(mode)
+	defer C.free(unsafe.Pointer(_file))
+	defer C.free(unsafe.Pointer(_mode))
+	return (*RWops)(unsafe.Pointer(C.SDL_RWFromFile(_file, _mode)))
+}
+
+// RWFromMem prepares a read-write memory buffer for use with RWops.
+// (https://wiki.libsdl.org/SDL_RWFromMem)
+func RWFromMem(mem []byte) (*RWops, error) {
+	if mem == nil {
+		return nil, ErrInvalidParameters
+	}
+
+	header := (*reflect.SliceHeader)(unsafe.Pointer(&mem))
+	_mem := unsafe.Pointer(header.Data)
+
+	rwops := (*RWops)(unsafe.Pointer(C.SDL_RWFromMem(_mem, C.int(len(mem)))))
+	if rwops == nil {
+		return nil, GetError()
+	}
+	return rwops, nil
+}
+
+// AllocRW allocates an empty, unpopulated RWops structure.
+// (https://wiki.libsdl.org/SDL_AllocRW)
+func AllocRW() *RWops {
+	return (*RWops)(unsafe.Pointer(C.SDL_AllocRW()))
+}
+
+// Free frees the RWops structure allocated by AllocRW().
+// (https://wiki.libsdl.org/SDL_FreeRW)
+func (rwops *RWops) Free() error {
+	if rwops == nil {
+		return ErrInvalidParameters
+	}
+
+	C.SDL_FreeRW(rwops.cptr())
+	return nil
+}
+
+// Size returns the size of the data stream in the RWops.
+// (https://wiki.libsdl.org/SDL_RWsize)
+func (rwops *RWops) Size() (int64, error) {
+	n := int64(C.RWsize(rwops.cptr()))
+	if n < 0 {
+		return n, GetError()
+	}
+	return n, nil
+}
+
+// Seek seeks within the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWseek)
+func (rwops *RWops) Seek(offset int64, whence int) (int64, error) {
+	if rwops == nil {
+		return -1, ErrInvalidParameters
+	}
+
+	ret := int64(C.RWseek(rwops.cptr(), C.Sint64(offset), C.int(whence)))
+	if ret < 0 {
+		return ret, GetError()
+	}
+	return ret, nil
+}
+
+// Read reads from a data source.
+// (https://wiki.libsdl.org/SDL_RWread)
+func (rwops *RWops) Read(buf []byte) (n int, err error) {
+	return rwops.Read2(buf, 1, uint(len(buf)))
+}
+
+// Read2 reads from a data source (native).
+// (https://wiki.libsdl.org/SDL_RWread)
+func (rwops *RWops) Read2(buf []byte, size, maxnum uint) (n int, err error) {
+	if rwops == nil || buf == nil {
+		return 0, ErrInvalidParameters
+	}
+
+	header := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_data := unsafe.Pointer(header.Data)
+
+	n = int(C.RWread(rwops.cptr(), _data, C.size_t(size), C.size_t(maxnum)))
+	if n == 0 {
+		err = GetError()
+	}
+	return
+}
+
+// Tell returns the current read/write offset in the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWtell)
+func (rwops *RWops) Tell() (int64, error) {
+	if rwops == nil {
+		return 0, ErrInvalidParameters
+	}
+
+	ret := int64(C.RWseek(rwops.cptr(), 0, C.int(RW_SEEK_CUR)))
+	if ret < 0 {
+		return ret, GetError()
+	}
+	return ret, nil
+}
+
+// Write writes to the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWwrite)
+func (rwops *RWops) Write(buf []byte) (n int, err error) {
+	return rwops.Write2(buf, 1, uint(len(buf)))
+}
+
+// Write2 writes to the RWops data stream (native).
+// (https://wiki.libsdl.org/SDL_RWwrite)
+func (rwops *RWops) Write2(buf []byte, size, num uint) (n int, err error) {
+	if rwops == nil || buf == nil {
+		return 0, ErrInvalidParameters
+	}
+
+	header := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_data := unsafe.Pointer(header.Data)
+
+	n = int(C.RWwrite(rwops.cptr(), _data, C.size_t(size), C.size_t(num)))
+	if n < int(num) {
+		err = GetError()
+	}
+	return
+}
+
+// Close closes and frees the allocated RWops structure.
+// (https://wiki.libsdl.org/SDL_RWclose)
+func (rwops *RWops) Close() error {
+	if rwops != nil && C.RWclose(rwops.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// ReadU8 reads a byte from the RWops.
+// (https://wiki.libsdl.org/SDL_ReadU8)
+func (rwops *RWops) ReadU8() uint8 {
+	if rwops == nil {
+		return 0
+	}
+	return uint8(C.SDL_ReadU8(rwops.cptr()))
+}
+
+// ReadLE16 reads 16 bits of little-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadLE16)
+func (rwops *RWops) ReadLE16() uint16 {
+	if rwops == nil {
+		return 0
+	}
+	return uint16(C.SDL_ReadLE16(rwops.cptr()))
+}
+
+// ReadBE16 read 16 bits of big-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadBE16)
+func (rwops *RWops) ReadBE16() uint16 {
+	if rwops == nil {
+		return 0
+	}
+	return uint16(C.SDL_ReadBE16(rwops.cptr()))
+}
+
+// ReadLE32 reads 32 bits of little-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadLE32)
+func (rwops *RWops) ReadLE32() uint32 {
+	if rwops == nil {
+		return 0
+	}
+	return uint32(C.SDL_ReadLE32(rwops.cptr()))
+}
+
+// ReadBE32 reads 32 bits of big-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadBE32)
+func (rwops *RWops) ReadBE32() uint32 {
+	if rwops == nil {
+		return 0
+	}
+	return uint32(C.SDL_ReadBE32(rwops.cptr()))
+}
+
+// ReadLE64 reads 64 bits of little-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadLE64)
+func (rwops *RWops) ReadLE64() uint64 {
+	if rwops == nil {
+		return 0
+	}
+	return uint64(C.SDL_ReadLE64(rwops.cptr()))
+}
+
+// ReadBE64 reads 64 bits of big-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadBE64)
+func (rwops *RWops) ReadBE64() uint64 {
+	if rwops == nil {
+		return 0
+	}
+	return uint64(C.SDL_ReadBE64(rwops.cptr()))
+}
+
+// LoadFile_RW loads all the data from an SDL data stream.
+// (https://wiki.libsdl.org/SDL_LoadFile_RW)
+func (src *RWops) LoadFileRW(freesrc bool) (data []byte, size int) {
+	var _size C.size_t
+	var _freesrc C.int = 0
+
+	if freesrc {
+		_freesrc = 1
+	}
+
+	_data := C.SDL_LoadFile_RW(src.cptr(), &_size, _freesrc)
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	sliceHeader.Cap = int(_size)
+	sliceHeader.Len = int(_size)
+	sliceHeader.Data = uintptr(_data)
+	size = int(_size)
+	return
+}
+
+// LoadFile loads an entire file
+// (https://wiki.libsdl.org/SDL_LoadFile)
+func LoadFile(file string) (data []byte, size int) {
+	return RWFromFile(file, "rb").LoadFileRW(true)
+}
+
+// WriteU8 writes a byte to the RWops.
+// (https://wiki.libsdl.org/SDL_WriteU8)
+func (rwops *RWops) WriteU8(value uint8) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteU8(rwops.cptr(), C.Uint8(value)))
+}
+
+// WriteLE16 writes 16 bits in native format to the RWops as little-endian data.
+// (https://wiki.libsdl.org/SDL_WriteLE16)
+func (rwops *RWops) WriteLE16(value uint16) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteLE16(rwops.cptr(), C.Uint16(value)))
+}
+
+// WriteBE16 writes 16 bits in native format to the RWops as big-endian data.
+// (https://wiki.libsdl.org/SDL_WriteBE16)
+func (rwops *RWops) WriteBE16(value uint16) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteBE16(rwops.cptr(), C.Uint16(value)))
+}
+
+// WriteLE32 writes 32 bits in native format to the RWops as little-endian data.
+// (https://wiki.libsdl.org/SDL_WriteLE32)
+func (rwops *RWops) WriteLE32(value uint32) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteLE32(rwops.cptr(), C.Uint32(value)))
+}
+
+// WriteBE32 writes 32 bits in native format to the RWops as big-endian data.
+// (https://wiki.libsdl.org/SDL_WriteBE32)
+func (rwops *RWops) WriteBE32(value uint32) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteBE32(rwops.cptr(), C.Uint32(value)))
+}
+
+// WriteLE64 writes 64 bits in native format to the RWops as little-endian data.
+// (https://wiki.libsdl.org/SDL_WriteLE64)
+func (rwops *RWops) WriteLE64(value uint64) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteLE64(rwops.cptr(), C.Uint64(value)))
+}
+
+// WriteBE64 writes 64 bits in native format to the RWops as big-endian data.
+// (https://wiki.libsdl.org/SDL_WriteBE64)
+func (rwops *RWops) WriteBE64(value uint64) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteBE64(rwops.cptr(), C.Uint64(value)))
+}