Merge branch 'master' into add-texture-npatch-binding

Author: bakpakin

api.txt

@@ -295,6 +295,7 @@
 
 // Basic geometric 3D shapes drawing functions
 [x] void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color)
+[x] void DrawPoint3D(Vector3 position, Color color)
 [x] void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color)
 [x] void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color)
 [x] void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color)

project.janet

@@ -30,7 +30,12 @@
 
   :cflags [;default-cflags ;cflags]
 
-  :defines {"PLATFORM_DESKTOP" true "_POSIX_C_SOURCE" "200809L" "_DARWIN_C_SOURCE" (if (= o :macos) "1" nil) "_GNU_SOURCE" true}
+  :defines {"PLATFORM_DESKTOP" true
+            "_POSIX_C_SOURCE" "200809L"
+            "_DARWIN_C_SOURCE" (if (= o :macos) "1" nil)
+            "_GNU_SOURCE" true
+            "SUPPORT_FILEFORMAT_BMP" true
+            "STB_IMAGE_IMPLEMENTATION" true}
 
   :source ["src/main.c"
            # raylib sources

src/3d.h

@@ -7,6 +7,14 @@ static Janet cfun_DrawLine3D(int32_t argc, Janet *argv) {
     return janet_wrap_nil();
 }
 
+static Janet cfun_DrawPoint3D(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    Vector3 pos = jaylib_getvec3(argv, 0);
+    Color color = jaylib_getcolor(argv, 1);
+    DrawPoint3D(pos, color);
+    return janet_wrap_nil();
+}
+
 static Janet cfun_DrawCircle3D(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 5);
     Vector3 center = jaylib_getvec3(argv, 0);
@@ -701,6 +709,10 @@ static JanetReg threed_cfuns[] = {
         "(draw-line-3d [start-x start-y start-z] [end-x end-y end-z] color)\n\n"
         "Draw a line in 3D world space"
     },
+    {"draw-point-3d", cfun_DrawPoint3D, 
+        "(draw-point-3d [center-x center-y center-z] color)\n\n"
+        "Draw a point in 3D space, actually a small line"
+    },
     {"draw-circle-3d", cfun_DrawCircle3D, 
         "(draw-circle-3d [center-x center-y center-z] radius [rot-x rot-y rot-z] rotation-angle color)\n\n"
         "Draw a circle in 3D world space"

src/image.h

@@ -7,6 +7,39 @@ static Janet cfun_LoadImage(int32_t argc, Janet *argv) {
     return janet_wrap_abstract(image);
 }
 
+static Janet cfun_LoadImageFromBuffer(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    const char *fileType = janet_getcstring(argv, 0);
+    JanetBuffer* data = janet_getbuffer(argv, 1);
+    Image *image = janet_abstract(&AT_Image, sizeof(Image));
+    *image = LoadImageFromMemory(fileType, data->data, data->count);
+    return janet_wrap_abstract(image);
+}
+
+static Janet cfun_GetBitmapHeaderBuffer(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    int16_t sizeX = (int16_t)janet_getnumber(argv, 0);
+    int16_t sizeY = (int16_t)janet_getnumber(argv, 1);
+    const int32_t headerlength = 26;
+    const int32_t magicheadersize = 12;
+    const int16_t planes = 1;
+    const int16_t bpp = 24;
+    const int32_t filesize = headerlength + (sizeX * sizeY);
+
+    JanetBuffer* data = janet_buffer(filesize);
+    janet_buffer_push_cstring(data, "BM");
+    janet_buffer_push_u32(data, filesize);
+    janet_buffer_push_u32(data, 0); // should be two int16, reserved.
+    janet_buffer_push_u32(data, headerlength);
+    janet_buffer_push_u32(data, magicheadersize); // if 12 we can skip alot of complicated(?) stuff in the header
+    janet_buffer_push_u16(data, sizeX);
+    janet_buffer_push_u16(data, sizeY);
+    janet_buffer_push_u16(data, planes);
+    janet_buffer_push_u16(data, bpp);
+
+    return janet_wrap_buffer(data);
+}
+
 static Janet cfun_IsImageReady(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 1);
     Image image = *jaylib_getimage(argv, 0);
@@ -651,6 +684,17 @@ static Janet cfun_GetImageDimensions(int32_t argc, Janet *argv) {
     return jaylib_wrap_vec2(dim);
 }
 
+static Janet cfun_LoadImageFromMemory(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 3);
+    const char *fileType = janet_getcstring(argv, 0);
+    const unsigned char *fileData = janet_getbytes(argv, 1).bytes;
+    int dataSize = janet_getinteger(argv, 2);
+
+    Image *image = janet_abstract(&AT_Image, sizeof(Image));
+    *image = LoadImageFromMemory(fileType, fileData, dataSize);
+    return janet_wrap_abstract(image);
+}
+
 /*
 // Image/Texture2D data loading/unloading/saving functions
 RLAPI Image LoadImagePro(void *data, int width, int height, int format);                                 // Load image from raw data with parameters
@@ -670,6 +714,14 @@ static const JanetReg image_cfuns[] = {
         "(load-image-1 file-name)\n\n"
         "Load image from file into CPU memory (RAM)"
     }, // load-image is janet core function, don't want to overwrite if we use (use jaylib)
+    {"load-image-from-buffer", cfun_LoadImageFromBuffer, 
+        "(load-image-from-buffer file-type buffer)\n\n"
+        "Load buffer as image object"
+    },
+    {"get-bitmap-header-buffer", cfun_GetBitmapHeaderBuffer, 
+        "(get-bitmap-header-buffer dimx dimy)\n\n"
+        "returns a header for a 24bpp bitmap with dimensions dimx*dimy"
+    },
     {"image-ready?", cfun_IsImageReady,
         "(image-ready? image)\n\n"
         "Check if an image is ready"
@@ -930,5 +982,9 @@ static const JanetReg image_cfuns[] = {
         "(set-texture-wrap texture wrap)\n\n"
         "Set texture wrapping mode"
     },
+    {"load-image-from-memory", cfun_LoadImageFromMemory,
+        "(load-image-from-memory filetype data size)\n\n"
+        "Load image from memory buffer, fileType refers to extension: i.e. '.png'"
+    },
     {NULL, NULL, NULL}
 };

src/text.h

@@ -42,17 +42,21 @@ static Janet cfun_IsFontReady(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_LoadFontEx(int32_t argc, Janet *argv) {
-    janet_fixarity(argc, 3);
+    janet_arity(argc, 2, 3);
     const char *fileName = janet_getcstring(argv, 0);
     int fontSize = janet_getinteger(argv, 1);
-    JanetView ints = janet_getindexed(argv, 2);
-    int *raw_ints = janet_smalloc(sizeof(int) * ints.len);
-    for (int32_t i = 0; i < ints.len; i++) {
-        raw_ints[i] = janet_getinteger(ints.items, i);
-    }
     Font *font = janet_abstract(&AT_Font, sizeof(Font));
-    *font = LoadFontEx(fileName, fontSize, raw_ints, ints.len);
-    janet_sfree(raw_ints);
+    if (argc == 2) {
+        *font = LoadFontEx(fileName, fontSize, NULL, 0);
+    } else {
+        JanetView ints = janet_getindexed(argv, 2);
+        int *raw_ints = janet_smalloc(sizeof(int) * ints.len);
+        for (int32_t i = 0; i < ints.len; i++) {
+            raw_ints[i] = janet_getinteger(ints.items, i);
+        }
+        *font = LoadFontEx(fileName, fontSize, raw_ints, ints.len);
+        janet_sfree(raw_ints);
+    }
     return janet_wrap_abstract(font);
 }
 
@@ -200,7 +204,7 @@ static JanetReg text_cfuns[] = {
         "Check if a font is ready"
     },
     {"load-font-ex", cfun_LoadFontEx,
-        "(load-font-ex file-name font-size font-chars)\n\n"
+        "(load-font-ex file-name font-size &opt font-chars)\n\n"
         "Load font from file with extended parameters"
     },
     {"load-font-from-memory", cfun_LoadFontFromMemory,

src/types.h

@@ -497,15 +497,42 @@ static Shader *jaylib_getshader(const Janet *argv, int32_t n) {
     return ((Shader *)janet_getabstract(argv, n, &AT_Shader));
 };
 
+int texture2d_get(void* p, Janet key, Janet *out);
+
 static const JanetAbstractType AT_Texture2D = {
     "jaylib/texture2d",
-    JANET_ATEND_NAME
+    NULL,
+    NULL,
+    texture2d_get,
+    JANET_ATEND_GET
 };
 
 static Texture2D *jaylib_gettexture2d(const Janet *argv, int32_t n) {
     return ((Texture2D *)janet_getabstract(argv, n, &AT_Texture2D));
 }
 
+int texture2d_get(void* p, Janet key, Janet *out) {
+	Texture2D *texture = (Texture2D *) p;
+	
+	if (!janet_checktype(key, JANET_KEYWORD)) {
+		janet_panic("expected keyword");
+	}
+
+	const uint8_t *kw = janet_unwrap_keyword(key);
+
+	if (!janet_cstrcmp(kw, "width")) {
+		*out = janet_wrap_integer(texture->width);
+		return 1;
+	}
+	
+	if (!janet_cstrcmp(kw, "height")) {
+		*out = janet_wrap_integer(texture->height);
+		return 1;
+	}
+	
+	return 0;
+}
+
 static const JanetAbstractType AT_Image = {
     "jaylib/image",
     JANET_ATEND_NAME

test/lenna.bmp

@@ -9,6 +9,20 @@
 (image-dither lenna 4 4 4 4)
 (def lenna-t (load-texture-from-image lenna))
 
+(def lenna-bmp (slurp "test/lenna.bmp"))
+(def lenna-b (load-image-from-buffer ".bmp" lenna-bmp))
+(image-dither lenna-b 4 4 4 4)
+(def lenna-bt (load-texture-from-image lenna-b))
+
+(def gen-bmp (get-bitmap-header-buffer 100 100))
+(each byte (range 0 (* 100 100))
+  (buffer/push-byte gen-bmp 0)    #b
+  (buffer/push-byte gen-bmp 0)    #g
+  (buffer/push-byte gen-bmp 0xff) #r
+  )
+(def gen-i (load-image-from-buffer ".bmp" gen-bmp))
+(def gen-t (load-texture-from-image gen-i))
+
 (def cells (gen-image-cellular 100 100 10))
 (def cells-t (load-texture-from-image cells))
 
@@ -20,6 +34,7 @@
   (clear-background :green)
 
   (draw-texture lenna-t 100 100 :white)
+  (draw-texture lenna-bt 200 200 :white)
   (draw-texture cells-t 600 0 :white)
   (draw-texture-n-patch nine-patch-t [[0 0 96 96] 32 32 32 32 :npatch-nine-patch] [0 0 96 138] [0 0] 0 :white)