aboutsummaryrefslogtreecommitdiff
path: root/fbwarn
diff options
context:
space:
mode:
Diffstat (limited to 'fbwarn')
-rw-r--r--fbwarn/src/BVGTypes.h56
-rw-r--r--fbwarn/src/extString.c19
-rw-r--r--fbwarn/src/extString.h3
-rw-r--r--fbwarn/src/parseBVG.c261
-rw-r--r--fbwarn/src/parseBVG.h19
-rw-r--r--fbwarn/src/warn.c47
6 files changed, 367 insertions, 38 deletions
diff --git a/fbwarn/src/BVGTypes.h b/fbwarn/src/BVGTypes.h
index 1ed1919..be7669f 100644
--- a/fbwarn/src/BVGTypes.h
+++ b/fbwarn/src/BVGTypes.h
@@ -1,8 +1,62 @@
#include <raylib.h>
#include <stdbool.h>
+
typedef struct BVGRectangle {
Rectangle rayrectangle;
- Color color;
bool fill;
float lineThickness;
+ Color color;
} BVGRectangle;
+
+typedef struct BVGRoundedRectangle {
+ BVGRectangle rectangle;
+ float roundness;
+ int segments;
+} BVGRoundedRectangle;
+
+typedef struct BVGCircle {
+ int centerX;
+ int centerY;
+ float radius;
+ bool drawSector;
+ float startAngle;
+ float endAngle;
+ int segments;
+ Color color;
+} BVGCircle;
+
+typedef struct BVGRing {
+ int centerX;
+ int centerY;
+ float inRadius;
+ float outRadius;
+ float startAngle;
+ float endAngle;
+ int segmets;
+ Color color;
+} BVGRing;
+
+typedef struct BVGEllipse {
+ int centerX;
+ int centerY;
+ float horizontalRadius;
+ float verticalRadius;
+ bool fill;
+ Color color;
+} BVGEllipse;
+
+typedef struct BVGTriangle {
+ Vector2 corner1;
+ Vector2 corner2;
+ Vector2 corner3;
+ bool fill;
+ Color color;
+} BVGTriangle;
+
+typedef struct BVGText {
+ char *text;
+ int x;
+ int y;
+ int fontSize;
+ Color color;
+} BVGText;
diff --git a/fbwarn/src/extString.c b/fbwarn/src/extString.c
index c93cffd..abe6728 100644
--- a/fbwarn/src/extString.c
+++ b/fbwarn/src/extString.c
@@ -13,3 +13,22 @@ char *strlwr(char *str)
return str;
}
+
+char *trim(char *str)
+{
+ char *result = strdup(str);
+ char *end;
+
+ while(isspace((unsigned char)*result)) result++;
+
+ if(*result == 0)
+ return result;
+
+ end = result + strlen(result) - 1;
+ while(end > result && isspace((unsigned char)*end)) end--;
+
+ // Write new null terminator character
+ end[1] = '\0';
+
+ return result;
+}
diff --git a/fbwarn/src/extString.h b/fbwarn/src/extString.h
index 06d2b49..19a97c6 100644
--- a/fbwarn/src/extString.h
+++ b/fbwarn/src/extString.h
@@ -1 +1,2 @@
-char *strlwr(char*);
+char *strlwr(char *);
+char *trim(char *);
diff --git a/fbwarn/src/parseBVG.c b/fbwarn/src/parseBVG.c
index ead9c83..94795f8 100644
--- a/fbwarn/src/parseBVG.c
+++ b/fbwarn/src/parseBVG.c
@@ -1,4 +1,5 @@
#include <stdbool.h>
+#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -15,6 +16,29 @@ void BVGDrawRectangle(BVGRectangle *rectangle) {
return;
}
+void BVGDrawRoundedRectangle(BVGRoundedRectangle *rectangle) {
+ if (rectangle->rectangle.fill) {
+ DrawRectangleRounded(rectangle->rectangle.rayrectangle, rectangle->roundness, rectangle->segments, rectangle->rectangle.color);
+ } else {
+ DrawRectangleRoundedLines(rectangle->rectangle.rayrectangle, rectangle->roundness, rectangle->segments, rectangle->rectangle.lineThickness, rectangle->rectangle.color);
+ }
+}
+
+void BVGDrawCircle(BVGCircle *circle) {
+ Vector2 center = {circle->centerX, circle->centerY};
+ if (circle->drawSector) {
+ DrawCircleSector(center, circle->radius, circle->startAngle, circle->endAngle, circle->segments, circle->color);
+ } else {
+ printf("center: %f, %f\n", center.x, center.y);
+ printf("radius: %f, color: %d\n", circle->radius, circle->color.a);
+ DrawCircle(circle->centerX, circle->centerY, circle->radius, circle->color);
+ }
+}
+
+void BVGDrawText(BVGText *text) {
+ DrawText(text->text, text->x, text->y, text->fontSize, text->color);
+}
+
// reads a given file
FILE *readFile(char *path) {
FILE *fp = fopen (path, "r");
@@ -41,6 +65,52 @@ char *multiToSingle(char *lines) {
}
/*
+ Collects all arguments from a function call
+ arguments are seperated with a ,
+*/
+void collectArgs(char *res[], char *call, int n) {
+ char **arg;
+ char *args[n];
+ for (arg = args; (*arg = strsep(&call, ",")) != NULL;)
+ if (**arg != '\0')
+ if (++arg >= &args[n])
+ break;
+ memcpy(res, args, sizeof(args));
+}
+
+/*
+ Order the arguments in the order specified with knownArgs
+ the res array contains only the values of each argument
+*/
+void orderArgs(char *res[], char *argv[], int n, char *knownArgs[]) {
+ for(int i=0; i<n; i++) {
+ for(int j=0; j<n; j++) {
+ if (strncmp(argv[i], knownArgs[j], strlen(knownArgs[j])) == 0) {
+ res[j] = argv[i]+strlen(knownArgs[j])+1;
+ }
+ }
+ }
+}
+
+/*
+ Parses a color from a hex representation
+ supports RRGGBB and RRGGBBAA
+ assumes that only the color value is in the string
+*/
+Color *parseColorFromHex(char *hex) {
+ Color *clr = malloc(sizeof(Color));
+ int r,g,b,a;
+ if (strlen(hex) == 6) {
+ sscanf(hex, "%02x%02x%02x", &r, &g, &b);
+ clr->r=r; clr->g=g; clr->b=b; clr->a=255;
+ } else {
+ sscanf(hex, "%02x%02x%02x%02x", &r, &g, &b, &a);
+ clr->r=r; clr->g=g; clr->b=b; clr->a=a;
+ }
+ return clr;
+}
+
+/*
Converts a given char pointer to a corresponding boolean value
expects the char to only contain true/false without any whitespace or similiar
case is ignored
@@ -56,57 +126,198 @@ bool parseBoolValue(char *value) {
}
}
+/*
+ Creates a BVGRectangle based on a BVG function call
+*/
BVGRectangle *BVGParseRectangle(char *argv[7]) {
BVGRectangle *result = malloc(sizeof(BVGRectangle));
Rectangle *rectangle = malloc(sizeof(Rectangle));
- argv[4][strlen(argv[4])-1] = '\0';
- argv[4] = argv[4]+strlen("color=#'");
+ size_t argN = 7;
+ char *args[argN];
+ char *knownArgs[7] = {"x", "y", "width", "height", "color", "fill", "thickness"};
+ //printf("118 Parsing...%s \n", args[0]);
+ orderArgs(args, argv, argN, knownArgs);
+ printf("119 Parsing...%s \n", args[0]);
int x, y, width, height, r, g, b, a;
float thickness = 1.0;
- Color *clr = malloc(sizeof(Color));
- sscanf(argv[0]+strlen("x="), "%d", &x);
- sscanf(argv[1]+strlen("y="), "%d", &y);
- sscanf(argv[2]+strlen("width="), "%d", &width);
- sscanf(argv[3]+strlen("height="), "%d", &height);
- if (strlen(argv[4]) == 6) {
- sscanf(argv[4], "%02x%02x%02x", &r, &g, &b);
- clr->r=r; clr->g=g; clr->b=b; clr->a=255;
- } else {
- sscanf(argv[4], "%02x%02x%02x%02x", &r, &g, &b, &a);
- clr->r=r; clr->g=g; clr->b=b; clr->a=a;
- }
- sscanf(argv[6]+strlen("thickness="), "%fd", &thickness);
+ bool fill = true;
+ sscanf(args[0], "%d", &x);
+ sscanf(args[1], "%d", &y);
+ sscanf(args[2], "%d", &width);
+ sscanf(args[3], "%d", &height);
+ args[4] = args[4]+2;
+ args[4][strlen(args[4])-1] = '\0';
+ Color *clr = parseColorFromHex(args[4]);
+ sscanf(args[6], "%fd", &thickness);
+ fill = parseBoolValue(args[5]);
printf("X: %d, Y: %d\n", x, y);
printf("Width: %d, Height: %d\n", width, height);
printf("Color: %d, %d, %d\n", r, g, b);
- printf("Fill: %d, Thickness: %f\n", parseBoolValue(argv[5]+strlen("fill=")), thickness);
+ printf("Fill: %d, Thickness: %f\n", fill, thickness);
rectangle->x=x; rectangle->y=y;
rectangle->height=height; rectangle->width=width;
result->rayrectangle=*rectangle;
-
result->color=*clr;
- result->fill=parseBoolValue(argv[5]+strlen("fill="));
+ result->fill=fill;
result->lineThickness=thickness;
+ return result;
+}
+
+/*
+ Creates a BVGRoundedrectangle based on a BVG function call
+*/
+BVGRoundedRectangle *BVGParseRoundedRectangle(char *argv[9]) {
+ BVGRoundedRectangle *result = malloc(sizeof(BVGRoundedRectangle));
+ BVGRectangle *bvgrectangle = malloc(sizeof(BVGRectangle));
+ Rectangle *rectangle = malloc(sizeof(Rectangle));
+ size_t argN = 9;
+ char *args[argN];
+ char *knownArgs[9] = {"x", "y", "width", "height", "color", "fill", "thickness", "roundness", "segments"};
+ orderArgs(args, argv, argN, knownArgs);
+ bvgrectangle = BVGParseRectangle(argv);
+ result->rectangle = *bvgrectangle;
+
+ float roundness;
+ int segments;
+ sscanf(args[7], "%fd", &roundness);
+ sscanf(args[8], "%d", &segments);
+
+ printf("Roundness: %fd, Segments: %d\n", roundness, segments);
+ result->roundness = roundness;
+ result->segments = segments;
return result;
}
+BVGCircle *BVGParseCircle(char *argv[4]) {
+ BVGCircle *result = malloc(sizeof(BVGCircle));
+ size_t argN = 4;
+ char *args[argN];
+ char *knownArgs[4] = {"x", "y", "radius", "color"};
+ orderArgs(args, argv, argN, knownArgs);
+ int x, y;
+ float radius;
+ Color *clr;
+ sscanf(args[0], "%d", &x);
+ sscanf(args[1], "%d", &y);
+ sscanf(args[2], "%fd", &radius);
+ args[3] = args[3]+2;
+ args[3][strlen(args[3])-1] = '\0';
+ clr = parseColorFromHex(args[3]);
+ printf("X: %d, Y: %d\n", x, y);
+ printf("radius: %f, color: %s\n", radius, args[3]);
+ result->drawSector=false;
+ result->centerX=x;
+ result->centerY=y;
+ result->color=*clr;
+ result->radius=radius;
+ return result;
+}
+
+BVGCircle *BVGParseCircleSegment(char *argv[7]) {
+ BVGCircle *result = malloc(sizeof(BVGCircle));
+ size_t argN = 7;
+ char *args[argN];
+ char *knownArgs[7] = {"x", "y", "radius", "color", "startangle", "endangle", "segments"};
+ orderArgs(args, argv, argN, knownArgs);
+ int x, y, segments;
+ float radius, startAngle, endAngle;
+ Color *clr;
+ sscanf(args[0], "%d", &x);
+ sscanf(args[1], "%d", &y);
+ sscanf(args[2], "%fd", &radius);
+ sscanf(args[4], "%fd", &startAngle);
+ sscanf(args[5], "%fd", &endAngle);
+ sscanf(args[6], "%d", &segments);
+ args[3] = args[3]+2;
+ args[3][strlen(args[3])-1] = '\0';
+ clr = parseColorFromHex(args[3]);
+ printf("X: %d, Y: %d\n", x, y);
+ printf("radius: %f, color: %s\n", radius, args[3]);
+ result->drawSector=true;
+ result->centerX=x;
+ result->centerY=y;
+ result->color=*clr;
+ result->radius=radius;
+ result->segments=segments;
+ result->startAngle=startAngle;
+ result->endAngle=endAngle;
+ return result;
+}
+
+BVGText *BVGParseText(char *argv[5]) {
+ BVGText *result = malloc(sizeof(BVGText));
+ size_t argN = 5;
+ char *args[argN];
+ char *knownArgs[5] = {"text", "x", "y", "size", "color"};
+ orderArgs(args, argv, argN, knownArgs);
+ args[0] = args[0]+1;
+ args[0][strlen(args[0])-1] = '\0';
+ char *text = args[0];
+ int x, y, size;
+ Color *clr;
+ sscanf(args[1], "%d", &x);
+ sscanf(args[2], "%d", &y);
+ sscanf(args[3], "%d", &size);
+ args[4] = args[4]+2;
+ args[4][strlen(args[4])-1] = '\0';
+ printf("Text: %s\n", text);
+ printf("X: %d, Y: %d\n", x, y);
+ printf("Size: %d, Color: %s\n", size, args[4]);
+ clr = parseColorFromHex(args[4]);
+ result->text=text; result->x=x;
+ result->y=y; result->fontSize=size;
+ result->color=*clr;
+ return result;
+}
+
+/*
+ Takes a BVG function call and calls the according C function
+*/
void matchFunctionCall(char *call, void *ret) {
printf("Matching %s\n", call);
char *funcCall = strdup(call);
char *funcName = strsep(&funcCall, "(");
- printf("Got function %s\n", funcName);
- if (strcmp(funcName, "rectangle ") == 0) {
- char **arg, *argv[7];
+ char *function = trim(strlwr(funcName));
+ free(funcName);
+ printf("Got function %s\n", function);
+ call[strlen(call)-1]='\0';
+ if (strcmp(function, "rectangle") == 0) {
+ char *argv[7];
call = call+strlen("rectangle (");
- for (arg = argv; (*arg = strsep(&call, ",")) != NULL;)
- if (**arg != '\0')
- if (++arg >= &argv[7])
- break;
+ collectArgs(argv, call, 7);
BVGRectangle *rect = malloc(sizeof(BVGRectangle));
rect = BVGParseRectangle(argv);
BVGDrawRectangle(rect);
+ } else if (strcmp(function, "roundedrectangle") == 0) {
+ char *argv[9];
+ call = call+strlen("roundedrectangle (");
+ collectArgs(argv, call, 9);
+ BVGRoundedRectangle *roundrect = malloc(sizeof(BVGRoundedRectangle));
+ roundrect = BVGParseRoundedRectangle(argv);
+ BVGDrawRoundedRectangle(roundrect);
+ } else if (strcmp(function, "circle") == 0) {
+ char *argv[4];
+ call = call+strlen("circle (");
+ collectArgs(argv, call, 4);
+ BVGCircle *circle = malloc(sizeof(BVGCircle));
+ circle = BVGParseCircle(argv);
+ BVGDrawCircle(circle);
+ } else if (strcmp(function, "circlesegment") == 0) {
+ char *argv[7];
+ call = call+strlen("circlesegment (");
+ collectArgs(argv, call, 7);
+ BVGCircle *circle = malloc(sizeof(BVGCircle));
+ circle = BVGParseCircleSegment(argv);
+ BVGDrawCircle(circle);
+ } else if (strcmp(function, "text") == 0) {
+ char *argv[5];
+ call = call+strlen("text (");
+ collectArgs(argv, call, 5);
+ BVGText *text = malloc(sizeof(BVGText));
+ text = BVGParseText(argv);
+ BVGDrawText(text);
}
return;
}
diff --git a/fbwarn/src/parseBVG.h b/fbwarn/src/parseBVG.h
index ed9b874..b349687 100644
--- a/fbwarn/src/parseBVG.h
+++ b/fbwarn/src/parseBVG.h
@@ -1,10 +1,21 @@
#include <stdio.h>
#include <stdlib.h>
+#include <stdbool.h>
#include "raylib.h"
#include "BVGTypes.h"
-void BVGDrawRectangle(BVGRectangle*);
-FILE *readFile(char*);
-char *multiToSingle(char*);
+FILE *readFile(char *);
+char *multiToSingle(char *);
void matchFunctionCall(char *);
-BVGRectangle *BVGParseRectangle(char*[7]);
+void collectArgs(char *[], char *, int);
+void orderArgs(char *[], char *[], int, char *[]);
+Color *parseColorFromHex(char *);
+bool parseBoolValue(char *);
+
+// Shape functions
+BVGRectangle *BVGParseRectangle(char *[7]);
+void BVGDrawRectangle(BVGRectangle*);
+BVGRoundedRectangle *BVGParseRoundedRectangle(char *[9]);
+void BVGDrawRoundedRectangle(BVGRoundedRectangle*);
+BVGCircle *BVGParseCircle(char *[4]);
+void BVGDrawCircle(BVGCircle);
diff --git a/fbwarn/src/warn.c b/fbwarn/src/warn.c
index 1589e48..e442643 100644
--- a/fbwarn/src/warn.c
+++ b/fbwarn/src/warn.c
@@ -5,26 +5,47 @@
#include <unistd.h>
int main(void) {
- char *rectA, *rectB, *rectC, *rectAFree, *rectBFree, *rectCFree, *singleA, *singleB, *singleC;
- rectAFree = rectA = strdup("rectangle (x=0,y=0,\nwidth=100,\nheight=100,\ncolor='#9787CFFF',\nfill=true,\nthickness=1.0)\n");
+ char *rectA, *rectB, *rectC, *rectD, *rectAFree, *rectBFree, *rectCFree, *rectDFree, *singleA, *singleB, *singleC, *singleD;
+ char *rectE, *rectF, *rectEFree, *rectFFree, *singleE, *singleF;
+ rectAFree = rectA = strdup("rectangle (x=10,y=20,\nwidth=100,\nheight=100,\ncolor='#9787CFFF',\nfill=true,\nthickness=1.0)\n");
if (rectA == NULL)
return 1;
singleA = multiToSingle(rectA);
free(rectAFree);
- rectBFree = rectB = strdup("rectangle (x=0,y=20,\nwidth=100,\nheight=60,\ncolor='#88C2B1FF',\nfill=false,\nthickness=5.0)\n");
+ rectBFree = rectB = strdup("rectangle (x=130,y=160,\nwidth=100,\nheight=60,\ncolor='#88C2B1FF',\nfill=false,\nthickness=5.0)\n");
if (rectB == NULL)
return 1;
singleB = multiToSingle(rectB);
free(rectBFree);
- rectCFree = rectC = strdup("rectangle (x=0,y=40,\nwidth=100,\nheight=20,\ncolor='#BE79A7FF',\nfill=true,\nthickness=3.0)\n");
+ rectCFree = rectC = strdup("circlesegment (x=300,y=200,radius=100,color='#BE79A7FF',startangle=0.0,endangle=90.0,segments=10)");
if (rectC == NULL)
return 1;
singleC = multiToSingle(rectC);
free(rectCFree);
-
- InitWindow (100, 100, ":3");
+
+ rectDFree = rectD = strdup("text (text='haiii :3',x=300,y=10,size=50,color='#DD98E5FF')");
+ if (rectD == NULL)
+ return 1;
+ singleD = multiToSingle(rectD);
+ free(rectDFree);
+
+ rectEFree = rectE = strdup("roundedrectangle (x=90,y=300,\nwidth=92,\nheight=20,\ncolor='#BE79A7FF',\nfill=false,\nthickness=3.0,roundness=5.0,segments=100)\n");
+ if (rectE == NULL)
+ return 1;
+ singleE = multiToSingle(rectE);
+ free(rectEFree);
+
+ rectFFree = rectF = strdup("circle (x=700,y=300,radius=90.0,color='#7676DCFF')\n");
+ if (rectF == NULL)
+ return 1;
+ singleF = multiToSingle(rectF);
+ free(rectFFree);
+
+
+ InitWindow (800, 400, ":3");
+
while (!WindowShouldClose ()) {
@@ -38,7 +59,19 @@ int main(void) {
char *parseC = strdup(singleC);
matchFunctionCall(parseC);
-
+
+ char *parseD = strdup(singleD);
+ matchFunctionCall(parseD);
+
+ char *parseE = strdup(singleE);
+ matchFunctionCall(parseE);
+
+ char *parseF = strdup(singleF);
+ matchFunctionCall(parseF);
+
+ char *text = malloc(strlen("100")*100);
+ sprintf(text, "%d", GetFPS());
+ DrawText(text, 2, 2, 20, MAROON);
EndDrawing ();
}