X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=otk%2Ftruerendercontrol.cc;h=1d5b8dc44bc37b3e327a699e3fda5a89c54aebaa;hb=0ebf6a17547f75c1fa961acbf3fdd59c0e494d22;hp=95a0a41650ca56e4d0bda2dd12f098e948d9d718;hpb=9f705c02b9c412c053fc12a2ebdc5cebe83400c8;p=chaz%2Fopenbox diff --git a/otk/truerendercontrol.cc b/otk/truerendercontrol.cc index 95a0a416..1d5b8dc4 100644 --- a/otk/truerendercontrol.cc +++ b/otk/truerendercontrol.cc @@ -1,26 +1,25 @@ // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*- -#ifdef HAVE_CONFIG_H -# include "../config.h" -#endif // HAVE_CONFIG_H +#include "config.h" #include "truerendercontrol.hh" #include "display.hh" #include "screeninfo.hh" #include "surface.hh" +#include "rendertexture.hh" extern "C" { #ifdef HAVE_STDLIB_H # include #endif // HAVE_STDLIB_H -#include "gettext.h" +#include "../src/gettext.h" #define _(str) gettext(str) } namespace otk { -TrueRenderControl::TrueRenderControl(const ScreenInfo *screen) +TrueRenderControl::TrueRenderControl(int screen) : RenderControl(screen), _red_offset(0), _green_offset(0), @@ -28,115 +27,76 @@ TrueRenderControl::TrueRenderControl(const ScreenInfo *screen) { printf("Initializing TrueColor RenderControl\n"); + const ScreenInfo *info = display->screenInfo(_screen); + XImage *timage = XCreateImage(**display, info->visual(), info->depth(), + ZPixmap, 0, NULL, 1, 1, 32, 0); + 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 = timage->red_mask; + green_mask = timage->green_mask; + blue_mask = timage->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; } - - // scale available colorspace to match our 256x256x256 cube - _red_bits = 255 / red_mask; - _green_bits = 255 / green_mask; - _blue_bits = 255 / blue_mask; + while (! (blue_mask & 1)) { _blue_offset++; blue_mask >>= 1; } - 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; - } + _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--; } + XFree(timage); } TrueRenderControl::~TrueRenderControl() { printf("Destroying TrueColor RenderControl\n"); - - } -static inline void renderPixel(XImage *im, unsigned char *dp, - unsigned long pixel) +void TrueRenderControl::reduceDepth(Surface &sf, XImage *im) const { - unsigned int bpp = im->bits_per_pixel + (im->byte_order == MSBFirst ? 1 : 0); - - switch (bpp) { - case 8: // 8bpp - *dp++ = pixel; - break; - case 16: // 16bpp LSB - *dp++ = pixel; - *dp++ = pixel >> 8; - break; - case 17: // 16bpp MSB - *dp++ = pixel >> 8; - *dp++ = pixel; - break; - case 24: // 24bpp LSB - *dp++ = pixel; - *dp++ = pixel >> 8; - *dp++ = pixel >> 16; - break; - case 25: // 24bpp MSB - *dp++ = pixel >> 16; - *dp++ = pixel >> 8; - *dp++ = pixel; - break; - case 32: // 32bpp LSB - *dp++ = pixel; - *dp++ = pixel >> 8; - *dp++ = pixel >> 16; - *dp++ = pixel >> 24; - break; - case 33: // 32bpp MSB - *dp++ = pixel >> 24; - *dp++ = pixel >> 16; - *dp++ = pixel >> 8; - *dp++ = pixel; + // since pixel32 is the largest possible pixel size, we can share the array + int r, g, b; + int x,y; + pixel32 *data = sf.pixelData(); + pixel16 *p = (pixel16*) data; + switch (im->bits_per_pixel) { + case 32: + if ((_red_offset != default_red_shift) || + (_blue_offset != default_blue_shift) || + (_green_offset != default_green_shift)) { + printf("cross endian conversion\n"); + for (y = 0; y < im->height; y++) { + for (x = 0; x < im->width; x++) { + r = (data[x] >> default_red_shift) & 0xFF; + g = (data[x] >> default_green_shift) & 0xFF; + b = (data[x] >> default_blue_shift) & 0xFF; + data[x] = (r << _red_offset) + (g << _green_offset) + + (b << _blue_offset); + } + data += im->width; + } + } + return; + case 16: + for (y = 0; y < im->height; y++) { + for (x = 0; x < im->width; x++) { + r = (data[x] >> default_red_shift) & 0xFF; + r = r >> _red_shift; + g = (data[x] >> default_green_shift) & 0xFF; + g = g >> _green_shift; + b = (data[x] >> default_blue_shift) & 0xFF; + b = b >> _blue_shift; + p[x] = (r << _red_offset) + (g << _green_offset) + (b << _blue_offset); + } + data += im->width; + p += im->bytes_per_line/2; + } break; default: - assert(false); // wtf? + printf("your bit depth is currently unhandled\n"); } } -void TrueRenderControl::render(Surface *sf) -{ - assert(sf); - - int w = sf->width(), h = sf->height(); - - XImage *im = XCreateImage(**display, _screen->visual(), _screen->depth(), - ZPixmap, 0, NULL, w, h, 32, 0); - - unsigned char *data = new unsigned char[im->bytes_per_line * h]; - unsigned char *dp = data; - - for (int y = 0; y < h/3; ++y) - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, _red_color_table[255*x/w] << _red_offset); - for (int y = 0; y < h/3; ++y) - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, _green_color_table[255*x/w] << _green_offset); - for (int y = 0; y < h/3; ++y) - for (int x = 0; x < w; ++x, dp += im->bits_per_pixel/8) - renderPixel(im, dp, _blue_color_table[255*x/w] << _blue_offset); - - printf("\nDone %d %d\n", im->bytes_per_line * h, dp - data); - - im->data = (char*) data; - - if (!sf->_pm) - sf->_pm = XCreatePixmap(**display, _screen->rootWindow(), w, h, - _screen->depth()); - XPutImage(**display, sf->_pm, DefaultGC(**display, _screen->screen()), - im, 0, 0, 0, 0, w, h); - - //delete [] image->data; - //image->data = NULL; - XDestroyImage(im); -} - }