/*
|
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
|
* Distributed under the terms of the MIT License.
|
*
|
* Authors:
|
* Jérôme Duval, korli@users.berlios.de
|
* Philippe Houdoin, philippe.houdoin@free.fr
|
* Artur Wyszynski, harakash@gmail.com
|
* Alexander von Gluck IV, kallisti5@unixzen.com
|
*/
|
|
|
#include "SoftwareRenderer.h"
|
|
#include <Autolock.h>
|
#include <interface/DirectWindowPrivate.h>
|
#include <GraphicsDefs.h>
|
#include <Screen.h>
|
#include <stdio.h>
|
#include <sys/time.h>
|
#include <new>
|
|
|
#ifdef DEBUG
|
# define TRACE(x...) printf("SoftwareRenderer: " x)
|
# define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
|
#else
|
# define TRACE(x...)
|
# define CALLED()
|
#endif
|
#define ERROR(x...) printf("SoftwareRenderer: " x)
|
|
|
extern const char* color_space_name(color_space space);
|
|
|
extern "C" _EXPORT BGLRenderer*
|
instantiate_gl_renderer(BGLView *view, ulong opts, BGLDispatcher *dispatcher)
|
{
|
return new SoftwareRenderer(view, opts, dispatcher);
|
}
|
|
SoftwareRenderer::SoftwareRenderer(BGLView *view, ulong options,
|
BGLDispatcher* dispatcher)
|
:
|
BGLRenderer(view, options, dispatcher),
|
fBitmap(NULL),
|
fDirectModeEnabled(false),
|
fInfo(NULL),
|
fInfoLocker("info locker"),
|
fOptions(options),
|
fColorSpace(B_NO_COLOR_SPACE)
|
{
|
CALLED();
|
|
// Disable double buffer for the moment.
|
//options &= ~BGL_DOUBLE;
|
|
// Initialize the "Haiku Software GL Pipe"
|
time_t beg;
|
time_t end;
|
beg = time(NULL);
|
fContextObj = new GalliumContext(options);
|
end = time(NULL);
|
TRACE("Haiku Software GL Pipe initialization time: %f.\n",
|
difftime(end, beg));
|
|
// Allocate a bitmap
|
BRect b = view->Bounds();
|
fColorSpace = BScreen(view->Window()).ColorSpace();
|
TRACE("%s: Colorspace:\t%s\n", __func__, color_space_name(fColorSpace));
|
|
fWidth = (GLint)b.IntegerWidth();
|
fHeight = (GLint)b.IntegerHeight();
|
|
_AllocateBitmap();
|
|
// Initialize the first "Haiku Software GL Pipe" context
|
beg = time(NULL);
|
fContextID = fContextObj->CreateContext(fBitmap);
|
end = time(NULL);
|
|
if (fContextID < 0)
|
ERROR("%s: There was an error creating the context!\n", __func__);
|
else {
|
TRACE("%s: Haiku Software GL Pipe context creation time: %f.\n",
|
__func__, difftime(end, beg));
|
}
|
|
if (!fContextObj->GetCurrentContext())
|
LockGL();
|
}
|
|
|
SoftwareRenderer::~SoftwareRenderer()
|
{
|
CALLED();
|
|
if (fContextObj)
|
delete fContextObj;
|
if (fBitmap)
|
delete fBitmap;
|
}
|
|
|
void
|
SoftwareRenderer::LockGL()
|
{
|
// CALLED();
|
BGLRenderer::LockGL();
|
|
color_space cs = BScreen(GLView()->Window()).ColorSpace();
|
|
BAutolock lock(fInfoLocker);
|
if (fDirectModeEnabled && fInfo != NULL) {
|
fWidth = fInfo->window_bounds.right - fInfo->window_bounds.left;
|
fHeight = fInfo->window_bounds.bottom - fInfo->window_bounds.top;
|
}
|
|
if (fBitmap && cs == fColorSpace && fContextObj->Validate(fWidth, fHeight)) {
|
fContextObj->SetCurrentContext(fBitmap, fContextID);
|
return;
|
}
|
|
fColorSpace = cs;
|
|
_AllocateBitmap();
|
fContextObj->SetCurrentContext(fBitmap, fContextID);
|
}
|
|
|
void
|
SoftwareRenderer::UnlockGL()
|
{
|
// CALLED();
|
if ((fOptions & BGL_DOUBLE) == 0) {
|
SwapBuffers();
|
}
|
fContextObj->SetCurrentContext(NULL, fContextID);
|
BGLRenderer::UnlockGL();
|
}
|
|
|
void
|
SoftwareRenderer::SwapBuffers(bool vsync)
|
{
|
// CALLED();
|
if (!fBitmap)
|
return;
|
|
BScreen screen(GLView()->Window());
|
|
fContextObj->SwapBuffers(fContextID);
|
|
BAutolock lock(fInfoLocker);
|
|
if (!fDirectModeEnabled || fInfo == NULL) {
|
if (GLView()->LockLooperWithTimeout(1000) == B_OK) {
|
GLView()->DrawBitmap(fBitmap, B_ORIGIN);
|
GLView()->UnlockLooper();
|
if (vsync)
|
screen.WaitForRetrace();
|
}
|
return;
|
}
|
|
// check the bitmap size still matches the size
|
if (fInfo->window_bounds.bottom - fInfo->window_bounds.top
|
!= fBitmap->Bounds().IntegerHeight()
|
|| fInfo->window_bounds.right - fInfo->window_bounds.left
|
!= fBitmap->Bounds().IntegerWidth()) {
|
ERROR("%s: Bitmap size doesn't match size!\n", __func__);
|
return;
|
}
|
|
uint32 bytesPerRow = fBitmap->BytesPerRow();
|
uint8 bytesPerPixel = bytesPerRow / fBitmap->Bounds().IntegerWidth();
|
|
for (uint32 i = 0; i < fInfo->clip_list_count; i++) {
|
clipping_rect *clip = &fInfo->clip_list[i];
|
int32 height = clip->bottom - clip->top + 1;
|
int32 bytesWidth
|
= (clip->right - clip->left + 1) * bytesPerPixel;
|
bytesWidth -= bytesPerPixel;
|
uint8 *p = (uint8 *)fInfo->bits + clip->top
|
* fInfo->bytes_per_row + clip->left * bytesPerPixel;
|
uint8 *b = (uint8 *)fBitmap->Bits()
|
+ (clip->top - fInfo->window_bounds.top) * bytesPerRow
|
+ (clip->left - fInfo->window_bounds.left) * bytesPerPixel;
|
|
for (int y = 0; y < height - 1; y++) {
|
memcpy(p, b, bytesWidth);
|
p += fInfo->bytes_per_row;
|
b += bytesPerRow;
|
}
|
}
|
|
if (vsync)
|
screen.WaitForRetrace();
|
}
|
|
|
void
|
SoftwareRenderer::Draw(BRect updateRect)
|
{
|
// CALLED();
|
if ((!fDirectModeEnabled || fInfo == NULL) && fBitmap)
|
GLView()->DrawBitmap(fBitmap, updateRect, updateRect);
|
}
|
|
|
status_t
|
SoftwareRenderer::CopyPixelsOut(BPoint location, BBitmap *bitmap)
|
{
|
CALLED();
|
color_space scs = fBitmap->ColorSpace();
|
color_space dcs = bitmap->ColorSpace();
|
|
if (scs != dcs && (scs != B_RGBA32 || dcs != B_RGB32)) {
|
ERROR("%s::CopyPixelsOut(): incompatible color space: %s != %s\n",
|
__PRETTY_FUNCTION__, color_space_name(scs), color_space_name(dcs));
|
return B_BAD_TYPE;
|
}
|
|
BRect sr = fBitmap->Bounds();
|
BRect dr = bitmap->Bounds();
|
|
// int32 w1 = sr.IntegerWidth();
|
// int32 h1 = sr.IntegerHeight();
|
// int32 w2 = dr.IntegerWidth();
|
// int32 h2 = dr.IntegerHeight();
|
|
sr = sr & dr.OffsetBySelf(location);
|
dr = sr.OffsetByCopy(-location.x, -location.y);
|
|
uint8 *ps = (uint8 *) fBitmap->Bits();
|
uint8 *pd = (uint8 *) bitmap->Bits();
|
uint32 *s, *d;
|
uint32 y;
|
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
|
s = (uint32 *)(ps + y * fBitmap->BytesPerRow());
|
s += (uint32) sr.left;
|
|
d = (uint32 *)(pd + (y + (uint32)(dr.top - sr.top))
|
* bitmap->BytesPerRow());
|
d += (uint32) dr.left;
|
memcpy(d, s, dr.IntegerWidth() * 4);
|
}
|
|
return B_OK;
|
}
|
|
|
status_t
|
SoftwareRenderer::CopyPixelsIn(BBitmap *bitmap, BPoint location)
|
{
|
CALLED();
|
|
color_space sourceCS = bitmap->ColorSpace();
|
color_space destinationCS = fBitmap->ColorSpace();
|
|
if (sourceCS != destinationCS
|
&& (sourceCS != B_RGB32 || destinationCS != B_RGBA32)) {
|
ERROR("%s::CopyPixelsIn(): incompatible color space: %s != %s\n",
|
__PRETTY_FUNCTION__, color_space_name(sourceCS),
|
color_space_name(destinationCS));
|
return B_BAD_TYPE;
|
}
|
|
BRect sr = bitmap->Bounds();
|
BRect dr = fBitmap->Bounds();
|
|
sr = sr & dr.OffsetBySelf(location);
|
dr = sr.OffsetByCopy(-location.x, -location.y);
|
|
uint8 *ps = (uint8 *) bitmap->Bits();
|
uint8 *pd = (uint8 *) fBitmap->Bits();
|
uint32 *s, *d;
|
uint32 y;
|
|
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
|
s = (uint32 *)(ps + y * bitmap->BytesPerRow());
|
s += (uint32) sr.left;
|
|
d = (uint32 *)(pd + (y + (uint32)(dr.top - sr.top))
|
* fBitmap->BytesPerRow());
|
d += (uint32) dr.left;
|
|
memcpy(d, s, dr.IntegerWidth() * 4);
|
}
|
|
return B_OK;
|
}
|
|
|
void
|
SoftwareRenderer::EnableDirectMode(bool enabled)
|
{
|
fDirectModeEnabled = enabled;
|
}
|
|
|
void
|
SoftwareRenderer::DirectConnected(direct_buffer_info *info)
|
{
|
// CALLED();
|
BAutolock lock(fInfoLocker);
|
if (info) {
|
if (!fInfo) {
|
fInfo = (direct_buffer_info *)calloc(1,
|
DIRECT_BUFFER_INFO_AREA_SIZE);
|
}
|
memcpy(fInfo, info, DIRECT_BUFFER_INFO_AREA_SIZE);
|
} else if (fInfo) {
|
free(fInfo);
|
fInfo = NULL;
|
}
|
}
|
|
|
void
|
SoftwareRenderer::FrameResized(float width, float height)
|
{
|
TRACE("%s: %f x %f\n", __func__, width, height);
|
|
BAutolock lock(fInfoLocker);
|
fWidth = (GLuint)width;
|
fHeight = (GLuint)height;
|
}
|
|
|
void
|
SoftwareRenderer::_AllocateBitmap()
|
{
|
// CALLED();
|
|
// allocate new size of back buffer bitmap
|
BAutolock lock(fInfoLocker);
|
if (fBitmap)
|
delete fBitmap;
|
|
if (fWidth < 1 || fHeight < 1) {
|
TRACE("%s: Can't allocate bitmap of %dx%d\n", __func__,
|
fWidth, fHeight);
|
return;
|
}
|
BRect rect(0.0, 0.0, fWidth, fHeight);
|
fBitmap = new (std::nothrow) BBitmap(rect, fColorSpace);
|
if (fBitmap == NULL) {
|
TRACE("%s: Can't create bitmap!\n", __func__);
|
return;
|
}
|
|
TRACE("%s: New bitmap size: %" B_PRId32 " x %" B_PRId32 "\n", __func__,
|
fBitmap->Bounds().IntegerWidth(), fBitmap->Bounds().IntegerHeight());
|
|
#if 0
|
// debug..
|
void *data = fBitmap->Bits();
|
memset(data, 0xcc, fBitmap->BitsLength());
|
#endif
|
}
|
