X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=render%2Frender.c;h=712ed7fbaf243714888ef319e238962eded4f26a;hb=f827fbcaee822a0ef7d573edeb551bf2c1865aac;hp=a1022bd0594fddaec218b7d3accbd0dcf8acc383;hpb=993fc6226d06f25513756251283e70054082ee8a;p=chaz%2Fopenbox diff --git a/render/render.c b/render/render.c index a1022bd0..712ed7fb 100644 --- a/render/render.c +++ b/render/render.c @@ -1,5 +1,10 @@ #include #include + +#ifdef USE_GL +# include +#endif + #include #include "render.h" #include "gradient.h" @@ -15,52 +20,117 @@ #endif int render_depth; +XVisualInfo render_visual_info; + Visual *render_visual; Colormap render_colormap; + int render_red_offset = 0, render_green_offset = 0, render_blue_offset = 0; int render_red_shift, render_green_shift, render_blue_shift; +int render_red_mask, render_green_mask, render_blue_mask; + + +#ifdef USE_GL + +GLXContext render_glx_context; + +int render_glx_rating(XVisualInfo *v) +{ + int er; + int rating = 0; + int val; + printf("evaluating visual %d\n", v->visualid); + glXGetConfig(ob_display, v, GLX_BUFFER_SIZE, &val); + printf("buffer size %d\n", val); + + switch (val) { + case 32: + rating += 300; + break; + case 24: + rating += 200; + break; + case 16: + rating += 100; + break; + } + + glXGetConfig(ob_display, v, GLX_LEVEL, &val); + printf("level %d\n", val); + if (val != 0) + rating = -10000; + + glXGetConfig(ob_display, v, GLX_DEPTH_SIZE, &val); + printf("depth size %d\n", val); + switch (val) { + case 32: + rating += 30; + break; + case 24: + rating += 20; + break; + case 16: + rating += 10; + break; + case 0: + rating -= 10000; + } + + glXGetConfig(ob_display, v, GLX_DOUBLEBUFFER, &val); + printf("double buffer %d\n", val); + if (val) + rating++; + return rating; +} +#endif /* USE_GL */ void render_startup(void) { + int count, i = 0, val, best = 0, rate = 0, temp; + XVisualInfo vimatch, *vilist; paint = x_paint; render_depth = DefaultDepth(ob_display, ob_screen); render_visual = DefaultVisual(ob_display, ob_screen); render_colormap = DefaultColormap(ob_display, ob_screen); - if (render_depth < 8) { - XVisualInfo vinfo_template, *vinfo_return; - /* search for a TrueColor Visual... if we can't find one... - we will use the default visual for the screen */ - int vinfo_nitems; - int best = -1; - - vinfo_template.screen = ob_screen; - vinfo_template.class = TrueColor; - vinfo_return = XGetVisualInfo(ob_display, - VisualScreenMask | VisualClassMask, - &vinfo_template, &vinfo_nitems); - if (vinfo_return) { - int i; - int max_depth = 1; - for (i = 0; i < vinfo_nitems; ++i) { - if (vinfo_return[i].depth > max_depth) { - if (max_depth == 24 && vinfo_return[i].depth > 24) - break; /* prefer 24 bit over 32 */ - max_depth = vinfo_return[i].depth; - best = i; - } +#ifdef USE_GL + vimatch.screen = ob_screen; + vimatch.class = TrueColor; + vilist = XGetVisualInfo(ob_display, VisualScreenMask | VisualClassMask, + &vimatch, &count); + + if (vilist) { + printf("looking for a GL visualin %d visuals\n", count); + for (i = 0; i < count; i++) { + glXGetConfig(ob_display, &vilist[i], GLX_USE_GL, &val); + if (val) { + temp = render_glx_rating(&vilist[i]); + if (temp > rate) { + best = i; + rate = temp; + } + } } - if (max_depth < render_depth) best = -1; - } - if (best != -1) { - render_depth = vinfo_return[best].depth; - render_visual = vinfo_return[best].visual; - render_colormap = XCreateColormap(ob_display, ob_root, render_visual, - AllocNone); - } - XFree(vinfo_return); - } + } + if (rate > 0) { + printf("picked visual %d with rating %d\n", best, rate); + render_depth = vilist[best].depth; + render_visual = vilist[best].visual; + render_colormap = XCreateColormap(ob_display, ob_root, + render_visual, AllocNone); + render_visual_info = vilist[best]; + render_glx_context = glXCreateContext(ob_display, &render_visual_info, + NULL, True); + if (render_glx_context == NULL) + printf("sadness\n"); + else { + paint = gl_paint; + } + } +#endif /*USE_GL*/ + + switch (render_visual->class) { case TrueColor: truecolor_startup(); @@ -87,9 +157,9 @@ void truecolor_startup(void) ZPixmap, 0, NULL, 1, 1, 32, 0); g_assert(timage != NULL); /* find the offsets for each color in the visual's masks */ - red_mask = timage->red_mask; - green_mask = timage->green_mask; - blue_mask = timage->blue_mask; + render_red_mask = red_mask = timage->red_mask; + render_green_mask = green_mask = timage->green_mask; + render_blue_mask = blue_mask = timage->blue_mask; render_red_offset = 0; render_green_offset = 0; @@ -117,7 +187,7 @@ void pseudocolor_startup(void) /* determine the number of colors and the bits-per-color */ pseudo_bpc = 2; /* XXX THIS SHOULD BE A USER OPTION */ g_assert(pseudo_bpc >= 1); - _ncolors = 1 << (pseudo_bpc * 3); + _ncolors = pseudo_ncolors(); if (_ncolors > 1 << render_depth) { g_warning("PseudoRenderControl: Invalid colormap size. Resizing.\n"); @@ -300,13 +370,6 @@ void x_paint(Window win, Appearance *l) if (oldp != None) XFreePixmap(ob_display, oldp); } -/* -void gl_paint(Window win, Appearance *l) -{ - glXMakeCurrent(ob_display, win, gl_context); -} -*/ - void render_shutdown(void) { } @@ -330,6 +393,8 @@ Appearance *appearance_new(SurfaceType type, int numtex) p->primary = NULL; p->secondary = NULL; p->border_color = NULL; + p->bevel_dark = NULL; + p->bevel_light = NULL; p->pixel_data = NULL; break; } @@ -366,6 +431,18 @@ Appearance *appearance_copy(Appearance *orig) spo->border_color->b); else spc->border_color = NULL; + if (spo->bevel_dark != NULL) + spc->bevel_dark = color_new(spo->bevel_dark->r, + spo->bevel_dark->g, + spo->bevel_dark->b); + else spc->bevel_dark = NULL; + + if (spo->bevel_light != NULL) + spc->bevel_light = color_new(spo->bevel_light->r, + spo->bevel_light->g, + spo->bevel_light->b); + else spc->bevel_light = NULL; + spc->interlaced = spo->interlaced; spc->border = spo->border; spc->pixel_data = NULL; @@ -388,10 +465,12 @@ void appearance_free(Appearance *a) g_free(a->texture); if (a->surface.type == Surface_Planar) { p = &a->surface.data.planar; - if (p->primary != NULL) color_free(p->primary); - if (p->secondary != NULL) color_free(p->secondary); - if (p->border_color != NULL) color_free(p->border_color); - if (p->pixel_data != NULL) g_free(p->pixel_data); + color_free(p->primary); + color_free(p->secondary); + color_free(p->border_color); + color_free(p->bevel_dark); + color_free(p->bevel_light); + g_free(p->pixel_data); } g_free(a); } @@ -400,23 +479,23 @@ void appearance_free(Appearance *a) void pixel32_to_pixmap(pixel32 *in, Pixmap out, int x, int y, int w, int h) { - unsigned char *scratch; + pixel32 *scratch; XImage *im = NULL; im = XCreateImage(ob_display, render_visual, render_depth, ZPixmap, 0, NULL, w, h, 32, 0); g_assert(im != NULL); - im->byte_order = endian; + im->byte_order = render_endian; /* this malloc is a complete waste of time on normal 32bpp as reduce_depth just sets im->data = data and returns */ - scratch = malloc(im->width * im->height * sizeof(pixel32)); + scratch = g_new(pixel32, im->width * im->height); im->data = (char*) scratch; reduce_depth(in, im); XPutImage(ob_display, out, DefaultGC(ob_display, ob_screen), im, 0, 0, x, y, w, h); im->data = NULL; XDestroyImage(im); - free(scratch); + g_free(scratch); } void appearance_minsize(Appearance *l, int *w, int *h) @@ -468,9 +547,101 @@ void appearance_minsize(Appearance *l, int *w, int *h) } } -void render_pixmap_to_rgba(Pixmap pmap, Pixmap mask, - int *w, int *h, gulong **data) +gboolean render_pixmap_to_rgba(Pixmap pmap, Pixmap mask, + int *w, int *h, pixel32 **data) +{ + Window xr; + int xx, xy; + guint pw, ph, mw, mh, xb, xd, i, x, y, di; + XImage *xi, *xm = NULL; + + if (!XGetGeometry(ob_display, pmap, &xr, &xx, &xy, &pw, &ph, &xb, &xd)) + return FALSE; + if (mask) { + if (!XGetGeometry(ob_display, mask, &xr, &xx, &xy, &mw, &mh, &xb, &xd)) + return FALSE; + if (pw != mw || ph != mh || xd != 1) + return FALSE; + } + + xi = XGetImage(ob_display, pmap, 0, 0, pw, ph, 0xffffffff, ZPixmap); + if (!xi) + return FALSE; + + if (mask) { + xm = XGetImage(ob_display, mask, 0, 0, mw, mh, 0xffffffff, ZPixmap); + if (!xm) + return FALSE; + } + + *data = g_new(pixel32, pw * ph); + increase_depth(*data, xi); + + if (mask) { + /* apply transparency from the mask */ + di = 0; + for (i = 0, y = 0; y < ph; ++y) { + for (x = 0; x < pw; ++x, ++i) { + if (!((((unsigned)xm->data[di + x / 8]) >> (x % 8)) & 0x1)) + (*data)[i] &= ~(0xff << default_alpha_offset); + } + di += xm->bytes_per_line; + } + } + + *w = pw; + *h = ph; + + return TRUE; +} + +#ifdef USE_GL +void gl_paint(Window win, Appearance *l) { - *w = *h = 0; - *data = NULL; + int err; + Window root, child; + int i, transferred = 0, sw, b, d; + pixel32 *source, *dest; + Pixmap oldp; + int tempx, tempy, absx, absy, absw, absh; + int x = l->area.x; + int y = l->area.y; + int w = l->area.width; + int h = l->area.height; + Rect tarea; /* area in which to draw textures */ + if (w <= 0 || h <= 0 || x+w <= 0 || y+h <= 0) return; + + g_assert(l->surface.type == Surface_Planar); + +printf("making %p, %p, %p current\n", ob_display, win, render_glx_context); + err = glXMakeCurrent(ob_display, win, render_glx_context); +g_assert(err != 0); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, 1376, 1032, 0, 0, 10); + if (XGetGeometry(ob_display, win, &root, &tempx, &tempy, + &absw, &absh, &b, &d) && + XTranslateCoordinates(ob_display, win, root, tempx, tempy, + &absx, &absy, &child)) + printf("window at %d, %d (%d,%d)\n", absx, absy, absw, absh); + else + return; + + glViewport(0, 0, 1376, 1032); + glMatrixMode(GL_MODELVIEW); + glTranslatef(-absx, 1032-absh-absy, 0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + + if (l->surface.data.planar.grad == Background_ParentRelative) { + printf("crap\n"); + } else + render_gl_gradient(&l->surface, absx+x, absy+y, absw, absh); + + glXSwapBuffers(ob_display, win); } + +#endif /* USE_GL */