X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=otk%2Ftruerendercontrol.cc;h=05a1d676775d6ef03dbf5723c0ae6245dcb37463;hb=bf24a3b7fcf8235a272a86c1e81e902aba2304d6;hp=95b629b1fc697aa700341f3584b3f18385d84f46;hpb=5b52a8f5610d3cc0a39ecb6b341e69596d892099;p=chaz%2Fopenbox diff --git a/otk/truerendercontrol.cc b/otk/truerendercontrol.cc index 95b629b1..05a1d676 100644 --- a/otk/truerendercontrol.cc +++ b/otk/truerendercontrol.cc @@ -7,6 +7,8 @@ #include "truerendercontrol.hh" #include "display.hh" #include "screeninfo.hh" +#include "surface.hh" +#include "rendertexture.hh" extern "C" { #ifdef HAVE_STDLIB_H @@ -19,35 +21,30 @@ extern "C" { namespace otk { -TrueRenderControl::TrueRenderControl(const ScreenInfo *screen) - : RenderControl(screen) +TrueRenderControl::TrueRenderControl(int screen) + : RenderControl(screen), + _red_offset(0), + _green_offset(0), + _blue_offset(0) { printf("Initializing TrueColor RenderControl\n"); + Visual *visual = display->screenInfo(_screen)->visual(); unsigned long red_mask, green_mask, blue_mask; // find the offsets for each color in the visual's masks - red_mask = screen->visual()->red_mask; - green_mask = screen->visual()->green_mask; - blue_mask = screen->visual()->blue_mask; + red_mask = visual->red_mask; + green_mask = visual->green_mask; + blue_mask = visual->blue_mask; - while (! (red_mask & 1)) { _red_offset++; red_mask >>= 1; } + while (! (red_mask & 1)) { _red_offset++; red_mask >>= 1; } while (! (green_mask & 1)) { _green_offset++; green_mask >>= 1; } - while (! (blue_mask & 1)) { _blue_offset++; blue_mask >>= 1; } - - // use the mask to determine the number of bits for each shade of color - // so, best case, red_mask == 0xff (255), with each bit as a different - // shade! - _red_bits = 255 / red_mask; - _green_bits = 255 / green_mask; - _blue_bits = 255 / blue_mask; - - // compute color tables, based on the number of bits for each shade - for (int i = 0; i < 256; i++) { - _red_color_table[i] = i / _red_bits; - _green_color_table[i] = i / _green_bits; - _blue_color_table[i] = i / _blue_bits; - } + while (! (blue_mask & 1)) { _blue_offset++; blue_mask >>= 1; } + + _red_shift = _green_shift = _blue_shift = 8; + while (red_mask) { red_mask >>= 1; _red_shift--; } + while (green_mask) { green_mask >>= 1; _green_shift--; } + while (blue_mask) { blue_mask >>= 1; _blue_shift--; } } TrueRenderControl::~TrueRenderControl() @@ -57,59 +54,12 @@ TrueRenderControl::~TrueRenderControl() } -static inline -void assignPixel(unsigned int bit_depth, unsigned char **data, unsigned long pixel) { - unsigned char *pixel_data = *data; - switch (bit_depth) { - case 8: // 8bpp - *pixel_data++ = pixel; - break; - - case 16: // 16bpp LSB - *pixel_data++ = pixel; - *pixel_data++ = pixel >> 8; - break; - - case 17: // 16bpp MSB - *pixel_data++ = pixel >> 8; - *pixel_data++ = pixel; - break; - - case 24: // 24bpp LSB - *pixel_data++ = pixel; - *pixel_data++ = pixel >> 8; - *pixel_data++ = pixel >> 16; - break; - - case 25: // 24bpp MSB - *pixel_data++ = pixel >> 16; - *pixel_data++ = pixel >> 8; - *pixel_data++ = pixel; - break; - - case 32: // 32bpp LSB - *pixel_data++ = pixel; - *pixel_data++ = pixel >> 8; - *pixel_data++ = pixel >> 16; - *pixel_data++ = pixel >> 24; - break; - case 33: // 32bpp MSB - *pixel_data++ = pixel >> 24; - *pixel_data++ = pixel >> 16; - *pixel_data++ = pixel >> 8; - *pixel_data++ = pixel; - break; - } - *data = pixel_data; // assign back so we don't lose our place -} - -void renderPixel(XImage *im, unsigned char *dp, unsigned long pixel) +static inline void renderPixel(XImage *im, unsigned char *dp, + unsigned long pixel) { - unsigned int bpp = im->bits_per_pixel + (im->byte_order == MSBFirst) ? 1 : 0; + unsigned int bpp = im->bits_per_pixel + (im->byte_order == MSBFirst ? 1 : 0); - printf("%lx \n", pixel); - switch (bpp) { case 8: // 8bpp *dp++ = pixel; @@ -144,53 +94,66 @@ void renderPixel(XImage *im, unsigned char *dp, unsigned long pixel) *dp++ = pixel >> 8; *dp++ = pixel; break; + default: + assert(false); // wtf? } } -void TrueRenderControl::render(::Drawable d) +void TrueRenderControl::drawGradientBackground( + Surface &sf, const RenderTexture &texture) const { - XGCValues gcv; - gcv.cap_style = CapProjecting; - - int w = 255, h = 32; - Pixmap p = XCreatePixmap(**display, d, w, h, _screen->depth()); - XImage *im = XCreateImage(**display, _screen->visual(), _screen->depth(), - ZPixmap, 0, NULL, w, h, 32, 0); - //GC gc = XCreateGC(**display, _screen->rootWindow(), GCCapStyle, &gcv); - - // XXX + 1? - unsigned char *data = new unsigned char[im->bytes_per_line * (h + 1)]; - unsigned char *dp = data; - - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, 0); - for (int y = 0; y < 10; ++y) - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, _red_color_table[x] << _red_offset); - for (int y = 0; y < 10; ++y) - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, _green_color_table[x] << _green_offset); - for (int y = 0; y < 10; ++y) - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, _blue_color_table[x] << _blue_offset); - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, 0); - - printf("\nDone\n"); - - im->data = (char*) data; - - XPutImage(**display, p, DefaultGC(**display, _screen->screen()), - im, 0, 0, 0, 0, w, h); + int w = sf.width(), h = sf.height(); - //delete [] image->data; - //image->data = NULL; - XDestroyImage(im); + const ScreenInfo *info = display->screenInfo(_screen); + XImage *im = XCreateImage(**display, info->visual(), info->depth(), + ZPixmap, 0, NULL, w, h, 32, 0); + + pixel32 *data = new pixel32[sf.height()*sf.width()]; + pixel32 current; + pixel32 *dp = data; + float dr, dg, db; + unsigned int r,g,b; + + dr = (float)(texture.secondary_color().red() - texture.color().red()); + dr/= (float)sf.height(); + + dg = (float)(texture.secondary_color().green() - texture.color().green()); + dg/= (float)sf.height(); + + db = (float)(texture.secondary_color().blue() - texture.color().blue()); + db/= (float)sf.height(); + + for (int y = 0; y < h; ++y) { + r = texture.color().red() + (int)(dr * y); + g = texture.color().green() + (int)(dg * y); + b = texture.color().blue() + (int)(db * y); + current = (r << 16) + + (g << 8) + + b; + for (int x = 0; x < w; ++x, dp ++) + *dp = current; + } + + im->data = (char*) data; + + sf.setPixmap(im); + + delete [] im->data; + im->data = NULL; + XDestroyImage(im); +} - XCopyArea(**display, p, d, DefaultGC(**display, _screen->screen()), - 0, 0, w, h, 0, 0); +void TrueRenderControl::drawBackground(Surface& sf, + const RenderTexture &texture) const +{ + assert(_screen == sf._screen); + assert(_screen == texture.color().screen()); - XFreePixmap(**display, p); + if (texture.gradient() == RenderTexture::Solid) { + drawSolidBackground(sf, texture); + } else { + drawGradientBackground(sf, texture); + } } }