i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

GL: Remove OpenGL kit, x86 Mesa

Browse Source 
* Depend on Mesa packages to provide functionality
This commit is contained in:
Alexander von Gluck IV
2013-12-22 23:36:02 -06:00
parent 657769a986
commit eb45d168e1
60 changed files with 60 additions and 5596 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/Jamfile
-1
View File
@@ -9,7 +9,6 @@ SubInclude HAIKU_TOP src add-ons kernel ;
SubInclude HAIKU_TOP src add-ons locale ;
SubInclude HAIKU_TOP src add-ons mail_daemon ;
SubInclude HAIKU_TOP src add-ons media ;
SubInclude HAIKU_TOP src add-ons opengl ;
SubInclude HAIKU_TOP src add-ons print ;
SubInclude HAIKU_TOP src add-ons screen_savers ;
SubInclude HAIKU_TOP src add-ons translators ;
src/add-ons/opengl/Jamfile
-12
View File
@@ -1,12 +0,0 @@
SubDir HAIKU_TOP src add-ons opengl ;
# Haiku Mesa Software Rasterizer
SubInclude HAIKU_TOP src add-ons opengl swrast ;
SubInclude HAIKU_TOP src add-ons opengl swrast_legacy ;
# Haiku Gallium Software Renderer
SubInclude HAIKU_TOP src add-ons opengl swpipe ;
# SubInclude HAIKU_TOP src add-ons opengl nvidia ;
# SubInclude HAIKU_TOP src add-ons opengl radeon ;
src/add-ons/opengl/nvidia/Jamfile
-24
View File
@@ -1,24 +0,0 @@
SubDir HAIKU_TOP src add-ons opengl nvidia ;
SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] : true ;
# We need our public GL headers also when not compiling for Haiku.
}
UseLibraryHeaders mesa ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa main ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa glapi ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa tnl ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa x86 ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa ppc ] ;
Addon NVidia\ Hardware\ Renderer : opengl :
NVidiaHardwareRenderer.cpp
: false
: libGL.so libmesa.a be
;
src/add-ons/opengl/nvidia/NVidiaHardwareRenderer.cpp
-46
View File
@@ -1,46 +0,0 @@
/*
* Copyright 2006-2012 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <stdio.h>
#include <Screen.h>
#include <GLRenderer.h>
extern "C" _EXPORT BGLRenderer*
instanciate_gl_renderer(BGLView* view, ulong options, BGLDispatcher* dispatcher)
{
if (!view)
return NULL;
BWindow *window = view->Window();
if (!window)
return NULL;
BScreen screen(window);
if (!screen.IsValid())
return NULL;
accelerant_device_info adi;
if (screen.GetDeviceInfo(&adi) !=B_OK)
return NULL;
fprintf(stderr, "Accelerant device info:\n"
" version: %ud\n"
" name: %s\n"
" chipset: %s\n"
" serial#: %s\n",
(unsigned int) adi.version, adi.name, adi.chipset, adi.serial_no);
flush(stderr);
// Check the view is attached to a screen driven by a NVidia chip:
if (strncmp(adi.name, "Nvidia", 6) == 0) {
// return new NVidiaHardwareRenderer(view, options, dispatcher);
return NULL;
}
return NULL;
}
src/add-ons/opengl/radeon/Jamfile
-24
View File
@@ -1,24 +0,0 @@
SubDir HAIKU_TOP src add-ons opengl radeon ;
SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] : true ;
# We need our public GL headers also when not compiling for Haiku.
}
UseLibraryHeaders mesa ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa main ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa glapi ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa tnl ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa x86 ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa ppc ] ;
Addon Radeon\ Hardware\ Renderer : opengl :
RadeonHardwareRenderer.cpp
: false
: libGL.so libmesa.a be
;
src/add-ons/opengl/radeon/RadeonHardwareRenderer.cpp
-55
View File
@@ -1,55 +0,0 @@
/*
* Copyright 2006-2012 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <stdio.h>
#include <Screen.h>
#include <GLRenderer.h>
extern "C" _EXPORT BGLRenderer*
instanciate_gl_renderer(BGLView* view, ulong options, BGLDispatcher* dispatcher)
{
if (!view) {
printf("view = NULL!\n");
return NULL;
}
BWindow* window = view->Window();
if (!window) {
printf("view's window = NULL!\n");
return NULL;
}
BScreen screen(window);
if (!screen.IsValid()) {
printf("Failed to get window's screen!\n");
return NULL;
}
accelerant_device_info adi;
if (screen.GetDeviceInfo(&adi) != B_OK) {
printf("screen.GetDeviceInfo() failed!\n");
return NULL;
}
printf("Accelerant device info:\n"
" version: %ud\n"
" name: %s\n"
" chipset: %s\n"
" serial#: %s\n",
(unsigned int) adi.version, adi.name, adi.chipset, adi.serial_no);
// Check the view is attached to a screen driven by a Radeon chip:
if (strcasecmp(adi.chipset, "radeon") == 0 ||
strcasecmp(adi.chipset, "radeon") == 0) {
// return new RadeonHardwareRenderer(view, options, dispatcher);
return NULL;
}
// We can't be a renderer for this view, sorry.
return NULL;
}
src/add-ons/opengl/swpipe/GalliumContext.cpp
-528
View File
@@ -1,528 +0,0 @@
/*
* Copyright 2012, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Artur Wyszynski, [email protected]
* Alexander von Gluck IV, [email protected]
*/
#include "GalliumContext.h"
#include "GLView.h"
#include "bitmap_wrapper.h"
#include "SoftwareWinsys.h"
extern "C" {
#include "glapi/glapi.h"
#include "main/context.h"
#include "main/framebuffer.h"
#include "main/renderbuffer.h"
#include "pipe/p_format.h"
#include "state_tracker/st_cb_fbo.h"
#include "state_tracker/st_cb_flush.h"
#include "state_tracker/st_context.h"
#include "state_tracker/st_gl_api.h"
#include "state_tracker/st_manager.h"
#include "state_tracker/sw_winsys.h"
#ifdef HAVE_LLVM
#include "llvmpipe/lp_public.h"
#else
#include "softpipe/sp_public.h"
#endif
}
#define TRACE_CONTEXT
#ifdef TRACE_CONTEXT
# define TRACE(x...) printf("GalliumContext: " x)
# define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
#else
# define TRACE(x...)
# define CALLED()
#endif
#define ERROR(x...) printf("GalliumContext: " x)
static void
hgl_viewport(struct gl_context* glContext, GLint x, GLint y,
GLsizei width, GLsizei height)
{
TRACE("%s(glContext: %p, x: %d, y: %d, w: %d, h: %d\n", __func__,
glContext, x, y, width, height);
struct gl_framebuffer *draw = glContext->WinSysDrawBuffer;
struct gl_framebuffer *read = glContext->WinSysReadBuffer;
// TODO: SLOW! We need to check for changes in bitmap vs gl_framebuffer
// size before doing a _mesa_resize_framebuffer.
if (draw)
_mesa_resize_framebuffer(glContext, draw, width, height);
if (read)
_mesa_resize_framebuffer(glContext, read, width, height);
}
static st_visual*
hgl_fill_st_visual(gl_config* glVisual)
{
struct st_visual* stVisual = CALLOC_STRUCT(st_visual);
if (!stVisual) {
ERROR("%s: Couldn't allocate st_visual\n", __func__);
return NULL;
}
// Determine color format
if (glVisual->redBits == 8) {
if (glVisual->alphaBits == 8)
stVisual->color_format = PIPE_FORMAT_B8G8R8A8_UNORM;
else
stVisual->color_format = PIPE_FORMAT_B8G8R8X8_UNORM;
} else {
stVisual->color_format = PIPE_FORMAT_B5G6R5_UNORM;
}
// Determine depth stencil format
switch (glVisual->depthBits) {
default:
case 0:
stVisual->depth_stencil_format = PIPE_FORMAT_NONE;
break;
case 16:
stVisual->depth_stencil_format = PIPE_FORMAT_Z16_UNORM;
break;
case 24:
if (glVisual->stencilBits == 0) {
stVisual->depth_stencil_format = PIPE_FORMAT_Z24X8_UNORM;
// or PIPE_FORMAT_X8Z24_UNORM?
} else {
stVisual->depth_stencil_format = PIPE_FORMAT_Z24_UNORM_S8_UINT;
// or PIPE_FORMAT_S8_UINT_Z24_UNORM?
}
break;
case 32:
stVisual->depth_stencil_format = PIPE_FORMAT_Z32_UNORM;
break;
}
stVisual->accum_format = (glVisual->haveAccumBuffer)
? PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
stVisual->buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK;
stVisual->render_buffer = ST_ATTACHMENT_FRONT_LEFT;
if (glVisual->doubleBufferMode) {
stVisual->buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
stVisual->render_buffer = ST_ATTACHMENT_BACK_LEFT;
}
if (glVisual->stereoMode) {
stVisual->buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
if (glVisual->doubleBufferMode)
stVisual->buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
}
if (glVisual->haveDepthBuffer || glVisual->haveStencilBuffer)
stVisual->buffer_mask |= ST_ATTACHMENT_DEPTH_STENCIL_MASK;
return stVisual;
}
static INLINE unsigned
round_up(unsigned n, unsigned multiple)
{
return (n + multiple - 1) & ~(multiple - 1);
}
static int
hook_stm_get_param(struct st_manager *smapi, enum st_manager_param param)
{
CALLED();
switch (param) {
case ST_MANAGER_BROKEN_INVALIDATE:
TRACE("%s: TODO: How should we handle BROKEN_INVALIDATE calls?\n",
__func__);
// For now we force validation of the framebuffer.
return 1;
}
return 0;
}
GalliumContext::GalliumContext(ulong options)
:
fOptions(options),
fCurrentContext(0),
fScreen(NULL)
{
CALLED();
// Make all contexts a known value
for (context_id i = 0; i < CONTEXT_MAX; i++)
fContext[i] = NULL;
CreateScreen();
pipe_mutex_init(fMutex);
}
GalliumContext::~GalliumContext()
{
CALLED();
// Destroy our contexts
pipe_mutex_lock(fMutex);
for (context_id i = 0; i < CONTEXT_MAX; i++)
DestroyContext(i);
pipe_mutex_unlock(fMutex);
pipe_mutex_destroy(fMutex);
// TODO: Destroy fScreen
}
status_t
GalliumContext::CreateScreen()
{
CALLED();
// Allocate winsys and attach callback hooks
struct sw_winsys* winsys = winsys_connect_hooks();
if (!winsys) {
ERROR("%s: Couldn't allocate sw_winsys!\n", __func__);
return B_ERROR;
}
#ifdef HAVE_LLVM
fScreen = llvmpipe_create_screen(winsys);
#else
fScreen = softpipe_create_screen(winsys);
#endif
if (fScreen == NULL) {
ERROR("%s: Couldn't create screen!\n", __FUNCTION__);
FREE(winsys);
return B_ERROR;
}
const char* driverName = fScreen->get_name(fScreen);
ERROR("%s: Using %s driver.\n", __func__, driverName);
return B_OK;
}
context_id
GalliumContext::CreateContext(Bitmap *bitmap)
{
CALLED();
struct hgl_context* context = CALLOC_STRUCT(hgl_context);
if (!context) {
ERROR("%s: Couldn't create pipe context!\n", __FUNCTION__);
return 0;
}
// Set up the initial things our context needs
context->bitmap = bitmap;
context->colorSpace = get_bitmap_color_space(bitmap);
context->draw = NULL;
context->read = NULL;
context->st = NULL;
context->api = st_gl_api_create();
if (!context->api) {
ERROR("%s: Couldn't obtain Mesa state tracker API!\n", __func__);
return -1;
}
context->manager = CALLOC_STRUCT(st_manager);
if (!context->manager) {
ERROR("%s: Couldn't allocate Mesa state tracker manager!\n", __func__);
return -1;
}
context->manager->get_param = hook_stm_get_param;
// Calculate visual configuration
const GLboolean rgbFlag = ((fOptions & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((fOptions & BGL_ALPHA) == BGL_ALPHA);
const GLboolean dblFlag = ((fOptions & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean stereoFlag = false;
const GLint depth = (fOptions & BGL_DEPTH) ? 24 : 0;
const GLint stencil = (fOptions & BGL_STENCIL) ? 8 : 0;
const GLint accum = 0; // (options & BGL_ACCUM) ? 16 : 0;
const GLint red = rgbFlag ? 8 : 0;
const GLint green = rgbFlag ? 8 : 0;
const GLint blue = rgbFlag ? 8 : 0;
const GLint alpha = alphaFlag ? 8 : 0;
TRACE("rgb :\t%d\n", (bool)rgbFlag);
TRACE("alpha :\t%d\n", (bool)alphaFlag);
TRACE("dbl :\t%d\n", (bool)dblFlag);
TRACE("stereo :\t%d\n", (bool)stereoFlag);
TRACE("depth :\t%d\n", depth);
TRACE("stencil :\t%d\n", stencil);
TRACE("accum :\t%d\n", accum);
TRACE("red :\t%d\n", red);
TRACE("green :\t%d\n", green);
TRACE("blue :\t%d\n", blue);
TRACE("alpha :\t%d\n", alpha);
gl_config* glVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green,
blue, alpha, depth, stencil, accum, accum, accum, alpha ? accum : 0, 1);
if (!glVisual) {
ERROR("%s: Couldn't create Mesa visual!\n", __func__);
return -1;
}
TRACE("depthBits :\t%d\n", glVisual->depthBits);
TRACE("stencilBits :\t%d\n", glVisual->stencilBits);
// Convert Mesa calculated visual into state tracker visual
context->stVisual = hgl_fill_st_visual(glVisual);
context->draw = new GalliumFramebuffer(context->stVisual, (void*)this);
context->read = new GalliumFramebuffer(context->stVisual, (void*)this);
if (!context->draw || !context->read) {
ERROR("%s: Problem allocating framebuffer!\n", __func__);
_mesa_destroy_visual(glVisual);
return -1;
}
// We need to assign the screen *before* calling st_api create_context
context->manager->screen = fScreen;
// Build state tracker attributes
struct st_context_attribs attribs;
memset(&attribs, 0, sizeof(attribs));
attribs.options.force_glsl_extensions_warn = false;
attribs.profile = ST_PROFILE_DEFAULT;
attribs.visual = *context->stVisual;
attribs.major = 1;
attribs.minor = 0;
//attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
struct st_api* api = context->api;
// Create context using state tracker api call
enum st_context_error result;
context->st = api->create_context(api, context->manager, &attribs,
&result, context->st);
if (!context->st) {
ERROR("%s: Couldn't create mesa state tracker context!\n",
__func__);
switch (result) {
case ST_CONTEXT_SUCCESS:
ERROR("%s: State tracker error: SUCCESS?\n", __func__);
break;
case ST_CONTEXT_ERROR_NO_MEMORY:
ERROR("%s: State tracker error: NO_MEMORY\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_API:
ERROR("%s: State tracker error: BAD_API\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_VERSION:
ERROR("%s: State tracker error: BAD_VERSION\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_FLAG:
ERROR("%s: State tracker error: BAD_FLAG\n", __func__);
break;
case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE:
ERROR("%s: State tracker error: BAD_ATTRIBUTE\n", __func__);
break;
case ST_CONTEXT_ERROR_UNKNOWN_FLAG:
ERROR("%s: State tracker error: UNKNOWN_FLAG\n", __func__);
break;
}
FREE(context);
return -1;
}
// Init Gallium3D Post Processing
//context->postProcess = pp_init(fScreen, context->postProcessEnable);
assert(!context->st->st_manager_private);
context->st->st_manager_private = (void*)this;
struct st_context *stContext = (struct st_context*)context->st;
stContext->ctx->Driver.Viewport = hgl_viewport;
// TODO: Closely review this next context logic...
context_id contextNext = -1;
pipe_mutex_lock(fMutex);
for (context_id i = 0; i < CONTEXT_MAX; i++) {
if (fContext[i] == NULL) {
fContext[i] = context;
contextNext = i;
break;
}
}
pipe_mutex_unlock(fMutex);
if (contextNext < 0) {
ERROR("%s: The next context is invalid... something went wrong!\n",
__func__);
//st_destroy_context(context->st);
FREE(context);
_mesa_destroy_visual(glVisual);
return -1;
}
TRACE("%s: context #%" B_PRIu64 " is the next available context\n",
__func__, contextNext);
return contextNext;
}
void
GalliumContext::DestroyContext(context_id contextID)
{
// fMutex should be locked *before* calling DestoryContext
// See if context is used
if (!fContext[contextID])
return;
if (fContext[contextID]->st) {
fContext[contextID]->st->flush(fContext[contextID]->st, 0, NULL);
fContext[contextID]->st->destroy(fContext[contextID]->st);
}
if (fContext[contextID]->postProcess)
pp_free(fContext[contextID]->postProcess);
// Delete framebuffer objects
if (fContext[contextID]->read)
delete fContext[contextID]->read;
if (fContext[contextID]->draw)
delete fContext[contextID]->draw;
if (fContext[contextID]->stVisual)
FREE(fContext[contextID]->stVisual);
if (fContext[contextID]->manager)
FREE(fContext[contextID]->manager);
FREE(fContext[contextID]);
}
status_t
GalliumContext::SetCurrentContext(Bitmap *bitmap, context_id contextID)
{
CALLED();
if (contextID < 0 || contextID > CONTEXT_MAX) {
ERROR("%s: Invalid context ID range!\n", __func__);
return B_ERROR;
}
pipe_mutex_lock(fMutex);
context_id oldContextID = fCurrentContext;
struct hgl_context* context = fContext[contextID];
pipe_mutex_unlock(fMutex);
if (!context) {
ERROR("%s: Invalid context provided (#%" B_PRIu64 ")!\n",
__func__, contextID);
return B_ERROR;
}
struct st_api* api = context->api;
if (!bitmap) {
api->make_current(context->api, NULL, NULL, NULL);
return B_OK;
}
// Everything seems valid, lets set the new context.
fCurrentContext = contextID;
if (oldContextID > 0 && oldContextID != contextID) {
fContext[oldContextID]->st->flush(fContext[oldContextID]->st,
ST_FLUSH_FRONT, NULL);
}
// We need to lock and unlock framebuffers before accessing them
context->draw->Lock();
context->read->Lock();
api->make_current(context->api, context->st, context->draw->fBuffer,
context->read->fBuffer);
context->draw->Unlock();
context->read->Unlock();
// TODO: Init textures before post-processing them
#if 0
pp_init_fbos(context->postProcess,
context->textures[ST_ATTACHMENT_BACK_LEFT]->width0,
context->textures[ST_ATTACHMENT_BACK_LEFT]->height0);
#endif
context->bitmap = bitmap;
//context->st->pipe->priv = context;
return B_OK;
}
status_t
GalliumContext::SwapBuffers(context_id contextID)
{
CALLED();
pipe_mutex_lock(fMutex);
struct hgl_context *context = fContext[contextID];
pipe_mutex_unlock(fMutex);
if (!context) {
ERROR("%s: context not found\n", __func__);
return B_ERROR;
}
// TODO: Where did st_notify_swapbuffers go?
//st_notify_swapbuffers(context->draw->stfb);
context->st->flush(context->st, ST_FLUSH_FRONT, NULL);
struct st_context *stContext = (struct st_context*)context->st;
unsigned nColorBuffers = stContext->state.framebuffer.nr_cbufs;
for (unsigned i = 0; i < nColorBuffers; i++) {
pipe_surface* surface = stContext->state.framebuffer.cbufs[i];
if (!surface) {
ERROR("%s: Color buffer %d invalid!\n", __func__, i);
continue;
}
TRACE("%s: Flushing color buffer #%d\n", __func__, i);
// We pass our destination bitmap to flush_fronbuffer which passes it
// to the private winsys display call.
fScreen->flush_frontbuffer(fScreen, surface->texture, 0, 0,
context->bitmap);
}
#if 0
// TODO... should we flush the z stencil buffer?
pipe_surface* zSurface = stContext->state.framebuffer.zsbuf;
fScreen->flush_frontbuffer(fScreen, surface->texture, 0, 0,
context->bitmap);
#endif
return B_OK;
}
src/add-ons/opengl/swpipe/GalliumContext.h
-82
View File
@@ -1,82 +0,0 @@
/*
* Copyright 2009, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Alexander von Gluck IV, [email protected]
*/
#ifndef GALLIUMCONTEXT_H
#define GALLIUMCONTEXT_H
#include <stddef.h>
extern "C" {
#include "state_tracker/st_api.h"
#include "pipe/p_compiler.h"
#include "pipe/p_screen.h"
#include "postprocess/filters.h"
#include "os/os_thread.h"
}
#include "bitmap_wrapper.h"
#include "GalliumFramebuffer.h"
#define CONTEXT_MAX 32
typedef int64 context_id;
struct hgl_context
{
struct st_api* api;
// State Tracker API
struct st_manager* manager;
// State Tracker Manager
struct st_context_iface* st;
// State Tracker Interface Object
struct st_visual* stVisual;
// State Tracker Visual
struct pipe_resource* textures[ST_ATTACHMENT_COUNT];
// Post processing
struct pp_queue_t* postProcess;
unsigned int postProcessEnable[PP_FILTERS];
Bitmap* bitmap;
color_space colorSpace;
GalliumFramebuffer* draw;
GalliumFramebuffer* read;
};
class GalliumContext {
public:
GalliumContext(ulong options);
~GalliumContext();
context_id CreateContext(Bitmap* bitmap);
void DestroyContext(context_id contextID);
context_id GetCurrentContext() { return fCurrentContext; };
status_t SetCurrentContext(Bitmap *bitmap,
context_id contextID);
status_t SwapBuffers(context_id contextID);
private:
status_t CreateScreen();
void Flush();
ulong fOptions;
struct hgl_context* fContext[CONTEXT_MAX];
context_id fCurrentContext;
struct pipe_screen* fScreen;
pipe_mutex fMutex;
};
#endif /* GALLIUMCONTEXT_H */
src/add-ons/opengl/swpipe/GalliumFramebuffer.cpp
-115
View File
@@ -1,115 +0,0 @@
/*
* Copyright 2012, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Artur Wyszynski, [email protected]
* Alexander von Gluck IV, [email protected]
*/
#include "GalliumFramebuffer.h"
extern "C" {
#include "main/context.h"
#include "main/framebuffer.h"
#include "main/renderbuffer.h"
#include "pipe/p_format.h"
}
#define TRACE_FRAMEBUFFER
#ifdef TRACE_FRAEMBUFFER
# define TRACE(x...) printf("GalliumFramebuffer: " x)
# define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
#else
# define TRACE(x...)
# define CALLED()
#endif
#define ERROR(x...) printf("GalliumFramebuffer: " x)
static boolean
hgl_framebuffer_flush_front(struct st_context_iface *stctx,
struct st_framebuffer_iface* stfb, enum st_attachment_type statt)
{
CALLED();
// TODO: I have *NO* idea how we are going to access this data...
#if 0
struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
pipe_mutex_lock(stwfb->fb->mutex);
struct pipe_resource* resource = textures[statt];
if (resource)
stw_framebuffer_present_locked(...);
#endif
return TRUE;
}
static boolean
hgl_framebuffer_validate(struct st_framebuffer_iface* stfb,
const enum st_attachment_type* statts, unsigned count,
struct pipe_resource** out)
{
CALLED();
return TRUE;
}
GalliumFramebuffer::GalliumFramebuffer(struct st_visual* visual,
void* privateContext)
:
fBuffer(NULL)
{
CALLED();
fBuffer = CALLOC_STRUCT(st_framebuffer_iface);
if (!fBuffer) {
ERROR("%s: Couldn't calloc framebuffer!\n", __func__);
return;
}
fBuffer->visual = visual;
fBuffer->flush_front = hgl_framebuffer_flush_front;
fBuffer->validate = hgl_framebuffer_validate;
fBuffer->st_manager_private = privateContext;
pipe_mutex_init(fMutex);
}
GalliumFramebuffer::~GalliumFramebuffer()
{
CALLED();
// We lock and unlock to try and make sure we wait for anything
// using the framebuffer to finish
Lock();
if (!fBuffer) {
ERROR("%s: Strange, no Gallium Framebuffer to free?\n", __func__);
return;
}
FREE(fBuffer);
Unlock();
pipe_mutex_destroy(fMutex);
}
status_t
GalliumFramebuffer::Lock()
{
CALLED();
pipe_mutex_lock(fMutex);
return B_OK;
}
status_t
GalliumFramebuffer::Unlock()
{
CALLED();
pipe_mutex_unlock(fMutex);
return B_OK;
}
src/add-ons/opengl/swpipe/GalliumFramebuffer.h
-34
View File
@@ -1,34 +0,0 @@
/*
* Copyright 2012, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Alexander von Gluck IV, [email protected]
*/
#ifndef GALLIUMFRAMEBUFFER_H
#define GALLIUMFRAMEBUFFER_H
extern "C" {
#include "os/os_thread.h"
#include "pipe/p_screen.h"
#include "state_tracker/st_api.h"
}
class GalliumFramebuffer {
public:
GalliumFramebuffer(struct st_visual* visual,
void* privateContext);
~GalliumFramebuffer();
status_t Lock();
status_t Unlock();
struct st_framebuffer_iface* fBuffer;
private:
pipe_mutex fMutex;
};
#endif /* GALLIUMFRAMEBUFFER_H */
src/add-ons/opengl/swpipe/Jamfile
-47
View File
@@ -1,47 +0,0 @@
SubDir HAIKU_TOP src add-ons opengl swpipe ;
UseBuildFeatureHeaders mesa ;
UsePrivateHeaders interface ;
local sources =
SoftwareRenderer.cpp
SoftwareWinsys.cpp
GalliumContext.cpp
GalliumFramebuffer.cpp
bitmap_wrapper.cpp ;
Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
local privateHeaders = [ BuildFeatureAttribute mesa : privateHeaders : path ] ;
UseHeaders [ FDirName $(privateHeaders) gallium auxiliary ] ;
UseHeaders [ FDirName $(privateHeaders) gallium drivers ] ;
UseHeaders [ FDirName $(privateHeaders) gallium include ] ;
UseHeaders [ FDirName $(privateHeaders) mapi ] ;
UseHeaders [ FDirName $(privateHeaders) mesa ] ;
AddResources Software\ Renderer : SoftwareRenderer.rdef ;
if FIsBuildFeatureEnabled(llvm) {
Depends Software\ Renderer : $(HAIKU_LLVM_HEADERS_DEPENDENCY) ;
SubDirC++Flags [ FDefines HAVE_LLVM=0x0302 ] ;
}
# LLVM Pipe enabled Gallium Software Renderer
# Requires:
# - LLVM optional package
# - Mesa optional package compiled with LLVM installed
# SoftPipe enabled Gallium Software Renderer
# Requires:
# - Mesa optional package compiled *without* LLVM installed
Addon Software\ Renderer :
$(sources)
:
libGL.so
[ BuildFeatureAttribute mesa : galliumSoftpipeLibrary ]
[ BuildFeatureAttribute mesa : galliumLlvmpipeLibrary ]
[ BuildFeatureAttribute mesa : mesaLibrary ]
[ BuildFeatureAttribute mesa : glslLibrary ]
[ BuildFeatureAttribute mesa : galliumLibrary ]
$(HAIKU_LLVM_LIBS)
be translation stdc++ $(TARGET_LIBSUPC++)
;
src/add-ons/opengl/swpipe/SoftwareRenderer.cpp
-363
View File
@@ -1,363 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected]
* Alexander von Gluck IV, [email protected]
*/
#include "SoftwareRenderer.h"
#include <Autolock.h>
#include <DirectWindowPrivate.h>
#include <GraphicsDefs.h>
#include <Screen.h>
#include <stdio.h>
#include <sys/time.h>
#include <new>
#define TRACE_SOFTWARE
#ifdef TRACE_SOFTWARE
# 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();
fNewWidth = fWidth;
fNewHeight = fHeight;
_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) {
fNewWidth = fInfo->window_bounds.right - fInfo->window_bounds.left;
// + 1;
fNewHeight = fInfo->window_bounds.bottom - fInfo->window_bounds.top;
// + 1;
}
if (fBitmap && cs == fColorSpace && fNewWidth == fWidth
&& fNewHeight == fHeight) {
fContextObj->SetCurrentContext(fBitmap, fContextID);
return;
}
fColorSpace = cs;
fWidth = fNewWidth;
fHeight = fNewHeight;
_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;
}
uint8 bytesPerPixel = fInfo->bits_per_pixel / 8;
uint32 bytesPerRow = fBitmap->BytesPerRow();
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)
{
// CALLED();
BAutolock lock(fInfoLocker);
fNewWidth = (GLuint)width;
fNewHeight = (GLuint)height;
}
void
SoftwareRenderer::_AllocateBitmap()
{
// CALLED();
// allocate new size of back buffer bitmap
BAutolock lock(fInfoLocker);
delete fBitmap;
fBitmap = NULL;
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;
}
#if 0
// debug..
void *data = fBitmap->Bits();
memset(data, 0xcc, fBitmap->BitsLength());
#endif
}
src/add-ons/opengl/swpipe/SoftwareRenderer.h
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected]
* Alexander von Gluck IV, [email protected]
*/
#ifndef SOFTWARERENDERER_H
#define SOFTWARERENDERER_H
#include "GLRenderer.h"
#include "GalliumContext.h"
class SoftwareRenderer : public BGLRenderer {
public:
SoftwareRenderer(BGLView *view,
ulong bgl_options,
BGLDispatcher *dispatcher);
virtual ~SoftwareRenderer();
virtual void LockGL();
virtual void UnlockGL();
virtual void SwapBuffers(bool vsync = false);
virtual void Draw(BRect updateRect);
virtual status_t CopyPixelsOut(BPoint source, BBitmap *dest);
virtual status_t CopyPixelsIn(BBitmap *source, BPoint dest);
virtual void FrameResized(float width, float height);
virtual void EnableDirectMode(bool enabled);
virtual void DirectConnected(direct_buffer_info *info);
private:
void _AllocateBitmap();
GalliumContext* fContextObj;
BBitmap* fBitmap;
context_id fContextID;
bool fDirectModeEnabled;
direct_buffer_info* fInfo;
BLocker fInfoLocker;
ulong fOptions;
GLuint fWidth;
GLuint fHeight;
GLuint fNewWidth;
GLuint fNewHeight;
color_space fColorSpace;
};
#endif // SOFTPIPERENDERER_H
src/add-ons/opengl/swpipe/SoftwareRenderer.rdef
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright 2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
resource app_signature "application/x-vnd.Haiku-swpipe";
resource app_version {
major = 9,
middle = 0,
minor = 0,
variety = 0,
internal = 0,
short_info = "Software Renderer",
long_info = "Haiku Gallium Software GL Renderer"
};
resource vector_icon {
$"6E6369660A0200140294A9FF18020014028DFFFF97058C0500020006023B10B7"
$"37F036BA1A993D466848C719BEBE2000919292FFD5D5D5020016023900000000"
$"000000003EE0004AE00048E0005EF884C702000203392E8D383001BAD97F3C12"
$"8B4786BD48B8AD0D97BBFFFF7B4168DBE9FF4168DB97020002023A0C1238D099"
$"BE44203F4BD14B38844678240DF56A7D9FE1EA064CC704016B0500090A044024"
$"2438404C5C380A044028243C40505C3C0A042438243B5C3C5C380608BFBE4D59"
$"4D59515957575659585560406044603C5E3A5C3CCB4FBFBA5E3ECA9DC11F564B"
$"584A544C504C0606AF0F2F3D2F3D393D4034BF593542324130432F42364432C0"
$"3FBC5A2F48354A2F480608AE9A22303EB5BD3AB42542B755422E412F3C29322D"
$"32223C0204263726372538263F253E263F304430443143303C313D303C02043D"
$"423D423C433D4A3C493D4A495049504A4F49474A484947060DAEAAAE014E445A"
$"3456365E325E3D5D3F5A3A5542544E4D573A4E364439463342324A2242310A0A"
$"0002020102403CA00C88888C8CC1401673C40D6544F2950A01010002403CA000"
$"0000000000401673C40D65446CF80A08020304023EC16A0000000000003EC16A"
$"45DD1844C6550A030105123EC16A0000000000003EC16A45DD1844C655011784"
$"22040A040105023EC16A0000000000003EC16A45DD1844C6550A030108123EC1"
$"6A0000000000003EC16A45DD1844C65501178422040A0503080706023EC16A00"
$"00000000003EC16A45DD1844C6550A030206071A3EC16A0000000000003EC16A"
$"45DD1844C65510FF0215810004178222040A060106023EC16A0000000000003E"
$"C16A45DD1844C6550A070107023EC16A0000000000003EC16A45DD1844C655"
};
src/add-ons/opengl/swpipe/SoftwareWinsys.cpp
-212
View File
@@ -1,212 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Artur Wyszynski, [email protected]
* Alexander von Gluck IV, [email protected]
*/
#include "SoftwareWinsys.h"
#include <stdio.h>
#include "bitmap_wrapper.h"
extern "C" {
#include "state_tracker/st_api.h"
#include "state_tracker/sw_winsys.h"
#include "util/u_format.h"
#include "util/u_math.h"
#include "util/u_memory.h"
}
#define TRACE_WINSYS
#ifdef TRACE_WINSYS
# define TRACE(x...) printf("GalliumWinsys: " x)
# define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
#else
# define TRACE(x...)
# define CALLED()
#endif
#define ERROR(x...) printf("GalliumWinsys: " x)
// Cast
static INLINE struct haiku_displaytarget*
cast_haiku_displaytarget(struct sw_displaytarget* target)
{
return (struct haiku_displaytarget *)target;
}
static void
hook_winsys_destroy(struct sw_winsys* winsys)
{
CALLED();
FREE(winsys);
}
static boolean
hook_winsys_is_displaytarget_format_supported(struct sw_winsys* winsys,
unsigned textureUsage, enum pipe_format format)
{
CALLED();
// TODO STUB
return true;
}
static struct sw_displaytarget*
hook_winsys_displaytarget_create(struct sw_winsys* winsys,
unsigned textureUsage, enum pipe_format format, unsigned width,
unsigned height, unsigned alignment, unsigned* stride)
{
TRACE("%s: %dx%d\n", __func__, width, height);
struct haiku_displaytarget* haikuDisplayTarget
= CALLOC_STRUCT(haiku_displaytarget);
if (!haikuDisplayTarget) {
ERROR("%s: Couldn't allocate Haiku display target!\n",
__func__);
return NULL;
}
haikuDisplayTarget->format = format;
haikuDisplayTarget->width = width;
haikuDisplayTarget->height = height;
unsigned formatStride = util_format_get_stride(format, width);
unsigned blockSize = util_format_get_nblocksy(format, height);
haikuDisplayTarget->stride = align(formatStride, alignment);
haikuDisplayTarget->size = haikuDisplayTarget->stride * blockSize;
haikuDisplayTarget->data
= align_malloc(haikuDisplayTarget->size, alignment);
if (!haikuDisplayTarget->data) {
ERROR("%s: Couldn't allocate Haiku display target data!\n",
__func__);
FREE(haikuDisplayTarget);
return NULL;
}
*stride = haikuDisplayTarget->stride;
// Cast to ghost sw_displaytarget type
return (struct sw_displaytarget*)haikuDisplayTarget;
}
static void
hook_winsys_displaytarget_destroy(struct sw_winsys* winsys,
struct sw_displaytarget* displayTarget)
{
CALLED();
struct haiku_displaytarget* haikuDisplayTarget
= cast_haiku_displaytarget(displayTarget);
if (!haikuDisplayTarget) {
ERROR("%s: Attempt to destroy non-existant display target!\n",
__func__);
return;
}
if (haikuDisplayTarget->data != NULL)
align_free(haikuDisplayTarget->data);
FREE(haikuDisplayTarget);
}
static struct sw_displaytarget*
hook_winsys_displaytarget_from_handle(struct sw_winsys* winsys,
const struct pipe_resource* templat, struct winsys_handle* whandle,
unsigned* stride)
{
CALLED();
return NULL;
}
static boolean
hook_winsys_displaytarget_get_handle(struct sw_winsys* winsys,
struct sw_displaytarget* displayTarget, struct winsys_handle* whandle)
{
CALLED();
return FALSE;
}
static void*
hook_winsys_displaytarget_map(struct sw_winsys* winsys,
struct sw_displaytarget* displayTarget, unsigned flags)
{
CALLED();
struct haiku_displaytarget* haikuDisplayTarget
= cast_haiku_displaytarget(displayTarget);
return haikuDisplayTarget->data;
}
static void
hook_winsys_displaytarget_unmap(struct sw_winsys* winsys,
struct sw_displaytarget* disptarget)
{
return;
}
static void
hook_winsys_displaytarget_display(struct sw_winsys* winsys,
struct sw_displaytarget* displayTarget, void* contextPrivate)
{
CALLED();
if (!contextPrivate) {
ERROR("%s: Passed invalid private pointer!\n", __func__);
return;
}
Bitmap* bitmap = (Bitmap*)contextPrivate;
struct haiku_displaytarget* haikuDisplayTarget
= cast_haiku_displaytarget(displayTarget);
copy_bitmap_bits(bitmap, haikuDisplayTarget->data,
haikuDisplayTarget->size);
return;
}
struct sw_winsys*
winsys_connect_hooks()
{
CALLED();
struct sw_winsys* winsys = CALLOC_STRUCT(sw_winsys);
if (!winsys)
return NULL;
// Attach winsys hooks for Haiku
winsys->destroy = hook_winsys_destroy;
winsys->is_displaytarget_format_supported
= hook_winsys_is_displaytarget_format_supported;
winsys->displaytarget_create = hook_winsys_displaytarget_create;
winsys->displaytarget_from_handle = hook_winsys_displaytarget_from_handle;
winsys->displaytarget_get_handle = hook_winsys_displaytarget_get_handle;
winsys->displaytarget_map = hook_winsys_displaytarget_map;
winsys->displaytarget_unmap = hook_winsys_displaytarget_unmap;
winsys->displaytarget_display = hook_winsys_displaytarget_display;
winsys->displaytarget_destroy = hook_winsys_displaytarget_destroy;
return winsys;
}
src/add-ons/opengl/swpipe/SoftwareWinsys.h
-35
View File
@@ -1,35 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Alexander von Gluck IV, [email protected]
*/
#ifndef SOFTWAREWINSYS_H
#define SOFTWAREWINSYS_H
extern "C" {
#include "pipe/p_defines.h"
#include "state_tracker/st_api.h"
#include "state_tracker/sw_winsys.h"
}
struct haiku_displaytarget
{
enum pipe_format format;
unsigned width;
unsigned height;
unsigned stride;
unsigned size;
void* data;
};
struct sw_winsys* winsys_connect_hooks();
#endif
src/add-ons/opengl/swpipe/bitmap_wrapper.cpp
-117
View File
@@ -1,117 +0,0 @@
/*
* Copyright 2009, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Based on gallium gdi winsys
*
* Authors:
* Artur Wyszynski <[email protected]>
*/
#include <stdio.h>
#include <interface/Bitmap.h>
#include <storage/File.h>
#include <support/String.h>
#include <translation/BitmapStream.h>
#include <translation/TranslatorRoster.h>
#include "bitmap_wrapper.h"
extern "C" {
static int frameNo = 0;
Bitmap*
create_bitmap(int32 width, int32 height, color_space colorSpace)
{
BBitmap *bb = new BBitmap(BRect(0, 0, width, height), colorSpace);
if (bb)
return (Bitmap*)bb;
return NULL;
}
void
get_bitmap_size(const Bitmap* bitmap, int32* width, int32* height)
{
BBitmap *bb = (BBitmap*)bitmap;
if (bb && width && height) {
uint32 w = bb->Bounds().IntegerWidth() + 1;
uint32 h = bb->Bounds().IntegerHeight() + 1;
*width = w;
*height = h;
}
}
color_space
get_bitmap_color_space(const Bitmap* bitmap)
{
BBitmap *bb = (BBitmap*)bitmap;
if (bb)
return bb->ColorSpace();
return B_NO_COLOR_SPACE;
}
void
copy_bitmap_bits(const Bitmap* bitmap, void* data, int32 length)
{
BBitmap *bb = (BBitmap*)bitmap;
if (bb) {
color_space cs = bb->ColorSpace();
bb->ImportBits(data, length, bb->BytesPerRow(), 0, cs);
}
}
void
delete_bitmap(Bitmap* bitmap)
{
BBitmap *bb = (BBitmap*)bitmap;
delete bb;
}
int32
get_bitmap_bytes_per_row(const Bitmap* bitmap)
{
BBitmap *bb = (BBitmap*)bitmap;
if (bb)
return bb->BytesPerRow();
return 0;
}
int32
get_bitmap_bits_length(const Bitmap* bitmap)
{
BBitmap *bb = (BBitmap*)bitmap;
if (bb)
return bb->BitsLength();
return 0;
}
void
dump_bitmap(const Bitmap* bitmap)
{
BBitmap *bb = (BBitmap*)bitmap;
if (!bb)
return;
BString filename("/boot/home/frame_");
filename << (int32)frameNo << ".png";
BTranslatorRoster *roster = BTranslatorRoster::Default();
BBitmapStream stream(bb);
BFile dump(filename, B_CREATE_FILE | B_WRITE_ONLY);
roster->Translate(&stream, NULL, NULL, &dump, 0);
frameNo++;
}
}
src/add-ons/opengl/swpipe/bitmap_wrapper.h
-42
View File
@@ -1,42 +0,0 @@
/*
* Copyright 2009, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Based on gallium gdi winsys
*
* Authors:
* Artur Wyszynski <[email protected]>
*/
#ifndef __BBITMAP_WRAPPER_H__
#define __BBITMAP_WRAPPER_H__
#include <interface/GraphicsDefs.h>
#include <support/SupportDefs.h>
typedef void Bitmap;
#ifdef __cplusplus
extern "C" {
#endif
Bitmap* create_bitmap(int32 width, int32 height, color_space colorSpace);
void copy_bitmap_bits(const Bitmap* bitmap, void* data, int32 length);
void get_bitmap_size(const Bitmap* bitmap, int32* width, int32* height);
color_space get_bitmap_color_space(const Bitmap* bitmap);
int32 get_bitmap_bytes_per_row(const Bitmap* bitmap);
int32 get_bitmap_bits_length(const Bitmap* bitmap);
void delete_bitmap(Bitmap* bitmap);
void dump_bitmap(const Bitmap* bitmap);
#ifdef __cplusplus
}
#endif
#endif /* __BBITMAP_WRAPPER_H__ */
src/add-ons/opengl/swrast/Jamfile
-35
View File
@@ -1,35 +0,0 @@
SubDir HAIKU_TOP src add-ons opengl swrast ;
SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] : true ;
# We need our public GL headers also when not compiling for Haiku.
}
local defines = BEOS_THREADS GNU_ASSEMBLER ;
SubDirC++Flags [ FDefines $(defines) ] ;
local sources = MesaSoftwareRenderer.cpp ;
UsePrivateHeaders interface ;
UseBuildFeatureHeaders mesa ;
Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
UseHeaders [ BuildFeatureAttribute mesa : headers : path ] ;
local privateHeaders = [ BuildFeatureAttribute mesa : privateHeaders : path ] ;
UseHeaders [ FDirName $(privateHeaders) mesa ] ;
UseHeaders [ FDirName $(privateHeaders) mesa main ] ;
UseHeaders [ FDirName $(privateHeaders) mapi ] ;
UseHeaders [ FDirName $(privateHeaders) mapi glapi ] ;
AddResources Software\ Rasterizer : MesaSoftwareRenderer.rdef ;
Addon Software\ Rasterizer :
MesaSoftwareRenderer.cpp
:
[ BuildFeatureAttribute mesa : mesaLibrary ]
[ BuildFeatureAttribute mesa : glslLibrary ]
libGL.so be $(TARGET_LIBSUPC++)
;
src/add-ons/opengl/swrast/MesaSoftwareRenderer.cpp
-723
View File
@@ -1,723 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected]
* Alexander von Gluck, [email protected]
*/
#include "MesaSoftwareRenderer.h"
#include <Autolock.h>
#include <DirectWindowPrivate.h>
#include <GraphicsDefs.h>
#include <Screen.h>
#include <stdio.h>
#include <string.h>
extern "C" {
#include "extensions.h"
#include "drivers/common/driverfuncs.h"
#include "drivers/common/meta.h"
#include "main/api_exec.h"
#include "main/colormac.h"
#include "main/cpuinfo.h"
#include "main/buffers.h"
#include "main/formats.h"
#include "main/framebuffer.h"
#include "main/renderbuffer.h"
#include "main/version.h"
#include "main/vtxfmt.h"
#include "swrast/swrast.h"
#include "swrast/s_renderbuffer.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
#include "vbo/vbo.h"
//#define TRACE_SOFTGL
#ifdef TRACE_SOFTGL
# define TRACE(x...) printf("MesaSoftwareRenderer: " x)
# define CALLED() printf("MesaSoftwareRenderer: %s\n", __PRETTY_FUNCTION__)
#else
# define TRACE(x...)
# define CALLED()
#endif
#define ERROR(x...) printf("MesaSoftwareRenderer: " x)
}
extern const char* color_space_name(color_space space);
extern "C" _EXPORT BGLRenderer*
instantiate_gl_renderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
{
return new MesaSoftwareRenderer(view, options, dispatcher);
}
MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
: BGLRenderer(view, options, dispatcher),
fBitmap(NULL),
fDirectModeEnabled(false),
fInfo(NULL),
fInfoLocker("info locker"),
fContext(NULL),
fVisual(NULL),
fFrameBuffer(NULL),
fFrontRenderBuffer(NULL),
fBackRenderBuffer(NULL),
fColorSpace(B_NO_COLOR_SPACE)
{
CALLED();
fColorSpace = BScreen(GLView()->Window()).ColorSpace();
// We force single buffering for the time being
options &= ~BGL_DOUBLE;
const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
const GLboolean dblFlag = ((options & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean stereoFlag = false;
const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
const GLint red = rgbFlag ? 8 : 0;
const GLint green = rgbFlag ? 8 : 0;
const GLint blue = rgbFlag ? 8 : 0;
const GLint alpha = alphaFlag ? 8 : 0;
fOptions = options; // | BGL_INDIRECT;
struct dd_function_table functions;
fVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green,
blue, alpha, depth, stencil, accum, accum, accum,
alpha ? accum : 0, 1);
// Initialize device driver function table
_mesa_init_driver_functions(&functions);
functions.GetString = _GetString;
functions.UpdateState = _UpdateState;
functions.MapRenderbuffer = _RenderBufferMap;
functions.GetBufferSize = NULL;
functions.Error = _Error;
functions.Flush = _Flush;
// create core context
fContext = _mesa_create_context(API_OPENGL_COMPAT, fVisual, NULL,
&functions);
if (!fContext) {
ERROR("%s: Failed to create Mesa context!\n", __func__);
_mesa_destroy_visual(fVisual);
return;
}
/* Initialize the software rasterizer and helper modules. */
_swrast_CreateContext(fContext);
_vbo_CreateContext(fContext);
_tnl_CreateContext(fContext);
_swsetup_CreateContext(fContext);
_swsetup_Wakeup(fContext);
// Use default TCL pipeline
TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline;
_mesa_meta_init(fContext);
_mesa_enable_sw_extensions(fContext);
_mesa_enable_1_3_extensions(fContext);
_mesa_enable_1_4_extensions(fContext);
_mesa_enable_1_5_extensions(fContext);
_mesa_enable_2_0_extensions(fContext);
_mesa_enable_2_1_extensions(fContext);
_mesa_compute_version(fContext);
_mesa_initialize_dispatch_tables(fContext);
_mesa_initialize_vbo_vtxfmt(fContext);
// create core framebuffer
fFrameBuffer = _mesa_create_framebuffer(fVisual);
if (fFrameBuffer == NULL) {
ERROR("%s: Unable to calloc GL FrameBuffer!\n", __func__);
_mesa_destroy_visual(fVisual);
return;
}
// Setup front render buffer
fFrontRenderBuffer = _NewRenderBuffer(true);
if (fFrontRenderBuffer == NULL) {
ERROR("%s: FrontRenderBuffer is requested but unallocated!\n",
__func__);
_mesa_destroy_visual(fVisual);
free(fFrameBuffer);
return;
}
_mesa_add_renderbuffer(fFrameBuffer, BUFFER_FRONT_LEFT,
&fFrontRenderBuffer->Base);
// Setup back render buffer (if requested)
if (fVisual->doubleBufferMode) {
fBackRenderBuffer = _NewRenderBuffer(false);
if (fBackRenderBuffer == NULL) {
ERROR("%s: BackRenderBuffer is requested but unallocated!\n",
__func__);
_mesa_destroy_visual(fVisual);
free(fFrameBuffer);
return;
}
_mesa_add_renderbuffer(fFrameBuffer, BUFFER_BACK_LEFT,
&fBackRenderBuffer->Base);
}
_swrast_add_soft_renderbuffers(fFrameBuffer, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
BRect bounds = view->Bounds();
fWidth = (GLint)bounds.Width();
fHeight = (GLint)bounds.Height();
// some stupid applications (Quake2) don't even think about calling LockGL()
// before using glGetString and its glGet*() friends...
// so make sure there is at least a valid context.
if (!_mesa_get_current_context()) {
LockGL();
// not needed, we don't have a looper yet: UnlockLooper();
}
}
MesaSoftwareRenderer::~MesaSoftwareRenderer()
{
CALLED();
_swsetup_DestroyContext(fContext);
_swrast_DestroyContext(fContext);
_tnl_DestroyContext(fContext);
_vbo_DestroyContext(fContext);
_mesa_destroy_visual(fVisual);
_mesa_destroy_framebuffer(fFrameBuffer);
_mesa_destroy_context(fContext);
free(fInfo);
free(fFrameBuffer);
delete fBitmap;
}
void
MesaSoftwareRenderer::LockGL()
{
CALLED();
BGLRenderer::LockGL();
_mesa_make_current(fContext, fFrameBuffer, fFrameBuffer);
color_space colorSpace = BScreen(GLView()->Window()).ColorSpace();
GLuint width = fWidth;
GLuint height = fHeight;
BAutolock lock(fInfoLocker);
if (fDirectModeEnabled && fInfo != NULL) {
width = fInfo->window_bounds.right
- fInfo->window_bounds.left + 1;
height = fInfo->window_bounds.bottom
- fInfo->window_bounds.top + 1;
}
if (fColorSpace != colorSpace) {
fColorSpace = colorSpace;
_SetupRenderBuffer(&fFrontRenderBuffer->Base, fColorSpace);
if (fVisual->doubleBufferMode)
_SetupRenderBuffer(&fBackRenderBuffer->Base, fColorSpace);
}
_CheckResize(width, height);
}
void
MesaSoftwareRenderer::UnlockGL()
{
CALLED();
_mesa_make_current(fContext, NULL, NULL);
BGLRenderer::UnlockGL();
}
void
MesaSoftwareRenderer::SwapBuffers(bool VSync)
{
CALLED();
if (!fBitmap)
return;
if (fVisual->doubleBufferMode)
_mesa_notifySwapBuffers(fContext);
if (!fDirectModeEnabled || fInfo == NULL) {
if (GLView()->LockLooperWithTimeout(1000) == B_OK) {
GLView()->DrawBitmap(fBitmap, B_ORIGIN);
GLView()->UnlockLooper();
}
} else {
// TODO: Here the BGLView needs to be drawlocked.
_CopyToDirect();
}
if (VSync) {
BScreen screen(GLView()->Window());
screen.WaitForRetrace();
}
}
void
MesaSoftwareRenderer::Draw(BRect updateRect)
{
CALLED();
if (fBitmap && (!fDirectModeEnabled || (fInfo == NULL)))
GLView()->DrawBitmap(fBitmap, updateRect, updateRect);
}
status_t
MesaSoftwareRenderer::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)) {
fprintf(stderr, "CopyPixelsOut(): incompatible color space: %s != %s\n",
color_space_name(scs),
color_space_name(dcs));
return B_BAD_TYPE;
}
BRect sr = fBitmap->Bounds();
BRect dr = bitmap->Bounds();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8* ps = (uint8*)fBitmap->Bits();
uint8* pd = (uint8*)bitmap->Bits();
uint32* s;
uint32* 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
MesaSoftwareRenderer::CopyPixelsIn(BBitmap* bitmap, BPoint location)
{
CALLED();
color_space scs = bitmap->ColorSpace();
color_space dcs = fBitmap->ColorSpace();
if (scs != dcs && (dcs != B_RGBA32 || scs != B_RGB32)) {
fprintf(stderr, "CopyPixelsIn(): incompatible color space: %s != %s\n",
color_space_name(scs),
color_space_name(dcs));
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;
uint32* 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
MesaSoftwareRenderer::EnableDirectMode(bool enabled)
{
fDirectModeEnabled = enabled;
}
void
MesaSoftwareRenderer::DirectConnected(direct_buffer_info* info)
{
// TODO: I'm not sure we need to do this: BGLView already
// keeps a local copy of the direct_buffer_info passed by
// BDirectWindow::DirectConnected().
BAutolock lock(fInfoLocker);
if (info) {
if (!fInfo) {
fInfo = (direct_buffer_info*)malloc(DIRECT_BUFFER_INFO_AREA_SIZE);
if (!fInfo)
return;
}
memcpy(fInfo, info, DIRECT_BUFFER_INFO_AREA_SIZE);
} else if (fInfo) {
free(fInfo);
fInfo = NULL;
}
}
void
MesaSoftwareRenderer::FrameResized(float width, float height)
{
BAutolock lock(fInfoLocker);
_CheckResize((GLuint)width, (GLuint)height);
}
void
MesaSoftwareRenderer::_CheckResize(GLuint newWidth, GLuint newHeight)
{
CALLED();
if (fBitmap && newWidth == fWidth
&& newHeight == fHeight) {
return;
}
_mesa_resize_framebuffer(fContext, fFrameBuffer, newWidth, newHeight);
fHeight = newHeight;
fWidth = newWidth;
_AllocateBitmap();
}
void
MesaSoftwareRenderer::_AllocateBitmap()
{
CALLED();
// allocate new size of back buffer bitmap
delete fBitmap;
fBitmap = NULL;
if (fWidth < 1 || fHeight < 1) {
TRACE("%s: Cannot allocate bitmap < 1x1!\n", __func__);
return;
}
BRect rect(0.0, 0.0, fWidth - 1, fHeight - 1);
fBitmap = new BBitmap(rect, fColorSpace);
#if 0
// Used for platform optimized drawing
for (uint i = 0; i < fHeight; i++) {
fRowAddr[fHeight - i - 1] = (GLvoid *)((GLubyte *)fBitmap->Bits()
+ i * fBitmap->BytesPerRow());
}
#endif
fFrameBuffer->Width = fWidth;
fFrameBuffer->Height = fHeight;
TRACE("%s: Bitmap Size: %" B_PRIu32 "\n", __func__, fBitmap->BitsLength());
fFrontRenderBuffer->Buffer = (GLubyte*)fBitmap->Bits();
}
// #pragma mark - static
void
MesaSoftwareRenderer::_Error(gl_context* ctx)
{
CALLED();
#if 0
// TODO: err. Mesa dropped DriverCtx
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
if (mr && mr->GLView())
mr->GLView()->ErrorCallback((unsigned long)ctx->ErrorValue);
#endif
}
const GLubyte*
MesaSoftwareRenderer::_GetString(gl_context* ctx, GLenum name)
{
switch (name) {
case GL_VENDOR:
return (const GLubyte*) "Mesa Project";
case GL_RENDERER:
return (const GLubyte*) "Software Rasterizer";
default:
// Let core library handle all other cases
return NULL;
}
}
void
MesaSoftwareRenderer::_UpdateState(gl_context* ctx, GLuint new_state)
{
if (!ctx)
return;
CALLED();
_swrast_InvalidateState(ctx, new_state);
_swsetup_InvalidateState(ctx, new_state);
_vbo_InvalidateState(ctx, new_state);
_tnl_InvalidateState(ctx, new_state);
}
GLboolean
MesaSoftwareRenderer::_RenderBufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height)
{
CALLED();
render->Width = width;
render->Height = height;
struct swrast_renderbuffer *swRenderBuffer = swrast_renderbuffer(render);
swRenderBuffer->RowStride = width * _mesa_get_format_bytes(render->Format);
return GL_TRUE;
}
GLboolean
MesaSoftwareRenderer::_RenderBufferStorageMalloc(gl_context* ctx,
struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height)
{
CALLED();
render->Width = width;
render->Height = height;
struct swrast_renderbuffer *swRenderBuffer = swrast_renderbuffer(render);
if (swRenderBuffer != NULL) {
free(swRenderBuffer->Buffer);
swRenderBuffer->RowStride
= width * _mesa_get_format_bytes(render->Format);
uint32 size = swRenderBuffer->RowStride * height;
TRACE("%s: Allocate %" B_PRIu32 " bytes for RenderBuffer\n",
__func__, size);
swRenderBuffer->Buffer = (GLubyte*)malloc(size);
if (!swRenderBuffer->Buffer) {
ERROR("%s: Memory allocation failure!\n", __func__);
return GL_FALSE;
}
} else {
ERROR("%s: Couldn't obtain software renderbuffer!\n",
__func__);
return GL_FALSE;
}
return GL_TRUE;
}
void
MesaSoftwareRenderer::_Flush(gl_context* ctx)
{
CALLED();
#if 0
// TODO: err. Mesa dropped DriverCtx
if ((fOptions & BGL_DOUBLE) == 0) {
// TODO: SwapBuffers() can call _CopyToDirect(), which should
// be always called with with the BGLView drawlocked.
// This is not always the case if called from here.
SwapBuffers();
}
#endif
}
struct swrast_renderbuffer*
MesaSoftwareRenderer::_NewRenderBuffer(bool front)
{
CALLED();
struct swrast_renderbuffer *swRenderBuffer
= (struct swrast_renderbuffer*)calloc(1, sizeof *swRenderBuffer);
if (!swRenderBuffer) {
ERROR("%s: Failed calloc RenderBuffer\n", __func__);
return NULL;
}
_mesa_init_renderbuffer(&swRenderBuffer->Base, 0);
swRenderBuffer->Base.ClassID = HAIKU_SWRAST_RENDERBUFFER_CLASS;
swRenderBuffer->Base.RefCount = 1;
swRenderBuffer->Base.Delete = _RenderBufferDelete;
if (!front)
swRenderBuffer->Base.AllocStorage = _RenderBufferStorageMalloc;
else
swRenderBuffer->Base.AllocStorage = _RenderBufferStorage;
if (_SetupRenderBuffer(&swRenderBuffer->Base, fColorSpace) != B_OK) {
free(swRenderBuffer);
return NULL;
}
return swRenderBuffer;
}
status_t
MesaSoftwareRenderer::_SetupRenderBuffer(struct gl_renderbuffer* rb,
color_space colorSpace)
{
CALLED();
rb->InternalFormat = GL_RGBA;
switch (colorSpace) {
case B_RGBA32:
rb->_BaseFormat = GL_RGBA;
rb->Format = MESA_FORMAT_ARGB8888;
break;
case B_RGB32:
rb->_BaseFormat = GL_RGB;
rb->Format = MESA_FORMAT_XRGB8888;
break;
case B_RGB24:
rb->_BaseFormat = GL_RGB;
rb->Format = MESA_FORMAT_RGB888;
break;
case B_RGB16:
rb->_BaseFormat = GL_RGB;
rb->Format = MESA_FORMAT_RGB565;
break;
case B_RGB15:
rb->_BaseFormat = GL_RGB;
rb->Format = MESA_FORMAT_ARGB1555;
break;
default:
fprintf(stderr, "Unsupported screen color space %s\n",
color_space_name(fColorSpace));
debugger("Unsupported OpenGL color space");
return B_ERROR;
}
return B_OK;
}
/*! Y inverted Map RenderBuffer function
We use a BBitmap for storage which has Y inverted.
If the Mesa provided Map function ever allows external
control of this we can omit this function.
*/
void
MesaSoftwareRenderer::_RenderBufferMap(gl_context *ctx,
struct gl_renderbuffer *rb, GLuint x, GLuint y, GLuint w, GLuint h,
GLbitfield mode, GLubyte **mapOut, GLint *rowStrideOut)
{
if (rb->ClassID == HAIKU_SWRAST_RENDERBUFFER_CLASS) {
struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
const GLuint bpp = _mesa_get_format_bytes(rb->Format);
GLint rowStride = rb->Width * bpp; // in Bytes
y = rb->Height - y - 1;
*rowStrideOut = -rowStride;
*mapOut = (GLubyte *) srb->Buffer + y * rowStride + x * bpp;
} else {
_swrast_map_soft_renderbuffer(ctx, rb, x, y, w, h, mode,
mapOut, rowStrideOut);
}
}
void
MesaSoftwareRenderer::_RenderBufferDelete(struct gl_context *ctx,
struct gl_renderbuffer* rb)
{
CALLED();
if (rb != NULL) {
struct swrast_renderbuffer *swRenderBuffer
= swrast_renderbuffer(rb);
if (swRenderBuffer != NULL)
free(swRenderBuffer->Buffer);
}
free(rb);
}
void
MesaSoftwareRenderer::_CopyToDirect()
{
BAutolock lock(fInfoLocker);
// 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())
return;
uint8 bytesPerPixel = fInfo->bits_per_pixel / 8;
uint32 bytesPerRow = fBitmap->BytesPerRow();
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;
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; y++) {
memcpy(p, b, bytesWidth);
p += fInfo->bytes_per_row;
b += bytesPerRow;
}
}
}
src/add-ons/opengl/swrast/MesaSoftwareRenderer.h
-97
View File
@@ -1,97 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected]
*/
#ifndef MESASOFTWARERENDERER_H
#define MESASOFTWARERENDERER_H
#define HAIKU_SWRAST_RENDERBUFFER_CLASS 0x737752 // swR
#include "GLRenderer.h"
extern "C" {
#include "context.h"
#include "main/version.h"
#include "swrast/s_chan.h"
#include "swrast/s_context.h"
}
class MesaSoftwareRenderer : public BGLRenderer {
public:
MesaSoftwareRenderer(BGLView* view,
ulong bgl_options,
BGLDispatcher* dispatcher);
virtual ~MesaSoftwareRenderer();
virtual void LockGL();
virtual void UnlockGL();
virtual void SwapBuffers(bool VSync = false);
virtual void Draw(BRect updateRect);
virtual status_t CopyPixelsOut(BPoint source, BBitmap* dest);
virtual status_t CopyPixelsIn(BBitmap* source, BPoint dest);
virtual void FrameResized(float width, float height);
virtual void EnableDirectMode(bool enabled);
virtual void DirectConnected(direct_buffer_info* info);
private:
static void _Error(gl_context* ctx);
static const GLubyte* _GetString(gl_context* ctx, GLenum name);
void _CheckResize(GLuint newWidth, GLuint newHeight);
static void _UpdateState(gl_context* ctx, GLuint newState);
static void _Flush(gl_context *ctx);
struct swrast_renderbuffer* _NewRenderBuffer(bool front);
status_t _SetupRenderBuffer(struct gl_renderbuffer* rb,
color_space colorSpace);
/* Mesa callbacks */
static void _RenderBufferDelete(struct gl_context *ctx,
struct gl_renderbuffer* rb);
static GLboolean _RenderBufferStorage(gl_context* ctx,
struct gl_renderbuffer* render,
GLenum internalFormat,
GLuint width, GLuint height);
static GLboolean _RenderBufferStorageMalloc(gl_context* ctx,
struct gl_renderbuffer* render,
GLenum internalFormat,
GLuint width, GLuint height);
static void _RenderBufferMap(gl_context *ctx,
struct gl_renderbuffer *rb,
GLuint x, GLuint y, GLuint w, GLuint h,
GLbitfield mode, GLubyte **mapOut,
GLint *rowStrideOut);
void _AllocateBitmap();
void _CopyToDirect();
BBitmap* fBitmap;
bool fDirectModeEnabled;
direct_buffer_info* fInfo;
BLocker fInfoLocker;
ulong fOptions;
gl_context* fContext;
gl_config* fVisual;
struct gl_framebuffer* fFrameBuffer;
struct swrast_renderbuffer* fFrontRenderBuffer;
struct swrast_renderbuffer* fBackRenderBuffer;
GLuint fWidth;
GLuint fHeight;
color_space fColorSpace;
void* fRowAddr[SWRAST_MAX_HEIGHT];
};
#endif // MESASOFTWARERENDERER_H
src/add-ons/opengl/swrast/MesaSoftwareRenderer.rdef
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright 2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
resource app_signature "application/x-vnd.Haiku-swrast";
resource app_version {
major = 9,
middle = 0,
minor = 0,
variety = 0,
internal = 0,
short_info = "Software Rasterizer",
long_info = "Haiku Mesa Software GL Rasterizer"
};
resource vector_icon {
$"6E6369660A0200140294A9FF18020014028DFFFF97058C0500020006023B10B7"
$"37F036BA1A993D466848C719BEBE2000919292FFD5D5D5020016023900000000"
$"000000003EE0004AE00048E0005EF884C702000203392E8D383001BAD97F3C12"
$"8B4786BD48B8AD0D97BBFFFF7B4168DBE9FF4168DB97020002023A0C1238D099"
$"BE44203F4BD14B38844678240DF56A7D9FE1EA064CC704016B0500090A044024"
$"2438404C5C380A044028243C40505C3C0A042438243B5C3C5C380608BFBE4D59"
$"4D59515957575659585560406044603C5E3A5C3CCB4FBFBA5E3ECA9DC11F564B"
$"584A544C504C0606AF0F2F3D2F3D393D4034BF593542324130432F42364432C0"
$"3FBC5A2F48354A2F480608AE9A22303EB5BD3AB42542B755422E412F3C29322D"
$"32223C0204263726372538263F253E263F304430443143303C313D303C02043D"
$"423D423C433D4A3C493D4A495049504A4F49474A484947060DAEAAAE014E445A"
$"3456365E325E3D5D3F5A3A5542544E4D573A4E364439463342324A2242310A0A"
$"0002020102403CA00C88888C8CC1401673C40D6544F2950A01010002403CA000"
$"0000000000401673C40D65446CF80A08020304023EC16A0000000000003EC16A"
$"45DD1844C6550A030105123EC16A0000000000003EC16A45DD1844C655011784"
$"22040A040105023EC16A0000000000003EC16A45DD1844C6550A030108123EC1"
$"6A0000000000003EC16A45DD1844C65501178422040A0503080706023EC16A00"
$"00000000003EC16A45DD1844C6550A030206071A3EC16A0000000000003EC16A"
$"45DD1844C65510FF0215810004178222040A060106023EC16A0000000000003E"
$"C16A45DD1844C6550A070107023EC16A0000000000003EC16A45DD1844C655"
};
src/add-ons/opengl/swrast_legacy/Jamfile
-54
View File
@@ -1,54 +0,0 @@
SubDir HAIKU_TOP src add-ons opengl swrast_legacy ;
SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] : true ;
# We need our public GL headers also when not compiling for Haiku.
}
{
local defines ;
defines = BEOS_THREADS GNU_ASSEMBLER ;
if $(TARGET_ARCH) = x86 {
defines += USE_X86_ASM USE_MMX_ASM USE_3DNOW_ASM USE_SSE_ASM ;
} else if $(TARGET_ARCH) = ppc {
# Not yet supported, as current Mesa3D PPC assembly is Linux-dependent!
# defines += USE_PPC_ASM ;
} else if $(TARGET_ARCH) = sparc {
defines += USE_SPARC_ASM ;
}
SubDirC++Flags [ FDefines $(defines) ] ;
}
local sources = MesaSoftwareRenderer.cpp ;
UsePrivateHeaders interface ;
UseBuildFeatureHeaders mesa ;
Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
UseHeaders [ BuildFeatureAttribute mesa : headers : path ] ;
local privateHeaders = [ BuildFeatureAttribute mesa : privateHeaders : path ] ;
UseHeaders [ FDirName $(privateHeaders) mesa ] ;
UseHeaders [ FDirName $(privateHeaders) mesa main ] ;
UseHeaders [ FDirName $(privateHeaders) mapi ] ;
UseHeaders [ FDirName $(privateHeaders) mapi glapi ] ;
# For older versions of Mesa
UseHeaders [ FDirName $(privateHeaders) mesa glapi ] ;
UseHeaders [ FDirName $(privateHeaders) mesa tnl ] ;
UseHeaders [ FDirName $(privateHeaders) mesa x86 ] ;
AddResources Legacy\ Software\ Rasterizer : MesaSoftwareRenderer.rdef ;
Addon Legacy\ Software\ Rasterizer :
$(sources)
:
[ BuildFeatureAttribute mesa : mesaLibrary ]
libGL.so be $(TARGET_LIBSUPC++)
;
src/add-ons/opengl/swrast_legacy/MesaSoftwareRenderer.cpp
-901
View File
@@ -1,901 +0,0 @@
/*
* Copyright 2006-2011, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected]
* Alexander von Gluck, [email protected]
*/
/*
* Mesa 3-D graphics library
* Version: 6.1
*
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*/
#include "MesaSoftwareRenderer.h"
#include <Autolock.h>
#include <DirectWindowPrivate.h>
#include <GraphicsDefs.h>
#include <Screen.h>
#include <stdio.h>
#include <string.h>
extern "C" {
#include "extensions.h"
#include "drivers/common/driverfuncs.h"
#include "drivers/common/meta.h"
#include "main/colormac.h"
#include "main/cpuinfo.h"
#include "main/buffers.h"
#include "main/formats.h"
#include "main/framebuffer.h"
#include "main/renderbuffer.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
#include "vbo/vbo.h"
//#define TRACE_SOFTGL
#ifdef TRACE_SOFTGL
# define TRACE(x...) printf("MesaSoftwareRenderer: " x)
# define CALLED() printf("MesaSoftwareRenderer: %s\n", __PRETTY_FUNCTION__)
#else
# define TRACE(x...)
# define CALLED()
#endif
#define ERROR(x...) printf("MesaSoftwareRenderer: " x)
}
extern const char* color_space_name(color_space space);
// BeOS component ordering for B_RGBA32 bitmap format
#if B_HOST_IS_LENDIAN
#define BE_RCOMP 2
#define BE_GCOMP 1
#define BE_BCOMP 0
#define BE_ACOMP 3
#else
// Big Endian B_RGBA32 bitmap format
#define BE_RCOMP 1
#define BE_GCOMP 2
#define BE_BCOMP 3
#define BE_ACOMP 0
#endif
/**********************************************************************/
/***** Read/write spans/arrays of pixels *****/
/**********************************************************************/
extern "C" {
/* 32-bit RGBA */
#define NAME(PREFIX) PREFIX##_RGBA32
#define RB_TYPE GLubyte
#define SPAN_VARS \
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
#define INIT_PIXEL_PTR(P, X, Y) \
GLubyte* P = ((GLubyte**)mr->GetRows())[Y] + (X) * 4
#define INC_PIXEL_PTR(P) P += 4
#define STORE_PIXEL(DST, X, Y, VALUE) \
DST[BE_RCOMP] = VALUE[RCOMP]; \
DST[BE_GCOMP] = VALUE[GCOMP]; \
DST[BE_BCOMP] = VALUE[BCOMP]; \
DST[BE_ACOMP] = VALUE[ACOMP]
#define STORE_PIXEL_RGB(DST, X, Y, VALUE) \
DST[BE_RCOMP] = VALUE[RCOMP]; \
DST[BE_GCOMP] = VALUE[GCOMP]; \
DST[BE_BCOMP] = VALUE[BCOMP]; \
DST[BE_ACOMP] = 255
#define FETCH_PIXEL(DST, SRC) \
DST[RCOMP] = SRC[BE_RCOMP]; \
DST[GCOMP] = SRC[BE_GCOMP]; \
DST[BCOMP] = SRC[BE_BCOMP]; \
DST[ACOMP] = SRC[BE_ACOMP]
#include "swrast/s_spantemp.h"
/* 32-bit RGB */
#define NAME(PREFIX) PREFIX##_RGB32
#define RB_TYPE GLubyte
#define SPAN_VARS \
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
#define INIT_PIXEL_PTR(P, X, Y) \
GLuint* P = (GLuint*)(((GLubyte**)mr->GetRows())[Y] + (X) * 4)
#define INC_PIXEL_PTR(P) P += 1
#define STORE_PIXEL(DST, X, Y, VALUE) \
*DST = ( ((VALUE[RCOMP]) << 16) | \
((VALUE[GCOMP]) << 8) | \
((VALUE[BCOMP]) ) )
#define FETCH_PIXEL(DST, SRC) \
DST[RCOMP] = ((*SRC & 0x00ff0000) >> 16); \
DST[GCOMP] = ((*SRC & 0x0000ff00) >> 8); \
DST[BCOMP] = ((*SRC & 0x000000ff)); \
DST[ACOMP] = 0xff;
#include "swrast/s_spantemp.h"
/* 24-bit RGB */
#define NAME(PREFIX) PREFIX##_RGB24
#define RB_TYPE GLubyte
#define SPAN_VARS \
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
#define INIT_PIXEL_PTR(P, X, Y) \
GLubyte* P = ((GLubyte**)mr->GetRows())[Y] + (X) * 3
#define INC_PIXEL_PTR(P) P += 3
#define STORE_PIXEL(DST, X, Y, VALUE) \
DST[BE_RCOMP] = VALUE[RCOMP]; \
DST[BE_GCOMP] = VALUE[GCOMP]; \
DST[BE_BCOMP] = VALUE[BCOMP];
#define FETCH_PIXEL(DST, SRC) \
DST[RCOMP] = SRC[BE_RCOMP]; \
DST[GCOMP] = SRC[BE_GCOMP]; \
DST[BCOMP] = SRC[BE_BCOMP]; \
DST[ACOMP] = 0xff;
#include "swrast/s_spantemp.h"
/* 16-bit RGB */
#define NAME(PREFIX) PREFIX##_RGB16
#define RB_TYPE GLubyte
#define SPAN_VARS \
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
#define INIT_PIXEL_PTR(P, X, Y) \
GLushort* P = (GLushort*)(((GLubyte**)mr->GetRows())[Y] + (X) * 2)
#define INC_PIXEL_PTR(P) P += 1
#define STORE_PIXEL(DST, X, Y, VALUE) \
*DST = ( (((VALUE[RCOMP]) & 0xf8) << 8) | \
(((VALUE[GCOMP]) & 0xfc) << 3) | \
(((VALUE[BCOMP]) ) >> 3) )
#define FETCH_PIXEL(DST, SRC) \
DST[RCOMP] = ((*SRC & 0xf800) >> 8); \
DST[GCOMP] = ((*SRC & 0x07e0) >> 3); \
DST[BCOMP] = ((*SRC & 0x001f) << 3); \
DST[ACOMP] = 0xff
#include "swrast/s_spantemp.h"
/* 15-bit RGB */
#define NAME(PREFIX) PREFIX##_RGB15
#define RB_TYPE GLubyte
#define SPAN_VARS \
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
#define INIT_PIXEL_PTR(P, X, Y) \
GLushort* P = (GLushort*)(((GLubyte**)mr->GetRows())[Y] + (X) * 2)
#define INC_PIXEL_PTR(P) P += 1
#define STORE_PIXEL(DST, X, Y, VALUE) \
*DST = ( (((VALUE[RCOMP]) & 0xf8) << 7) | \
(((VALUE[GCOMP]) & 0xf8) << 2) | \
(((VALUE[BCOMP]) ) >> 3) )
#define FETCH_PIXEL(DST, SRC) \
DST[RCOMP] = ((*SRC & 0x7c00) >> 7); \
DST[GCOMP] = ((*SRC & 0x03e0) >> 2); \
DST[BCOMP] = ((*SRC & 0x001f) << 3); \
DST[ACOMP] = 0xff
#include "swrast/s_spantemp.h"
}
extern "C" _EXPORT BGLRenderer*
instantiate_gl_renderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
{
return new MesaSoftwareRenderer(view, options, dispatcher);
}
MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
: BGLRenderer(view, options, dispatcher),
fBitmap(NULL),
fDirectModeEnabled(false),
fInfo(NULL),
fInfoLocker("info locker"),
fContext(NULL),
fVisual(NULL),
fFrameBuffer(NULL),
fFrontRenderBuffer(NULL),
fBackRenderBuffer(NULL),
fColorSpace(B_NO_COLOR_SPACE)
{
CALLED();
fClearColor[BE_RCOMP] = 0;
fClearColor[BE_GCOMP] = 0;
fClearColor[BE_BCOMP] = 0;
fClearColor[BE_ACOMP] = 0;
fClearIndex = 0;
fColorSpace = BScreen(GLView()->Window()).ColorSpace();
// We force single buffering for the time being
options &= ~BGL_DOUBLE;
const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
const GLboolean dblFlag = ((options & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean stereoFlag = false;
const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
const GLint red = rgbFlag ? 8 : 0;
const GLint green = rgbFlag ? 8 : 0;
const GLint blue = rgbFlag ? 8 : 0;
const GLint alpha = alphaFlag ? 8 : 0;
fOptions = options; // | BGL_INDIRECT;
struct dd_function_table functions;
fVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green,
blue, alpha, depth, stencil, accum, accum, accum,
alpha ? accum : 0, 1);
// Initialize device driver function table
_mesa_init_driver_functions(&functions);
functions.GetString = _GetString;
functions.UpdateState = _UpdateState;
functions.GetBufferSize = NULL;
functions.Error = _Error;
functions.Viewport = _Viewport;
functions.Flush = _Flush;
// create core context
fContext = _mesa_create_context(fVisual, NULL, &functions, this);
if (!fContext) {
ERROR("%s: Failed to create Mesa context!\n", __func__);
_mesa_destroy_visual(fVisual);
return;
}
/* Initialize the software rasterizer and helper modules. */
_swrast_CreateContext(fContext);
_vbo_CreateContext(fContext);
_tnl_CreateContext(fContext);
_swsetup_CreateContext(fContext);
_swsetup_Wakeup(fContext);
// Use default TCL pipeline
TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline;
_mesa_meta_init(fContext);
_mesa_enable_sw_extensions(fContext);
_mesa_enable_1_3_extensions(fContext);
_mesa_enable_1_4_extensions(fContext);
_mesa_enable_1_5_extensions(fContext);
_mesa_enable_2_0_extensions(fContext);
_mesa_enable_2_1_extensions(fContext);
// create core framebuffer
fFrameBuffer = (struct msr_framebuffer*)calloc(1,
sizeof(*fFrameBuffer));
if (fFrameBuffer == NULL) {
ERROR("%s: Unable to calloc GL FrameBuffer!\n", __func__);
_mesa_destroy_visual(fVisual);
return;
}
_mesa_initialize_window_framebuffer(&fFrameBuffer->base, fVisual);
// Setup front render buffer
fFrontRenderBuffer = _NewRenderBuffer(true);
if (fFrontRenderBuffer == NULL) {
ERROR("%s: FrontRenderBuffer is requested but unallocated!\n",
__func__);
_mesa_destroy_visual(fVisual);
free(fFrameBuffer);
return;
}
_mesa_add_renderbuffer(&fFrameBuffer->base, BUFFER_FRONT_LEFT,
&fFrontRenderBuffer->base);
// Setup back render buffer (if requested)
if (fVisual->doubleBufferMode) {
fBackRenderBuffer = _NewRenderBuffer(false);
if (fBackRenderBuffer == NULL) {
ERROR("%s: BackRenderBuffer is requested but unallocated!\n",
__func__);
_mesa_destroy_visual(fVisual);
free(fFrameBuffer);
return;
}
_mesa_add_renderbuffer(&fFrameBuffer->base, BUFFER_BACK_LEFT,
&fBackRenderBuffer->base);
}
_mesa_add_soft_renderbuffers(&fFrameBuffer->base, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
BRect bounds = view->Bounds();
fWidth = fNewWidth = (GLint)bounds.Width();
fHeight = fNewHeight = (GLint)bounds.Height();
// some stupid applications (Quake2) don't even think about calling LockGL()
// before using glGetString and its glGet*() friends...
// so make sure there is at least a valid context.
if (!_mesa_get_current_context()) {
LockGL();
// not needed, we don't have a looper yet: UnlockLooper();
}
}
MesaSoftwareRenderer::~MesaSoftwareRenderer()
{
CALLED();
_swsetup_DestroyContext(fContext);
_swrast_DestroyContext(fContext);
_tnl_DestroyContext(fContext);
_vbo_DestroyContext(fContext);
_mesa_destroy_visual(fVisual);
_mesa_destroy_framebuffer(&fFrameBuffer->base);
_mesa_destroy_context(fContext);
free(fInfo);
free(fFrameBuffer);
delete fBitmap;
}
void
MesaSoftwareRenderer::LockGL()
{
CALLED();
BGLRenderer::LockGL();
_mesa_make_current(fContext, &fFrameBuffer->base, &fFrameBuffer->base);
color_space colorSpace = BScreen(GLView()->Window()).ColorSpace();
BAutolock lock(fInfoLocker);
if (fDirectModeEnabled && fInfo != NULL) {
fNewWidth = fInfo->window_bounds.right
- fInfo->window_bounds.left + 1;
fNewHeight = fInfo->window_bounds.bottom
- fInfo->window_bounds.top + 1;
}
if (fColorSpace != colorSpace) {
fColorSpace = colorSpace;
_SetupRenderBuffer(fFrontRenderBuffer, fColorSpace);
if (fVisual->doubleBufferMode)
_SetupRenderBuffer(fBackRenderBuffer, fColorSpace);
}
_CheckResize();
}
void
MesaSoftwareRenderer::UnlockGL()
{
CALLED();
_mesa_make_current(fContext, NULL, NULL);
BGLRenderer::UnlockGL();
}
void
MesaSoftwareRenderer::SwapBuffers(bool VSync)
{
CALLED();
if (!fBitmap)
return;
if (fVisual->doubleBufferMode)
_mesa_notifySwapBuffers(fContext);
if (!fDirectModeEnabled || fInfo == NULL) {
if (GLView()->LockLooperWithTimeout(1000) == B_OK) {
GLView()->DrawBitmap(fBitmap, B_ORIGIN);
GLView()->UnlockLooper();
}
} else {
// TODO: Here the BGLView needs to be drawlocked.
_CopyToDirect();
}
if (VSync) {
BScreen screen(GLView()->Window());
screen.WaitForRetrace();
}
}
void
MesaSoftwareRenderer::Draw(BRect updateRect)
{
CALLED();
if (fBitmap && (!fDirectModeEnabled || (fInfo == NULL)))
GLView()->DrawBitmap(fBitmap, updateRect, updateRect);
}
status_t
MesaSoftwareRenderer::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)) {
fprintf(stderr, "CopyPixelsOut(): incompatible color space: %s != %s\n",
color_space_name(scs),
color_space_name(dcs));
return B_BAD_TYPE;
}
BRect sr = fBitmap->Bounds();
BRect dr = bitmap->Bounds();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8* ps = (uint8*) fBitmap->Bits();
uint8* pd = (uint8*) bitmap->Bits();
uint32* s;
uint32* 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
MesaSoftwareRenderer::CopyPixelsIn(BBitmap* bitmap, BPoint location)
{
CALLED();
color_space scs = bitmap->ColorSpace();
color_space dcs = fBitmap->ColorSpace();
if (scs != dcs && (dcs != B_RGBA32 || scs != B_RGB32)) {
fprintf(stderr, "CopyPixelsIn(): incompatible color space: %s != %s\n",
color_space_name(scs),
color_space_name(dcs));
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;
uint32* 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
MesaSoftwareRenderer::EnableDirectMode(bool enabled)
{
fDirectModeEnabled = enabled;
}
void
MesaSoftwareRenderer::DirectConnected(direct_buffer_info* info)
{
// TODO: I'm not sure we need to do this: BGLView already
// keeps a local copy of the direct_buffer_info passed by
// BDirectWindow::DirectConnected().
BAutolock lock(fInfoLocker);
if (info) {
if (!fInfo) {
fInfo = (direct_buffer_info*)malloc(DIRECT_BUFFER_INFO_AREA_SIZE);
if (!fInfo)
return;
}
memcpy(fInfo, info, DIRECT_BUFFER_INFO_AREA_SIZE);
} else if (fInfo) {
free(fInfo);
fInfo = NULL;
}
}
void
MesaSoftwareRenderer::FrameResized(float width, float height)
{
BAutolock lock(fInfoLocker);
fNewWidth = (GLuint)width;
fNewHeight = (GLuint)height;
_CheckResize();
}
void
MesaSoftwareRenderer::_CheckResize()
{
CALLED();
if (fBitmap && fNewWidth == fWidth
&& fNewHeight == fHeight) {
return;
}
fHeight = fNewHeight;
fWidth = fNewWidth;
_mesa_resize_framebuffer(fContext, &fFrameBuffer->base, fWidth, fHeight);
_AllocateBitmap();
}
void
MesaSoftwareRenderer::_AllocateBitmap()
{
CALLED();
// allocate new size of back buffer bitmap
delete fBitmap;
fBitmap = NULL;
if (fWidth < 1 || fHeight < 1) {
TRACE("%s: Cannot allocate bitmap < 1x1!\n", __func__);
return;
}
BRect rect(0.0, 0.0, fWidth - 1, fHeight - 1);
fBitmap = new BBitmap(rect, fColorSpace);
for (uint i = 0; i < fHeight; i++) {
fRowAddr[fHeight - i - 1] = (GLvoid *)((GLubyte *)fBitmap->Bits()
+ i * fBitmap->BytesPerRow());
}
fFrontRenderBuffer->size = fBitmap->BitsLength();
if (fVisual->doubleBufferMode)
fBackRenderBuffer->size = fBitmap->BitsLength();
fFrameBuffer->width = fWidth;
fFrameBuffer->height = fHeight;
TRACE("%s: Bitmap Size: %" B_PRIu32 "\n", __func__, fBitmap->BitsLength());
fFrontRenderBuffer->base.Data = fBitmap->Bits();
}
// #pragma mark - static
void
MesaSoftwareRenderer::_Error(gl_context* ctx)
{
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
if (mr && mr->GLView())
mr->GLView()->ErrorCallback((unsigned long)ctx->ErrorValue);
}
const GLubyte*
MesaSoftwareRenderer::_GetString(gl_context* ctx, GLenum name)
{
switch (name) {
case GL_VENDOR:
return (const GLubyte*) "Mesa Project";
case GL_RENDERER: {
_mesa_get_cpu_features();
static char buffer[256] = { '\0' };
if (!buffer[0]) {
char* cpuInfo = _mesa_get_cpu_string();
// Let's build an renderer string
sprintf(buffer, "Software Rasterizer for %s", cpuInfo);
free(cpuInfo);
}
return (const GLubyte*) buffer;
}
default:
// Let core library handle all other cases
return NULL;
}
}
void
MesaSoftwareRenderer::_Viewport(gl_context* ctx, GLint x, GLint y, GLsizei w,
GLsizei h)
{
CALLED();
gl_framebuffer* draw = ctx->WinSysDrawBuffer;
gl_framebuffer* read = ctx->WinSysReadBuffer;
struct msr_framebuffer* msr = msr_framebuffer(draw);
_mesa_resize_framebuffer(ctx, draw, msr->width, msr->height);
_mesa_resize_framebuffer(ctx, read, msr->width, msr->height);
}
void
MesaSoftwareRenderer::_UpdateState(gl_context* ctx, GLuint new_state)
{
if (!ctx)
return;
CALLED();
_swrast_InvalidateState(ctx, new_state);
_swsetup_InvalidateState(ctx, new_state);
_vbo_InvalidateState(ctx, new_state);
_tnl_InvalidateState(ctx, new_state);
}
void
MesaSoftwareRenderer::_ClearFront(gl_context* ctx)
{
CALLED();
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
BGLView* bglview = mr->GLView();
assert(bglview);
BBitmap* bitmap = mr->fBitmap;
assert(bitmap);
GLuint* start = (GLuint*)bitmap->Bits();
size_t pixelSize = 0;
get_pixel_size_for(bitmap->ColorSpace(), &pixelSize, NULL, NULL);
const GLuint* clearPixelPtr = (const GLuint*)mr->fClearColor;
const GLuint clearPixel = B_LENDIAN_TO_HOST_INT32(*clearPixelPtr);
int x = ctx->DrawBuffer->_Xmin;
int y = ctx->DrawBuffer->_Ymin;
uint32 width = ctx->DrawBuffer->_Xmax - x;
uint32 height = ctx->DrawBuffer->_Ymax - y;
GLboolean all = (width == ctx->DrawBuffer->Width
&& height == ctx->DrawBuffer->Height);
if (all) {
const int numPixels = mr->fWidth * mr->fHeight;
if (clearPixel == 0) {
memset(start, 0, numPixels * pixelSize);
} else {
for (int i = 0; i < numPixels; i++) {
start[i] = clearPixel;
}
}
} else {
// XXX untested
start += y * mr->fWidth + x;
for (uint32 i = 0; i < height; i++) {
for (uint32 j = 0; j < width; j++) {
start[j] = clearPixel;
}
start += mr->fWidth;
}
}
}
GLboolean
MesaSoftwareRenderer::_FrontRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height)
{
CALLED();
render->Data = NULL;
render->Width = width;
render->Height = height;
return GL_TRUE;
}
GLboolean
MesaSoftwareRenderer::_BackRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height)
{
CALLED();
struct msr_renderbuffer* mrb = msr_renderbuffer(render);
free(render->Data);
_FrontRenderbufferStorage(ctx, render, internalFormat, width, height);
if (mrb->size)
ERROR("%s: suspicious malloc of 0 bytes.\n", __func__);
render->Data = malloc(mrb->size);
return GL_TRUE;
}
void
MesaSoftwareRenderer::_Flush(gl_context* ctx)
{
CALLED();
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
if ((mr->fOptions & BGL_DOUBLE) == 0) {
// TODO: SwapBuffers() can call _CopyToDirect(), which should
// be always called with with the BGLView drawlocked.
// This is not always the case if called from here.
mr->SwapBuffers();
}
}
struct msr_renderbuffer*
MesaSoftwareRenderer::_NewRenderBuffer(bool front)
{
CALLED();
struct msr_renderbuffer *msr
= (struct msr_renderbuffer*)calloc(1, sizeof *msr);
if (!msr) {
ERROR("%s: Failed calloc RenderBuffer\n", __func__);
return NULL;
}
_mesa_init_renderbuffer(&msr->base, 0);
if (_SetupRenderBuffer(msr, fColorSpace) != B_OK) {
free(msr);
return NULL;
}
if (front)
msr->base.AllocStorage = _FrontRenderbufferStorage;
else {
msr->base.AllocStorage = _BackRenderbufferStorage;
msr->base.Delete = _DeleteBackBuffer;
}
return msr;
}
status_t
MesaSoftwareRenderer::_SetupRenderBuffer(
struct msr_renderbuffer* buffer, color_space colorSpace)
{
CALLED();
buffer->base.DataType = GL_UNSIGNED_BYTE;
buffer->base.Data = NULL;
switch (colorSpace) {
case B_RGBA32:
buffer->base._BaseFormat = GL_RGBA;
buffer->base.Format = MESA_FORMAT_ARGB8888;
buffer->base.GetRow = get_row_RGBA32;
buffer->base.GetValues = get_values_RGBA32;
buffer->base.PutRow = put_row_RGBA32;
buffer->base.PutValues = put_values_RGBA32;
buffer->base.PutRowRGB = put_row_rgb_RGBA32;
buffer->base.PutMonoRow = put_mono_row_RGBA32;
buffer->base.PutMonoValues = put_values_RGBA32;
break;
case B_RGB32:
buffer->base._BaseFormat = GL_RGB;
buffer->base.Format = MESA_FORMAT_ARGB8888;
buffer->base.GetRow = get_row_RGB32;
buffer->base.GetValues = get_values_RGB32;
buffer->base.PutRow = put_row_RGB32;
buffer->base.PutValues = put_values_RGB32;
buffer->base.PutRowRGB = put_row_rgb_RGB32;
buffer->base.PutMonoRow = put_mono_row_RGB32;
buffer->base.PutMonoValues = put_values_RGB32;
break;
case B_RGB24:
buffer->base._BaseFormat = GL_RGB;
buffer->base.Format = MESA_FORMAT_RGB888;
buffer->base.GetRow = get_row_RGB24;
buffer->base.GetValues = get_values_RGB24;
buffer->base.PutRow = put_row_RGB24;
buffer->base.PutValues = put_values_RGB24;
buffer->base.PutRowRGB = put_row_rgb_RGB24;
buffer->base.PutMonoRow = put_mono_row_RGB24;
buffer->base.PutMonoValues = put_values_RGB24;
break;
case B_RGB16:
buffer->base._BaseFormat = GL_RGB;
buffer->base.Format = MESA_FORMAT_RGB565;
buffer->base.GetRow = get_row_RGB16;
buffer->base.GetValues = get_values_RGB16;
buffer->base.PutRow = put_row_RGB16;
buffer->base.PutValues = put_values_RGB16;
buffer->base.PutRowRGB = put_row_rgb_RGB16;
buffer->base.PutMonoRow = put_mono_row_RGB16;
buffer->base.PutMonoValues = put_values_RGB16;
break;
case B_RGB15:
buffer->base._BaseFormat = GL_RGB;
buffer->base.Format = MESA_FORMAT_ARGB1555;
buffer->base.GetRow = get_row_RGB15;
buffer->base.GetValues = get_values_RGB15;
buffer->base.PutRow = put_row_RGB15;
buffer->base.PutValues = put_values_RGB15;
buffer->base.PutRowRGB = put_row_rgb_RGB15;
buffer->base.PutMonoRow = put_mono_row_RGB15;
buffer->base.PutMonoValues = put_values_RGB15;
break;
default:
fprintf(stderr, "Unsupported screen color space %s\n",
color_space_name(fColorSpace));
debugger("Unsupported OpenGL color space");
return B_ERROR;
}
return B_OK;
}
void
MesaSoftwareRenderer::_DeleteBackBuffer(struct gl_renderbuffer* rb)
{
CALLED();
free(rb->Data);
free(rb);
}
void
MesaSoftwareRenderer::_CopyToDirect()
{
BAutolock lock(fInfoLocker);
// 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())
return;
uint8 bytesPerPixel = fInfo->bits_per_pixel / 8;
uint32 bytesPerRow = fBitmap->BytesPerRow();
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;
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; y++) {
memcpy(p, b, bytesWidth);
p += fInfo->bytes_per_row;
b += bytesPerRow;
}
}
}
src/add-ons/opengl/swrast_legacy/MesaSoftwareRenderer.h
-131
View File
@@ -1,131 +0,0 @@
/*
* Copyright 2006-2008, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected]
*/
/*
* Mesa 3-D graphics library
* Version: 6.1
*
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*/
#ifndef MESASOFTWARERENDERER_H
#define MESASOFTWARERENDERER_H
#include "GLRenderer.h"
extern "C" {
#include "context.h"
#include "main/version.h"
#define gl_context GLcontext
#define gl_config GLvisual
struct msr_renderbuffer {
struct gl_renderbuffer base;
uint32 size;
};
static INLINE struct msr_renderbuffer*
msr_renderbuffer(struct gl_renderbuffer* rb)
{
return (struct msr_renderbuffer*)rb;
}
struct msr_framebuffer {
struct gl_framebuffer base;
uint32 width;
uint32 height;
};
static INLINE struct msr_framebuffer*
msr_framebuffer(struct gl_framebuffer* rb)
{
return (struct msr_framebuffer*)rb;
}
}
class MesaSoftwareRenderer : public BGLRenderer {
public:
MesaSoftwareRenderer(BGLView* view,
ulong bgl_options,
BGLDispatcher* dispatcher);
virtual ~MesaSoftwareRenderer();
virtual void LockGL();
virtual void UnlockGL();
virtual void SwapBuffers(bool VSync = false);
virtual void Draw(BRect updateRect);
virtual status_t CopyPixelsOut(BPoint source, BBitmap* dest);
virtual status_t CopyPixelsIn(BBitmap* source, BPoint dest);
virtual void FrameResized(float width, float height);
GLvoid** GetRows() { return fRowAddr; }
virtual void EnableDirectMode(bool enabled);
virtual void DirectConnected(direct_buffer_info* info);
private:
static void _Error(gl_context* ctx);
static const GLubyte* _GetString(gl_context* ctx, GLenum name);
static void _Viewport(gl_context* ctx, GLint x, GLint y,
GLsizei w, GLsizei h);
void _CheckResize();
static void _UpdateState(gl_context* ctx, GLuint newState);
static void _ClearFront(gl_context* ctx);
static GLboolean _FrontRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render,
GLenum internalFormat,
GLuint width, GLuint height);
static GLboolean _BackRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render,
GLenum internalFormat,
GLuint width, GLuint height);
static void _Flush(gl_context *ctx);
struct msr_renderbuffer* _NewRenderBuffer(bool front);
status_t _SetupRenderBuffer(struct msr_renderbuffer*
buffer, color_space colorSpace);
static void _DeleteBackBuffer(struct gl_renderbuffer* rb);
void _AllocateBitmap();
void _CopyToDirect();
BBitmap* fBitmap;
bool fDirectModeEnabled;
direct_buffer_info* fInfo;
BLocker fInfoLocker;
ulong fOptions;
gl_context* fContext;
gl_config* fVisual;
struct msr_framebuffer* fFrameBuffer;
struct msr_renderbuffer* fFrontRenderBuffer;
struct msr_renderbuffer* fBackRenderBuffer;
GLchan fClearColor[4]; // buffer clear color
GLuint fClearIndex; // buffer clear color index
GLuint fWidth, fNewWidth;
GLuint fHeight, fNewHeight;
color_space fColorSpace;
GLvoid* fRowAddr[MAX_HEIGHT];
// address of first pixel in each image row
};
#endif // MESASOFTWARERENDERER_H
src/add-ons/opengl/swrast_legacy/MesaSoftwareRenderer.rdef
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright 2012, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
resource app_signature "application/x-vnd.Haiku-swrast_legacy";
resource app_version {
major = 7,
middle = 8,
minor = 2,
variety = 0,
internal = 0,
short_info = "Legacy Software Rasterizer",
long_info = "Haiku Legacy Mesa Software GL Rasterizer (gcc2)"
};
resource vector_icon {
$"6E6369660A020014029448FF18020014028DA5FF50058C0500020006023B10B7"
$"37F036BA1A993D466848C719BEBE2000919292FFD5D5D5020016023900000000"
$"000000003EE0004AE00048E0005EF884C702000203392E8D383001BAD97F3C12"
$"8B4786BD48B8AD0D97BBFFFF7B4168DBE9FF4168DB97020002023A0C1238D099"
$"BE44203F4BD14B38844678240DF56A7D9FE1EA064CC704016B0500090A044024"
$"2438404C5C380A044028243C40505C3C0A042438243B5C3C5C380608BFBE4D59"
$"4D59515957575659585560406044603C5E3A5C3CCB4FBFBA5E3ECA9DC11F564B"
$"584A544C504C0606AF0F2F3D2F3D393D4034BF593542324130432F42364432C0"
$"3FBC5A2F48354A2F480608AE9A22303EB5BD3AB42542B755422E412F3C29322D"
$"32223C0204263726372538263F253E263F304430443143303C313D303C02043D"
$"423D423C433D4A3C493D4A495049504A4F49474A484947060DAEAAAE014E445A"
$"3456365E325E3D5D3F5A3A5542544E4D573A4E364439463342324A2242310A0A"
$"0002020102403CA00C88888C8CC1401673C40D6544F2950A01010002403CA000"
$"0000000000401673C40D65446CF80A08020304023EC16A0000000000003EC16A"
$"45DD1844C6550A030105123EC16A0000000000003EC16A45DD1844C655011784"
$"22040A040105023EC16A0000000000003EC16A45DD1844C6550A030108123EC1"
$"6A0000000000003EC16A45DD1844C65501178422040A0503080706023EC16A00"
$"00000000003EC16A45DD1844C6550A030206071A3EC16A0000000000003EC16A"
$"45DD1844C65510FF0215810004178222040A060106023EC16A0000000000003E"
$"C16A45DD1844C6550A070107023EC16A0000000000003EC16A45DD1844C655"
};
src/add-ons/screen_savers/flurry/Jamfile
+2 -1
View File
@@ -21,8 +21,9 @@ Includes [ FGristFiles $(sources) ] :
ScreenSaver Flurry :
$(sources) :
be screensaver GL localestub $(TARGET_LIBSUPC++)
be screensaver localestub $(TARGET_LIBSUPC++)
[ BuildFeatureAttribute glu : library ]
[ BuildFeatureAttribute mesa : library ]
;
DoCatalogs Flurry :
src/add-ons/screen_savers/glife/Jamfile
+2 -1
View File
@@ -25,8 +25,9 @@ AddResources GLife : GLife.rdef ;
ScreenSaver GLife :
$(sources) :
be screensaver GL localestub $(TARGET_LIBSUPC++)
be screensaver localestub $(TARGET_LIBSUPC++)
[ BuildFeatureAttribute glu : library ]
[ BuildFeatureAttribute mesa : library ]
;
DoCatalogs GLife :
src/add-ons/screen_savers/gravity/Jamfile
+2 -1
View File
@@ -28,8 +28,9 @@ Includes [ FGristFiles $(sources) ] :
ScreenSaver Gravity :
$(sources)
:
be screensaver GL localestub $(TARGET_LIBSTDC++)
be screensaver localestub $(TARGET_LIBSTDC++)
[ BuildFeatureAttribute glu : library ]
[ BuildFeatureAttribute mesa : library ]
;
DoCatalogs Gravity :
src/apps/3dmov/Jamfile
+6 -2
View File
@@ -8,6 +8,7 @@ if $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) < 3 {
SubDirC++Flags --no-warnings ;
}
local sources =
Application.cpp
MainWindow.cpp
@@ -17,13 +18,16 @@ local sources =
ViewCube.cpp
ViewSphere.cpp
GLUtility.cpp
;
;
Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
Application 3DMov :
$(sources)
: be GL game localestub media translation $(TARGET_LIBSUPC++)
:
be game
[ BuildFeatureAttribute mesa : library ]
localestub media translation $(TARGET_LIBSUPC++)
: 3dmov.rdef
;
src/apps/glteapot/Jamfile
+2 -1
View File
@@ -21,8 +21,9 @@ Includes [ FGristFiles $(sources) ] :
Application GLTeapot :
$(sources)
:
be GL game localestub $(TARGET_LIBSUPC++)
be game localestub $(TARGET_LIBSUPC++)
[ BuildFeatureAttribute glu : library ]
[ BuildFeatureAttribute mesa : library ]
: GLTeapot.rdef
;
src/apps/haiku3d/Jamfile
+2 -1
View File
@@ -38,7 +38,8 @@ Includes [ FGristFiles $(sources) ] :
Application Haiku3d :
$(sources)
:
be game GL media translation $(TARGET_LIBSTDC++)
be game media translation $(TARGET_LIBSTDC++)
[ BuildFeatureAttribute glu : library ]
[ BuildFeatureAttribute mesa : library ]
: Haiku3d.rdef
;
src/kits/Jamfile
-1
View File
@@ -107,7 +107,6 @@ SubInclude HAIKU_TOP src kits media ;
SubInclude HAIKU_TOP src kits midi ;
SubInclude HAIKU_TOP src kits midi2 ;
SubInclude HAIKU_TOP src kits network ;
SubInclude HAIKU_TOP src kits opengl ;
SubInclude HAIKU_TOP src kits package ;
SubInclude HAIKU_TOP src kits print ;
SubInclude HAIKU_TOP src kits screensaver ;
src/kits/opengl/GLDispatcher.cpp
-75
View File
@@ -1,75 +0,0 @@
/*
* Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000-2012 Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Brian Paul <[email protected]>
* Philippe Houdoin <[email protected]>
*/
extern "C" {
#include "glapi.h"
#if __GNUC__ > 2
// New Mesa
#include "glapi_priv.h"
#endif
/*
* NOTE: this file portion implements C-based dispatch of the OpenGL entrypoints
* (glAccum, glBegin, etc).
* This code IS NOT USED if we're compiling on an x86 system and using
* the glapi_x86.S assembly code.
*/
#if !(defined(USE_X86_ASM) || defined(USE_SPARC_ASM))
#define KEYWORD1 PUBLIC
#define KEYWORD2
#define NAME(func) gl##func
#define DISPATCH(func, args, msg) \
const struct _glapi_table* dispatch; \
dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
(dispatch->func) args
#define RETURN_DISPATCH(func, args, msg) \
const struct _glapi_table* dispatch; \
dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
return (dispatch->func) args
#endif
}
/* NOTE: this file portion implement a thin OpenGL entrypoints dispatching
C++ wrapper class
*/
#include "GLDispatcher.h"
BGLDispatcher::BGLDispatcher()
{
}
BGLDispatcher::~BGLDispatcher()
{
}
status_t
BGLDispatcher::CheckTable(const struct _glapi_table* table)
{
_glapi_check_table(table ? table : _glapi_get_dispatch());
return B_OK;
}
status_t
BGLDispatcher::SetTable(struct _glapi_table* table)
{
_glapi_set_dispatch(table);
return B_OK;
}
src/kits/opengl/GLDispatcher.h
-109
View File
@@ -1,109 +0,0 @@
/*
* Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000-2012 Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Brian Paul <[email protected]>
* Philippe Houdoin <[email protected]>
*/
#ifndef GLDISPATCHER_H
#define GLDISPATCHER_H
#include <BeBuild.h>
#include <GL/gl.h>
#include <SupportDefs.h>
#include "glheader.h"
extern "C" {
#include "glapi.h"
}
class BGLDispatcher
{
// Private unimplemented copy constructors
BGLDispatcher(const BGLDispatcher &);
BGLDispatcher & operator=(const BGLDispatcher &);
public:
BGLDispatcher();
~BGLDispatcher();
void SetCurrentContext(void* context);
void* CurrentContext();
struct _glapi_table* Table();
status_t CheckTable(
const struct _glapi_table* dispatch = NULL);
status_t SetTable(struct _glapi_table* dispatch);
uint32 TableSize();
const _glapi_proc operator[](const char* functionName);
const char* operator[](uint32 offset);
const _glapi_proc AddressOf(const char* functionName);
uint32 OffsetOf(const char* functionName);
};
// Inlines methods
inline void
BGLDispatcher::SetCurrentContext(void* context)
{
_glapi_set_context(context);
}
inline void*
BGLDispatcher::CurrentContext()
{
return _glapi_get_context();
}
inline struct _glapi_table*
BGLDispatcher::Table()
{
return _glapi_get_dispatch();
}
inline uint32
BGLDispatcher::TableSize()
{
return _glapi_get_dispatch_table_size();
}
inline const _glapi_proc
BGLDispatcher::operator[](const char* functionName)
{
return _glapi_get_proc_address(functionName);
}
inline const char*
BGLDispatcher::operator[](uint32 offset)
{
return _glapi_get_proc_name((GLuint) offset);
}
inline const _glapi_proc
BGLDispatcher::AddressOf(const char* functionName)
{
return _glapi_get_proc_address(functionName);
}
inline uint32
BGLDispatcher::OffsetOf(const char* functionName)
{
return (uint32) _glapi_get_proc_offset(functionName);
}
#endif // GLDISPATCHER_H
src/kits/opengl/GLRenderer.cpp
-104
View File
@@ -1,104 +0,0 @@
/*
* Copyright 2006-2008, Philippe Houdoin. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include "GLRenderer.h"
#include "GLDispatcher.h"
BGLRenderer::BGLRenderer(BGLView* view, ulong glOptions,
BGLDispatcher* dispatcher)
:
fRefCount(1),
fView(view),
fOptions(glOptions),
fDispatcher(dispatcher)
{
}
BGLRenderer::~BGLRenderer()
{
delete fDispatcher;
}
void
BGLRenderer::Acquire()
{
atomic_add(&fRefCount, 1);
}
void
BGLRenderer::Release()
{
if (atomic_add(&fRefCount, -1) < 1)
delete this;
}
void
BGLRenderer::LockGL()
{
}
void
BGLRenderer::UnlockGL()
{
}
void
BGLRenderer::SwapBuffers(bool VSync)
{
}
void
BGLRenderer::Draw(BRect updateRect)
{
}
status_t
BGLRenderer::CopyPixelsOut(BPoint source, BBitmap* dest)
{
return B_ERROR;
}
status_t
BGLRenderer::CopyPixelsIn(BBitmap* source, BPoint dest)
{
return B_ERROR;
}
void
BGLRenderer::FrameResized(float width, float height)
{
}
void
BGLRenderer::DirectConnected(direct_buffer_info* info)
{
}
void
BGLRenderer::EnableDirectMode(bool enabled)
{
}
status_t BGLRenderer::_Reserved_Renderer_0(int32 n, void* p) { return B_ERROR; }
status_t BGLRenderer::_Reserved_Renderer_1(int32 n, void* p) { return B_ERROR; }
status_t BGLRenderer::_Reserved_Renderer_2(int32 n, void* p) { return B_ERROR; }
status_t BGLRenderer::_Reserved_Renderer_3(int32 n, void* p) { return B_ERROR; }
status_t BGLRenderer::_Reserved_Renderer_4(int32 n, void* p) { return B_ERROR; }
src/kits/opengl/GLRendererRoster.cpp
-222
View File
@@ -1,222 +0,0 @@
/*
* Copyright 2006-2012 Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Philippe Houdoin <[email protected]>
*/
#include <driver_settings.h>
#include <image.h>
#include <safemode_defs.h>
#include <Directory.h>
#include <FindDirectory.h>
#include <Path.h>
#include <String.h>
#include "GLDispatcher.h"
#include "GLRendererRoster.h"
#include <new>
#include <string.h>
extern "C" status_t _kern_get_safemode_option(const char* parameter,
char* buffer, size_t* _bufferSize);
GLRendererRoster::GLRendererRoster(BGLView* view, ulong options)
:
fNextID(0),
fView(view),
fOptions(options),
fSafeMode(false),
fABISubDirectory(NULL)
{
char parameter[32];
size_t parameterLength = sizeof(parameter);
if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE,
parameter, &parameterLength) == B_OK) {
if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
|| !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
|| !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
fSafeMode = true;
}
if (_kern_get_safemode_option(B_SAFEMODE_DISABLE_USER_ADD_ONS,
parameter, &parameterLength) == B_OK) {
if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
|| !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
|| !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
fSafeMode = true;
}
// We might run in compatibility mode on a system with a different ABI. The
// renderers matching our ABI can usually be found in respective
// subdirectories of the opengl add-ons directories.
system_info info;
if (get_system_info(&info) == B_OK
&& (info.abi & B_HAIKU_ABI_MAJOR)
!= (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR)) {
switch (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR) {
case B_HAIKU_ABI_GCC_2:
fABISubDirectory = "gcc2";
break;
case B_HAIKU_ABI_GCC_4:
fABISubDirectory = "gcc4";
break;
}
}
AddDefaultPaths();
}
GLRendererRoster::~GLRendererRoster()
{
}
BGLRenderer*
GLRendererRoster::GetRenderer(int32 id)
{
RendererMap::const_iterator iterator = fRenderers.find(id);
if (iterator == fRenderers.end())
return NULL;
struct renderer_item item = iterator->second;
return item.renderer;
}
void
GLRendererRoster::AddDefaultPaths()
{
// add user directories first, so that they can override system renderers
const directory_which paths[] = {
B_USER_NONPACKAGED_ADDONS_DIRECTORY,
B_USER_ADDONS_DIRECTORY,
B_SYSTEM_NONPACKAGED_ADDONS_DIRECTORY,
B_SYSTEM_ADDONS_DIRECTORY,
};
for (uint32 i = fSafeMode ? 4 : 0;
i < sizeof(paths) / sizeof(paths[0]); i++) {
BPath path;
status_t status = find_directory(paths[i], &path, true);
if (status == B_OK && path.Append("opengl") == B_OK)
AddPath(path.Path());
}
}
status_t
GLRendererRoster::AddPath(const char* path)
{
BDirectory directory(path);
status_t status = directory.InitCheck();
if (status < B_OK)
return status;
// if a subdirectory for our ABI exists, use that instead
if (fABISubDirectory != NULL) {
BEntry entry(&directory, fABISubDirectory);
if (entry.IsDirectory()) {
status = directory.SetTo(&entry);
if (status != B_OK)
return status;
}
}
node_ref nodeRef;
status = directory.GetNodeRef(&nodeRef);
if (status < B_OK)
return status;
int32 count = 0;
int32 files = 0;
entry_ref ref;
BEntry entry;
while (directory.GetNextRef(&ref) == B_OK) {
entry.SetTo(&ref);
if (entry.InitCheck() == B_OK && !entry.IsFile())
continue;
if (CreateRenderer(ref) == B_OK)
count++;
files++;
}
if (files != 0 && count == 0)
return B_BAD_VALUE;
return B_OK;
}
status_t
GLRendererRoster::AddRenderer(BGLRenderer* renderer,
image_id image, const entry_ref* ref, ino_t node)
{
renderer_item item;
item.renderer = renderer;
item.image = image;
item.node = node;
if (ref != NULL)
item.ref = *ref;
try {
fRenderers[fNextID] = item;
} catch (...) {
return B_NO_MEMORY;
}
renderer->fOwningRoster = this;
renderer->fID = fNextID++;
return B_OK;
}
status_t
GLRendererRoster::CreateRenderer(const entry_ref& ref)
{
BEntry entry(&ref);
node_ref nodeRef;
status_t status = entry.GetNodeRef(&nodeRef);
if (status < B_OK)
return status;
BPath path(&ref);
image_id image = load_add_on(path.Path());
if (image < B_OK)
return image;
BGLRenderer* (*instantiate_renderer)
(BGLView* view, ulong options, BGLDispatcher* dispatcher);
status = get_image_symbol(image, "instantiate_gl_renderer",
B_SYMBOL_TYPE_TEXT, (void**)&instantiate_renderer);
if (status == B_OK) {
BGLRenderer* renderer
= instantiate_renderer(fView, fOptions, new BGLDispatcher());
if (!renderer) {
unload_add_on(image);
return B_UNSUPPORTED;
}
if (AddRenderer(renderer, image, &ref, nodeRef.node) != B_OK) {
renderer->Release();
// this will delete the renderer
unload_add_on(image);
}
return B_OK;
}
unload_add_on(image);
return status;
}
src/kits/opengl/GLRendererRoster.h
-51
View File
@@ -1,51 +0,0 @@
/*
* Copyright 2006-2012, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Philippe Houdoin <[email protected]>
*/
#ifndef _GLRENDERER_ROSTER_H
#define _GLRENDERER_ROSTER_H
#include <GLRenderer.h>
#include <map>
struct renderer_item {
BGLRenderer* renderer;
entry_ref ref;
ino_t node;
image_id image;
};
typedef std::map<renderer_id, renderer_item> RendererMap;
class GLRendererRoster {
public:
GLRendererRoster(BGLView* view, ulong options);
virtual ~GLRendererRoster();
BGLRenderer* GetRenderer(int32 id = 0);
private:
void AddDefaultPaths();
status_t AddPath(const char* path);
status_t AddRenderer(BGLRenderer* renderer,
image_id image, const entry_ref* ref, ino_t node);
status_t CreateRenderer(const entry_ref& ref);
RendererMap fRenderers;
int32 fNextID;
BGLView* fView;
ulong fOptions;
bool fSafeMode;
const char* fABISubDirectory;
};
#endif /* _GLRENDERER_ROSTER_H */
src/kits/opengl/GLView.cpp
-642
View File
@@ -1,642 +0,0 @@
/*
* Copyright 2006-2012, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected]
* Stefano Ceccherini, [email protected]
*/
#include <GLView.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <DirectWindow.h>
#include <GLRenderer.h>
#include "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);
}
src/kits/opengl/Jamfile
-66
View File
@@ -1,66 +0,0 @@
SubDir HAIKU_TOP src kits opengl ;
SetSubDirSupportedPlatformsBeOSCompatible ;
local sources =
GLView.cpp
GLDispatcher.cpp
GLRenderer.cpp
GLRendererRoster.cpp
;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] : true ;
# We need our public GL headers also when not compiling for Haiku.
}
local architectureObject ;
for architectureObject in [ MultiArchSubDirSetup ] {
on $(architectureObject) {
local architecture = $(TARGET_PACKAGING_ARCH) ;
UsePrivateHeaders interface ;
UsePrivateSystemHeaders ;
UseBuildFeatureHeaders glu ;
UseBuildFeatureHeaders mesa ;
Includes [ FGristFiles $(sources) ]
: [ BuildFeatureAttribute glu : headers ] ;
Includes [ FGristFiles $(sources) ]
: [ BuildFeatureAttribute mesa : headers ] ;
UseHeaders [ BuildFeatureAttribute mesa : headers : path ] ;
local privateHeaders
= [ BuildFeatureAttribute mesa : privateHeaders : path ] ;
UseHeaders [ FDirName $(privateHeaders) mesa ] ;
UseHeaders [ FDirName $(privateHeaders) mesa main ] ;
UseHeaders [ FDirName $(privateHeaders) mapi ] ;
UseHeaders [ FDirName $(privateHeaders) mapi glapi ] ;
# For older versions of Mesa
UseHeaders [ FDirName $(privateHeaders) mesa glapi ] ;
LINKFLAGS on libGL.so = [ on libGL.so return $(LINKFLAGS) ]
-Xlinker --whole-archive -Xlinker --no-undefined ;
# For GCC2
if $(architecture) = x86_gcc2 {
SubDirC++Flags --no-warnings ;
}
SharedLibrary [ MultiArchDefaultGristFiles libGL.so ] : $(sources) :
# GLU
[ BuildFeatureAttribute glu : library ]
# GLAPI Dispatch code (from Mesa buildpackage)
[ BuildFeatureAttribute mesa : glapiLibrary ]
# External libraries:
game # BWindowScreen needed by BGLScreen stub class
network
be
$(TARGET_LIBSTDC++)
;
}
}
src/libs/glut/Jamfile
+4 -7
View File
@@ -1,13 +1,9 @@
SubDir HAIKU_TOP src libs glut ;
UseLibraryHeaders glut ;
SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] : true ;
# We need our public GL headers also when not compiling for Haiku.
}
local sourcesCc =
# C sources
glut_8x13.c
@@ -71,7 +67,8 @@ for architectureObject in [ MultiArchSubDirSetup ] {
$(sourcesCpp)
$(sourcesCc)
:
GL game be $(TARGET_LIBSTDC++)
game be $(TARGET_LIBSTDC++)
[ BuildFeatureAttribute mesa : library ]
[ BuildFeatureAttribute glu : library ]
;
}
src/tests/kits/opengl/demos/gears/Jamfile
+3 -1
View File
@@ -20,5 +20,7 @@ Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
SimpleTest GLGears :
$(sources)
: be GL
:
be
[ BuildFeatureAttribute mesa : library ]
;
src/tests/kits/opengl/direct_mode/Jamfile
+3 -1
View File
@@ -18,6 +18,8 @@ Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
SimpleTest GLDirectMode :
$(sources)
: be game GL $(TARGET_LIBSUPC++)
:
be game $(TARGET_LIBSUPC++)
[ BuildFeatureAttribute mesa : library ]
: GLDirectMode.rdef
;
src/tests/kits/opengl/glinfo/Jamfile
+5 -3
View File
@@ -1,8 +1,9 @@
SubDir HAIKU_TOP src tests kits opengl glinfo ;
UseBuildFeatureHeaders glu ;
UseBuildFeatureHeaders mesa ;
UseBuildFeatureHeaders glu ;
UsePrivateHeaders interface ;
UseLibraryHeaders glut ;
local sources =
OpenGLApp.cpp
@@ -15,8 +16,8 @@ local sources =
;
Includes [ FGristFiles $(sources) ] :
[ BuildFeatureAttribute glu : headers ]
[ BuildFeatureAttribute mesa : headers ]
[ BuildFeatureAttribute glu : headers ]
;
# Dependency needed to trigger downloading/unzipping the package before
# compiling the files.
@@ -24,9 +25,10 @@ Includes [ FGristFiles $(sources) ] :
Preference GLInfo :
$(sources)
:
be GL libglut.so
be libglut.so
translation libcolumnlistview.a localestub
$(TARGET_LIBSUPC++)
[ BuildFeatureAttribute mesa : library ]
[ BuildFeatureAttribute glu : library ]
:
GLInfo.rdef
src/tests/kits/opengl/glsl/Jamfile
+3 -1
View File
@@ -23,5 +23,7 @@ StaticLibrary libshaderutil.a :
SimpleTest brick :
brick.c
: libshaderutil.a be GL
:
libshaderutil.a be
[ BuildFeatureAttribute mesa : library ]
;
src/tests/kits/opengl/glut/game_mode/Jamfile
+6 -1
View File
@@ -1,6 +1,9 @@
SubDir HAIKU_TOP src tests kits opengl glut game_mode ;
UseBuildFeatureHeaders mesa ;
# GLUT
UseHeaders [ FDirName $(HAIKU_TOP) headers os opengl ] ;
SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
@@ -18,5 +21,7 @@ Includes [ FGristFiles $(sources) ] : [ BuildFeatureAttribute mesa : headers ] ;
SimpleTest GLUTGameMode :
$(sources)
: be GL libglut.so
:
be libglut.so
[ BuildFeatureAttribute mesa : library ]
;