implemented some render functions; next step is to load a modern GL context;

bite.c

···
 
 static be_Context _context;
 
+static const be_Config _conf = {
+    .window = {
+        .title = "bitEngine "BITE_VERSION,
+        .width = 640, .height = 380,
+        .flags = 0
+    }
+};
+
 int _init_context(be_Context* ctx, const be_Config* conf);
 void _poll_events(be_Context* ctx);
 
···
 
 be_Config bite_init_config(const char* title, int w, int h) {
     be_Config c = {0};
-    title = title != NULL ? title : "bitEngine";
+    title = title != NULL ? title : "bitEngine "BITE_VERSION;
+    int len = strlen(title);
     strcpy(c.window.title, title);
     c.window.width = w;
     c.window.height = h;
···
 }
 
 be_Context* bite_create(const be_Config* conf) {
+    conf = conf ? conf : &(_conf);
     be_Context* ctx = malloc(sizeof(*ctx));
     if (!ctx) {
         fprintf(stderr, "Failed to alloc memory for context\n");
···
     return ctx->window.width;
 }
 
+/*********************
+ * Render
+ *********************/
+
+static GLuint _create_program(GLuint vert, GLuint frag) {
+    GLuint program = glCreateProgram();
+    glAttachShader(program, vert);
+    glAttachShader(program, frag);
+    glLinkProgram(program);
+    
+    int success;
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+    if (!success) {}
+
+    return program;
+}
+
+be_Shader* bite_create_shader(const char* vert, const char* frag) {
+    be_Shader* shader = NULL;
+    GLuint program;
+    GLuint vert, frag;
+
+    return shader;
+}
+
+void bite_render_clear_color(float r, float g, float b, float a) {
+glClearColor(r, g, b, a);
+}
+
+void bite_render_clear(void) {
+glClear(GL_COLOR_BUFFER_BIT);
+}
+
+struct be_Texture {
+GLuint handle;
+int width, height;
+int filter[2];
+int wrap[2];
+};
+ 
+ struct be_Framebuffer {
+    GLuint handle;
+    be_Texture* texture;
+ };
+ 
+ struct be_Shader {
+    GLuint handle;
+    int world_uniform;
+    int modelview_uniform;
+ };
+ 
+ void bite_bind_framebuffer(be_Framebuffer* fbo) {
+    if (!fbo) glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    else glBindFramebuffer(GL_FRAMEBUFFER, fbo->handle);
+ }
+ 
+ void bite_bind_texture(be_Texture* tex) {
+    if (!tex) glBindTexture(GL_TEXTURE_2D, 0);
+    else glBindTexture(GL_TEXTURE_2D, tex->handle);
+ }
+ 
+ void bite_use_shader(be_Shader* shader) {
+    if (!shader) glUseProgram(0);
+    else glUseProgram(shader->handle);
+ }
 
 /*********************
  * Timer

bite.h

···
 typedef unsigned int be_u32;
 typedef unsigned long int be_u64;
 
+typedef struct {float x, y, w, h; } be_Rect;
+
 typedef struct be_Context be_Context;
 
 typedef struct be_Window be_Window;
···
 typedef struct be_Font be_Font;
 
 typedef void(*be_EventCallback)(be_Context*, be_Event*);
+
+#define BITE_TRUE  1
+#define BITE_FALSE 0
+
+#define BITE_OK 0
+#define BITE_ERROR -1
+
+#define BITE_RESULT int
+#define BITE_BOOL be_u8
 
 enum {
     BITE_NONE = 0,
···
     BITEK_LEFT
 };
 
+enum {
+    BITE_POINTS = 0,
+    BITE_LINES,
+    BITE_TRIANGLES
+};
+
 struct be_Event {
     int type;
     union {
···
 
 BITE_API void bite_register_callback(be_Context* ctx, int type, be_EventCallback callback);
 
-BITE_API int bite_should_close(be_Context* ctx);
+BITE_API BITE_BOOL bite_should_close(be_Context* ctx);
 BITE_API void bite_set_should_close(be_Context* ctx, int should_close);
 
 BITE_API void bite_poll_events(be_Context* ctx);
···
  * Render
  *********************/
 
+BITE_API be_Shader* bite_create_shader(const char* vert, const char* src);
+BITE_API void bite_destroy_shader(be_Shader* shader);
+
+BITE_API be_Texture* bite_create_texture(int w, int h, int format, void* data);
+BITE_API void bite_destroy_texture(be_Texture* texture);
+
+BITE_API be_Framebuffer* bite_create_framebuffer(void);
+BITE_API void bite_destroy_framebuffer(be_Framebuffer* fbo);
+BITE_API BITE_RESULT bite_framebuffer_attach_texture(be_Framebuffer* fbo, be_Texture* texture);
+
+BITE_API void bite_render_clear_color(float r, float g, float b, float a);
 BITE_API void bite_render_clear(void);
+
+BITE_API void bite_bind_framebuffer(be_Framebuffer* fbo);
+BITE_API void bite_bind_texture(be_Texture* tex);
+BITE_API void bite_use_shader(be_Shader* shader);
+
+BITE_API void bite_render_point(float x, float y);
+BITE_API void bite_render_line(float x0, float y0, float x1, float y1);
+BITE_API void bite_render_rect(be_Rect* rect);
+BITE_API void bite_render_rectangle(float x, float y, float w, float h);
+BITE_API void bite_render_circle(float x, float y, float radius);
+BITE_API void bite_render_triangle(float x0, float y0, float x1, float y1, float x2, float y2);
+
+BITE_API void bite_render_texture(be_Texture* tex, be_Rect* src, be_Rect* dest);
 
 /*********************
  * Timer

main.c

···
     // printf("Entering render function\n");
     be_Context* ctx = (be_Context*)data;
     bite_poll_events(ctx);
-    // glClearColor(0.3f, 0.4f, 0.4f, 1.f);
-    // glClear(GL_COLOR_BUFFER_BIT);
-    // glBegin(GL_TRIANGLES);
-    // glColor3f(1.f, 0.f, 0.f);
-    // glVertex2f(0.f, 0.5f);
-    // glColor3f(0.f, 1.f, 0.f);
-    // glVertex2f(-0.5f, -0.5f);
-    // glColor3f(0.f, 0.f, 1.f);
-    // glVertex2f(0.5f, -0.5f);
-    // glEnd();
     bite_simple_triangle();
     bite_swap(ctx);
 }