mirrors/Nuklear
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

converted buffer states to flags

Browse Source
This commit is contained in:
vurtun 2015-05-02 15:41:11 +02:00
parent 62981aba66
commit 3e051adc12
5 changed files with 95 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
demo/opengl.c
View File

@ -624,7 +624,7 @@ main(int argc, char *argv[])
memset(&in, 0, sizeof in);
memory.memory = calloc(MAX_MEMORY, 1);
memory.size = MAX_MEMORY;
gui_buffer_init_fixed(&buffer, &memory, GUI_CLIP);
gui_buffer_init_fixed(&buffer, &memory, GUI_BUFFER_CLIPPING);
font.userdata = glfont;
font.height = glfont->height;

87
demo/win32.c
View File

@ -104,8 +104,8 @@ font_new(HDC hdc, const char *name, int height)
XFont *font = malloc(sizeof(XFont));
font->height = height;
font->handle = CreateFont(height, 0, 0, 0, 0, FALSE, FALSE, FALSE,
ANSI_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,
ANTIALIASED_QUALITY, DEFAULT_PITCH, name);
ANSI_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,
ANTIALIASED_QUALITY, DEFAULT_PITCH, name);
old = SelectObject(hdc, font->handle);
GetTextMetrics(hdc, &metrics);
@ -305,12 +305,12 @@ draw(XSurface *surf, struct gui_command_list *list)
case GUI_COMMAND_RECT: {
struct gui_command_rect *r = (void*)cmd;
surface_draw_rect(surf, r->x, r->y, r->w, r->h,
r->color.r, r->color.g, r->color.b);
r->color.r, r->color.g, r->color.b);
} break;
case GUI_COMMAND_CIRCLE: {
struct gui_command_circle *c = (void*)cmd;
surface_draw_circle(surf, c->x, c->y, c->w, c->h,
c->color.r, c->color.g, c->color.b);
c->color.r, c->color.g, c->color.b);
} break;
case GUI_COMMAND_TRIANGLE: {
struct gui_command_triangle *t = (void*)cmd;
@ -319,7 +319,7 @@ draw(XSurface *surf, struct gui_command_list *list)
} break;
case GUI_COMMAND_TEXT: {
struct gui_command_text *t = (void*)cmd;
XWindow *xw = t->font;
XWindow *xw = t->font;
surface_draw_text(surf, xw->font, t->x, t->y, t->w, t->h, (const char*)t->string,
t->length, t->bg.r, t->bg.g, t->bg.b, t->fg.r, t->fg.g, t->fg.b);
} break;
@ -422,20 +422,19 @@ LRESULT CALLBACK
wnd_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_DESTROY:
PostQuitMessage(WM_QUIT);
running = 0;
quit = 1;
break;
case WM_SIZE:
if (xw.backbuffer) {
xw.width = LOWORD(lParam);
xw.height = HIWORD(lParam);
surface_resize(xw.backbuffer, xw.hdc, xw.width, xw.height);
}
break;
default:
return DefWindowProc(hWnd, msg, wParam, lParam);
case WM_DESTROY:
PostQuitMessage(WM_QUIT);
running = 0;
quit = 1;
break;
case WM_SIZE:
if (xw.backbuffer) {
xw.width = LOWORD(lParam);
xw.height = HIWORD(lParam);
surface_resize(xw.backbuffer, xw.hdc, xw.width, xw.height);
} break;
default:
return DefWindowProc(hWnd, msg, wParam, lParam);
}
return 0;
}
@ -468,11 +467,11 @@ WinMain(HINSTANCE hInstance, HINSTANCE prev, LPSTR lpCmdLine, int show)
xw.wc.lpszClassName = "GUI";
RegisterClass(&xw.wc);
xw.hWnd = CreateWindowEx(
0, xw.wc.lpszClassName, "Demo",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
0, 0, hInstance, 0);
0, xw.wc.lpszClassName, "Demo",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
0, 0, hInstance, 0);
xw.hdc = GetDC(xw.hWnd);
GetClientRect(xw.hWnd, &xw.rect);
@ -485,7 +484,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE prev, LPSTR lpCmdLine, int show)
memset(&in, 0, sizeof in);
memory.memory = calloc(MAX_MEMORY, 1);
memory.size = MAX_MEMORY;
gui_buffer_init_fixed(&buffer, &memory, GUI_CLIP);
gui_buffer_init_fixed(&buffer, &memory, GUI_BUFFER_CLIPPING);
font.userdata = &xw;
font.height = (gui_float)xw.font->height;
@ -505,37 +504,37 @@ WinMain(HINSTANCE hInstance, HINSTANCE prev, LPSTR lpCmdLine, int show)
while (running && !quit) {
/* Input */
MSG msg;
start = timestamp(freq);
MSG msg;
start = timestamp(freq);
gui_input_begin(&in);
while (PeekMessage(&msg, xw.hWnd, 0, 0, PM_REMOVE)) {
if (msg.message == WM_KEYDOWN) key(&in, &msg, gui_true);
else if (msg.message == WM_KEYUP) key(&in, &msg, gui_false);
else if (msg.message == WM_LBUTTONDOWN) btn(&in, &msg, gui_true);
else if (msg.message == WM_LBUTTONUP) btn(&in, &msg, gui_false);
else if (msg.message == WM_MOUSEMOVE) motion(&in, &msg);
else if (msg.message == WM_CHAR) text(&in, &msg);
while (PeekMessage(&msg, xw.hWnd, 0, 0, PM_REMOVE)) {
if (msg.message == WM_KEYDOWN) key(&in, &msg, gui_true);
else if (msg.message == WM_KEYUP) key(&in, &msg, gui_false);
else if (msg.message == WM_LBUTTONDOWN) btn(&in, &msg, gui_true);
else if (msg.message == WM_LBUTTONUP) btn(&in, &msg, gui_false);
else if (msg.message == WM_MOUSEMOVE) motion(&in, &msg);
else if (msg.message == WM_CHAR) text(&in, &msg);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
DispatchMessage(&msg);
}
gui_input_end(&in);
/* GUI */
/* GUI */
gui_buffer_begin(&canvas, &buffer, xw.width, xw.height);
running = gui_panel_begin(&layout, &panel, "Demo", &canvas, &in);
demo_panel(&layout, &demo);
gui_panel_end(&layout, &panel);
gui_buffer_end(&list, &buffer, &canvas, &status);
/* Draw */
surface_begin(xw.backbuffer);
surface_clear(xw.backbuffer, 255, 255, 255);
draw(xw.backbuffer, &list);
surface_end(xw.backbuffer, xw.hdc);
/* Draw */
surface_begin(xw.backbuffer);
surface_clear(xw.backbuffer, 255, 255, 255);
draw(xw.backbuffer, &list);
surface_end(xw.backbuffer, xw.hdc);
/* Timing */
dt = timestamp(freq) - start;
if (dt < DTIME) Sleep(DTIME - dt);
dt = timestamp(freq) - start;
if (dt < DTIME) Sleep(DTIME - dt);
}
font_del(xw.font);

2
demo/xlib.c
View File

@ -511,7 +511,7 @@ main(int argc, char *argv[])
memset(&in, 0, sizeof in);
memory.memory = calloc(MAX_MEMORY, 1);
memory.size = MAX_MEMORY;
gui_buffer_init_fixed(&buffer, &memory, GUI_CLIP);
gui_buffer_init_fixed(&buffer, &memory, GUI_BUFFER_CLIPPING);
font.userdata = xw.font;
font.height = (gui_float)xw.font->height;

84
gui.c
View File

@ -827,9 +827,8 @@ gui_buffer_push(struct gui_command_buffer* buffer,
void *tail;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return NULL;
if (!buffer) return NULL;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return NULL;
buffer->needed += size;
unaligned = (gui_byte*)buffer->end + size;
@ -862,8 +861,8 @@ gui_buffer_push_scissor(struct gui_command_buffer *buffer, gui_float x, gui_floa
{
struct gui_command_scissor *cmd;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return;
cmd = gui_buffer_push(buffer, GUI_COMMAND_SCISSOR, sizeof(*cmd));
if (!cmd) return;
@ -885,10 +884,10 @@ gui_buffer_push_line(struct gui_command_buffer *buffer, gui_float x0, gui_float
{
struct gui_command_line *cmd;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return;
if (buffer->clipping == GUI_CLIP) {
if (buffer->flags & GUI_BUFFER_CLIPPING) {
const struct gui_rect *r = &buffer->clip;
if (!INBOX(x0, y0, r->x, r->y, r->w, r->h) &&
(!INBOX(x1, y1, r->x, r->y, r->w, r->h))) {
@ -911,10 +910,10 @@ gui_buffer_push_rect(struct gui_command_buffer *buffer, gui_float x, gui_float y
{
struct gui_command_rect *cmd;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return;
if (buffer->clipping == GUI_CLIP) {
if (buffer->flags & GUI_BUFFER_CLIPPING) {
const struct gui_rect *r = &buffer->clip;
if (!INTERSECT(r->x, r->y, r->w, r->h, x, y, w, h)) {
buffer->clipped_memory += sizeof(*cmd);
@ -937,10 +936,10 @@ gui_buffer_push_circle(struct gui_command_buffer *buffer, gui_float x, gui_float
{
struct gui_command_circle *cmd;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return;
if (buffer->clipping == GUI_CLIP) {
if (buffer->flags & GUI_BUFFER_CLIPPING) {
const struct gui_rect *r = &buffer->clip;
if (!INTERSECT(r->x, r->y, r->w, r->h, x, y, w, h)) {
buffer->clipped_memory += sizeof(*cmd);
@ -964,10 +963,10 @@ gui_buffer_push_triangle(struct gui_command_buffer *buffer, gui_float x0, gui_fl
{
struct gui_command_triangle *cmd;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return;
if (buffer->clipping == GUI_CLIP) {
if (buffer->flags & GUI_BUFFER_CLIPPING) {
const struct gui_rect *r = &buffer->clip;
if (!INBOX(x0, y0, r->x, r->y, r->w, r->h) &&
!INBOX(x1, y1, r->x, r->y, r->w, r->h) &&
@ -994,10 +993,10 @@ gui_buffer_push_image(struct gui_command_buffer *buffer, gui_float x, gui_float
{
struct gui_command_image *cmd;
assert(buffer);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || buffer->state == GUI_BUFFER_LOCKED) return;
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || buffer->flags & GUI_BUFFER_LOCKED) return;
if (buffer->clipping == GUI_CLIP) {
if (buffer->flags == GUI_BUFFER_CLIPPING) {
const struct gui_rect *r = &buffer->clip;
if (!INTERSECT(r->x, r->y, r->w, r->h, x, y, w, h)) {
buffer->clipped_memory += sizeof(*cmd);
@ -1022,11 +1021,11 @@ gui_buffer_push_text(struct gui_command_buffer *buffer, gui_float x, gui_float y
struct gui_command_text *cmd;
assert(buffer);
assert(font);
assert(buffer->state != GUI_BUFFER_LOCKED);
assert(!(buffer->flags & GUI_BUFFER_LOCKED));
if (!buffer || !string || !length) return;
if (buffer->state == GUI_BUFFER_LOCKED) return;
if (buffer->flags & GUI_BUFFER_LOCKED) return;
if (buffer->clipping == GUI_CLIP) {
if (buffer->flags & GUI_BUFFER_CLIPPING) {
const struct gui_rect *r = &buffer->clip;
if (!INTERSECT(r->x, r->y, r->w, r->h, x, y, w, h)) {
buffer->clipped_memory += sizeof(*cmd);
@ -1050,27 +1049,26 @@ gui_buffer_push_text(struct gui_command_buffer *buffer, gui_float x, gui_float y
void
gui_buffer_init_fixed(struct gui_command_buffer *buffer, const struct gui_memory *memory,
enum gui_clipping clipping)
gui_flags clipping)
{
assert(buffer);
assert(memory);
if (!buffer || !memory) return;
zero(buffer, sizeof(*buffer));
buffer->type = GUI_BUFFER_OWNER;
buffer->state = GUI_BUFFER_ACTIVE;
buffer->flags = GUI_BUFFER_OWNER;
if (clipping) buffer->flags |= GUI_BUFFER_CLIPPING;
buffer->memory = memory->memory;
buffer->capacity = memory->size;
buffer->begin = buffer->memory;
buffer->end = buffer->begin;
buffer->clipping = clipping;
buffer->clip = null_rect;
buffer->grow_factor = 0;
}
void
gui_buffer_init(struct gui_command_buffer *buffer, const struct gui_allocator *memory,
gui_size initial_size, gui_float grow_factor, enum gui_clipping clipping)
gui_size initial_size, gui_float grow_factor, gui_flags clipping)
{
assert(buffer);
assert(memory);
@ -1078,8 +1076,8 @@ gui_buffer_init(struct gui_command_buffer *buffer, const struct gui_allocator *m
if (!buffer || !memory || !initial_size) return;
zero(buffer, sizeof(*buffer));
buffer->type = GUI_BUFFER_OWNER;
buffer->state = GUI_BUFFER_ACTIVE;
buffer->flags = GUI_BUFFER_OWNER;
if (clipping) buffer->flags |= GUI_BUFFER_CLIPPING;
buffer->memory = memory->alloc(memory->userdata, initial_size);
buffer->allocator = *memory;
buffer->capacity = initial_size;
@ -1087,26 +1085,24 @@ gui_buffer_init(struct gui_command_buffer *buffer, const struct gui_allocator *m
buffer->end = buffer->begin;
buffer->grow_factor = grow_factor;
buffer->clip = null_rect;
buffer->clipping = clipping;
}
void
gui_buffer_lock(struct gui_command_buffer *buffer, struct gui_command_buffer *sub,
enum gui_clipping clipping)
gui_flags clipping)
{
assert(buffer);
assert(sub);
assert(buffer->state != GUI_BUFFER_LOCKED);
if (!buffer || !sub || buffer->state == GUI_BUFFER_LOCKED) return;
assert(buffer->flags & GUI_BUFFER_LOCKED);
if (!buffer || !sub || !(buffer->flags & GUI_BUFFER_LOCKED)) return;
buffer->state = GUI_BUFFER_LOCKED;
sub->type = GUI_BUFFER_SUB;
sub->state = GUI_BUFFER_ACTIVE;
buffer->flags |= GUI_BUFFER_LOCKED;
sub->flags = GUI_BUFFER_DEFAULT;
if (clipping) sub->flags |= GUI_BUFFER_CLIPPING;
sub->memory = buffer->memory;
sub->allocator = buffer->allocator;
sub->begin = buffer->end;
sub->end = sub->begin;
sub->clipping = clipping;
sub->grow_factor = buffer->grow_factor;
sub->allocated = buffer->allocated;
sub->capacity = buffer->capacity;
@ -1122,7 +1118,7 @@ gui_buffer_unlock(struct gui_command_buffer *buffer, struct gui_command_buffer *
assert(buffer);
assert(sub);
if (!buffer || !sub) return;
buffer->state = GUI_BUFFER_ACTIVE;
buffer->flags &= (gui_flags)~GUI_BUFFER_LOCKED;
buffer->memory = sub->memory;
buffer->end = sub->end;
buffer->allocated = sub->allocated;
@ -1130,7 +1126,7 @@ gui_buffer_unlock(struct gui_command_buffer *buffer, struct gui_command_buffer *
buffer->count += sub->count;
buffer->needed += sub->needed;
zero(sub, sizeof(*sub));
sub->state = GUI_BUFFER_LOCKED;
sub->flags = GUI_BUFFER_LOCKED;
}
void
@ -1162,9 +1158,9 @@ gui_buffer_end(struct gui_command_list *list, struct gui_command_buffer *buffer,
assert(canvas);
if (!buffer || !canvas) return;
if (status) {
status->allocated = (buffer->type == GUI_BUFFER_SUB) ?
status->allocated = (!(buffer->flags & GUI_BUFFER_OWNER)) ?
buffer->allocated - buffer->sub_size: buffer->allocated;
status->size = (buffer->type == GUI_BUFFER_SUB) ?
status->size = (!(buffer->flags & GUI_BUFFER_OWNER)) ?
buffer->capacity - buffer->sub_cap: buffer->capacity;
status->needed = buffer->needed;
status->clipped_commands = buffer->clipped_cmds;
@ -1191,8 +1187,8 @@ gui_buffer_clear(struct gui_command_buffer *buffer)
{
assert(buffer);
if (!buffer || !buffer->memory || !buffer->allocator.free) return;
if (buffer->type != GUI_BUFFER_OWNER) return;
if (buffer->state == GUI_BUFFER_LOCKED) return;
if (!(buffer->flags & GUI_BUFFER_OWNER)) return;
if (buffer->flags & GUI_BUFFER_LOCKED) return;
buffer->allocator.free(buffer->allocator.userdata, buffer->memory);
}

30
gui.h
View File

@ -281,30 +281,20 @@ struct gui_command_text {
gui_char string[1];
};
enum gui_clipping {
GUI_NO_CLIP,
GUI_CLIP
};
enum gui_buffer_type {
GUI_BUFFER_OWNER,
GUI_BUFFER_SUB
};
enum gui_buffer_state {
GUI_BUFFER_ACTIVE,
GUI_BUFFER_LOCKED,
enum gui_buffer_flags {
GUI_BUFFER_DEFAULT = 0,
GUI_BUFFER_CLIPPING = 0x01,
GUI_BUFFER_OWNER = 0x02,
GUI_BUFFER_LOCKED = 0x04
};
struct gui_command_buffer {
void *memory;
enum gui_buffer_type type;
enum gui_buffer_state state;
gui_flags flags;
struct gui_allocator allocator;
struct gui_command *begin;
struct gui_command *end;
struct gui_rect clip;
enum gui_clipping clipping;
gui_size clipped_cmds;
gui_size clipped_memory;
gui_float grow_factor;
@ -439,14 +429,14 @@ void gui_input_end(struct gui_input*);
/* Buffer */
void gui_buffer_init(struct gui_command_buffer*, const struct gui_allocator*,
gui_size initial_size, gui_float grow_factor, enum gui_clipping);
gui_size initial_size, gui_float grow_factor, gui_flag clipping);
void gui_buffer_init_fixed(struct gui_command_buffer*, const struct gui_memory*,
enum gui_clipping);
gui_flag clipping);
void gui_buffer_begin(struct gui_canvas *canvas, struct gui_command_buffer *buffer,
gui_size width, gui_size height);
void gui_buffer_lock(struct gui_command_buffer *buffer, struct gui_command_buffer *sub,
enum gui_clipping clipping)
void gui_buffer_unlock(struct gui_command_buffer *buf, struct gui_command_buffer *sub)
gui_flag clipping);
void gui_buffer_unlock(struct gui_command_buffer *buf, struct gui_command_buffer *sub);
void *gui_buffer_push(struct gui_command_buffer*,
enum gui_command_type, gui_size size);
void gui_buffer_push_scissor(struct gui_command_buffer*, gui_float, gui_float,