298 lines
6.9 KiB
Objective-C
298 lines
6.9 KiB
Objective-C
/******************************************************************************
|
|
Copyright (C) 2013 by Ruwen Hahn <palana@stunned.de>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
******************************************************************************/
|
|
|
|
#include "gl-subsystem.h"
|
|
#include <OpenGL/OpenGL.h>
|
|
|
|
#import <Cocoa/Cocoa.h>
|
|
#import <AppKit/AppKit.h>
|
|
|
|
|
|
//#include "util/darray.h"
|
|
|
|
|
|
struct gl_windowinfo {
|
|
NSView *view;
|
|
};
|
|
|
|
struct gl_platform {
|
|
NSOpenGLContext *context;
|
|
};
|
|
|
|
static NSOpenGLContext *gl_context_create(void)
|
|
{
|
|
unsigned attrib_count = 0;
|
|
|
|
#define ADD_ATTR(x) \
|
|
{ attributes[attrib_count++] = (NSOpenGLPixelFormatAttribute)x; }
|
|
#define ADD_ATTR2(x, y) { ADD_ATTR(x); ADD_ATTR(y); }
|
|
|
|
NSOpenGLPixelFormatAttribute attributes[40];
|
|
|
|
ADD_ATTR(NSOpenGLPFADoubleBuffer);
|
|
ADD_ATTR2(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
|
|
ADD_ATTR(0);
|
|
|
|
#undef ADD_ATTR2
|
|
#undef ADD_ATTR
|
|
|
|
NSOpenGLPixelFormat *pf;
|
|
pf = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
|
|
if(!pf) {
|
|
blog(LOG_ERROR, "Failed to create pixel format");
|
|
return NULL;
|
|
}
|
|
|
|
NSOpenGLContext *context;
|
|
context = [[NSOpenGLContext alloc] initWithFormat:pf shareContext:nil];
|
|
[pf release];
|
|
if(!context) {
|
|
blog(LOG_ERROR, "Failed to create context");
|
|
return NULL;
|
|
}
|
|
|
|
[context clearDrawable];
|
|
|
|
return context;
|
|
}
|
|
|
|
struct gl_platform *gl_platform_create(gs_device_t *device, uint32_t adapter)
|
|
{
|
|
struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
|
|
|
|
plat->context = gl_context_create();
|
|
if (!plat->context)
|
|
goto fail;
|
|
|
|
[plat->context makeCurrentContext];
|
|
|
|
if (!gladLoadGL())
|
|
goto fail;
|
|
|
|
return plat;
|
|
|
|
fail:
|
|
blog(LOG_ERROR, "gl_platform_create failed");
|
|
gl_platform_destroy(plat);
|
|
|
|
UNUSED_PARAMETER(device);
|
|
UNUSED_PARAMETER(adapter);
|
|
return NULL;
|
|
}
|
|
|
|
void gl_platform_destroy(struct gl_platform *platform)
|
|
{
|
|
if(!platform)
|
|
return;
|
|
|
|
[platform->context release];
|
|
platform->context = nil;
|
|
|
|
bfree(platform);
|
|
}
|
|
|
|
bool gl_platform_init_swapchain(struct gs_swap_chain *swap)
|
|
{
|
|
UNUSED_PARAMETER(swap);
|
|
|
|
return true;
|
|
}
|
|
|
|
void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
|
|
{
|
|
UNUSED_PARAMETER(swap);
|
|
}
|
|
|
|
struct gl_windowinfo *gl_windowinfo_create(const struct gs_init_data *info)
|
|
{
|
|
if(!info)
|
|
return NULL;
|
|
|
|
if(!info->window.view)
|
|
return NULL;
|
|
|
|
struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo));
|
|
|
|
wi->view = info->window.view;
|
|
[info->window.view setWantsBestResolutionOpenGLSurface:YES];
|
|
|
|
return wi;
|
|
}
|
|
|
|
void gl_windowinfo_destroy(struct gl_windowinfo *wi)
|
|
{
|
|
if(!wi)
|
|
return;
|
|
|
|
wi->view = nil;
|
|
bfree(wi);
|
|
}
|
|
|
|
void gl_update(gs_device_t *device)
|
|
{
|
|
[device->plat->context update];
|
|
}
|
|
|
|
void device_enter_context(gs_device_t *device)
|
|
{
|
|
[device->plat->context makeCurrentContext];
|
|
}
|
|
|
|
void device_leave_context(gs_device_t *device)
|
|
{
|
|
UNUSED_PARAMETER(device);
|
|
|
|
[NSOpenGLContext clearCurrentContext];
|
|
}
|
|
|
|
void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swap)
|
|
{
|
|
if(device->cur_swap == swap)
|
|
return;
|
|
|
|
device->cur_swap = swap;
|
|
if (swap) {
|
|
[device->plat->context setView:swap->wi->view];
|
|
} else {
|
|
[device->plat->context clearDrawable];
|
|
}
|
|
}
|
|
|
|
void device_present(gs_device_t *device)
|
|
{
|
|
[device->plat->context flushBuffer];
|
|
}
|
|
|
|
void gl_getclientsize(const struct gs_swap_chain *swap, uint32_t *width,
|
|
uint32_t *height)
|
|
{
|
|
if(width) *width = swap->info.cx;
|
|
if(height) *height = swap->info.cy;
|
|
}
|
|
|
|
gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device,
|
|
void *iosurf)
|
|
{
|
|
IOSurfaceRef ref = (IOSurfaceRef)iosurf;
|
|
struct gs_texture_2d *tex = bzalloc(sizeof(struct gs_texture_2d));
|
|
|
|
OSType pf = IOSurfaceGetPixelFormat(ref);
|
|
if (pf != 'BGRA')
|
|
blog(LOG_ERROR, "Unexpected pixel format: %d (%c%c%c%c)", pf,
|
|
pf >> 24, pf >> 16, pf >> 8, pf);
|
|
|
|
const enum gs_color_format color_format = GS_BGRA;
|
|
|
|
tex->base.device = device;
|
|
tex->base.type = GS_TEXTURE_2D;
|
|
tex->base.format = GS_BGRA;
|
|
tex->base.levels = 1;
|
|
tex->base.gl_format = convert_gs_format(color_format);
|
|
tex->base.gl_internal_format = convert_gs_internal_format(color_format);
|
|
tex->base.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
|
|
tex->base.gl_target = GL_TEXTURE_RECTANGLE;
|
|
tex->base.is_dynamic = false;
|
|
tex->base.is_render_target = false;
|
|
tex->base.gen_mipmaps = false;
|
|
tex->width = IOSurfaceGetWidth(ref);
|
|
tex->height = IOSurfaceGetHeight(ref);
|
|
|
|
if (!gl_gen_textures(1, &tex->base.texture))
|
|
goto fail;
|
|
|
|
if (!gl_bind_texture(tex->base.gl_target, tex->base.texture))
|
|
goto fail;
|
|
|
|
CGLError err = CGLTexImageIOSurface2D(
|
|
[[NSOpenGLContext currentContext] CGLContextObj],
|
|
tex->base.gl_target,
|
|
tex->base.gl_internal_format,
|
|
tex->width, tex->height,
|
|
tex->base.gl_format,
|
|
tex->base.gl_type,
|
|
ref, 0);
|
|
|
|
if(err != kCGLNoError) {
|
|
blog(LOG_ERROR, "CGLTexImageIOSurface2D: %u, %s"
|
|
" (device_texture_create_from_iosurface)",
|
|
err, CGLErrorString(err));
|
|
|
|
gl_success("CGLTexImageIOSurface2D");
|
|
goto fail;
|
|
}
|
|
|
|
if (!gl_tex_param_i(tex->base.gl_target,
|
|
GL_TEXTURE_MAX_LEVEL, 0))
|
|
goto fail;
|
|
|
|
if (!gl_bind_texture(tex->base.gl_target, 0))
|
|
goto fail;
|
|
|
|
return (gs_texture_t*)tex;
|
|
|
|
fail:
|
|
gs_texture_destroy((gs_texture_t*)tex);
|
|
blog(LOG_ERROR, "device_texture_create_from_iosurface (GL) failed");
|
|
return NULL;
|
|
}
|
|
|
|
bool gs_texture_rebind_iosurface(gs_texture_t *texture, void *iosurf)
|
|
{
|
|
if (!texture)
|
|
return false;
|
|
|
|
if (!iosurf)
|
|
return false;
|
|
|
|
struct gs_texture_2d *tex = (struct gs_texture_2d*)texture;
|
|
IOSurfaceRef ref = (IOSurfaceRef)iosurf;
|
|
|
|
OSType pf = IOSurfaceGetPixelFormat(ref);
|
|
if (pf != 'BGRA')
|
|
blog(LOG_ERROR, "Unexpected pixel format: %d (%c%c%c%c)", pf,
|
|
pf >> 24, pf >> 16, pf >> 8, pf);
|
|
|
|
if (tex->width != IOSurfaceGetWidth(ref) ||
|
|
tex->height != IOSurfaceGetHeight(ref))
|
|
return false;
|
|
|
|
if (!gl_bind_texture(tex->base.gl_target, tex->base.texture))
|
|
return false;
|
|
|
|
CGLError err = CGLTexImageIOSurface2D(
|
|
[[NSOpenGLContext currentContext] CGLContextObj],
|
|
tex->base.gl_target,
|
|
tex->base.gl_internal_format,
|
|
tex->width, tex->height,
|
|
tex->base.gl_format,
|
|
tex->base.gl_type,
|
|
ref, 0);
|
|
|
|
if(err != kCGLNoError) {
|
|
blog(LOG_ERROR, "CGLTexImageIOSurface2D: %u, %s"
|
|
" (gs_texture_rebind_iosurface)",
|
|
err, CGLErrorString(err));
|
|
|
|
gl_success("CGLTexImageIOSurface2D");
|
|
return false;
|
|
}
|
|
|
|
if (!gl_bind_texture(tex->base.gl_target, 0))
|
|
return false;
|
|
|
|
return true;
|
|
}
|