/*
* Copyright 2006-2012, Haiku. 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
* Stefano Ceccherini, burton666@libero.it
*/
#include <kernel/image.h>
#include <GLView.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <DirectWindow.h>
#include <GLRenderer.h>
#include "interface/DirectWindowPrivate.h"
#include "GLDispatcher.h"
#include "GLRendererRoster.h"
struct glview_direct_info {
direct_buffer_info* direct_info;
bool direct_connected;
bool enable_direct_mode;
glview_direct_info();
~glview_direct_info();
};
BGLView::BGLView(BRect rect, const char* name, ulong resizingMode, ulong mode,
ulong options)
:
BView(rect, name, B_FOLLOW_ALL_SIDES, mode | B_WILL_DRAW | B_FRAME_EVENTS),
// | B_FULL_UPDATE_ON_RESIZE)
fGc(NULL),
fOptions(options),
fDitherCount(0),
fDrawLock("BGLView draw lock"),
fDisplayLock("BGLView display lock"),
fClipInfo(NULL),
fRenderer(NULL),
fRoster(NULL),
fDitherMap(NULL)
{
fRoster = new GLRendererRoster(this, options);
}
BGLView::~BGLView()
{
delete fClipInfo;
if (fRenderer)
fRenderer->Release();
}
void
BGLView::LockGL()
{
// TODO: acquire the OpenGL API lock it on this glview
fDisplayLock.Lock();
if (fRenderer)
fRenderer->LockGL();
}
void
BGLView::UnlockGL()
{
if (fRenderer)
fRenderer->UnlockGL();
fDisplayLock.Unlock();
// TODO: release the GL API lock to others glviews
}
void
BGLView::SwapBuffers()
{
SwapBuffers(false);
}
void
BGLView::SwapBuffers(bool vSync)
{
if (fRenderer) {
_LockDraw();
fRenderer->SwapBuffers(vSync);
_UnlockDraw();
}
}
BView*
BGLView::EmbeddedView()
{
return NULL;
}
void*
BGLView::GetGLProcAddress(const char* procName)
{
BGLDispatcher* glDispatcher = NULL;
if (fRenderer)
glDispatcher = fRenderer->GLDispatcher();
if (glDispatcher)
return (void*)glDispatcher->AddressOf(procName);
return NULL;
}
status_t
BGLView::CopyPixelsOut(BPoint source, BBitmap* dest)
{
if (!fRenderer)
return B_ERROR;
if (!dest || !dest->Bounds().IsValid())
return B_BAD_VALUE;
return fRenderer->CopyPixelsOut(source, dest);
}
status_t
BGLView::CopyPixelsIn(BBitmap* source, BPoint dest)
{
if (!fRenderer)
return B_ERROR;
if (!source || !source->Bounds().IsValid())
return B_BAD_VALUE;
return fRenderer->CopyPixelsIn(source, dest);
}
/*! Mesa's GLenum is not ulong but uint, so we can't use GLenum
without breaking this method signature.
Instead, we have to use the effective BeOS's SGI OpenGL GLenum type:
unsigned long.
*/
void
BGLView::ErrorCallback(unsigned long errorCode)
{
char msg[32];
sprintf(msg, "GL: Error code $%04lx.", errorCode);
// TODO: under BeOS R5, it call debugger(msg);
fprintf(stderr, "%s\n", msg);
}
void
BGLView::Draw(BRect updateRect)
{
if (fRenderer) {
_LockDraw();
fRenderer->Draw(updateRect);
_UnlockDraw();
return;
}
// TODO: auto-size and center the string
MovePenTo(8, 32);
DrawString("No OpenGL renderer available!");
}
void
BGLView::AttachedToWindow()
{
BView::AttachedToWindow();
fBounds = Bounds();
for (BView* view = this; view != NULL; view = view->Parent())
view->ConvertToParent(&fBounds);
fRenderer = fRoster->GetRenderer();
if (fRenderer != NULL) {
// Jackburton: The following code was commented because it doesn't look
// good in "direct" mode:
// when the window is moved, the app_server doesn't paint the view's
// background, and the stuff behind the window itself shows up.
// Setting the view color to black, instead, looks a bit more elegant.
#if 0
// Don't paint white window background when resized
SetViewColor(B_TRANSPARENT_32_BIT);
#else
SetViewColor(0, 0, 0);
#endif
// Set default OpenGL viewport:
LockGL();
glViewport(0, 0, Bounds().IntegerWidth(), Bounds().IntegerHeight());
UnlockGL();
fRenderer->FrameResized(Bounds().IntegerWidth(),
Bounds().IntegerHeight());
if (fClipInfo) {
fRenderer->DirectConnected(fClipInfo->direct_info);
fRenderer->EnableDirectMode(fClipInfo->enable_direct_mode);
}
return;
}
fprintf(stderr, "no renderer found! \n");
// No Renderer, no rendering. Setup a minimal "No Renderer" string drawing
// context
SetFont(be_bold_font);
// SetFontSize(16);
}
void
BGLView::AllAttached()
{
BView::AllAttached();
}
void
BGLView::DetachedFromWindow()
{
if (fRenderer)
fRenderer->Release();
fRenderer = NULL;
BView::DetachedFromWindow();
}
void
BGLView::AllDetached()
{
BView::AllDetached();
}
void
BGLView::FrameResized(float width, float height)
{
fBounds = Bounds();
for (BView* v = this; v; v = v->Parent())
v->ConvertToParent(&fBounds);
if (fRenderer) {
LockGL();
_LockDraw();
_CallDirectConnected();
fRenderer->FrameResized(width, height);
_UnlockDraw();
UnlockGL();
}
BView::FrameResized(width, height);
}
status_t
BGLView::Perform(perform_code d, void* arg)
{
return BView::Perform(d, arg);
}
status_t
BGLView::Archive(BMessage* data, bool deep) const
{
return BView::Archive(data, deep);
}
void
BGLView::MessageReceived(BMessage* msg)
{
BView::MessageReceived(msg);
}
void
BGLView::SetResizingMode(uint32 mode)
{
BView::SetResizingMode(mode);
}
void
BGLView::GetPreferredSize(float* _width, float* _height)
{
if (_width)
*_width = 0;
if (_height)
*_height = 0;
}
void
BGLView::Show()
{
BView::Show();
}
void
BGLView::Hide()
{
BView::Hide();
}
BHandler*
BGLView::ResolveSpecifier(BMessage* msg, int32 index, BMessage* specifier,
int32 form, const char* property)
{
return BView::ResolveSpecifier(msg, index, specifier, form, property);
}
status_t
BGLView::GetSupportedSuites(BMessage* data)
{
return BView::GetSupportedSuites(data);
}
void
BGLView::DirectConnected(direct_buffer_info* info)
{
if (fClipInfo == NULL) {
fClipInfo = new (std::nothrow) glview_direct_info();
if (fClipInfo == NULL)
return;
}
direct_buffer_info* localInfo = fClipInfo->direct_info;
switch (info->buffer_state & B_DIRECT_MODE_MASK) {
case B_DIRECT_START:
fClipInfo->direct_connected = true;
memcpy(localInfo, info, DIRECT_BUFFER_INFO_AREA_SIZE);
_UnlockDraw();
break;
case B_DIRECT_MODIFY:
_LockDraw();
memcpy(localInfo, info, DIRECT_BUFFER_INFO_AREA_SIZE);
_UnlockDraw();
break;
case B_DIRECT_STOP:
fClipInfo->direct_connected = false;
_LockDraw();
break;
}
if (fRenderer)
_CallDirectConnected();
}
void
BGLView::EnableDirectMode(bool enabled)
{
if (fRenderer)
fRenderer->EnableDirectMode(enabled);
if (fClipInfo == NULL) {
fClipInfo = new (std::nothrow) glview_direct_info();
if (fClipInfo == NULL)
return;
}
fClipInfo->enable_direct_mode = enabled;
}
void
BGLView::_LockDraw()
{
if (!fClipInfo || !fClipInfo->enable_direct_mode)
return;
fDrawLock.Lock();
}
void
BGLView::_UnlockDraw()
{
if (!fClipInfo || !fClipInfo->enable_direct_mode)
return;
fDrawLock.Unlock();
}
void
BGLView::_CallDirectConnected()
{
if (!fClipInfo)
return;
direct_buffer_info* localInfo = fClipInfo->direct_info;
direct_buffer_info* info = (direct_buffer_info*)malloc(
DIRECT_BUFFER_INFO_AREA_SIZE);
if (info == NULL)
return;
memcpy(info, localInfo, DIRECT_BUFFER_INFO_AREA_SIZE);
// Collect the rects into a BRegion, then clip to the view's bounds
BRegion region;
for (uint32 c = 0; c < localInfo->clip_list_count; c++)
region.Include(localInfo->clip_list[c]);
BRegion boundsRegion = fBounds.OffsetByCopy(localInfo->window_bounds.left,
localInfo->window_bounds.top);
info->window_bounds = boundsRegion.RectAtInt(0);
// window_bounds are now view bounds
region.IntersectWith(&boundsRegion);
info->clip_list_count = region.CountRects();
info->clip_bounds = region.FrameInt();
for (uint32 c = 0; c < info->clip_list_count; c++)
info->clip_list[c] = region.RectAtInt(c);
fRenderer->DirectConnected(info);
free(info);
}
//---- virtual reserved methods ----------
void BGLView::_ReservedGLView1() {}
void BGLView::_ReservedGLView2() {}
void BGLView::_ReservedGLView3() {}
void BGLView::_ReservedGLView4() {}
void BGLView::_ReservedGLView5() {}
void BGLView::_ReservedGLView6() {}
void BGLView::_ReservedGLView7() {}
void BGLView::_ReservedGLView8() {}
// #pragma mark -
// BeOS compatibility: contrary to others BView's contructors,
// BGLView one wants a non-const name argument.
BGLView::BGLView(BRect rect, char* name, ulong resizingMode, ulong mode,
ulong options)
:
BView(rect, name, B_FOLLOW_ALL_SIDES, mode | B_WILL_DRAW | B_FRAME_EVENTS),
fGc(NULL),
fOptions(options),
fDitherCount(0),
fDrawLock("BGLView draw lock"),
fDisplayLock("BGLView display lock"),
fClipInfo(NULL),
fRenderer(NULL),
fRoster(NULL),
fDitherMap(NULL)
{
fRoster = new GLRendererRoster(this, options);
}
#if 0
// TODO: implement BGLScreen class...
BGLScreen::BGLScreen(char* name, ulong screenMode, ulong options,
status_t* error, bool debug)
:
BWindowScreen(name, screenMode, error, debug)
{
}
BGLScreen::~BGLScreen()
{
}
void
BGLScreen::LockGL()
{
}
void
BGLScreen::UnlockGL()
{
}
void
BGLScreen::SwapBuffers()
{
}
void
BGLScreen::ErrorCallback(unsigned long errorCode)
{
// Mesa's GLenum is not ulong but uint!
char msg[32];
sprintf(msg, "GL: Error code $%04lx.", errorCode);
// debugger(msg);
fprintf(stderr, "%s\n", msg);
return;
}
void
BGLScreen::ScreenConnected(bool enabled)
{
}
void
BGLScreen::FrameResized(float width, float height)
{
return BWindowScreen::FrameResized(width, height);
}
status_t
BGLScreen::Perform(perform_code d, void* arg)
{
return BWindowScreen::Perform(d, arg);
}
status_t
BGLScreen::Archive(BMessage* data, bool deep) const
{
return BWindowScreen::Archive(data, deep);
}
void
BGLScreen::MessageReceived(BMessage* msg)
{
BWindowScreen::MessageReceived(msg);
}
void
BGLScreen::Show()
{
BWindowScreen::Show();
}
void
BGLScreen::Hide()
{
BWindowScreen::Hide();
}
BHandler*
BGLScreen::ResolveSpecifier(BMessage* msg, int32 index, BMessage* specifier,
int32 form, const char* property)
{
return BWindowScreen::ResolveSpecifier(msg, index, specifier,
form, property);
}
status_t
BGLScreen::GetSupportedSuites(BMessage* data)
{
return BWindowScreen::GetSupportedSuites(data);
}
//---- virtual reserved methods ----------
void BGLScreen::_ReservedGLScreen1() {}
void BGLScreen::_ReservedGLScreen2() {}
void BGLScreen::_ReservedGLScreen3() {}
void BGLScreen::_ReservedGLScreen4() {}
void BGLScreen::_ReservedGLScreen5() {}
void BGLScreen::_ReservedGLScreen6() {}
void BGLScreen::_ReservedGLScreen7() {}
void BGLScreen::_ReservedGLScreen8() {}
#endif
const char* color_space_name(color_space space)
{
#define C2N(a) case a: return #a
switch (space) {
C2N(B_RGB24);
C2N(B_RGB32);
C2N(B_RGBA32);
C2N(B_RGB32_BIG);
C2N(B_RGBA32_BIG);
C2N(B_GRAY8);
C2N(B_GRAY1);
C2N(B_RGB16);
C2N(B_RGB15);
C2N(B_RGBA15);
C2N(B_CMAP8);
default:
return "Unknown!";
};
#undef C2N
};
glview_direct_info::glview_direct_info()
{
// TODO: See direct_window_data() in app_server's ServerWindow.cpp
direct_info = (direct_buffer_info*)calloc(1, DIRECT_BUFFER_INFO_AREA_SIZE);
direct_connected = false;
enable_direct_mode = false;
}
glview_direct_info::~glview_direct_info()
{
free(direct_info);
}