raylib.stub

(import (srfi 159)
        (srfi 1)
        (chibi match))

(c-include "raylib.h")
(c-system-include "stdbool.h")

(define-syntax <<hlpr
  (syntax-rules (>>)
    ((_ () (arg ...)) (syntax-error "<< lambda must have a closing >>"))
    ((_ (>>) (arg ...))
     (syntax-error "<< lambda must have a body after >>"))
    ((_ (>> body body* ...) (arg ...))
     (lambda (arg ...) body body* ...))
    ((_ (other-arg rest ...) (arg ...))
     (<<hlpr (rest ...) (other-arg arg ...)))))

(define-syntax <<
  (syntax-rules ()
      ((_ parts ...)
       (<<hlpr (parts ...) ()))))

(define (empty-list? a)
  (eq? a '()))

(define (display-nl s)
  (display s)
  (newline))

(define (foldl fn-it-ac lst . init)
  (match init
    ((? empty-list? _)
     (foldl fn-it-ac (cdr lst) (car lst)))
    (init
     (let loop ((acc (car init))
                (rest lst))
       (if (empty-list? rest) acc
           (loop (fn-it-ac (car rest) acc)
                 (cdr rest)))))))

(define (join-with strings sep)
  (if (eq? strings '()) ""
      (foldl
       (lambda (it ac)
         (string-append ac sep it))
       strings)))

(define (struct-type? type-name)
  (let ((item (find (<< it >> (eq? (car it) type-name)) *types*)))
    (if item
        (eq? (cadr (memq 'type: item)) 'struct)
        #f)))

(define (generate-arg-list args)
  (join-with (map (lambda (arg)
                    (match arg
                      ((type name)
                       (cond ((struct-type? type)
                              (string-append (symbol->string type) " * " (symbol->string name)))
                             ((eq? type 'boolean)
                              (string-append "bool " (symbol->string name)))
                             ((eq? type 'unsigned-int)
                              (string-append "unsigned int " (symbol->string name)))
                             ((equal? '(pointer void) type)
                              (string-append "void * " (symbol->string name)))
                             ((eq? type 'string)
                              (string-append "char * " (symbol->string name)))
                             (else (string-append (symbol->string type) " " (symbol->string name))))))) args)
             ", "))

(define (generate-call-arg-list args)
  (join-with (map (lambda (arg)
                    (match arg
                      ((type name)
                       (cond
                        ((struct-type? type)
                         (string-append  "*" (symbol->string name)))
                        ((eq? type 'string)
                         (symbol->string name))
                        (else (symbol->string name)))))) args)
             ", "))

(define (generate-return-type return-type)
  (cond ((struct-type? return-type)
         (string-append (symbol->string return-type) " *"))
        ((eq? return-type 'boolean) "bool")
        (else (symbol->string return-type))))

(define (get-struct-fields type)
  (map (<< entry >> (cons (vector-ref (car entry) 0) (cdr entry)))
       (let loop ((lst (find (<< it >> (eq? (car it) type)) *types*)))
         (if (list? (car lst)) lst
             (loop (cdr lst))))))

;; Despite the generate name, this function does generate a copier
;; that allocates char * memory in the case of strings
(define (generate-copy-code struct-type from-name to-name)
  (let* ((struct-name (symbol->string struct-type))
         (from-name (symbol->string from-name))
         (to-name (symbol->string to-name))
         (body (let loop ((field-info (get-struct-fields struct-type))
                          (lines '()))
                 (if (eq? '() field-info) (join-with lines "\n")
                     (loop (cdr field-info)
                           (cons (match (car field-info)
                                   ((type name rest ...)
                                    (let ((name (symbol->string name)))
                                      (cond ((struct-type? type)
                                             (string-append "Copy" (symbol->string type) "NoAlloc("
                                                            "&(" from-name "->" name "),&(" to-name "->" name "));"))
                                            ((eq? type 'string)
                                             (string-append
                                              ;; NB. this does alloc strings.
                                              to-name "->" name " = (char*)malloc(sizeof(char)*strlen(" from-name "->" name"));\n"
                                              "str_copy(" to-name "->" name "," from-name "->" name ");\n"))
                                            (else
                                             (string-append to-name "->" name " = " from-name "->" name ";")))))) lines))))))
    (string-append "void Copy" struct-name "NoAlloc(" struct-name " * " from-name ", " struct-name " * " to-name "){\n"
                   body "\n}")))

(define (declare-struct-copier struct-name)
  (c-declare (generate-copy-code struct-name 'from_pointer 'to_pointer)))

(define (generate-pointer-passthrough return-type function-name args)
  (let ((function-name (symbol->string function-name))
        (return-type-name (symbol->string return-type)))
    (string-append
     (generate-return-type return-type) " " function-name "Pr(" (generate-arg-list args) "){\n" 
     (cond ((eq? return-type 'void)
            (string-append function-name "(" (generate-call-arg-list args) ");\n"))
           ((not (struct-type? return-type))
            (string-append "return " function-name "(" (generate-call-arg-list args) ");\n"))
           ((struct-type? return-type)
            (string-append return-type-name " tmp = " function-name "(" (generate-call-arg-list args) ");\n"
                           return-type-name " * out = (" return-type-name "*)malloc(sizeof(" return-type-name "));\n" 
                           "Copy" return-type-name "NoAlloc(&tmp,out);"
                           "return out;\n")))
           "}")))

(define (declare-pointer-passthrough-f return-type function-name args)
  (c-declare (generate-pointer-passthrough return-type function-name args)))

(define (ensure-string o)
  (with-output-to-string (lambda ()
                           (display o))))

(define (symbol->string* s)
  (cond ((symbol? s) (symbol->string s))
        ((string? s) s)
        (else (error (string-append "Error " (ensure-string s) " is neither string nor symbol.")))))

(define (generate-base-array-type-code type)
  (let* ((base (symbol->string* type))
         (base-ptr (string-append base "*"))
         (struct-name (string-append base "Array"))
         (struct-name-ptr (string-append struct-name "*"))
         (maker-c-symbol (string->symbol
                          (string-append
                           "Make" base "Array")))
         (maker-symbol (string-append
                        (string-append "make-" base "-array")))
         (getter-c-symbol (string->symbol
                           (string-append
                            "Get" base "ArrayEl")))
         (getter-symbol (string->symbol
                         (string-append "get-" base "-array-el")))
         (setter-c-symbol (string->symbol
                           (string-append
                            "Set" base "ArrayEl")))
         (setter-symbol (string->symbol
                         (string-append "set-" base "-array-el!"))))
    (string-append "typedef struct " struct-name " {
  int count;
  "base-ptr" data;
} " struct-name";

void Free"struct-name"Pr("struct-name-ptr"s){
  free(s->data);
  free(s);
}

" struct-name-ptr " Make" base "Array(int count){
  "struct-name-ptr" a = ("struct-name-ptr")malloc(sizeof("struct-name"));
  a->data = ("base-ptr")malloc(sizeof("base")*count);
  a->count = count;
  return a;
}

"base " Get"base"ArrayEl("struct-name-ptr" s, int index){
  return s->data[index % s->count];
}

void Set"base"ArrayEl("struct-name-ptr" s, int index, "base" val){
  s->data[index % s->count] = val;
}
")))

(define (symbol-append . args)
  (string->symbol (apply string-append (map symbol->string* args))))

(define-syntax declare-c-base-type-array
  (er-macro-transformer
   (lambda (e r c)
     (let* ((type (cadr e))
            (struct-type (symbol-append
                          type "Array"))
            (predicate (symbol-append
                        type "-array?"))
            (finalizer (symbol-append
                        "Free" type "ArrayPr"))
            (maker (symbol-append
                    "make-" type "-array"))
            (c-maker (symbol-append
                      "Make" type "Array"))
            (element-getter
             (symbol-append
              "get-" type "-array-element"))
            (c-element-getter
             (symbol-append
              "Get" type "ArrayEl"))
            (element-setter
             (symbol-append
              "set-" type "-array-element!"))
            (c-element-setter
             (symbol-append
              "Set" type "ArrayEl"))
            (count-getter
             (symbol-append "get-" type "-array-count")))
       `(begin
          (c-declare (generate-base-array-type-code ',type))
          (define-c-struct ,struct-type
            predicate: ,predicate
            finalizer: ,finalizer
            ((pointer ,type) elements)
            (int count ,count-getter))
          (define-c (free ,struct-type) (,maker ,c-maker) (int))
          (define-c ,type (,element-getter ,c-element-getter) (,struct-type int))
          (define-c void (,element-setter ,c-element-setter) (,struct-type int ,type)))))))

(declare-c-base-type-array int)
(declare-c-base-type-array float)


(define-syntax declare-pointer-passthrough
  (syntax-rules ()
    ((_ return-type function-name args)
     (declare-pointer-passthrough-f (quote return-type)
                                    (quote function-name)
                                    (quote args)))))

;; Type Wrappers
(c-declare "
void FreeImagePr(Image * im){
  UnloadImage(*im);
  free(im);
}
")

(define-c-struct Image
  predicate: image?
  finalizer: FreeImagePr
  ((link void) data)
  (int width get-image-width set-image-width!)
  (int height get-image-height set-image-height!)
  (int mipmaps get-image-mipmaps set-image-mipmaps!)
  (int format get-image-format set-image-format!))

(declare-struct-copier 'Image)

(c-declare "

Rectangle * MakeRectanglePr(float x, float y, float w, float h){
  Rectangle * r;
  r = malloc(sizeof(Rectangle));
  r->x = x;
  r->y = y;
  r->width = w;
  r->height = h;
  return r;
}

void FreeRectanglePr(Rectangle * r){
  free(r);
}
")

(define-c-struct Rectangle
  predicate: rectangle?
  finalizer: FreeRectanglePr
  (float x get-rectangle-x set-rectangle-x!)
  (float y get-rectangle-y set-rectangle-y!)
  (float width get-rectangle-width set-rectangle-width!)
  (float height get-rectangle-height set-rectangle-height!))
(declare-struct-copier 'Rectangle)

(define-c (free Rectangle) (--rectangle MakeRectanglePr) (float float float float))

(c-declare "
Color * MakeColorPr(unsigned char r,
                    unsigned char g,
                    unsigned char b,
                    unsigned char a){
  Color * c = malloc(sizeof(Color));
  c->r = r;
  c->g = g;
  c->b = b;
  c->a = a;
  return c;
}

void FreeColorPr(Color * c){
  free(c);
}
")

(define-c-struct Color
  predicate: color?
  finalizer: FreeColorPr
  (unsigned-char r get-color-r set-color-r!)
  (unsigned-char g get-color-g set-color-g!)
  (unsigned-char b get-color-b set-color-b!)
  (unsigned-char a get-color-a set-color-a!))
(declare-struct-copier 'Color)

(define-c (free Color) (--color MakeColorPr) (unsigned-char unsigned-char unsigned-char unsigned-char))

(c-declare "
void FreeVector2Pr(Vector2 * v){
  free(v);
}

Vector2 * MakeVector2Pr(float x, float y){
  Vector2 * v = (Vector2*)malloc(sizeof(Vector2));
  v->x = x;
  v->y = y;
  return v;
}
")

(define-c-struct Vector2
  predicate: vector-2?
  finalizer: FreeVector2Pr
  (float x get-vector-2-x set-vector-2-x!)
  (float y get-vector-2-y set-vector-2-y!))
(declare-struct-copier 'Vector2)

(define-c (free Vector2) (make-vector-2 MakeVector2Pr) (float float))

(c-declare "
Vector3 * MakeVector3Pr(float x, float y, float z){
  Vector3 * out = (Vector3*)malloc(sizeof(Vector3));
  out->x = x;
  out->y = y;
  out->z = z;
  return out;
}

void FreeVector3Pr(Vector3 * v){
  free(v);
}
")

(define-c-struct Vector3
  predicate: vector-3?
  finalizer: FreeVector3Pr
  (float x get-vector-3-x set-vector-3-x!)
  (float y get-vector-3-y set-vector-3-y!)
  (float z get-vector-3-z set-vector-3-z!))
(declare-struct-copier 'Vector3)

(define-c (free Vector3) (make-vector-3 MakeVector3Pr) (float float float))

; Vector4
(c-declare "
Vector4 * MakeVector4Pr(float x, float y, float z, float w){
  Vector4 * out = (Vector4*)malloc(sizeof(Vector4));
  out->x = x;
  out->y = y;
  out->z = z;
  out->w = w;
  return out;
}

void FreeVector4Pr(Vector4 * v){
  free(v);
}
")

(define-c-struct Vector4
  predicate: vector-3?
  finalizer: FreeVector4Pr
  (float x get-vector-3-x set-vector-3-x!)
  (float y get-vector-3-y set-vector-3-y!)
  (float z get-vector-3-z set-vector-3-z!)
  (float w get-vector-3-w set-vector-3-w!))
(declare-struct-copier 'Vector4)

(define-c (free Vector4) (make-vector-4 MakeVector4Pr) (float float float float))


; /* Camera2D material */

(c-declare "
Vector2 * GetCamera2DOffset(Camera2D * c){
  Vector2 * out = (Vector2*)malloc(sizeof(Vector2));
  out->x = c->offset.x;
  out->y = c->offset.y;
  return out;
}

Vector2 * GetCamera2DTarget(Camera2D * c){
  Vector2 * out = (Vector2*)malloc(sizeof(Vector2));
  out->x = c->target.x;
  out->y = c->target.y;
  return out;
}

void SetCamera2DOffset(Camera2D * c, Vector2 * v){
  c->offset.x = v->x;
  c->offset.y = v->y;
}

void SetCamera2DTarget(Camera2D * c, Vector2 * v){
  c->target.x = v->x;
  c->target.y = v->y;
}

")

(define-c-struct Camera2D
  predicate: camera-2d?
  finalizer: FreeCamera2DPr
  ((struct Vector2) offset )
  ((struct Vector2) target )
  (float rotation camera-2d-rotation set-camera-2d-rotation!)
  (float zoom camera-2d-zoom set-camera-2d-zoom!))
(declare-struct-copier 'Camera2D)

(define-c (free Vector2) (get-camera-2d-offset GetCamera2DOffset) (Camera2D))
(define-c (free Vector2) (get-camera-2d-target GetCamera2DTarget) (Camera2D))
(define-c void (set-camera-2d-offset! SetCamera2DOffset) (Camera2D Vector2))
(define-c void (set-camera-2d-target! SetCamera2DTarget) (Camera2D Vector2))

;; Camera3D Material

(c-declare "
void FreeCamera3DPr(Camera3D * c){
  free(c);
}

Camera3D * MakeCamera3DPr(Vector3 * position, Vector3 * target, Vector3 * up, float fovy, int type){
  Camera3D * c = (Camera3D*) malloc(sizeof(Camera3D));

  c->position.x = position->x;
  c->position.y = position->y;
  c->position.z = position->z;

  c->target.x = target->x;
  c->target.y = target->y;
  c->target.z = target->z;

  c->up.x = up->x;
  c->up.y = up->y;
  c->up.z = up->z;

  c->fovy = fovy;
  c->type = type;

  return c;
}

Vector3 * GetCamera3DPosition(Camera3D * c){
  Vector3 * v = (Vector3*)malloc(sizeof(Vector3));
  v->x = c->position.x;
  v->y = c->position.y;
  v->z = c->position.z;
  return v;
}

Vector3 * GetCamera3DTarget(Camera3D * c){
  Vector3 * v = (Vector3*)malloc(sizeof(Vector3));
  v->x = c->target.x;
  v->y = c->target.y;
  v->z = c->target.z;
  return v;
}

Vector3 * GetCamera3DUp(Camera3D * c){
  Vector3 * v = (Vector3*)malloc(sizeof(Vector3));
  v->x = c->up.x;
  v->y = c->up.y;
  v->z = c->up.z;
  return v;
}

void SetCamera3DPosition(Camera3D * c, Vector3 * v){
  c->position.x = v->x;
  c->position.y = v->y;
  c->position.z = v->z;
}

void SetCamera3DTarget(Camera3D * c, Vector3 * v){
  c->target.x = v->x;
  c->target.y = v->y;
  c->target.z = v->z;
}

void SetCamera3DUp(Camera3D * c, Vector3 * v){
  c->up.x = v->x;
  c->up.y = v->y;
  c->up.z = v->z;
}

")

(define-c-struct Camera3D
  predicate: camera-3d?
  finalizer: FreeCamera3DPr
  ((struct Vector3) position)
  ((struct Vector3) target)
  ((struct Vector3) up)
  (float fovy get-camera-3d-fovy set-camera-3d-fovy!)
  (int type get-camera-3d-type set-camera-3d-type!))
(declare-struct-copier 'Camera3D)

(define-c Camera3D (make-camera-3d MakeCamera3DPr)
  (Vector3 Vector3 Vector3 float int))

(define-c (free Vector3) (get-camera-3d-position GetCamera3DPosition) (Camera3D))
(define-c (free Vector3) (get-camera-3d-target GetCamera3DTarget) (Camera3D))
(define-c (free Vector3) (get-camera-3d-up GetCamera3DUp) (Camera3D))

(define-c void (set-camera-3d-position! SetCamera3DPosition) (Camera3D Vector3))
(define-c void (set-camera-3d-target! SetCamera3DTarget) (Camera3D Vector3))
(define-c void (set-camera-3d-up! SetCamera3DUp) (Camera3D Vector3))

(c-declare "
void FreeTexture2DPr(Texture2D * t){
  UnloadTexture(*t);
  free(t);
}
")

(define-c-struct Texture2D
  predicate: texture-2d?
  finalizer: FreeTexture2DPr
  (unsigned-int id get-texture-2d-id set-texture-2d-id!)
  (int width get-texture-2d-width set-texture-2d-width!)
  (int height get-texture-2d-height set-texture-2d-height!)
  (int mipmaps get-texture-2d-mipmaps set-texture-2d-mipmaps!)
  (int format get-texture-2d-format set-texture-2d-format!))
(declare-struct-copier 'Texture2D)

(c-declare "
void FreeRenderTexture2DPr(RenderTexture2D * r){
  UnloadRenderTexture(*r);
  free(r);
}

Texture2D * GetRenderTexture2DTexture(RenderTexture2D * r){
  return &(r->texture);
}

Texture2D * GetRenderTexture2DDepth(RenderTexture2D * r){
  return &(r->depth);
}

")

(define-c-struct RenderTexture2D
  predicate: render-texture-2d?
  finalizer: FreeRenderTexture2DPr
  (unsigned-int id get-render-texture-2d-id set-render-texture-2d-id!)
  ((struct Texture2D) texture)
  ((struct Texture2D) depth)
  (boolean depthTexture get-render-texture-2d-depth-texture set-render-texture-2d-depth-texure!))
(declare-struct-copier 'RenderTexture2D)

(define-c Texture2D (get-render-texture-2d-texture GetRenderTexture2DTexture) (RenderTexture2D))
(define-c Texture2D (get-render-texture-2d-depth GetRenderTexture2DTexture) (RenderTexture2D))

;; Ray

(c-declare "
Ray * MakeRayPr(Vector3 * position, Vector3 * direction){
  Ray * r = (Ray*)malloc(sizeof(Ray));
  r->position.x = position->x;
  r->position.y = position->y;
  r->position.z = position->z;

  r->direction.x = direction->x;
  r->direction.y = direction->y;
  r->direction.z = direction->z;

  return r;
}

void FreeRayPr(Ray * r){
  free(r);
}

Vector3 * GetRayPosition(Ray * r){
  Vector3 * out = (Vector3*)malloc(sizeof(Vector3));
  out->x = r->position.x;
  out->y = r->position.y;
  out->z = r->position.z;
  return out;
}

Vector3 * GetRayDirection(Ray * r){
  Vector3 * out = (Vector3*)malloc(sizeof(Vector3));
  out->x = r->direction.x;
  out->y = r->direction.y;
  out->z = r->direction.z;
  return out;
}

void SetRayPosition(Ray * r, Vector3 * v){
  r->position.x = v->x;
  r->position.y = v->y;
  r->position.z = v->z;
}

void SetRayDirection(Ray * r, Vector3 * v){
  r->direction.x = v->x;
  r->direction.y = v->y;
  r->direction.z = v->z;
}
")

(define-c-struct Ray
  predicate: ray?
  finalizer: FreeRayPr
  ((struct Vector3) position)
  ((struct Vector3) direction))
(declare-struct-copier 'Ray)

(define-c (free Vector3) (get-ray-position GetRayPosition) (Ray))
(define-c (free Vector3) (get-ray-direction GetRayDirection) (Ray))
(define-c void (set-ray-position! SetRayPosition) (Ray Vector3))
(define-c void (set-ray-direction! SetRayDirection) (Ray Vector3))
(define-c (free Ray) (ray MakeRayPr) (Vector3 Vector3))

;; Matrix type

(c-declare "
void FreeMatrixPr(Matrix * m){
  free(m);
}

Matrix * MakeMatrixPr(
float m0,
float m1,
float m2,
float m3,
float m4,
float m5,
float m6,
float m7,
float m8,
float m9,
float m10,
float m11,
float m12,
float m13,
float m14,
float m15
){
  Matrix * m = (Matrix*)malloc(sizeof(Matrix));
  m->m0 = m0;
m->m1 = m1;
m->m2 = m2;
m->m3 = m3;
m->m4 = m4;
m->m5 = m5;
m->m6 = m6;
m->m7 = m7;
m->m8 = m8;
m->m9 = m9;
m->m10 = m10;
m->m11 = m11;
m->m12 = m12;
m->m13 = m13;
m->m14 = m14;
m->m15 = m15;
return m;
}
")

(define-c-struct Matrix
  predicate: matrix?
  finalizer: FreeMatrixPr
  (float m0 get-matrix-m0 set-matrix-m0!)
  (float m1 get-matrix-m1 set-matrix-m1!)
  (float m2 get-matrix-m2 set-matrix-m2!)
  (float m3 get-matrix-m3 set-matrix-m3!)
  (float m4 get-matrix-m4 set-matrix-m4!)
  (float m5 get-matrix-m5 set-matrix-m5!)
  (float m6 get-matrix-m6 set-matrix-m6!)
  (float m7 get-matrix-m7 set-matrix-m7!)
  (float m8 get-matrix-m8 set-matrix-m8!)
  (float m9 get-matrix-m9 set-matrix-m9!)
  (float m10 get-matrix-m10 set-matrix-m10!)
  (float m11 get-matrix-m11 set-matrix-m11!)
  (float m12 get-matrix-m12 set-matrix-m12!)
  (float m13 get-matrix-m13 set-matrix-m13!)
  (float m14 get-matrix-m14 set-matrix-m14!)
  (float m15 get-matrix-m15 set-matrix-m15!))
(declare-struct-copier 'Matrix)

(define-c (free Matrix) (make-matrix MakeMatrixPr)
  (float
   float
   float
   float
   float
   float
   float
   float
   float
   float
   float
   float
   float
   float
   float
   float))

(c-declare "
void FreeCharInfoPr(CharInfo * c){
  free(c->data);
  free(c);
}
")

(define-c-struct CharInfo
  predicate: char-info?
  finalizer: FreeCharInfoPr
  (int value get-value set-value!)
  ((struct Rectangle) rec get-rectangle)
  (int offsetX)
  (int offsetY)
  ((pointer unsigned-char) data))

;(declare-struct-copier 'CharInfo)
(c-declare "
void CopyCharInfoNoAlloc(CharInfo * from_pointer, CharInfo * to_pointer){
  to_pointer->data = from_pointer->data;
  to_pointer->offsetY = from_pointer->offsetY;
  to_pointer->offsetX = from_pointer->offsetX;
  CopyRectangleNoAlloc(&(from_pointer->rec),&(to_pointer->rec));
  to_pointer->value = from_pointer->value;
}
")

(c-declare "
void FreeFontPr(Font * f){
  FreeCharInfoPr(f->chars);
  free(f);
}
")

(define-c-struct Font
  predicate: font?
  finalizer: FreeFontPr
  ((struct Texture2D) texture get-texture)
  (int baseSize get-base-size)
  (int charsCount get-chars-count)
  ((struct CharInfo) chars get-chars))

(c-declare "
void CopyFontNoAlloc(Font * from_pointer, Font * to_pointer){
  int i, n;
  //CopyCharInfoNoAlloc(&(from_pointer->chars),&(to_pointer->chars));
  to_pointer->charsCount = from_pointer->charsCount;
  to_pointer->baseSize = from_pointer->baseSize;
  CopyTexture2DNoAlloc(&(from_pointer->texture),&(to_pointer->texture));
  n = from_pointer->charsCount;
  to_pointer->chars = (CharInfo*)malloc(sizeof(CharInfo)*n);
  for(i = 0; i < n; i++){
    to_pointer->chars[i] = from_pointer->chars[i];
  }
}
")

(c-declare "
void FreeMeshPr(Mesh * m){
  UnloadMesh(m);
}
")

(define-c-struct Mesh
  predicate: mesh?
  finalizer: FreeMeshPr 
  (int vertexCount get-vertext-count)
  (int triangleCount get-triangle-count)
  ((pointer float) vertices)
  ((pointer float) texcoords)
  ((pointer float) texcoords2)
  ((pointer float) normals)
  ((pointer float) tangents)
  ((pointer unsigned-char) colors)
  ((pointer short) indices)
  ((pointer float) animVertices)
  ((pointer float) animNormals)
  ((pointer int) boneIds)
  ((pointer float) boneWeights)
  (unsigned-int vaoId)
  ((array unsigned-int 7) vboId))

(c-declare "void CopyMeshNoAlloc(Mesh * from_pointer, Mesh * to_pointer){
  int i;
  to_pointer->vertexCount = from_pointer->vertexCount;
  to_pointer->triangleCount = from_pointer->triangleCount;
  to_pointer->vertices = from_pointer->vertices;
  to_pointer->texcoords = from_pointer->texcoords;
  to_pointer->texcoords2 = from_pointer->texcoords2;
  to_pointer->normals = from_pointer->normals;
  to_pointer->tangents = from_pointer->tangents;
  to_pointer->colors = from_pointer->colors;
  to_pointer->indices = from_pointer->indices;
  to_pointer->animVertices = from_pointer->animVertices;
  to_pointer->animNormals = from_pointer->animNormals;
  to_pointer->boneIds = from_pointer->boneIds;
  to_pointer->boneWeights = from_pointer->boneWeights;
  to_pointer->vaoId = from_pointer->vaoId;
  for(i = 0; i < 7; i++) {
    to_pointer->vboId[i] = from_pointer->vboId[i];
  }  
}")

(c-declare "void FreeMaterialMapPr(MaterialMap * m){
  free(m);
}")

(define-c-struct MaterialMap
  predicate: material-map?
  finalizer: FreeMaterialMapPr
  ((struct Texture2D) texture)
  ((struct Color) color)
  (float value))

(c-declare "void FreeMaterialPr(Material * m){
  UnloadMaterial(*m);
  free(m);
}

void CopyMaterialNoAlloc(Material * from_pointer, Material * to_pointer){
  int i;
  to_pointer->shader = from_pointer->shader;
  for(i = 0; i < MAX_MATERIAL_MAPS; i++){
    to_pointer->maps[i] = from_pointer->maps[i];
  }
  to_pointer->params = from_pointer->params;
}
")

(define-c-struct Material
  predicate: material?
  finalizer: FreeMaterialPr
  ((struct Shader) shader)
  ((pointer (struct MaterialMap)) maps)
  ((pointer float) params))

(c-declare "void FreeModelPr(Model * m){
  UnloadModel(*m);
  free(m);
}")

(define-c-struct Model
  predicate: model?
  finalizer: FreeModelPr
  ((struct Matrix) transform)
  (int meshCount)
  ((pointer (struct Mesh)) meshes)
  (int materialCount)
  ((pointer (struct Material)) materials)
  ((pointer int) meshMaterial)
  (int boneCount)
  ((pointer (struct BoneInfo)) bones)
  ((pointer (struct Transform)) bindPose))

(c-declare "void CopyModelNoAlloc(Model * from_pointer, Model * to_pointer){
  to_pointer->transform = from_pointer->transform;
  to_pointer->meshCount = from_pointer->meshCount;
  to_pointer->meshes = from_pointer->meshes;
  to_pointer->materialCount = from_pointer->materialCount;
  to_pointer->materials = from_pointer->materials;
  to_pointer->meshMaterial = from_pointer->meshMaterial;
  to_pointer->boneCount = from_pointer->boneCount;
  to_pointer->bones = from_pointer->bones;
  to_pointer->bindPose = from_pointer->bindPose;
}")

(define-c-struct ModelAnimation
  predicate: model-animation?
  (int boneCount)
  ((pointer (struct BoneInfo)) bones)
  (int frameCount)
  ((pointer (pointer Transform)) framePoses))

(c-declare "void CopyModelAnimationNoAlloc(ModelAnimation * from, ModelAnimation * to){
  to->boneCount = from->boneCount;
  to->bones = from->bones;
  to->frameCount = from->frameCount;
  to->framePoses = from->framePoses;
}")

;; // Bounding box type
;; typedef struct BoundingBox {
;;     Vector3 min;            // Minimum vertex box-corner
;;     Vector3 max;            // Maximum vertex box-corner
;; } BoundingBox;

(define-c-struct BoundingBox
  predicate: bounding-box?
  ((struct Vector3) min)
  ((struct Vector3) max))

(declare-struct-copier 'BoundingBox)

(c-declare "
Vector3 * GetBoundingBoxMin(BoundingBox * bb){
  Vector3 * v = (Vector3*)malloc(sizeof(Vector3));
  CopyVector3NoAlloc(&(bb->min),v);
  return v;
}

Vector3 * GetBoundingBoxMax(BoundingBox * bb){
  Vector3 * v = (Vector3*)malloc(sizeof(Vector3));
  CopyVector3NoAlloc(&(bb->max),v);
  return v;
}
")

(c-declare "
void FreeRayHitInfo(RayHitInfo * r){
  free(r);
}
")

(define-c-struct RayHitInfo
  predicate: ray-hit-info?
  finalizer: FreeRayHitInfo
  (boolean hit ray-hit-info-get-hit)
  (float distance ray-hit-info-get-distance)
  ((struct Vector3) position)
  ((struct Vector3) normal))

(c-declare "
Vector3 * RayHitInfoGetPosition(RayHitInfo * r){
  Vector3 * out = (Vector3*)malloc(sizeof(Vector3));
  CopyVector3NoAlloc(&(r->position),out);
  return out;
}
Vector3 * RayHitInfoGetNormal(RayHitInfo * r){
  Vector3 * out = (Vector3*)malloc(sizeof(Vector3));
  CopyVector3NoAlloc(&(r->normal),out);
  return out;
}
")

(c-declare "
void FreeShaderPr(Shader * shader){
  UnloadShader(*shader);
  free(shader);
}
")

(define MAX_SHADER_LOCATIONS 32)

(define-c-struct Shader
  predicate: shader?
  finalizer: FreeShaderPr
  (unsigned-int id get-shader-id)
  ((array int MAX_SHADER_LOCATIONS) locs))

(c-declare "void CopyShaderNoAlloc(Shader * from, Shader * to){
  int i;
  to->id = from->id;
  for(i = 0; i < MAX_SHADER_LOCATIONS; i++){
    to->locs[i] = from->locs[i];
  }
}")

(declare-struct-copier 'RayHitInfo)

(c-declare "void FreeWavePr(Wave * w){
  UnloadWave(*w);
  free(w);
}")

(define-c-struct Wave
  predicate: wave?
  finalizer: FreeWavePr
  (unsigned-int sampleCount get-wave-sample-count)
  (unsigned-int sampleRate get-wave-sample-rate)
  (unsigned-int sampleSize get-sample-size)
  (unsigned-int channels get-channels)
  ((pointer void) data))

(c-declare "
void CopyWaveNoAlloc(Wave * from, Wave * to){
  to->sampleCount = from->sampleCount;
  to->sampleRate = from->sampleRate;
  to->sampleSize = from->sampleSize;
  to->channels = from->channels;
  to->data = from->data;
}
")

(c-declare "void FreeSoundPr(Sound * pr){
  UnloadSound(*pr);
  free(pr);
}")

(define-c-struct Sound
  predicate: Sound?
  finalizer: FreeSoundPr
  ((pointer void) audioBuffer)
  (unsigned-int source get-source)
  (unsigned-int buffer get-buffer)
  (int format))

(c-declare "void CopySoundNoAlloc(Sound * from, Sound * to){
  to->audioBuffer = from->audioBuffer;
  to->source = from->source;
  to->buffer = from->buffer;
  to->format = from->format;
}")

(c-declare "void FreeAudioStreamPr(AudioStream * a){
  CloseAudioStream(*a);
  free(a);
}")
(define-c-struct AudioStream
  predicate: audio-stream?
  finalizer: FreeAudioStreamPr
  (unsigned-int sampleRate audio-stream-get-sample-rate)
  (unsigned-int sampleSize audio-stream-get-sample-size)
  (unsigned-int channels audio-stream-get-channels)
  ((pointer void) audioBuffer)
  (int format)
  (unsigned-int source)
  ((array (unsigned-int) 2) buffers))

(c-declare "void CopyAudioStreamNoAlloc(AudioStream * from, AudioStream * to){
  int i;
  to->sampleRate = from->sampleRate;
  to->sampleSize = from->sampleSize;
  to->channels = from->channels;
  to->audioBuffer = from->audioBuffer;

  to->format = from->format;
  to->source = from->source;
  for( i=0; i<2; i++ ){
    to->buffers[i] = from->buffers[i];
  }
}")

;; void InitWindow(int width, int height, const char *title);              // Initialize window and OpenGL context
(define-c void (init-window InitWindow) (int int string))
;; boolean WindowShouldClose(void);                                           // Check if KEY_ESCAPE pressed or Close icon pressed
(define-c boolean (window-should-close? WindowShouldClose) ())
;; void CloseWindow(void);                                                 // Close window and unload OpenGL context
(define-c void (close-window CloseWindow) ())
;; boolean IsWindowReady(void);                                               // Check if window has been initialized successfully
(define-c boolean (window-ready? IsWindowReady) ())
;; boolean IsWindowMinimized(void);                                           // Check if window has been minimized (or lost focus)
(define-c boolean (window-minimized? IsWindowMinimized) ())
;; boolean IsWindowResized(void);                                             // Check if window has been resized
(define-c boolean (window-resized? IsWindowResized) ())
;; boolean IsWindowHidden(void);                                              // Check if window is currently hidden
(define-c boolean (window-hidden? IsWindowHidden) ())
;; void ToggleFullscreen(void);                                            // Toggle fullscreen mode (only PLATFORM_DESKTOP)
(define-c void (toggle-fullscreen ToggleFullscreen) ())
;; void UnhideWindow(void);                                                // Show the window
(define-c void (unhide-window UnhideWindow) ())
;; void HideWindow(void);                                                  // Hide the window
(define-c void (hide-window HideWindow) ())
;; void SetWindowIcon(Image image);                                        // Set icon for window (only PLATFORM_DESKTOP)
(define-c void (set-window-icon SetWindowIconPr) (Image))
;; void SetWindowTitle(const char *title);                                 // Set title for window (only PLATFORM_DESKTOP)
(define-c void (set-window-title SetWindowTitle) (string))
;; void SetWindowPosition(int x, int y);                                   // Set window position on screen (only PLATFORM_DESKTOP)
(define-c void (set-window-position SetWindowPosition) (int int))
;; void SetWindowMonitor(int monitor);                                     // Set monitor for the current window (fullscreen mode)
(define-c void (set-window-monitor SetWindowMonitor) (int))
;; void SetWindowMinSize(int width, int height);                           // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
(define-c void (set-window-min-size SetWindowMinSize) (int int))
;; void SetWindowSize(int width, int height);                              // Set window dimensions
(define-c void (set-window-size SetWindowSize) (int int))
;; void *GetWindowHandle(void);                                            // Get native window handle
(define-c (pointer void) (get-window-handle GetWindowHandle) ())
;; int GetScreenWidth(void);                                               // Get current screen width
(define-c int (get-screen-width GetScreenWidth) ())
;; int GetScreenHeight(void);                                              // Get current screen height
(define-c int (get-screen-height GetScreenHeight) ())
;; int GetMonitorCount(void);                                              // Get number of connected monitors
(define-c int (get-monitor-count GetMonitorCount) ())
;; int GetMonitorWidth(int monitor);                                       // Get primary monitor width
(define-c int (get-monitor-width GetMonitorWidth) (int))
;; int GetMonitorHeight(int monitor);                                      // Get primary monitor height
(define-c int (get-monitor-height GetMonitorHeight) (int))
;; int GetMonitorPhysicalWidth(int monitor);                               // Get primary monitor physical width in millimetres
(define-c int (get-monitor-physical-width GetMonitorPhysicalWidth) (int))
;; int GetMonitorPhysicalHeight(int monitor);                              // Get primary monitor physical height in millimetres
(define-c int (get-monitor-physical-height GetMonitorPhysicalHeight) (int))
;; const char *GetMonitorName(int monitor);                                // Get the human-readable, UTF-8 encoded name of the primary monitor
(define-c string (get-monitor-name GetMonitorName) (int))
;; const char *GetClipboardText(void);                                     // Get clipboard text content
(define-c string (get-clipboard-text GetClipboardText) ())
;; void SetClipboardText(const char *text);                                // Set clipboard text content
(define-c void (set-clipboard-text SetClipboardText) (string))

;; // Cursor-related functions
;;    void ShowCursor(void);                                                  // Shows cursor
(define-c void (show-cursor ShowCursor) ())
;;    void HideCursor(void);                                                  // Hides cursor
(define-c void (hide-cursor HideCursor) ())
;;    bool IsCursorHidden(void);                                              // Check if cursor is not visible
(define-c boolean (cursor-hidden? IsCursorHidden) ())
;;    void EnableCursor(void);                                                // Enables cursor (unlock cursor)
(define-c void (enable-cursor EnableCursor) ())
;;    void DisableCursor(void);                                               // Disables cursor (lock cursor)
(define-c void (disable-cursor DisableCursor) ())

;; // Drawing-related functions
;; RLAPI void ClearBackground(Color color);                          // Set background color (framebuffer clear color)
(define-c void (clear-background ClearBackgroundPr) (Color))
;; RLAPI void BeginDrawing(void);                                    // Setup canvas (framebuffer) to start drawing
(define-c void (begin-drawing BeginDrawing) ())
;; RLAPI void EndDrawing(void);                                      // End canvas drawing and swap buffers (double buffering)
(define-c void (end-drawing EndDrawing) ())
;; RLAPI void BeginMode2D(Camera2D camera);                          // Initialize 2D mode with custom camera (2D)
(define-c void (begin-mode-2d BeginMode2DPr) (Camera2D))
;; RLAPI void EndMode2D(void);                                       // Ends 2D mode with custom camera
(define-c void (end-mode-2d EndMode2D) ())
;; RLAPI void BeginMode3D(Camera3D camera);                          // Initializes 3D mode with custom camera (3D)
(c-declare "
void BeginMode3DPr(Camera3D * c){
  BeginMode3D(*c);
}
")
(define-c void (begin-mode-3d BeginMode3DPr) (Camera3D))
;; RLAPI void EndMode3D(void);                                       // Ends 3D mode and returns to default 2D orthographic mode
(define-c void (end-mode-3d EndMode3D) ())

(c-declare "
void BeginTextureModePr(RenderTexture2D * r){
  BeginTextureMode(*r);
}
")
;; RLAPI void BeginTextureMode(RenderTexture2D target);              // Initializes render texture for drawing
(define-c void (begin-texture-mode BeginTextureModePr) (RenderTexture2D))
;; RLAPI void EndTextureMode(void);                                  // Ends drawing to render texture
(define-c void (end-texture-mode EndTextureMode) ())

;; // Screen-space-related functions
;; RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera);      // Returns a ray trace from mouse position
(c-declare "
Ray * GetMouseRayPr(Vector2 * mousePosition, Camera3D * camera){
  Ray * out = (Ray*)malloc(sizeof(Ray));
  Ray r = GetMouseRay(*mousePosition,(Camera) (*camera));
  out->position.x = r.position.x;
  out->position.y = r.position.y;
  out->position.z = r.position.z;

  out->direction.x = r.direction.x;
  out->direction.y = r.direction.y;
  out->direction.z = r.direction.z;

  return out;
}
")
(define-c (free Ray) (get-mouse-ray GetMouseRayPr) (Vector2 Camera3D))
;; RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);  // Returns the screen space position for a 3d world space position
(c-declare "
Vector2 * GetWorldToScreenPr(Vector3 * position, Camera3D * camera){
  Vector2 * out = (Vector2*) malloc(sizeof(Vector2));
  Vector2 r = GetWorldToScreen(*position,(Camera)(*camera));
  out->x = r.x;
  out->y = r.y;
  return out;
}
")
(define-c (free Vector2) (get-world-to-screen GetWorldToScreenPr) (Vector3 Camera3D))

;; RLAPI Matrix GetCameraMatrix(Camera camera);                      // Returns camera transform matrix (view matrix)
(c-declare "
Matrix * GetCameraMatrixPr(Camera3D * c){
  Matrix * out = (Matrix*)malloc(sizeof(Matrix));
  Matrix tmp = GetCameraMatrix((Camera)(*c));
  out->m0 = tmp.m0;
  out->m1 = tmp.m1;
  out->m2 = tmp.m2;
  out->m3 = tmp.m3;
  out->m4 = tmp.m4;
  out->m5 = tmp.m5;
  out->m6 = tmp.m6;
  out->m7 = tmp.m7;
  out->m8 = tmp.m8;
  out->m9 = tmp.m9;
  out->m10 = tmp.m10;
  out->m11 = tmp.m11;
  out->m12 = tmp.m12;
  out->m13 = tmp.m13;
  out->m14 = tmp.m14;
  out->m15 = tmp.m15;
  return out;
}
")
(define-c (free Matrix) (get-camera-matrix GetCameraMatrixPr) (Camera3D))

;; // Timing-related functions
;; RLAPI void SetTargetFPS(int fps);                                 // Set target FPS (maximum)
(define-c void (set-target-fps SetTargetFPS) (int))
;; RLAPI int GetFPS(void);                                           // Returns current FPS
(define-c int (get-fps GetFPS) ())
;; RLAPI float GetFrameTime(void);                                   // Returns time in seconds for last frame drawn
(define-c float (get-frame-time GetFrameTime) ())
;; RLAPI double GetTime(void);                                       // Returns elapsed time in seconds since InitWindow()
(define-c double (get-time GetTime) ())

;; // Color-related functions
;; RLAPI int ColorToInt(Color color);                                // Returns hexadecimal value for a Color
(c-declare "
int ColorToIntPr(Color * c){
  return ColorToInt(*c);
}
")
(define-c int (color-to-int ColorToIntPr) (Color))
;; RLAPI Vector4 ColorNormalize(Color color);                        // Returns color normalized as float [0..1]
(c-declare "
Vector4 * ColorNormalizePr(Color * c){
  Vector4 * out = (Vector4*) malloc(sizeof(Color));
  Vector4 tmp = ColorNormalize(*c);
  out->x = tmp.x;
  out->y = tmp.y;
  out->z = tmp.z;
  out->w = tmp.w;
  return out;
}
")
(define-c (free Vector4) (color-normalize ColorNormalizePr) (Color))

;; RLAPI Vector3 ColorToHSV(Color color);                            // Returns HSV values for a Color
(c-declare "
Vector3 * ColorToHSVPr(Color * c){
  Vector3 * out = (Vector3*)malloc(sizeof(Vector3));
  Vector3 tmp = ColorToHSV(*c);
  out->x = tmp.x;
  out->y = tmp.y;
  out->z = tmp.z;
  return out;
}
")
(define-c (free Vector3) (color-to-hsv ColorToHSVPr) (Color))

;; RLAPI Color ColorFromHSV(Vector3 hsv);                            // Returns a Color from HSV values
(c-declare "
Color * ColorFromHSVPr(Vector3 * hsv){
  Color * out = (Color*) malloc(sizeof(Color));
  Color tmp = ColorFromHSV(*hsv);
  out->r = tmp.r;
  out->g = tmp.g;
  out->b = tmp.b;
  out->a = tmp.a;
  return out;
}
")
(define-c (free Color) (color-from-hsv ColorFromHSVPr) (Vector3))

;; RLAPI Color GetColor(int hexValue);                               // Returns a Color struct from hexadecimal value
(c-declare "
Color * GetColorPr(int hexValue){
  Color * out = (Color*)malloc(sizeof(Color));
  Color tmp = GetColor(hexValue);
  out->r = tmp.r;
  out->g = tmp.g;
  out->b = tmp.b;
  out->a = tmp.a;
  return out;
}
")
(define-c (free Color) (get-color GetColorPr) (int))
(define-c (free Color) (int->color GetColorPr) (int))

;; RLAPI Color Fade(Color color, float alpha);                       // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
(c-declare "
Color * FadePr(Color * color, float alpha){
  Color * out = (Color*)malloc(sizeof(Color));
  Color tmp = Fade(*color, alpha);
  out->r = tmp.r;
  out->g = tmp.g;
  out->b = tmp.b;
  out->a = tmp.a;
  return out;
}
")
(define-c (free Color) (fade FadePr) (Color float))

;; // Misc. functions
;; RLAPI void SetConfigFlags(unsigned char flags);                   // Setup window configuration flags (view FLAGS)
(define-c void (set-config-flags SetConfigFlags) (unsigned-char))
;; RLAPI void SetTraceLogLevel(int logType);                         // Set the current threshold (minimum) log level
(define-c void (set-trace-log-level SetTraceLogLevel) (int))
;; RLAPI void SetTraceLogExit(int logType);                          // Set the exit threshold (minimum) log level
(define-c void (set-trace-log-exit SetTraceLogExit) (int))

;; Plan - have a global variable in chibi that contains
;; the scheme function to call.
;; register once a callback that calls that function.
;; RLAPI void SetTraceLogCallback(TraceLogCallback callback);        // Set a trace log callback to enable custom logging
;; TODO - figure out how to wrap method calls

;; RLAPI void TraceLog(int logType, const char *text, ...);          // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR)
(define-c void (trace-log TraceLog) (int string))
;; RLAPI void TakeScreenshot(const char *fileName);                  // Takes a screenshot of current screen (saved a .png)
(define-c void (take-screenshot TakeScreenshot) (string))
;; RLAPI int GetRandomValue(int min, int max);                       // Returns a random value between min and max (both included)
(define-c int (get-random-value GetRandomValue) (int int))

;; // Files management functions
;; RLAPI bool FileExists(const char *fileName);                      // Check if file exists
(define-c boolean (file-exists FileExists) (string))

;; RLAPI bool IsFileExtension(const char *fileName, const char *ext);// Check file extension
(define-c boolean (file-extension? IsFileExtension) (string string))

;; RLAPI const char *GetExtension(const char *fileName);             // Get pointer to extension for a filename string
(define-c string (get-extension GetExtension) (string))

;; RLAPI const char *GetFileName(const char *filePath);              // Get pointer to filename for a path string
(define-c string (get-file-name GetFileName) (string))

;; RLAPI const char *GetFileNameWithoutExt(const char *filePath);    // Get filename string without extension (memory should be freed)
(define-c string (get-file-name-without-ext GetFileNameWithoutExt) (string))

;; RLAPI const char *GetDirectoryPath(const char *fileName);         // Get full path for a given fileName (uses static string)
(define-c string (get-directory-path GetDirectoryPath) (string))

;; RLAPI const char *GetWorkingDirectory(void);                      // Get current working directory (uses static string)
(define-c string (get-working-directory GetWorkingDirectory) ())

;; RLAPI char **GetDirectoryFiles(const char *dirPath, int *count);  // Get filenames in a directory path (memory should be freed)
;; TODO
;; RLAPI void ClearDirectoryFiles(void);                             // Clear directory files paths buffers (free memory)
;; TODO

;; RLAPI bool ChangeDirectory(const char *dir);                      // Change working directory, returns true if success
(define-c boolean (change-directory ChangeDirectory) (string))

;; RLAPI bool IsFileDropped(void);                                   // Check if a file has been dropped into window
(define-c boolean (file-dropped? IsFileDropped) ())

;; RLAPI char **GetDroppedFiles(int *count);                         // Get dropped files names (memory should be freed)
;; TODO
;; RLAPI void ClearDroppedFiles(void);                               // Clear dropped files paths buffer (free memory)
;; TODO

;; RLAPI long GetFileModTime(const char *fileName);                  // Get file modification time (last write time)
(define-c long (get-file-mod-time GetFileModTime) (string))

(define-c (free Image) (load-image LoadImagePr) (string))

;; // Persistent storage management
;; RLAPI void StorageSaveValue(int position, int value);             // Save integer value to storage file (to defined position)
(define-c void (storage-save-value StorageSaveValue) (int int))
;; RLAPI int StorageLoadValue(int position);                         // Load integer value from storage file (from defined position)
(define-c int (storage-load-value StorageLoadValue) (int))

;; RLAPI void OpenURL(const char *url);                              // Open URL with default system browser (if available)
(define-c void (open-url OpenURL) (string))

;; // Input-related functions: keyboard
;; RLAPI bool IsKeyPressed(int key);                             // Detect if a key has been pressed once
(define-c boolean (key-pressed? IsKeyPressed) (int))
;; RLAPI bool IsKeyDown(int key);                                // Detect if a key is being pressed
(define-c boolean (key-down? IsKeyDown) (int))
;; RLAPI bool IsKeyReleased(int key);                            // Detect if a key has been released once
(define-c boolean (key-released? IsKeyReleased) (int))
;; RLAPI bool IsKeyUp(int key);                                  // Detect if a key is NOT being pressed
(define-c boolean (key-up? IsKeyUp) (int))
;; RLAPI int GetKeyPressed(void);                                // Get latest key pressed
(define-c int (get-key-pressed GetKeyPressed) ())
;; RLAPI void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
(define-c void (set-exit-key SetExitKey) (int))

;; // Input-related functions: gamepads
;; RLAPI bool IsGamepadAvailable(int gamepad);                   // Detect if a gamepad is available
(define-c boolean (gamepad-available? IsGamepadAvailable) (int))
;; RLAPI bool IsGamepadName(int gamepad, const char *name);      // Check gamepad name (if available)
(define-c boolean (gamepad-name? IsGamepadName) (int string))
;; RLAPI const char *GetGamepadName(int gamepad);                // Return gamepad internal name id
(define-c string (get-gamepad-name GetGamepadName) (int))
;; RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Detect if a gamepad button has been pressed once
(define-c boolean (gamepad-button-pressed? IsGamepadButtonPressed) (int int))
;; RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Detect if a gamepad button is being pressed
(define-c boolean (gamepad-button-down? IsGamepadButtonDown) (int int))
;; RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Detect if a gamepad button has been released once
(define-c boolean (gamepad-button-released? IsGamepadButtonReleased) (int int))
;; RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Detect if a gamepad button is NOT being pressed
(define-c boolean (gamepad-button-up? IsGamepadButtonUp) (int int))
;; RLAPI int GetGamepadButtonPressed(void);                      // Get the last gamepad button pressed
(define-c int (get-gameplad-button-pressed GetGamepadButtonPressed) ())
;; RLAPI int GetGamepadAxisCount(int gamepad);                   // Return gamepad axis count for a gamepad
(define-c int (get-gamepad-axis-count GetGamepadAxisCount) (int))
;; RLAPI float GetGamepadAxisMovement(int gamepad, int axis);    // Return axis movement value for a gamepad axis
(define-c float (get-gamepad-axis-movement GetGamepadAxisMovement) (int int))

;; // Input-related functions: mouse
;; RLAPI bool IsMouseButtonPressed(int button);                  // Detect if a mouse button has been pressed once
(define-c boolean (mouse-button-pressed? IsMouseButtonPressed) (int))
;; RLAPI bool IsMouseButtonDown(int button);                     // Detect if a mouse button is being pressed
(define-c boolean (mouse-button-down? IsMouseButtonDown) (int))
;; RLAPI bool IsMouseButtonReleased(int button);                 // Detect if a mouse button has been released once
(define-c boolean (mouse-button-released? IsMouseButtonReleased) (int))
;; RLAPI bool IsMouseButtonUp(int button);                       // Detect if a mouse button is NOT being pressed
(define-c boolean (mouse-button-up? IsMouseButtonUp) (int))
;; RLAPI int GetMouseX(void);                                    // Returns mouse position X
(define-c int (get-mouse-x GetMouseX) ())
;; RLAPI int GetMouseY(void);                                    // Returns mouse position Y
(define-c int (get-mouse-y GetMouseY) ())
;; RLAPI Vector2 GetMousePosition(void);                         // Returns mouse position XY
(c-declare "
Vector2 * GetMousePositionPr(){
  Vector2 * v = (Vector2*)malloc(sizeof(Vector2));
  Vector2 tmp = GetMousePosition();
  v->x = tmp.x;
  v->y = tmp.y;
  return v;
}
")
(define-c (free Vector2) (get-mouse-position GetMousePositionPr) ())
;; RLAPI void SetMousePosition(int x, int y);                    // Set mouse position XY
(define-c void (set-mouse-position SetMousePosition) (int int))
;; RLAPI void SetMouseOffset(int offsetX, int offsetY);          // Set mouse offset
(define-c void (set-mouse-offset SetMouseOffset) (int int))
;; RLAPI void SetMouseScale(float scaleX, float scaleY);         // Set mouse scaling
(define-c void (set-mouse-scale SetMouseScale) (float float))
;; RLAPI int GetMouseWheelMove(void);                            // Returns mouse wheel movement Y
(define-c int (get-mouse-wheel-move GetMouseWheelMove) ())

;; // Input-related functions: touch
;; RLAPI int GetTouchX(void);                                    // Returns touch position X for touch point 0 (relative to screen size)
(define-c int (get-touch-x GetTouchX) ())
;; RLAPI int GetTouchY(void);                                    // Returns touch position Y for touch point 0 (relative to screen size)
(define-c int (get-touch-y GetTouchY) ())
;; RLAPI Vector2 GetTouchPosition(int index);                    // Returns touch position XY for a touch point index (relative to screen size)
(c-declare "
Vector2 * GetTouchPositionPr(int index){
  Vector2 * out = (Vector2*)malloc(sizeof(Vector2));
  Vector2 tmp = GetTouchPosition(index);
  out->x = tmp.x;
  out->y = tmp.y;
  return out;
}
")
(define-c (free Vector2) (get-touch-position GetTouchPositionPr) (int))

;; //------------------------------------------------------------------------------------
;; // Gestures and Touch Handling Functions (Module: gestures)
;; //------------------------------------------------------------------------------------
;; RLAPI void SetGesturesEnabled(unsigned int gestureFlags);     // Enable a set of gestures using flags
(define-c void (set-gestures-enabled SetGesturesEnabled) (unsigned-int))
;; RLAPI bool IsGestureDetected(int gesture);                    // Check if a gesture have been detected
(define-c boolean (gesture-detected? IsGestureDetected) (int))
;; RLAPI int GetGestureDetected(void);                           // Get latest detected gesture
(define-c int (get-gesture-detected GetGestureDetected) ())
;; RLAPI int GetTouchPointsCount(void);                          // Get touch points count
(define-c int (get-touch-points-count GetTouchPointsCount) ())
;; RLAPI float GetGestureHoldDuration(void);                     // Get gesture hold time in milliseconds
(define-c float (get-gesture-hold-duration GetGestureHoldDuration) ())
;; RLAPI Vector2 GetGestureDragVector(void);                     // Get gesture drag vector
(c-declare "
Vector2 * GetGestureDragVectorPr(){
  Vector2 * out = (Vector2*) malloc(sizeof(Vector2));
  Vector2 tmp = GetGestureDragVector();
  out->x = tmp.x;
  out->y = tmp.y;
  return out;
}
")
(define-c (free Vector2) (get-gesture-drag-vector GetGestureDragVectorPr) ())
;; RLAPI float GetGestureDragAngle(void);                        // Get gesture drag angle
(define-c float (get-gesture-drag-angle GetGestureDragAngle) ())
;; RLAPI Vector2 GetGesturePinchVector(void);                    // Get gesture pinch delta
(c-declare "
Vector2 * GetGesturePinchVectorPr(){
  Vector2* out = (Vector2*)malloc(sizeof(Vector2));
  Vector2 tmp = GetGesturePinchVector();
  out->x = tmp.x;
  out->y = tmp.y;
  return out;
}
")
(define-c (free Vector2) (get-gesture-pinch-vector GetGesturePinchVectorPr) ())
;; RLAPI float GetGesturePinchAngle(void);                       // Get gesture pinch angle
(define-c float (get-gesture-pinch-angle GetGesturePinchAngle) ())


;; //------------------------------------------------------------------------------------
;; // Camera System Functions (Module: camera)
;; //------------------------------------------------------------------------------------
;; RLAPI void SetCameraMode(Camera camera, int mode);                // Set camera mode (multiple camera modes available)
(c-declare "
void SetCameraModePr(Camera3D * c, int mode){
  SetCameraMode(*c, mode);
}
")
(define-c void (set-camera-mode SetCameraModePr) (Camera3D int))

;; RLAPI void UpdateCamera(Camera *camera);                          // Update camera position for selected mode
(c-declare "
void UpdateCameraPr(Camera3D * camera){
  UpdateCamera((Camera*)camera);
}
")
(define-c void (update-camera UpdateCamera) (Camera3D))

;; RLAPI void SetCameraPanControl(int panKey);                       // Set camera pan key to combine with mouse movement (free camera)
(define-c void (set-camera-pan-control SetCameraPanControl) (int))

;; RLAPI void SetCameraAltControl(int altKey);                       // Set camera alt key to combine with mouse movement (free camera)
(define-c void (set-camera-alt-control SetCameraAltControl) (int))

;; RLAPI void SetCameraSmoothZoomControl(int szKey);                 // Set camera smooth zoom key to combine with mouse (free camera)
(define-c void (set-camera-smooth-zoom-control SetCameraSmoothZoomControl) (int))

;; RLAPI void SetCameraMoveControls(int frontKey, int backKey, int rightKey, int leftKey, int upKey, int downKey); // Set camera move controls (1st person and 3rd person cameras)
(define-c void (set-camera-move-controls SetCameraMoveControls)
  (int int int int int int))

;; // Basic shapes drawing functions
;; RLAPI void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel
(declare-pointer-passthrough void DrawPixel ((int posX) (int posY) (Color color)))
(define-c void (draw-pixel DrawPixelPr) (int int Color))

;; ;; RLAPI void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel (Vector version)
(declare-pointer-passthrough void DrawPixelV ((Vector2 position) (Color color)))
(define-c void (draw-pixel-v DrawPixelVPr) (Vector2 Color))

;; ;; RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                // Draw a line
(declare-pointer-passthrough void DrawLine ((int startX) (int startY) (int endX) (int endY) (Color color)))
(define-c void (draw-line DrawLinePr) (int int int int Color))

;; ;; RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (Vector version)
(declare-pointer-passthrough void DrawLineV ((Vector2 startPos) (Vector2 endPos) (Color color)))
(define-c void (draw-line-v DrawLineVPr) (Vector2 Vector2 Color))

;; RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line defining thickness
(declare-pointer-passthrough void DrawLineEx
                             ((Vector2 startPos) (Vector2 endPos) (float thick) (Color color)))
(define-c void (draw-line-ex DrawLineExPr) (Vector2 Vector2 float Color))

;; ;; RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw a line using cubic-bezier curves in-out
(declare-pointer-passthrough void DrawLineBezier ((Vector2 startPos) (Vector2 endPos) (float thick) (Color color)))
(define-c void (draw-line-bezier DrawLineBezierPr) (Vector2 Vector2 float Color))

;; ;; RLAPI void DrawLineStrip(Vector2 *points, int numPoints, Color color);                                   // Draw lines sequence
(c-declare "
sexp sexp_draw_line_strip_stub_custom (sexp ctx, sexp self, sexp_sint_t n, sexp arg0, sexp arg1) {
  int n_vectors;
  int i;
  sexp res;
  Vector2 * v2a;
  sexp_gc_var1(hd);
  if (! (sexp_pointerp(arg0) && sexp_pairp(arg0)))
    return sexp_type_exception(ctx, self, sexp_unbox_fixnum(sexp_opcode_arg1_type(self)), arg0);
  if (! (sexp_pointerp(arg1) && (sexp_pointer_tag(arg1) == sexp_unbox_fixnum(sexp_opcode_arg2_type(self)))))
    return sexp_type_exception(ctx, self, sexp_unbox_fixnum(sexp_opcode_arg2_type(self)), arg1);
  n_vectors = sexp_sint_value(sexp_length(ctx, arg0));
  v2a = (Vector2*)malloc(sizeof(Vector2)*n_vectors);
  sexp_gc_preserve1(ctx, hd);
  hd = arg0;
  i = 0;
  while(i<n_vectors){
    CopyVector2NoAlloc(sexp_cpointer_value(hd),v2a + i);
    hd = sexp_car(hd);
  }
  sexp_gc_release1(hd);

  res = ((DrawLineStrip(v2a, sexp_sint_value(arg1), *((struct Color*)sexp_cpointer_value(arg1)))), SEXP_VOID);
  free(v2a);
  return res;
}
")
(add-post-init-hook
 (lambda ()
     (c-declare "op = sexp_define_foreign(ctx, env, \"draw-line-strip\", 3, sexp_make_vector_3_stub);
  if (sexp_opcodep(op)) {
    sexp_opcode_return_type(op) = SEXP_VOID;
    sexp_opcode_arg1_type(op) = sexp_make_fixnum(SEXP_PAIR);
    sexp_opcode_arg2_type(op) = sexp_make_fixnum(sexp_type_tag(sexp_Color_type_obj));
  }
")))


;; ;; RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
(declare-pointer-passthrough void DrawCircle ((int centerX) (int centerY) (float radius) (Color color)))
(define-c void (draw-circle DrawCirclePr) (int int float Color))

;; ;; RLAPI void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);     // Draw a piece of a circle
(declare-pointer-passthrough void DrawCircleSector ((Vector2 center) (float radius) (int startAngle) (int endAngle) (int segments) (Color color)))
(define-c void (draw-circle-sector DrawCircleSectorPr) (Vector2 float int int int Color))

;; ;; RLAPI void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);    // Draw circle sector outline
(declare-pointer-passthrough void DrawCircleSectorLines ((Vector2 center) (float radius) (int startAngle) (int endAngle) (int segments) (Color color)))
(define-c void (draw-circle-sector-lines DrawCircleSectorLinesPr) (Vector2 float int int int Color))

;; ;; RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);       // Draw a gradient-filled circle
(declare-pointer-passthrough void DrawCircleGradient ((int centerX) (int centerY) (float radius) (Color color1) (Color color2)))
(define-c void (draw-circle-gradient DrawCircleGradientPr) (int int float Color Color))

;; ;; RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
(declare-pointer-passthrough void DrawCircleV ((Vector2 center) (float radius) (Color color)))
(define-c void (draw-circle-v DrawCircleVPr) (Vector2 float Color))

;; ;; RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
(declare-pointer-passthrough void DrawCircleLines ((int centerX) (int centerY) (float radius) (Color color)))
(define-c void (draw-circle-lines DrawCircleLinesPr) (int int float Color))

;; ;; RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring
(declare-pointer-passthrough void DrawRing ((Vector2 center) (float innerRadius) (float outerRadius) (int startAngle) (int endAngle) (int segments) (Color color)))
(define-c void (draw-ring DrawRingPr) (Vector2 float float int int int Color))

;; ;; RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color);    // Draw ring outline
(declare-pointer-passthrough void DrawRingLines ((Vector2 center) (float innerRadius) (float outerRadius) (int startAngle) (int endAngle) (int segments) (Color color)))
(define-c void (draw-ring-lines DrawRingLinesPr) (Vector2 float float int int int Color))

;; ;; RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color);                        // Draw a color-filled rectangle
(declare-pointer-passthrough void DrawRectangle ((int posX) (int posY) (int width) (int height) (Color color)))
(define-c void (draw-rectangle DrawRectanglePr) (int int int int Color))

;; ;; RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
(declare-pointer-passthrough void DrawRectangleV ((Vector2 position) (Vector2 size) (Color color)))
(define-c void (draw-rectangle-v DrawRectangleVPr) (Vector2 Vector2 Color))

;; ;; RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
(declare-pointer-passthrough void DrawRectangleRec ((Rectangle rec) (Color color)))
(define-c void (draw-rectangle-rec DrawRectangleRecPr) (Rectangle Color))

;; ;; RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
(declare-pointer-passthrough void DrawRectanglePro ((Rectangle rec) (Vector2 origin) (float rotation) (Color color)))
(define-c void (draw-rectangle-pro DrawRectangleProPr) (Rectangle Vector2 float Color))

;; ;; RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
(declare-pointer-passthrough void DrawRectangleGradientV
                             ((int posX)
                              (int posY)
                              (int width)
                              (int height)
                              (Color color1)
                              (Color color2)))
(define-c void (draw-rectangle-gradient DrawRectangleGradientVPr)
  (int int int int Color Color))

;; ;; RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
(declare-pointer-passthrough void DrawRectangleGradientH ((int posX) (int posY) (int width) (int height) (Color color1) (Color color2)))
(define-c void (draw-rectangle-gradient-h DrawRectangleGradientHPr) (int int int int Color Color))

;; ;; RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors
(declare-pointer-passthrough void DrawRectangleGradientEx ((Rectangle rec) (Color c1) (Color c2) (Color c3) (Color c4)))
(define-c void (draw-rectangle-gradient-ex DrawRectangleGradientExPr) (Rectangle Color Color Color Color))

;; ;; RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
(declare-pointer-passthrough void DrawRectangleLines ((int posX) (int posY) (int width) (int height) (Color color)))
(define-c void (draw-rectangle-lines DrawRectangleLinesPr) (int int int int Color))

;; ;; RLAPI void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color);                              // Draw rectangle outline with extended parameters
(declare-pointer-passthrough void DrawRectangleLinesEx ((Rectangle rec) (int lineThick) (Color color)))
(define-c void (draw-rectangle-lines-ex DrawRectangleLinesExPr) (Rectangle int Color))

;; ;; RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);              // Draw rectangle with rounded edges
(declare-pointer-passthrough void DrawRectangleRounded ((Rectangle rec) (float roundness) (int segments) (Color color)))
(define-c void (draw-rectangle-rounded DrawRectangleRoundedPr) (Rectangle float int Color))

;; ;; RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color); // Draw rectangle with rounded edges outline
(declare-pointer-passthrough void DrawRectangleRoundedLines ((Rectangle rec) (float roundness) (int segments) (int lineThick) (Color color)))
(define-c void (draw-rectangle-rounded-lines DrawRectangleRoundedLinesPr) (Rectangle float int int Color))

;; ;; RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle
(declare-pointer-passthrough void DrawTriangle ((Vector2 v1) (Vector2 v2) (Vector2 v3) (Color color)))
(define-c void (draw-triangle DrawTrianglePr) (Vector2 Vector2 Vector2 Color))

;; ;; RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline
(declare-pointer-passthrough void DrawTriangleLines ((Vector2 v1) (Vector2 v2) (Vector2 v3) (Color color)))
(define-c void (draw-triangle-lines DrawTriangleLinesPr) (Vector2 Vector2 Vector2 Color))

;; ;; RLAPI void DrawTriangleFan(Vector2 *points, int numPoints, Color color);                                 // Draw a triangle fan defined by points
;; TODO

;; ;; RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
(declare-pointer-passthrough void DrawPoly ((Vector2 c) (int sides) (float radius) (float rotation) (Color color)))
(define-c void (draw-poly DrawPolyPr) (Vector2 int float float Color))

;; // Text drawing functions
;; RLAPI void DrawFPS(int posX, int posY);                                                     // Shows current FPS
(define-c void (draw-fps DrawFPS) (int int))
;; RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color);       // Draw text (using default font)
(declare-pointer-passthrough void DrawText ((string text) (int posX) (int posY) (int fontSize) (Color color)))
(define-c void (draw-text DrawTextPr) (string int int int Color))

;; RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint);                // Draw text using font and additional parameters
(declare-pointer-passthrough void DrawTextEx ((Font font) (string text) (Vector2 position) (float fontSize) (float spacing) (Color tint)))
(define-c void (draw-text-ex DrawTextExPr) (Font string Vector2 float float Color))

;; RLAPI void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint);   // Draw text using font inside rectangle limits
(declare-pointer-passthrough void DrawTextRec ((Font font) (string text) (Rectangle rec) (float fontSize) (float spacing) (boolean wordWrap) (Color tint)))
(define-c void (draw-text-rec DrawTextRecPr) (Font string Rectangle float float boolean Color))

;; RLAPI void DrawTextRecEx(Font font,
;;                          const char *text,
;;                          Rectangle rec,
;;                          float fontSize,
;;                          float spacing,
;;                          bool wordWrap,
;;                          Color tint,
;;                          int selectStart,
;;                          int selectLength,
;;                          Color selectText,
;;                          Color selectBack);    // Draw text using font inside rectangle limits with support for text selection
(declare-pointer-passthrough void DrawTextRecEx ((Font font)
                                                 (string text)
                                                 (Rectangle rec)
                                                 (float fontSize)
                                                 (float spacing)
                                                 (boolean wordWrap)
                                                 (Color tint)
                                                 (int selectStart)
                                                 (int selectLength)
                                                 (Color selectText)
                                                 (Color selectBack)))
(define-c void (draw-text-rec-ex DrawTextRecExPr) (Font
                                                   string
                                                   Rectangle
                                                   float
                                                   float
                                                   boolean
                                                   Color
                                                   int
                                                   int
                                                   Color
                                                   Color))

;; // Text misc. functions
;; RLAPI int MeasureText(const char *text, int fontSize);                                      // Measure string width for default font
(define-c int (measure-text MeasureText) (string int))

;; RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);    // Measure string size for Font
(declare-pointer-passthrough Vector2 MeasureTextEx ((Font font) (string text) (float fontSize) (float spacing)))
(define-c Vector2 (measure-text-ex MeasureTextExPr) (Font string float float))

;; RLAPI int GetGlyphIndex(Font font, int character);                                          // Get index position for a unicode character on font
(declare-pointer-passthrough int GetGlyphIndex ((Font font) (int character)))
(define-c int (get-glyph-index GetGlyphIndexPr) (Font int))

;; RLAPI int GetNextCodepoint(const char *text, int *count);                                   // Returns next codepoint in a UTF8 encoded string
(define-c int GetNextCodepoint (string (result int)))

;; // Text strings management functions
;; // NOTE: Some strings allocate memory internally for returned strings, just be careful!
;; RLAPI bool TextIsEqual(const char *text1, const char *text2);                               // Check if two text string are equal
;; RLAPI unsigned int TextLength(const char *text);                                            // Get text length, checks for '\0' ending
;; RLAPI unsigned int TextCountCodepoints(const char *text);                                   // Get total number of characters (codepoints) in a UTF8 encoded string
;; RLAPI const char *TextFormat(const char *text, ...);                                        // Text formatting with variables (sprintf style)
;; RLAPI const char *TextSubtext(const char *text, int position, int length);                  // Get a piece of a text string
;; RLAPI const char *TextReplace(char *text, const char *replace, const char *by);             // Replace text string (memory should be freed!)
;; RLAPI const char *TextInsert(const char *text, const char *insert, int position);           // Insert text in a position (memory should be freed!)
;; RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter);        // Join text strings with delimiter
;; RLAPI const char **TextSplit(const char *text, char delimiter, int *count);                 // Split text into multiple strings
;; RLAPI void TextAppend(char *text, const char *append, int *position);                       // Append text at specific position and move cursor!
;; RLAPI int TextFindIndex(const char *text, const char *find);                                // Find first text occurrence within a string
;; RLAPI const char *TextToUpper(const char *text);                      // Get upper case version of provided string
;; RLAPI const char *TextToLower(const char *text);                      // Get lower case version of provided string
;; RLAPI const char *TextToPascal(const char *text);                     // Get Pascal case notation version of provided string
;; RLAPI int TextToInteger(const char *text);                            // Get integer value from text (negative values not supported)

;; We aren't binding the above in favor of native chibi-scheme string
;; functions.

;; // Basic geometric 3D shapes drawing functions
;; RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
(declare-pointer-passthrough void DrawLine3D ((Vector3 startPos) (Vector3 endPos) (Color color)))
(define-c void (draw-line-3d DrawLine3DPr) (Vector3 Vector3 Color))

;; RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
(declare-pointer-passthrough void DrawCircle3D ((Vector3 center) (float radius) (Vector3 rotationAxis) (float rotationAngle) (Color color)))
(define-c void (draw-circle-3d DrawCircle3DPr) (Vector3 float Vector3 float Color))

;; RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
(declare-pointer-passthrough void DrawCube ((Vector3 position) (float width) (float height) (float length) (Color color)))
(define-c void (draw-cube DrawCubePr) (Vector3 float float float Color))

;; RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
(declare-pointer-passthrough void DrawCubeV ((Vector3 position) (Vector3 size) (Color color)))
(define-c void (draw-cube-v DrawCubeVPr) (Vector3 Vector3 Color))

;; RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
(declare-pointer-passthrough void DrawCubeWires ((Vector3 position) (float width) (float height) (float length) (Color color)))
(define-c void (draw-cube-wires DrawCubeWiresPr) (Vector3 float float float Color))

;; RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  // Draw cube wires (Vector version)
(declare-pointer-passthrough void DrawCubeWiresV ((Vector3 position) (Vector3 size) (Color color)))
(define-c void (draw-cube-wires-v DrawCubeWiresVPr) (Vector3 Vector3 Color))

;; RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured
(declare-pointer-passthrough void DrawCubeTexture ((Texture2D texture) (Vector3 position) (float width) (float height) (float length) (Color color)))
(define-c void (draw-cube-texture DrawCubeTexturePr) (Texture2D Vector3 float float float Color))

;; RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
(declare-pointer-passthrough void DrawSphere ((Vector3 centerPos) (float radius) (Color color)))
(define-c void (draw-sphere DrawSpherePr) (Vector3 float Color))

;; RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
(declare-pointer-passthrough void DrawSphereEx ((Vector3 centerPos) (float radius) (int rings) (int slices) (Color color)))
(define-c void (draw-sphere-ex DrawSphereExPr) (Vector3 float int int Color))

;; RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
(declare-pointer-passthrough void DrawSphereWires ((Vector3 centerPos) (float radius) (int rings) (int slices) (Color color)))
(define-c void (draw-sphere-wires DrawSphereWiresPr) (Vector3 float int int Color))

;; RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
(declare-pointer-passthrough void DrawCylinder ((Vector3 position) (float radiusTop) (float radiusBottom) (float height) (int slices) (Color color)))
(define-c void (draw-cylinder DrawCylinderPr) (Vector3 float float float int Color))

;; RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
(declare-pointer-passthrough void DrawCylinderWires ((Vector3 position) (float radiusTop) (float radiusBottom) (float height) (int slices) (Color color)))
(define-c void (draw-cylinder-wires DrawCylinderWiresPr) (Vector3 float float float int Color))

;; RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
(declare-pointer-passthrough void DrawPlane ((Vector3 centerPos) (Vector2 size) (Color color)))
(define-c void (draw-plane DrawPlanePr) (Vector3 Vector2 Color))

;; RLAPI void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
(declare-pointer-passthrough void DrawRay ((Ray ray) (Color color)))
(define-c void (draw-ray DrawRayPr) (Ray Color))

;; RLAPI void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
(define-c void (draw-grid DrawGrid) (int float))

;; RLAPI void DrawGizmo(Vector3 position);                                                                  // Draw simple gizmo
(declare-pointer-passthrough void DrawGizmo ((Vector3 position)))
(define-c void (draw-gizmo DrawGizmoPr) (Vector3))

;; // Model loading/unloading functions
;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;; !!!                                                                                !!
;; !!! NB - at present the internals of Models and Meshes that are heap allocated     !!
;; !!! are shallow copied - care must be taken when freeing these objects.            !!
;; !!! Consequently, these are not tagged with Chibi's GC.                            !!
;; !!!                                                                                !!
;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;; RLAPI Model LoadModel(const char *fileName);                                                            // Load model from files (meshes and materials)
(declare-pointer-passthrough Model LoadModel ((string fileName)))
(define-c Model (load-model LoadModelPr) (string))

;; RLAPI Model LoadModelFromMesh(Mesh mesh);                                                               // Load model from generated mesh (default material)
(declare-pointer-passthrough Model LoadModelFromMesh ((Mesh mesh)))
(define-c Mesh (load-model-from-mesh LoadModelFromMeshPr) (Mesh))

;; RLAPI void UnloadModel(Model model);                                                                    // Unload model from memory (RAM and/or VRAM)
(declare-pointer-passthrough void UnloadModel ((Model model)))
(define-c void (unload-model UnloadModelPr) (Model))

(c-declare "typedef struct MeshArray {
  Mesh * elements;
  int length;
} MeshArray;

MeshArray * LoadMeshesToMeshArray(char * filename){
  int length;
  MeshArray * mesh_array = (MeshArray*)malloc(sizeof(MeshArray));
  mesh_array->elements = LoadMeshes(filename, &(mesh_array->length));
  return mesh_array;
}

void FreeMeshArray(MeshArray * ma){
  free(ma);
}

Mesh * MeshArrayGetMesh(MeshArray * ma, int index){
  return ma->elements + (index % ma->length);
}
")

(define-c-struct MeshArray
  predicate: mesh-array?
  finalizer: FreeMeshArray
  ((pointer Mesh) elements)
  (int length mesh-array-get-length))

;; // Mesh loading/unloading functions
;; RLAPI Mesh *LoadMeshes(const char *fileName, int *meshCount);                                           // Load meshes from model file
(define-c (free MeshArray) (load-meshes-to-mesh-array LoadMeshesToMeshArray) (string))
(define-c Mesh (mesh-array-get-mesh MeshArrayGetMesh) (MeshArray int))

;; RLAPI void ExportMesh(Mesh mesh, const char *fileName);                                                 // Export mesh data to file
(declare-pointer-passthrough void ExportMesh ((Mesh mesh) (string filename)))
(define-c void (export-mesh ExportMeshPr) (Mesh string))

;; RLAPI void UnloadMesh(Mesh *mesh);                                                                      // Unload mesh from memory (RAM and/or VRAM)
(define-c void (unload-mesh UnloadMesh) (Mesh))

(c-declare "
typedef struct MaterialArray {
  Material * elements;
  int length;
} MaterialArray;

MaterialArray * LoadMaterialsToMaterialArray(const char * filename){
  MaterialArray * ma = (MaterialArray*)malloc(sizeof(MaterialArray));
  ma->elements = LoadMaterials(filename, &(ma->length));
  return ma;
}

void FreeMaterialArray(MaterialArray * m){
  free(m);
}

Material * MaterialArrayGetMaterial(MaterialArray * m, int index){
  return m->elements + (index % m->length);
}
")
(define-c-struct MaterialArray
  predicate: mesh-array?
  finalizer: FreeMaterialArray
  ((pointer Material) elements)
  (int length mesh-array-get-length))
;; // Material loading/unloading functions
;; RLAPI Material *LoadMaterials(const char *fileName, int *materialCount);                                // Load materials from model file
(define-c (free MaterialArray) (load-materials-to-material-array LoadMaterialsToMaterialArray) (string))

;; RLAPI Material LoadMaterialDefault(void);                                                               // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
(declare-pointer-passthrough Material LoadMaterialDefault ())
(define-c (free Material) (load-material-default LoadMaterialDefaultPr) ())

;; RLAPI void UnloadMaterial(Material material);                                                           // Unload material from GPU memory (VRAM)
(declare-pointer-passthrough void UnloadMaterial ((Material material)))
(define-c void (unload-material UnloadMaterialPr) (Material))

;; RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture);                      // Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...)
(c-declare "
void SetMaterialTexturePrNStd(Material * material, int mapType, Texture2D * texture){
  SetMaterialTexture(material, mapType, *texture);
}
")
(define-c void (set-material-texture SetMaterialTexturePrNStd) (Material int Texture2D))

;; RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId);                              // Set material for a mesh
(define-c void (set-model-mesh-material SetModelMeshMaterial) (Model int int))

;; // Model animations loading/unloading functions
;; RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount);                       // Load model animations from file
(c-declare "
typedef struct ModelAnimationArray {
  ModelAnimation * elements;
  int length;
} ModelAnimationArray;

ModelAnimationArray * LoadModelAnimationsToModelAnimationArray(const char * filename){
  ModelAnimationArray * ma = (ModelAnimationArray*)malloc(sizeof(ModelAnimationArray));
  ma->elements = LoadModelAnimations(filename, &(ma->length));
  return ma;
}

void FreeModelAnimationArray(ModelAnimationArray * m){
  free(m);
}

ModelAnimation * ModelAnimationArrayGetModelAnimation(ModelAnimationArray * m, int index){
  return m->elements + (index % m->length);
}
")
(define-c-struct ModelAnimationArray
  predicate: mesh-array?
  finalizer: FreeModelAnimationArray
  ((pointer ModelAnimation) elements)
  (int length mesh-array-get-length))
(define-c (free ModelAnimationArray) (load-model-animations-array LoadModelAnimationsToModelAnimationArray) (string))
;; RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);                           // Update model animation pose
(declare-pointer-passthrough void UpdateModelAnimation ((Model model) (ModelAnimation anim) (int frame)))
(define-c void (update-model-animation UpdateModelAnimationPr) (Model ModelAnimation int))
;; RLAPI void UnloadModelAnimation(ModelAnimation anim);                                                   // Unload animation data
(declare-pointer-passthrough void UnloadModelAnimation ((ModelAnimation anim)))
(define-c void (unload-model-animation UnloadModelAnimationPr) (ModelAnimation))

;; RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim);                                     // Check model animation skeleton match
(declare-pointer-passthrough boolean IsModelAnimationValid ((Model model) (ModelAnimation anim)))
(define-c boolean (model-animation-valid? IsModelAnimationValidPr) (Model ModelAnimation))

;; // Mesh generation functions
;; RLAPI Mesh GenMeshPoly(int sides, float radius);                                                        // Generate polygonal mesh
(declare-pointer-passthrough Mesh GenMeshPoly ((int sides) (float radius)))
(define-c Mesh (gen-mesh-poly GenMeshPolyPr) (int float))

;; RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                 // Generate plane mesh (with subdivisions)
(declare-pointer-passthrough Mesh GenMeshPlane ((float width) (float length) (int resX) (int rezZ)))
(define-c Mesh (gen-mesh-plane GenMeshPlanePr) (float float int int))

;; RLAPI Mesh GenMeshCube(float width, float height, float length);                                        // Generate cuboid mesh
(declare-pointer-passthrough Mesh GenMeshCube ((float width) (float height) (float length)))
(define-c Mesh (gen-mesh-cube GenMeshCubePr) (float float float))

;; RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                                          // Generate sphere mesh (standard sphere)
(declare-pointer-passthrough Mesh GenMeshSphere ((float radius) (int rings) (int slices)))
(define-c Mesh (gen-mesh-sphere GenMeshSpherePr) (float int int))

;; RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices);                                      // Generate half-sphere mesh (no bottom cap)
(declare-pointer-passthrough Mesh GenMeshHemiSphere ((float radius) (int rings) (int slices)))
(define-c Mesh (gen-mesh-hemisphere GenMeshHemiSpherePr) (float int int))

;; RLAPI Mesh GenMeshCylinder(float radius, float height, int slices);                                     // Generate cylinder mesh
(declare-pointer-passthrough Mesh GenMeshCylinder ((float radius) (float height) (int slices)))
(define-c Mesh (gen-mesh-cylinder GenMeshCylinderPr) (float float int))

;; RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                               // Generate torus mesh
(declare-pointer-passthrough Mesh GenMeshTorus ((float radius) (float size) (int radSeq) (int sides)))
(define-c Mesh (gen-mesh-torus GenMeshTorusPr) (float float int int))

;; RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                                // Generate trefoil knot mesh
(declare-pointer-passthrough Mesh GenMeshKnot ((float radius) (float size) (int radSeq) (int sides)))
(define-c Mesh (gen-mesh-knot GenMeshKnotPr) (float float int int))

;; RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                             // Generate heightmap mesh from image data
(declare-pointer-passthrough Mesh GenMeshHeightmap ((Image image) (Vector3 size)))
(define-c Mesh (gen-mesh-height-map GenMeshHeightmapPr) (Image Vector3))

;; RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                                           // Generate cubes-based map mesh from image data
(declare-pointer-passthrough Mesh GenMeshCubicmap ((Image cubicmap) (Vector3 cubeSize)))
(define-c Mesh (gen-mesh-cubic-map GenMeshCubicmapPr) (Image Vector3))

;; // Mesh manipulation functions
;; RLAPI BoundingBox MeshBoundingBox(Mesh mesh);                                                           // Compute mesh bounding box limits
(declare-pointer-passthrough BoundingBox MeshBoundingBox ((Mesh mesh)))
(define-c (free BoundingBox) (mesh-bounding-box MeshBoundingBoxPr) (Mesh))
(define-c (free Vector3) (get-bounding-box-min GetBoundingBoxMin) (BoundingBox))
(define-c (free Vector3) (get-bounding-box-max GetBoundingBoxMax) (BoundingBox))

;; RLAPI void MeshTangents(Mesh *mesh);                                                                    // Compute mesh tangents
(define-c void (mesh-tangents MeshTangents) (Mesh))
;; RLAPI void MeshBinormals(Mesh *mesh);                                                                   // Compute mesh binormals
(define-c void (mesh-binormals MeshBinormals) (Mesh))

;; RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);                           // Draw a model (with texture if set)
(declare-pointer-passthrough void DrawModel ((Model model) (Vector3 position) (float scale) (Color tint)))
(define-c void (draw-model DrawModelPr) (Model Vector3 float Color))

;; RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
(declare-pointer-passthrough void DrawModelEx
                             ((Model model)
                              (Vector3 position)
                              (Vector3 rotationAxis)
                              (float rotationAngle)
                              (Vector3 scale)
                              (Color tint)))
(define-c void (draw-model-ex DrawModelExPr)
  (Model Vector3 Vector3 float Vector3 Color))

;; RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                      // Draw a model wires (with texture if set)
(declare-pointer-passthrough void DrawModelWires ((Model model) (Vector3 position) (float scale) (Color tint)))
(define-c void (draw-model-wires DrawModelWiresPr) (Model Vector3 float Color))

;; RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
(declare-pointer-passthrough void DrawModelWiresEx
                             ((Model model)
                              (Vector3 position)
                              (Vector3 rotationAxis)
                              (float rotationAngle)
                              (Vector3 scale)
                              (Color tint)))
(define-c void (draw-model-wires-ex DrawModelWiresExPr)
  (Model Vector3 Vector3 float Vector3 Color))

;; RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                               // Draw bounding box (wires)
(declare-pointer-passthrough void DrawBoundingBox ((BoundingBox box) (Color color)))
(define-c void (draw-bounding-box DrawBoundingBoxPr) (BoundingBox Color))

(c-declare "
void DrawBillboardPr(Camera3D * camera, Texture2D * texture, Vector3 * center, float size, Color * tint){
DrawBillboard((Camera)*camera, *texture, *center, size, *tint);
}
void DrawBillboardRecPr(Camera3D * camera, Texture2D * texture, Rectangle * sourceRec, Vector3 * center, float size, Color * tint){
DrawBillboardRec((Camera)*camera, *texture, *sourceRec, *center, size, *tint);
}
")

;; RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint);     // Draw a billboard texture
(define-c void (draw-billboard DrawBillboardPr) (Camera3D Texture2D Vector3 float Color))

;; RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); // Draw a billboard texture defined by sourceRec
(define-c void (draw-billboard-rec DrawBillboardRecPr) (Camera3D Texture2D Rectangle Vector3 float Color))

;; // Collision detection functions
;; RLAPI bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);       // Detect collision between two spheres
(declare-pointer-passthrough boolean CheckCollisionSpheres ((Vector3 centerA) (float radiusA) (Vector3 centerB) (float radiusB)))
(define-c boolean (check-collisions-spheres CheckCollisionSpheresPr) (Vector3 float Vector3 float))

;; RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                     // Detect collision between two bounding boxes
(declare-pointer-passthrough boolean CheckCollisionBoxes ((BoundingBox box1) (BoundingBox box2)))
(define-c boolean (check-collision-boxes CheckCollisionBoxesPr) (BoundingBox BoundingBox))

;; RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radiusSphere);          // Detect collision between box and sphere
(declare-pointer-passthrough boolean CheckCollisionBoxSphere ((BoundingBox box) (Vector3 centerSphere) (float radiusSphere)))
(define-c boolean (check-collision-box-sphere CheckCollisionBoxSpherePr) (BoundingBox Vector3 float))

;; RLAPI bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius);                // Detect collision between ray and sphere
(declare-pointer-passthrough boolean CheckCollisionRaySphere ((Ray ray) (Vector3 spherePosition) (float sphereRadius)))
(define-c boolean (check-collision-ray-sphere CheckCollisionRaySpherePr) (Ray Vector3 float))

;; RLAPI bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint); // Detect collision between ray and sphere, returns collision point
(c-declare "
typedef struct RaySphereCollisionInfo {
  bool collision;
  Vector3 point;
} RaySphereCollisionInfo;

void FreeRaySphereCollisionInfo(RaySphereCollisionInfo * r){
  free(r);
}

RaySphereCollisionInfo * CheckCollisionRaySphereExPr(Ray * ray, Vector3 * spherePosition, float sphereRadius){
  RaySphereCollisionInfo * info = (RaySphereCollisionInfo*)malloc(sizeof(RaySphereCollisionInfo));
  info->collision = CheckCollisionRaySphereEx(*ray, *spherePosition, sphereRadius, &(info->point));
  return info;
}

Vector3 * RaySphereCollisionInfoGetPoint(RaySphereCollisionInfo * r){
  Vector3 * out = (Vector3*) malloc(sizeof(Vector3));
  CopyVector3NoAlloc(&(r->point), out);
  return out;
}
")
(define-c-struct RaySphereCollisionInfo
  predicate: ray-sphere-collision-info?
  finalizer: FreeRaySphereCollisionInfo
  (boolean collision ray-sphere-collision-info-get-collision)
  ((struct Vector3) point))
(define-c (free Vector3) (ray-sphere-collision-info-get-point RaySphereCollisionInfoGetPoint) (RaySphereCollisionInfo))
(define-c (free RaySphereCollisionInfo) (check-collision-ray-sphere-ex-- CheckCollisionRaySphereExPr) (Ray Vector3 float))

;; RLAPI bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                              // Detect collision between ray and box
(declare-pointer-passthrough boolean CheckCollisionRayBox ((Ray ray) (BoundingBox box)))
(define-c boolean (check-collision-ray-box CheckCollisionRayBoxPr) (Ray BoundingBox))

;; RLAPI RayHitInfo GetCollisionRayModel(Ray ray, Model *model);                                           // Get collision info between ray and model
(c-declare "
RayHitInfo * GetCollisionRayModelPr(Ray * ray, Model * model){
  RayHitInfo tmp = GetCollisionRayModel(*ray, model);
  RayHitInfo * out = (RayHitInfo*)malloc(sizeof(RayHitInfo));
  CopyRayHitInfoNoAlloc(&tmp,out);return out;
}
")
(define-c (free RayHitInfo) (get-collision-ray-model GetCollisionRayModelPr) (Ray Model))

;; RLAPI RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                  // Get collision info between ray and triangle
(declare-pointer-passthrough RayHitInfo GetCollisionRayTriangle ((Ray ray) (Vector3 p1) (Vector3 p2) (Vector3 p3)))
(define-c (free RayHitInfo) (get-collision-ray-triangle GetCollisionRayTrianglePr) (Ray Vector3 Vector3 Vector3))

;; RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                    // Get collision info between ray and ground plane (Y-normal plane)
(declare-pointer-passthrough RayHitInfo GetCollisionRayGround ((Ray ray) (float groundHeight)))
(define-c (free RayHitInfo) (get-collision-ray-ground GetCollisionRayGroundPr) (Ray float))

;; // Shader loading/unloading functions
;; RLAPI char *LoadText(const char *fileName);                               // Load chars array from text file
(define-c string (load-text LoadText) (string))
;; RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);  // Load shader from files and bind default locations
(declare-pointer-passthrough Shader LoadShader ((string vsFileName) (string fsFileName)))
(define-c (free Shader) (load-shader LoadShaderPr) (string string))

;; RLAPI Shader LoadShaderCode(char *vsCode, char *fsCode);                  // Load shader from code strings and bind default locations
(declare-pointer-passthrough Shader LoadShaderCode ((string vsCode) (string fsCode)))
(define-c (free Shader) (load-shader-code LoadShaderCodePr) (string string))
;; RLAPI void UnloadShader(Shader shader);                                   // Unload shader from GPU memory (VRAM)
;; Above should be handled automatically by the GC

;; RLAPI Shader GetShaderDefault(void);                                      // Get default shader
(declare-pointer-passthrough Shader GetShaderDefault ())
(define-c Shader (get-shader-default GetShaderDefaultPr) ())

;; RLAPI Texture2D GetTextureDefault(void);                                  // Get default texture
(declare-pointer-passthrough Texture2D GetTextureDefault ())
(define-c Texture2D (get-texture-default GetTextureDefaultPr) ())

;; // Shader configuration functions
;; RLAPI int GetShaderLocation(Shader shader, const char *uniformName);      // Get shader uniform location
(declare-pointer-passthrough int GetShaderLocation ((Shader shader) (string unifornName)))
(define-c int (get-shader-location GetShaderLocationPr) (Shader string))

;; RLAPI void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType);               // Set shader uniform value
(c-declare "
void SetShaderValuePr(Shader * shader, int uniformLoc, const void * value, int uniformType){
  SetShaderValue(*shader, uniformLoc, value, uniformType);
}
")
(define-c void (set-shader-value SetShaderValuePr) (Shader int (pointer void) int))

;; RLAPI void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count);   // Set shader uniform value vector
(c-declare "
void SetShaderValueVPr(Shader * shader, int uniformLoc, const void * value, int uniformType, int count){
  SetShaderValueV(*shader, uniformLoc, value, uniformType, count);
}
")
(define-c void (set-shader-value-v SetShaderValueVPr) (Shader int (pointer void) int int))
;; TODO

;; RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);         // Set shader uniform value (matrix 4x4)
(declare-pointer-passthrough void SetShaderValueMatrix ((Shader shader) (int uniformLoc) (Matrix mat)))
(define-c void (set-shader-value-matrix SetShaderValueMatrixPr) (Shader int Matrix))

;; RLAPI void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture); // Set shader uniform value for texture
(declare-pointer-passthrough void SetShaderValueTexture ((Shader shader) (int uniformLoc) (Texture2D texture)))
(define-c void (set-shader-value-texture SetShaderValueTexturePr) (Shader int Texture2D))

;; RLAPI void SetMatrixProjection(Matrix proj);                              // Set a custom projection matrix (replaces internal projection matrix)
(declare-pointer-passthrough void SetMatrixProjection ((Matrix proj)))
(define-c void (set-matrix-project SetMatrixProjectionPr) (Matrix))

;; RLAPI void SetMatrixModelview(Matrix view);                               // Set a custom modelview matrix (replaces internal modelview matrix)
(declare-pointer-passthrough void SetMatrixModelview ((Matrix view)))
(define-c void (set-matrix-modelview SetMatrixModelviewPr) (Matrix))

;; RLAPI Matrix GetMatrixModelview();                                        // Get internal modelview matrix
(declare-pointer-passthrough Matrix GetMatrixModelview ())
(define-c (free Matrix) (get-matrix-modelview GetMatrixModelviewPr) ())

;; // Texture maps generation (PBR)
;; // NOTE: Required shaders should be provided
;; RLAPI Texture2D GenTextureCubemap(Shader shader, Texture2D skyHDR, int size);       // Generate cubemap texture from HDR texture
(declare-pointer-passthrough Texture2D GenTextureCubemap ((Shader shader) (Texture2D skyHDR) (int size)))
(define-c (free Texture2D) (gen-texture-cubemap GenTextureCubemapPr) (Shader Texture2D int))

;; RLAPI Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size);   // Generate irradiance texture using cubemap data
(declare-pointer-passthrough Texture2D GenTextureIrradiance ((Shader shader) (Texture2D cubemap) (int size)))
(define-c (free Texture2D) (gen-texture-irradiance GenTextureIrradiancePr) (Shader Texture2D int))

;; RLAPI Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size);    // Generate prefilter texture using cubemap data
(declare-pointer-passthrough Texture2D GenTexturePrefilter ((Shader shader) (Texture2D cubemap) (int size)))
(define-c (free Texture2D) (gen-texture-prefilter GenTexturePrefilterPr) (Shader Texture2D int))

;; RLAPI Texture2D GenTextureBRDF(Shader shader, int size);                  // Generate BRDF texture
(declare-pointer-passthrough Texture2D GenTextureBRDF ((Shader shader) (int size)))
(define-c (free Texture2D) (gen-texture-brdf GenTextureBRDFPr) (Shader int))

;; // Shading begin/end functions
;; RLAPI void BeginShaderMode(Shader shader);                                // Begin custom shader drawing
(declare-pointer-passthrough void BeginShaderMode ((Shader shader)))
(define-c void (begin-shader-mode BeginShaderModePr) (Shader))

;; RLAPI void EndShaderMode(void);                                           // End custom shader drawing (use default shader)
(define-c void (end-shader-mode EndShaderMode) ())

;; RLAPI void BeginBlendMode(int mode);                                      // Begin blending mode (alpha, additive, multiplied)
(define-c void (begin-blend-mode BeginBlendMode) (int))

;; RLAPI void EndBlendMode(void);                                            // End blending mode (reset to default: alpha blending)
(define-c void (end-blend-mode EndBlendMode) ())

;; RLAPI void BeginScissorMode(int x, int y, int width, int height);         // Begin scissor mode (define screen area for following drawing)
(define-c void (begin-scissor-mode BeginScissorMode) (int int int int))

;; RLAPI void EndScissorMode(void);                                          // End scissor mode
(define-c void (end-scissor-mode EndScissorMode) ())

;; TODO - no need for VR right now
;; // VR control functions
;; RLAPI void InitVrSimulator(void);                       // Init VR simulator for selected device parameters
;; RLAPI void CloseVrSimulator(void);                      // Close VR simulator for current device
;; RLAPI void UpdateVrTracking(Camera *camera);            // Update VR tracking (position and orientation) and camera
;; RLAPI void SetVrConfiguration(VrDeviceInfo info, Shader distortion);      // Set stereo rendering configuration parameters 
;; RLAPI bool IsVrSimulatorReady(void);                    // Detect if VR simulator is ready
;; RLAPI void ToggleVrMode(void);                          // Enable/Disable VR experience
;; RLAPI void BeginVrDrawing(void);                        // Begin VR simulator stereo rendering
;; RLAPI void EndVrDrawing(void);                          // End VR simulator stereo rendering

;; // Audio device management functions
;; RLAPI void InitAudioDevice(void);                                     // Initialize audio device and context
(define-c void (init-audio-device InitAudioDevice) ())

;; RLAPI void CloseAudioDevice(void);                                    // Close the audio device and context
(define-c void (close-audio-device CloseAudioDevice) ())

;; RLAPI bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
(define-c void (audio-device-ready? IsAudioDeviceReady) ())

;; RLAPI void SetMasterVolume(float volume);                             // Set master volume (listener)
(define-c void (set-master-volume SetMasterVolume) (float))

;; // Wave/Sound loading/unloading functions
;; RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
(declare-pointer-passthrough Wave LoadWave ((string filename)))
(define-c (free Wave) (load-wave LoadWavePr) (string))

;; RLAPI Wave LoadWaveEx(void *data, int sampleCount, int sampleRate, int sampleSize, int channels); // Load wave data from raw array data
(c-declare "
Wave * LoadWaveExPr(void * data, int sampleCount, int sampleRate, int sampleSize, int channels){
  Wave tmp = LoadWaveEx(data, sampleCount, sampleRate, sampleSize, channels);
  Wave * out = (Wave*)malloc(sizeof(Wave));
  CopyWaveNoAlloc(&tmp,out);return out;
}
")
(define-c (free Wave) (load-wave-ex LoadWaveExPr) ((pointer void) int int int int))

;; RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
(declare-pointer-passthrough Sound LoadSound ((string filename)))
(define-c (free Sound) (load-sound LoadSoundPr) (string))

;; RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
(declare-pointer-passthrough Sound LoadSoundFromWave ((Wave wave)))
(define-c (free Sound) (load-sound-from-wave LoadSoundFromWavePr) (Wave))

;; RLAPI void UpdateSound(Sound sound, const void *data, int samplesCount);// Update sound buffer with new data
(c-declare "
void UpdateSoundPr(Sound * sound, void * data, int samplesCount){
UpdateSound(*sound, data, samplesCount);
}
")
(define-c void (update-sound UpdateSoundPr) (Sound (pointer void) int))

;; RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
(declare-pointer-passthrough void UnloadWave ((Wave wave)))
(define-c void (unload-wave UnloadWavePr) (Wave))

;; RLAPI void UnloadSound(Sound sound);                                  // Unload sound
(declare-pointer-passthrough void UnloadSound ((Sound sound)))
(define-c void (unload-sound UnloadSoundPr) (Sound))

;; RLAPI void ExportWave(Wave wave, const char *fileName);               // Export wave data to file
(declare-pointer-passthrough void ExportWave ((Wave wave) (string filename)))
(define-c void (export-wave ExportWavePr) (Wave string))

;; RLAPI void ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h)
(declare-pointer-passthrough void ExportWaveAsCode ((Wave wave) (string filename)))
(define-c void (export-wave-as-code ExportWaveAsCodePr) (Wave string))

;; RLAPI void PlaySound(Sound sound);                                    // Play a sound
(declare-pointer-passthrough void PlaySound ((Sound sound)))
(define-c void (play-sound PlaySoundPr) (Sound))

;; RLAPI void PauseSound(Sound sound);                                   // Pause a sound
(declare-pointer-passthrough void PauseSound ((Sound sound)))
(define-c void (pause-sound PauseSoundPr) (Sound))

;; RLAPI void ResumeSound(Sound sound);                                  // Resume a paused sound
(declare-pointer-passthrough void ResumeSound ((Sound sound)))
(define-c void (resume-sound ResumeSoundPr) (Sound))

;; RLAPI void StopSound(Sound sound);                                    // Stop playing a sound
(declare-pointer-passthrough void StopSound ((Sound sound)))
(define-c void (stop-sound StopSoundPr) (Sound))

;; RLAPI bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
(declare-pointer-passthrough boolean IsSoundPlaying ((Sound sound)))
(define-c void (sound-playing? IsSoundPlayingPr) (Sound))

;; RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
(declare-pointer-passthrough void SetSoundVolume ((Sound sound) (float volume)))
(define-c void (set-sound-volume SetSoundVolumePr) (Sound float))

;; RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
(declare-pointer-passthrough void SetSoundPitch ((Sound sound) (float pitch)))
(define-c void (set-sound-pitch SetSoundPitchPr) (Sound float))

;; RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels);  // Convert wave data to desired format
(define-c void (wave-format WaveFormat) (Wave int int int))

;; RLAPI Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
(declare-pointer-passthrough Wave WaveCopy ((Wave wave)))
(define-c Wave (wave-copy WaveCopyPr) (Wave))

;; RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample);     // Crop a wave to defined samples range
(define-c void (wave-crop WaveCrop) (Wave int int))

;; RLAPI float *GetWaveData(Wave wave);                                  // Get samples data from wave as a floats array
;; TODO
(c-declare "
floatArray * GetWaveDataPr(Wave * wave){
  int i; int n;
  float * d;
  floatArray * fa;
  n = wave->sampleCount;
  fa = MakefloatArray(wave->sampleCount);
  d = GetWaveData(*wave);
  for(i=0; i<n; i++){
    fa->data[i] = d[i];
  } 
  return fa;
}
")
(define-c (free floatArray) (get-wave-data GetWaveDataPr) (Wave))

(define-c-type Music)
(define-c Music (load-music-stream LoadMusicStream) (string))
(define-c void (unload-music-stream UnloadMusicStream) (Music))
(define-c void (play-music-stream PlayMusicStream) (Music))
(define-c void (update-music-stream UpdateMusicStream) (Music))
(define-c void (stop-music-stream StopMusicStream) (Music))
(define-c void (pause-music-stream PauseMusicStream) (Music))
(define-c boolean (music-playing? IsMusicPlaying) (Music))
(define-c void (set-music-volume SetMusicVolume) (Music float))
(define-c void (set-music-loop-count SetMusicLoopCount) (Music int))
(define-c float (get-music-time-length GetMusicTimeLength) (Music))
(define-c float (get-music-time-played GetMusicTimePlayed) (Music))

;; RLAPI AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Init audio stream (to stream raw audio pcm data)
(declare-pointer-passthrough AudioStream InitAudioStream ((unsigned-int sampleRate)
                                                          (unsigned-int sampleSize)
                                                          (unsigned-int channels)))
(define-c (free AudioStream) (init-audio-stream InitAudioStreamPr) (unsigned-int unsigned-int unsigned-int))

;; RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); // Update audio stream buffers with data
(declare-pointer-passthrough void UpdateAudioStream ((AudioStream stream)
                                                     ((pointer void) data)
                                                     (int samplesCount)))
(define-c void (update-audio-stream UpdateAudioStreamPr) (AudioStream (pointer void) int))

;; RLAPI void CloseAudioStream(AudioStream stream);                      // Close audio stream and free memory
(declare-pointer-passthrough void CloseAudioStream ((AudioStream stream)))
(define-c void (close-audio-stream CloseAudioStreamPr) (AudioStream))

;; RLAPI bool IsAudioBufferProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
(declare-pointer-passthrough void IsAudioBufferProcessed ((AudioStream stream)))
(define-c void (audio-buffer-processed? IsAudioBufferProcessedPr) (AudioStream))

;; RLAPI void PlayAudioStream(AudioStream stream);                       // Play audio stream
(declare-pointer-passthrough void PlayAudioStream ((AudioStream stream)))
(define-c void (play-audio-stream PlayAudioStreamPr) (AudioStream))

;; RLAPI void PauseAudioStream(AudioStream stream);                      // Pause audio stream
(declare-pointer-passthrough void PauseAudioStream ((AudioStream stream)))
(define-c void (pause-audio-stream PauseAudioStreamPr) (AudioStream))

;; RLAPI void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
(declare-pointer-passthrough void ResumeAudioStream ((AudioStream stream)))
(define-c void (resume-audio-stream ResumeAudioStreamPr) (AudioStream))

;; RLAPI bool IsAudioStreamPlaying(AudioStream stream);                  // Check if audio stream is playing
(declare-pointer-passthrough void IsAudioStreamPlaying ((AudioStream stream)))
(define-c void (audio-stream-playing? IsAudioStreamPlayingPr) (AudioStream))

;; RLAPI void StopAudioStream(AudioStream stream);                       // Stop audio stream
(declare-pointer-passthrough void StopAudioStream ((AudioStream stream)))
(define-c void (stop-audio-stream StopAudioStreamPr) (AudioStream))

;; RLAPI void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
(declare-pointer-passthrough void SetAudioStreamVolume ((AudioStream stream) (float volume)))
(define-c void (set-audio-stream-volume SetAudioStreamVolumePr) (AudioStream float))

;; RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
(declare-pointer-passthrough void SetAudioStreamPitch ((AudioStream stream) (float pitch)))
(define-c void (set-audio-stream-pitch SetAudioStreamPitchPr) (AudioStream float))