don't depend on sokol
parent
86e5eaaac9
commit
20f6e2f2dc
5
justfile
5
justfile
|
|
@ -12,5 +12,6 @@ run: build
|
|||
|
||||
transpile_shaders_metal:
|
||||
mkdir -p bin/transpiled_shaders
|
||||
naga shaders/vertex.wgsl bin/transpiled_shaders/vertex.metal --metal-version 1.2
|
||||
naga shaders/fragment.wgsl bin/transpiled_shaders/fragment.metal --metal-version 1.2
|
||||
|
||||
xcrun -sdk macosx metal -o bin/transpiled_shaders/text_atlas.ir -c shaders/text_atlas.metal
|
||||
xcrun -sdk macosx metallib -o bin/shaders.metallib bin/transpiled_shaders/text_atlas.ir
|
||||
|
|
|
|||
|
|
@ -1,21 +0,0 @@
|
|||
#version 330 core
|
||||
struct VertexOutput {
|
||||
vec4 position;
|
||||
vec2 tex_coord;
|
||||
};
|
||||
uniform sampler2D _group_0_binding_0_fs;
|
||||
|
||||
smooth in vec2 _vs2fs_location0;
|
||||
layout(location = 0) out vec4 _fs2p_location0;
|
||||
|
||||
void main() {
|
||||
VertexOutput input_ = VertexOutput(gl_FragCoord, _vs2fs_location0);
|
||||
float text_color = 0.0;
|
||||
vec4 _e8 = texture(_group_0_binding_0_fs, vec2(vec2(input_.tex_coord.x, input_.tex_coord.y)));
|
||||
text_color = _e8.x;
|
||||
float _e11 = text_color;
|
||||
float _e17 = text_color;
|
||||
_fs2p_location0 = vec4((_e11 * vec3(1.0, 1.0, 1.0)), _e17);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
struct VertexOutput {
|
||||
@builtin(position) position: vec4<f32>,
|
||||
@location(0) tex_coord: vec2<f32>,
|
||||
}
|
||||
|
||||
@group(0) @binding(0)
|
||||
var texture: texture_2d<f32>;
|
||||
@group(0) @binding(1)
|
||||
var texture_sampler: sampler;
|
||||
|
||||
@fragment
|
||||
fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
|
||||
var text_color = textureSample(texture, texture_sampler, vec2<f32>(input.tex_coord.x, input.tex_coord.y)).r;
|
||||
|
||||
return vec4<f32>(text_color * vec3<f32>(1., 1., 1.), text_color);
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include <metal_stdlib>
|
||||
|
||||
using namespace metal;
|
||||
|
||||
struct VertexInput {
|
||||
float2 position;
|
||||
float2 tex_coord;
|
||||
};
|
||||
|
||||
struct VertexOutput {
|
||||
float4 position [[position]];
|
||||
float2 tex_coord;
|
||||
};
|
||||
|
||||
struct Glyph {
|
||||
float2 atlas_position;
|
||||
float2 size;
|
||||
float2 target_position;
|
||||
float y_offset;
|
||||
float _haha_alignment;
|
||||
};
|
||||
|
||||
struct UniformParams {
|
||||
float2 screen_size;
|
||||
};
|
||||
|
||||
float4 to_device_position(float2 position, float2 size) {
|
||||
return float4(((position / size) * 2.0) - float2(1.0), 1.0, 1.0);
|
||||
}
|
||||
|
||||
vertex VertexOutput
|
||||
vs_main(
|
||||
uint vertex_id [[vertex_id]],
|
||||
uint glyph_id [[instance_id]],
|
||||
constant VertexInput *vertices [[buffer(0)]],
|
||||
constant Glyph *glyphs [[buffer(1)]],
|
||||
constant UniformParams ¶ms [[buffer(2)]]
|
||||
)
|
||||
{
|
||||
VertexOutput out;
|
||||
|
||||
Glyph glyph = glyphs[glyph_id];
|
||||
|
||||
float2 scaled_size = ((vertices[vertex_id].position + 1.0) / 2.0) * (glyph.size/2.0);
|
||||
float2 scaled_size_2 = ((vertices[vertex_id].position + 1.0) / 2.0) * (glyph.size);
|
||||
float2 glyph_pos = scaled_size + glyph.target_position + float2(0, glyph.y_offset/2.0+32);
|
||||
float4 device_position = to_device_position(glyph_pos, params.screen_size);
|
||||
float2 atlas_position = (scaled_size_2 + glyph.atlas_position) / 1024.0;
|
||||
|
||||
device_position.y = -device_position.y;
|
||||
|
||||
out.position = device_position;
|
||||
out.tex_coord = atlas_position;
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
fragment float4 fs_main(VertexOutput in [[stage_in]],
|
||||
texture2d<float, access::sample> texture [[texture(0)]])
|
||||
{
|
||||
constexpr sampler texture_sampler (mag_filter::linear, min_filter::linear);
|
||||
|
||||
float text_color = texture.sample(texture_sampler, in.tex_coord).r;
|
||||
return float4(text_color * float3(1,1,1), text_color);
|
||||
}
|
||||
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
#version 330 core
|
||||
uniform uint naga_vs_first_instance;
|
||||
|
||||
struct VertexInput {
|
||||
vec3 position;
|
||||
vec2 tex_coord;
|
||||
vec2 atlas_position;
|
||||
vec2 size;
|
||||
vec2 target_position;
|
||||
float y_offset;
|
||||
uint glyph_id;
|
||||
};
|
||||
struct VertexOutput {
|
||||
vec4 position;
|
||||
vec2 tex_coord;
|
||||
};
|
||||
uniform vec4 screen_size;
|
||||
|
||||
layout(location = 0) in vec3 _p2vs_location0;
|
||||
layout(location = 1) in vec2 _p2vs_location1;
|
||||
layout(location = 2) in vec2 _p2vs_location2;
|
||||
layout(location = 3) in vec2 _p2vs_location3;
|
||||
layout(location = 4) in vec2 _p2vs_location4;
|
||||
layout(location = 5) in float _p2vs_location5;
|
||||
smooth out vec2 _vs2fs_location0;
|
||||
|
||||
vec4 to_device_position(vec2 position, vec2 size) {
|
||||
return vec4((((position / size) * 2.0) - vec2(1.0)), 1.0, 1.0);
|
||||
}
|
||||
|
||||
void main() {
|
||||
VertexInput input_ = VertexInput(_p2vs_location0, _p2vs_location1, _p2vs_location2, _p2vs_location3, _p2vs_location4, _p2vs_location5, (uint(gl_InstanceID) + naga_vs_first_instance));
|
||||
VertexOutput out_ = VertexOutput(vec4(0.0), vec2(0.0));
|
||||
vec4 vertex_pos = vec4(0.0);
|
||||
vec2 atlas_position = vec2(0.0);
|
||||
vec4 _e28 = to_device_position((((((input_.position.xy + vec2(1.0)) / vec2(2.0)) * (input_.size / vec2(2.0))) + input_.target_position) + vec2(0.0, ((input_.y_offset / 2.0) + 32.0))), screen_size.xy);
|
||||
vertex_pos = _e28;
|
||||
atlas_position = (((((input_.position.xy + vec2(1.0)) / vec2(2.0)) * input_.size) + input_.atlas_position) / vec2(1024.0));
|
||||
vec4 _e47 = vertex_pos;
|
||||
out_.position = _e47;
|
||||
vec2 _e49 = atlas_position;
|
||||
out_.tex_coord = _e49;
|
||||
VertexOutput _e50 = out_;
|
||||
gl_Position = _e50.position;
|
||||
_vs2fs_location0 = _e50.tex_coord;
|
||||
gl_Position.yz = vec2(-gl_Position.y, gl_Position.z * 2.0 - gl_Position.w);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
struct VertexInput {
|
||||
@location(0) position: vec3<f32>,
|
||||
@location(1) tex_coord: vec2<f32>,
|
||||
|
||||
@location(2) atlas_position: vec2<f32>,
|
||||
@location(3) size: vec2<f32>,
|
||||
@location(4) target_position: vec2<f32>,
|
||||
@location(5) y_offset: f32,
|
||||
|
||||
@builtin(instance_index) glyph_id: u32,
|
||||
}
|
||||
|
||||
struct VertexOutput {
|
||||
@builtin(position) position: vec4<f32>,
|
||||
@location(0) tex_coord: vec2<f32>,
|
||||
}
|
||||
|
||||
struct Params {
|
||||
screen_size: vec4<f32>,
|
||||
}
|
||||
|
||||
fn to_device_position(position: vec2<f32>, size: vec2<f32>) -> vec4<f32> {
|
||||
return vec4<f32>((((position / size) * 2.) - 1.), 1., 1.);
|
||||
}
|
||||
|
||||
@group(0) @binding(0)
|
||||
var<uniform> params: Params;
|
||||
|
||||
@vertex
|
||||
fn vs_main(input: VertexInput) -> VertexOutput {
|
||||
var out: VertexOutput;
|
||||
|
||||
var vertex_pos = to_device_position(((input.position.xy + 1.) / 2.) * (input.size/2.0) + input.target_position + vec2<f32>(0., (input.y_offset/2.0)+32), params.screen_size.xy);
|
||||
vertex_pos.y = -vertex_pos.y;
|
||||
var atlas_position = (((input.position.xy + 1.) / 2.) * input.size + input.atlas_position) / vec2<f32>(1024);
|
||||
|
||||
out.position = vertex_pos;
|
||||
out.tex_coord = atlas_position;
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
-DED_UI_IMPLEMENTATION
|
||||
-DED_HT_IMPLEMENTATION
|
||||
-DED_STRING_IMPLEMENTATION
|
||||
-DED_GFX_IMPLEMENTATION
|
||||
-I../vendor/
|
||||
-ObjC
|
||||
|
|
|
|||
|
|
@ -0,0 +1,362 @@
|
|||
// Graphics layer abstraction.
|
||||
|
||||
#ifndef ED_GFX_INCLUDED
|
||||
#define ED_GFX_INCLUDED
|
||||
#include <AppKit/AppKit.h>
|
||||
#include <Foundation/Foundation.h>
|
||||
#include <CoreGraphics/CoreGraphics.h>
|
||||
#include <Metal/Metal.h>
|
||||
#include <QuartzCore/QuartzCore.h>
|
||||
#include <QuartzCore/CoreAnimation.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "ed_array.h"
|
||||
|
||||
bool keep_running = true;
|
||||
|
||||
@interface EDGFXView : NSView
|
||||
@end
|
||||
@interface AppDelegate : NSObject<NSApplicationDelegate>
|
||||
@end
|
||||
@interface WindowDelegate : NSObject<NSWindowDelegate>
|
||||
@end
|
||||
|
||||
#define wrapIdArray(T) typedef id<T> _ ## T;\
|
||||
arrayTemplate(_ ## T);
|
||||
|
||||
wrapIdArray(MTLRenderPipelineState);
|
||||
wrapIdArray(MTLBuffer);
|
||||
wrapIdArray(MTLTexture);
|
||||
|
||||
#if defined(__APPLE__)
|
||||
typedef struct {
|
||||
NSApplication *application;
|
||||
NSWindow *window;
|
||||
EDGFXView *view;
|
||||
bool keep_running;
|
||||
|
||||
// Metal objects
|
||||
id<MTLDevice> device;
|
||||
CAMetalLayer *metal_layer;
|
||||
id<MTLLibrary> library;
|
||||
id<MTLCommandQueue> command_queue;
|
||||
|
||||
array(_MTLRenderPipelineState) pipelines;
|
||||
array(_MTLBuffer) buffers;
|
||||
array(_MTLTexture) textures;
|
||||
} _metal_gfx_context;
|
||||
#endif
|
||||
|
||||
typedef void (*_gfx_frame_func)();
|
||||
typedef struct {
|
||||
#if defined(__APPLE__)
|
||||
_metal_gfx_context backend;
|
||||
#else
|
||||
#error "Unsupported platform"
|
||||
#endif
|
||||
|
||||
uint32_t frame_width;
|
||||
uint32_t frame_height;
|
||||
_gfx_frame_func frame_func;
|
||||
} gfx_context_t;
|
||||
static gfx_context_t _gfx_context;
|
||||
|
||||
#ifdef ED_GFX_IMPLEMENTATION
|
||||
|
||||
#if defined(__APPLE__)
|
||||
static void _metal_gfx_present(_metal_gfx_context *cx);
|
||||
static void _metal_gfx_send_events(_metal_gfx_context *cx);
|
||||
|
||||
@implementation AppDelegate
|
||||
- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender {
|
||||
keep_running = false;
|
||||
|
||||
return NSTerminateCancel;
|
||||
}
|
||||
|
||||
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender {
|
||||
keep_running = false;
|
||||
|
||||
return NO;
|
||||
}
|
||||
@end
|
||||
|
||||
@implementation WindowDelegate
|
||||
- (BOOL)windowShouldClose:(NSApplication *)sender {
|
||||
keep_running = false;
|
||||
return YES;
|
||||
}
|
||||
|
||||
- (void)windowDidResize:(NSNotification *)notification {
|
||||
NSLog(@"did resize\n");
|
||||
|
||||
_gfx_context.frame_width = _gfx_context.backend.window.contentView.frame.size.width;
|
||||
_gfx_context.frame_height = _gfx_context.backend.window.contentView.frame.size.height;
|
||||
[_gfx_context.backend.metal_layer setDrawableSize:CGSizeMake(_gfx_context.frame_width, _gfx_context.frame_height)];
|
||||
|
||||
_metal_gfx_present(&_gfx_context.backend);
|
||||
}
|
||||
@end
|
||||
|
||||
@implementation EDGFXView
|
||||
- (BOOL)isOpaque {
|
||||
return YES;
|
||||
}
|
||||
- (void)updateLayer {
|
||||
_metal_gfx_present(&_gfx_context.backend);
|
||||
}
|
||||
|
||||
- (BOOL)wantsLayer {
|
||||
return YES;
|
||||
}
|
||||
- (BOOL)wantsUpdateLayer {
|
||||
return YES;
|
||||
}
|
||||
- (NSViewLayerContentsRedrawPolicy)layerContentsRedrawPolicy {
|
||||
return NSViewLayerContentsRedrawOnSetNeedsDisplay;
|
||||
}
|
||||
@end
|
||||
|
||||
static _metal_gfx_context _metal_gfx_init_context(uint32_t width, uint32_t height) {
|
||||
NSApplication *application = [NSApplication sharedApplication];
|
||||
if (application == NULL) {
|
||||
fprintf(stderr, "NSApplication:sharedApplication failed\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
NSString *title = @"editor - [C is Illegal]";
|
||||
|
||||
NSRect rect = NSMakeRect(0, 0, width, height);
|
||||
NSWindow *window = [[NSWindow alloc] initWithContentRect:rect
|
||||
styleMask:NSWindowStyleMaskTitled|NSWindowStyleMaskClosable|NSWindowStyleMaskMiniaturizable|NSWindowStyleMaskResizable
|
||||
backing:NSBackingStoreBuffered
|
||||
defer:NO];
|
||||
EDGFXView *view = [[EDGFXView alloc] initWithFrame:rect];
|
||||
[view updateTrackingAreas];
|
||||
[window setTitle:title];
|
||||
[window setContentView:view];
|
||||
[window setDelegate:[[WindowDelegate alloc] init]];
|
||||
[window makeKeyAndOrderFront:NULL];
|
||||
|
||||
// TODO: make this work
|
||||
// if (application.mainMenu == NULL) {
|
||||
// NSMenu *menu = [[NSMenu alloc] initWithTitle:@"an_editor"];
|
||||
// if (menu == NULL) {
|
||||
// fprintf(stderr, "failed to create application menu\n");
|
||||
// exit(1);
|
||||
// }
|
||||
// application.mainMenu = menu;
|
||||
// }
|
||||
[application setDelegate:[[AppDelegate alloc] init]];
|
||||
[application setActivationPolicy:NSApplicationActivationPolicyRegular];
|
||||
[application setPresentationOptions:NSApplicationPresentationDefault];
|
||||
[application finishLaunching];
|
||||
|
||||
id<MTLDevice> device = MTLCreateSystemDefaultDevice();
|
||||
|
||||
CAMetalLayer *metal_layer = [CAMetalLayer layer];
|
||||
metal_layer.device = device;
|
||||
metal_layer.pixelFormat = MTLPixelFormatRGBA8Unorm;
|
||||
metal_layer.frame = CGRectMake(0, 0, width, height);
|
||||
metal_layer.needsDisplayOnBoundsChange = YES;
|
||||
metal_layer.presentsWithTransaction = YES;
|
||||
metal_layer.autoresizingMask = kCALayerWidthSizable|kCALayerHeightSizable;
|
||||
view.wantsLayer = YES;
|
||||
[view.layer addSublayer:metal_layer];
|
||||
view.layerContentsRedrawPolicy = NSViewLayerContentsRedrawOnSetNeedsDisplay;
|
||||
|
||||
|
||||
NSError *libraryError = NULL;
|
||||
NSURL *libraryURL = [[NSBundle mainBundle] URLForResource:@"./shaders" withExtension:@"metallib"];
|
||||
if (libraryURL == NULL) {
|
||||
fprintf(stderr, "Couldn't find library file\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
id<MTLLibrary> library = [device newLibraryWithURL:libraryURL error:&libraryError];
|
||||
|
||||
if (library == NULL) {
|
||||
if (libraryError.description != NULL) {
|
||||
NSLog(@"Error description: %@\n", libraryError.description);
|
||||
}
|
||||
|
||||
exit(1);
|
||||
}
|
||||
|
||||
id<MTLCommandQueue> command_queue = [device newCommandQueue];
|
||||
id<MTLFunction> vertex_func = [library newFunctionWithName:@"vs_main"];
|
||||
id<MTLFunction> fragment_func = [library newFunctionWithName:@"fs_main"];
|
||||
|
||||
MTLRenderPipelineDescriptor *pipeline_descriptor = [[MTLRenderPipelineDescriptor alloc] init];
|
||||
[pipeline_descriptor setVertexFunction:vertex_func];
|
||||
[pipeline_descriptor setFragmentFunction:fragment_func];
|
||||
pipeline_descriptor.colorAttachments[0].pixelFormat = MTLPixelFormatRGBA8Unorm;
|
||||
|
||||
NSError *pipeline_error = NULL;
|
||||
array(_MTLRenderPipelineState) pipelines = newArray(_MTLRenderPipelineState, 2);
|
||||
pushArray(_MTLRenderPipelineState, &pipelines, [device newRenderPipelineStateWithDescriptor:pipeline_descriptor error:&pipeline_error]);
|
||||
|
||||
array(_MTLBuffer) buffers = newArray(_MTLBuffer, 8);
|
||||
array(_MTLTexture) textures = newArray(_MTLTexture, 8);
|
||||
|
||||
if (pipeline_error != NULL) {
|
||||
if (pipeline_error.description != NULL) {
|
||||
NSLog(@"Error description: %@\n", pipeline_error.description);
|
||||
}
|
||||
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return (_metal_gfx_context) {
|
||||
.application = application,
|
||||
.window = window,
|
||||
.view = view,
|
||||
.keep_running = true,
|
||||
|
||||
.device = device,
|
||||
.metal_layer = metal_layer,
|
||||
.library = library,
|
||||
.command_queue = command_queue,
|
||||
.pipelines = pipelines,
|
||||
.buffers = buffers,
|
||||
.textures = textures,
|
||||
};
|
||||
}
|
||||
|
||||
void _metal_gfx_send_events(_metal_gfx_context *cx) {
|
||||
NSEvent *event = [cx->application nextEventMatchingMask:NSEventMaskAny
|
||||
untilDate:[NSDate distantPast] inMode:NSDefaultRunLoopMode dequeue:YES];
|
||||
|
||||
[cx->application sendEvent:event];
|
||||
[cx->application updateWindows];
|
||||
}
|
||||
|
||||
void _metal_gfx_present(_metal_gfx_context *cx) {
|
||||
_gfx_context.frame_func();
|
||||
|
||||
id<CAMetalDrawable> drawable = [cx->metal_layer nextDrawable];
|
||||
|
||||
id<MTLCommandBuffer> command_buffer = [cx->command_queue commandBuffer];
|
||||
MTLRenderPassDescriptor *render_pass_desc = [MTLRenderPassDescriptor renderPassDescriptor];
|
||||
render_pass_desc.colorAttachments[0].texture = drawable.texture;
|
||||
render_pass_desc.colorAttachments[0].loadAction = MTLLoadActionClear;
|
||||
render_pass_desc.colorAttachments[0].clearColor = MTLClearColorMake(0,0,0,1);
|
||||
render_pass_desc.colorAttachments[0].storeAction = MTLStoreActionStore;
|
||||
|
||||
id<MTLRenderCommandEncoder> encoder = [command_buffer renderCommandEncoderWithDescriptor:render_pass_desc];
|
||||
[encoder setRenderPipelineState:cx->pipelines.data[0]];
|
||||
|
||||
// FIXME: allow these to be described by the user instead of hardcoded
|
||||
[encoder setVertexBuffer:cx->buffers.data[0] offset:0 atIndex:0];
|
||||
[encoder setVertexBuffer:cx->buffers.data[2] offset:0 atIndex:1];
|
||||
[encoder setVertexBuffer:cx->buffers.data[3] offset:0 atIndex:2];
|
||||
[encoder setFragmentTexture:cx->textures.data[0] atIndex:0];
|
||||
[encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle indexCount:6 indexType:MTLIndexTypeUInt16 indexBuffer:cx->buffers.data[1] indexBufferOffset:0 instanceCount:36];
|
||||
[encoder endEncoding];
|
||||
|
||||
[command_buffer presentDrawable:drawable];
|
||||
[command_buffer commit];
|
||||
|
||||
[command_buffer waitUntilScheduled];
|
||||
}
|
||||
|
||||
size_t _metal_gfx_push_texture_buffer(_metal_gfx_context *cx, uint32_t width, uint32_t height, const void *data, size_t len) {
|
||||
MTLTextureDescriptor *texture_desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatR8Unorm width:width height:height mipmapped:false];
|
||||
_MTLTexture texture = [cx->device newTextureWithDescriptor:texture_desc];
|
||||
|
||||
MTLRegion region = MTLRegionMake2D(0, 0, width, height);
|
||||
[texture replaceRegion:region mipmapLevel:0 slice:0 withBytes:data bytesPerRow:width*sizeof(uint8_t) bytesPerImage:len];
|
||||
|
||||
pushArray(_MTLTexture, &cx->textures, texture);
|
||||
return cx->textures.size-1;
|
||||
}
|
||||
|
||||
void _metal_gfx_resize_texture_buffer(_metal_gfx_context *cx, uint32_t width, size_t texture_index, uint32_t height) {
|
||||
[cx->textures.data[texture_index] setPurgeableState:MTLPurgeableStateEmpty];
|
||||
[cx->textures.data[texture_index] release];
|
||||
|
||||
MTLTextureDescriptor *texture_desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatR8Unorm width:width height:height mipmapped:false];
|
||||
cx->textures.data[texture_index] = [cx->device newTextureWithDescriptor:texture_desc];
|
||||
}
|
||||
|
||||
size_t _metal_gfx_push_vertex_buffer(_metal_gfx_context *cx, const void *data, size_t len) {
|
||||
pushArray(_MTLBuffer, &cx->buffers, [cx->device newBufferWithBytes:data
|
||||
length:len
|
||||
options:MTLResourceStorageModeShared]
|
||||
);
|
||||
|
||||
return cx->buffers.size-1;
|
||||
}
|
||||
size_t _metal_gfx_allocate_vertex_buffer(_metal_gfx_context *cx, size_t len) {
|
||||
pushArray(_MTLBuffer, &cx->buffers, [cx->device newBufferWithLength:len options:MTLResourceStorageModeShared]
|
||||
);
|
||||
|
||||
return cx->buffers.size-1;
|
||||
}
|
||||
void _metal_gfx_update_buffer(_metal_gfx_context *cx, size_t buffer_index, const void *data, size_t len) {
|
||||
void *buffer_contents = [cx->buffers.data[buffer_index] contents];
|
||||
|
||||
// FIXME: actually check to see if this will fit in the buffer
|
||||
memcpy(buffer_contents, data, len);
|
||||
}
|
||||
#endif
|
||||
|
||||
void * gfx_init_context(_gfx_frame_func frame_func, uint32_t width, uint32_t height) {
|
||||
__auto_type backend =
|
||||
#if defined(__APPLE__)
|
||||
_metal_gfx_init_context(width, height);
|
||||
#else
|
||||
#error "Unsupported graphics backend"
|
||||
#endif
|
||||
|
||||
_gfx_context.backend = backend;
|
||||
_gfx_context.frame_func = frame_func;
|
||||
_gfx_context.frame_width = width;
|
||||
_gfx_context.frame_height = height;
|
||||
|
||||
return &_gfx_context;
|
||||
}
|
||||
|
||||
void gfx_run_events(gfx_context_t *cx) {
|
||||
#if defined(__APPLE__)
|
||||
return _metal_gfx_send_events(&cx->backend);
|
||||
#else
|
||||
#error "Unsupported graphics backend"
|
||||
#endif
|
||||
}
|
||||
|
||||
size_t gfx_push_texture_buffer(gfx_context_t *cx, uint32_t width, uint32_t height, const void *data, size_t len) {
|
||||
#if defined(__APPLE__)
|
||||
return _metal_gfx_push_texture_buffer(&cx->backend, width, height, data, len);
|
||||
#else
|
||||
#error "Unsupported graphics backend"
|
||||
#endif
|
||||
}
|
||||
|
||||
size_t gfx_push_vertex_buffer(gfx_context_t *cx, const void *data, size_t len) {
|
||||
#if defined(__APPLE__)
|
||||
return _metal_gfx_push_vertex_buffer(&cx->backend, data, len);
|
||||
#else
|
||||
#error "Unsupported graphics backend"
|
||||
#endif
|
||||
}
|
||||
|
||||
size_t gfx_allocate_vertex_buffer(gfx_context_t *cx, size_t len) {
|
||||
#if defined(__APPLE__)
|
||||
return _metal_gfx_allocate_vertex_buffer(&cx->backend, len);
|
||||
#else
|
||||
#error "Unsupported graphics backend"
|
||||
#endif
|
||||
}
|
||||
|
||||
// FIXME: abstract different backends
|
||||
void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data, size_t len) {
|
||||
#if defined(__APPLE__)
|
||||
return _metal_gfx_update_buffer(&cx->backend, buffer_index, data, len);
|
||||
#else
|
||||
#error "Unsupported graphics backend"
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
257
src/main.c
257
src/main.c
|
|
@ -1,36 +1,13 @@
|
|||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
// #define ARENA_IMPLEMENTATION
|
||||
// #include <tsoding/arena.h>
|
||||
|
||||
#define SOKOL_DEBUG
|
||||
|
||||
#define SOKOL_APP_IMPL
|
||||
#define SOKOL_GFX_IMPL
|
||||
#define SOKOL_GLUE_IMPL
|
||||
#define SOKOL_FETCH_IMPL
|
||||
#define SOKOL_LOG_IMPL
|
||||
|
||||
// TODO: condition compilation
|
||||
#if defined (__APPLE__)
|
||||
#define SOKOL_METAL
|
||||
#elif defined (__linux__) || defined (__unix__)
|
||||
#define SOKOL_GLCORE33
|
||||
#else
|
||||
#error "Unsupported platform for shaders"
|
||||
#endif
|
||||
|
||||
#include <sokol/sokol_log.h>
|
||||
#include <sokol/sokol_gfx.h>
|
||||
#include <sokol/sokol_app.h>
|
||||
#include <sokol/sokol_glue.h>
|
||||
#include <sokol/sokol_fetch.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#define STB_TRUETYPE_IMPLEMENTATION
|
||||
#include <stb/std_truetype.h>
|
||||
|
||||
#define ED_GFX_IMPLEMENTATION
|
||||
#define ED_STRING_IMPLEMENTATION
|
||||
#define ED_HT_IMPLEMENTATION
|
||||
#define ED_UI_IMPLEMENTATION
|
||||
|
|
@ -38,7 +15,7 @@
|
|||
#include "ht.h"
|
||||
#include "ui.h"
|
||||
#include "ed_array.h"
|
||||
|
||||
#include "gfx.h"
|
||||
|
||||
// static Arena default_arena = {0};
|
||||
// static Arena temporary_arena = {0};
|
||||
|
|
@ -62,23 +39,15 @@ typedef struct {
|
|||
float size[2];
|
||||
float position[2];
|
||||
float y_offset;
|
||||
float _haha_alignment;
|
||||
} GpuGlyph;
|
||||
arrayTemplate(GpuGlyph);
|
||||
|
||||
typedef struct {
|
||||
float screen_size[4];
|
||||
float screen_size[2];
|
||||
} GpuUniformParams;
|
||||
|
||||
static struct {
|
||||
sg_pass_action pass_action;
|
||||
sg_pipeline pip;
|
||||
sg_bindings bind;
|
||||
|
||||
sg_image text_atlas_image;
|
||||
sg_sampler text_atlas_sampler;
|
||||
|
||||
sg_shader_desc scratch_shader_desc;
|
||||
|
||||
array(GpuUiRect) gpu_ui_rects;
|
||||
array(GpuGlyph) gpu_glyphs;
|
||||
array(GpuGlyph) glyph_cache;
|
||||
|
|
@ -86,13 +55,13 @@ static struct {
|
|||
bool should_exit;
|
||||
|
||||
ui_context ui_cx;
|
||||
gfx_context_t *gfx_cx;
|
||||
} state;
|
||||
|
||||
void queue_text(string text, float position[2]) {
|
||||
float x = 0;
|
||||
for (size_t i=0; i < text.len; ++i) {
|
||||
if (text.data[i] >= 32) {
|
||||
//GpuGlyph glyph = *((GpuGlyph *)(state.glyph_cache.data+((text.data[i] - 32) * sizeof(GpuGlyph))));
|
||||
GpuGlyph glyph = state.glyph_cache.data[text.data[i] - 32];
|
||||
|
||||
glyph.position[0] = x+position[0];
|
||||
|
|
@ -104,43 +73,25 @@ void queue_text(string text, float position[2]) {
|
|||
}
|
||||
}
|
||||
|
||||
void vertex_shader_loaded(const sfetch_response_t *response) {
|
||||
if (response->fetched) {
|
||||
state.scratch_shader_desc.vs = (sg_shader_stage_desc) {
|
||||
.source = response->data.ptr,
|
||||
.entry = "vs_main",
|
||||
.uniform_blocks[0] = {
|
||||
.size = sizeof(GpuUniformParams),
|
||||
.layout = SG_UNIFORMLAYOUT_STD140,
|
||||
.uniforms = {
|
||||
[0] = { .name = "screen_size", .type = SG_UNIFORMTYPE_FLOAT4 },
|
||||
},
|
||||
},
|
||||
};
|
||||
} else if (response->failed) {
|
||||
fprintf(stderr, "failed to load vertex shader\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
void ed_init(_gfx_frame_func frame_func) {
|
||||
state.gfx_cx = gfx_init_context(frame_func, 640, 480);
|
||||
state.ui_cx = ui_init_context();
|
||||
|
||||
void fragment_shader_loaded(const sfetch_response_t *response) {
|
||||
if (response->fetched) {
|
||||
state.scratch_shader_desc.fs = (sg_shader_stage_desc){
|
||||
.source = response->data.ptr,
|
||||
.entry = "fs_main",
|
||||
.images[0].used = true,
|
||||
.samplers[0].used = true,
|
||||
.image_sampler_pairs[0] = { .glsl_name = "_group_0_binding_0_fs", .used = true, .image_slot = 0, .sampler_slot = 0 },
|
||||
};
|
||||
state.scratch_shader_desc.fs.source = response->data.ptr;
|
||||
state.scratch_shader_desc.fs.entry = "fs_main";
|
||||
} else if (response->failed) {
|
||||
fprintf(stderr, "failed to load vertex shader\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
float vertices[] = {
|
||||
// positions texture coords
|
||||
-1.0f, 1.0f, 0.0f, 0.0f,
|
||||
1.0f, 1.0f, 1.0f, 0.0f,
|
||||
1.0f, -1.0f, 1.0f, 1.0f,
|
||||
-1.0f, -1.0f, 0.0f, 1.0f,
|
||||
};
|
||||
const uint16_t indices[] = { 0, 1, 2, 0, 2, 3 };
|
||||
|
||||
// NOTE: the order of these matter
|
||||
gfx_push_vertex_buffer(state.gfx_cx, vertices, sizeof(vertices));
|
||||
gfx_push_vertex_buffer(state.gfx_cx, indices, sizeof(indices));
|
||||
gfx_allocate_vertex_buffer(state.gfx_cx, state.gpu_glyphs.capacity * sizeof(GpuGlyph));
|
||||
gfx_allocate_vertex_buffer(state.gfx_cx, sizeof(GpuUniformParams));
|
||||
|
||||
void ed_init() {
|
||||
uint8_t ttf_buffer[1<<20];
|
||||
// TODO: grab default font from the system
|
||||
FILE *ttf_file = fopen("./bin/JetBrainsMono-Medium.ttf", "rb");
|
||||
|
|
@ -154,61 +105,6 @@ void ed_init() {
|
|||
stbtt_fontinfo font;
|
||||
stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer, 0));
|
||||
|
||||
sg_setup(&(sg_desc) {
|
||||
.environment = sglue_environment(),
|
||||
.logger.func = slog_func,
|
||||
});
|
||||
|
||||
float vertices[] = {
|
||||
// positions texture coords
|
||||
-1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
|
||||
1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
|
||||
1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
|
||||
-1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
|
||||
};
|
||||
state.bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc) {
|
||||
.data = SG_RANGE(vertices)
|
||||
});
|
||||
|
||||
const uint16_t indices[] = { 0, 1, 2, 0, 2, 3 };
|
||||
state.bind.index_buffer = sg_make_buffer(&(sg_buffer_desc) {
|
||||
.type = SG_BUFFERTYPE_INDEXBUFFER,
|
||||
.data = SG_RANGE(indices)
|
||||
});
|
||||
|
||||
sfetch_setup(&(sfetch_desc_t){ .logger.func = slog_func });
|
||||
|
||||
char vs_source[8000] = { 0 };
|
||||
char fs_source[8000] = { 0 };
|
||||
|
||||
sfetch_handle_t vs_handle = sfetch_send(&(sfetch_request_t) {
|
||||
#if defined (__APPLE__)
|
||||
.path = "./bin/transpiled_shaders/vertex.metal",
|
||||
#elif defined (__linux__) || defined (__unix__)
|
||||
.path = "./shaders/vertex.vert",
|
||||
#else
|
||||
#error "Unsupported platform for shaders"
|
||||
#endif
|
||||
.callback = vertex_shader_loaded,
|
||||
.buffer = { .ptr = vs_source, .size = sizeof(vs_source) },
|
||||
});
|
||||
sfetch_handle_t fs_handle = sfetch_send(&(sfetch_request_t) {
|
||||
#if defined (__APPLE__)
|
||||
.path = "./bin/transpiled_shaders/fragment.metal",
|
||||
#elif defined (__linux__) || defined (__unix__)
|
||||
.path = "./shaders/fragment.frag",
|
||||
#else
|
||||
#error "Unsupported platform for shaders"
|
||||
#endif
|
||||
.callback = fragment_shader_loaded,
|
||||
.buffer = { .ptr = fs_source, .size = sizeof(fs_source) },
|
||||
});
|
||||
|
||||
// block until files are loaded
|
||||
while (sfetch_handle_valid(vs_handle) || sfetch_handle_valid(fs_handle)) {
|
||||
sfetch_dowork();
|
||||
}
|
||||
|
||||
const int font_bitmap_size = 1024;
|
||||
const int rasterized_font_height = 64;
|
||||
uint8_t *font_bitmap = context_alloc(font_bitmap_size*font_bitmap_size * sizeof(uint8_t));
|
||||
|
|
@ -267,52 +163,12 @@ void ed_init() {
|
|||
x += width;
|
||||
}
|
||||
|
||||
state.bind.vertex_buffers[1] = sg_make_buffer(&(sg_buffer_desc) {
|
||||
.size = state.gpu_glyphs.capacity * sizeof(GpuGlyph),
|
||||
.usage = SG_USAGE_STREAM,
|
||||
.label = "glyph buffer"
|
||||
});
|
||||
|
||||
state.text_atlas_sampler = sg_make_sampler(&(sg_sampler_desc) { .mag_filter = SG_FILTER_LINEAR });
|
||||
state.text_atlas_image = sg_make_image(&(sg_image_desc) {
|
||||
.width = font_bitmap_size,
|
||||
.height = font_bitmap_size,
|
||||
.pixel_format = SG_PIXELFORMAT_R8,
|
||||
.data.subimage[0][0] = { .ptr = font_bitmap, .size = font_bitmap_size*font_bitmap_size * sizeof(uint8_t) },
|
||||
});
|
||||
state.bind.fs.images[0] = state.text_atlas_image;
|
||||
state.bind.fs.samplers[0] = state.text_atlas_sampler;
|
||||
|
||||
state.pass_action = (sg_pass_action) {
|
||||
.colors[0] = {
|
||||
.load_action = SG_LOADACTION_CLEAR,
|
||||
.clear_value = { 0.0f, 0.0f, 0.0f, 1.0f }
|
||||
}
|
||||
};
|
||||
sg_shader shd = sg_make_shader(&state.scratch_shader_desc);
|
||||
state.pip = sg_make_pipeline(&(sg_pipeline_desc) {
|
||||
.shader = shd,
|
||||
.index_type = SG_INDEXTYPE_UINT16,
|
||||
.layout = {
|
||||
.buffers[1].step_func = SG_VERTEXSTEP_PER_INSTANCE,
|
||||
.attrs = {
|
||||
[0] = { .format=SG_VERTEXFORMAT_FLOAT3, .buffer_index = 0 },
|
||||
[1] = { .format=SG_VERTEXFORMAT_FLOAT2, .buffer_index = 0 },
|
||||
|
||||
[2] = { .format=SG_VERTEXFORMAT_FLOAT2, .buffer_index = 1 },
|
||||
[3] = { .format=SG_VERTEXFORMAT_FLOAT2, .buffer_index = 1 },
|
||||
[4] = { .format=SG_VERTEXFORMAT_FLOAT2, .buffer_index = 1 },
|
||||
[5] = { .format=SG_VERTEXFORMAT_FLOAT, .buffer_index = 1 },
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
state.ui_cx = ui_init_context();
|
||||
gfx_push_texture_buffer(state.gfx_cx, font_bitmap_size, font_bitmap_size, font_bitmap, font_bitmap_size*font_bitmap_size * sizeof(uint8_t));
|
||||
|
||||
}
|
||||
void ed_frame() {
|
||||
state.ui_cx.frame_elements.data[0].size.computed_size[0] = sapp_width();
|
||||
state.ui_cx.frame_elements.data[0].size.computed_size[1] = sapp_height();
|
||||
state.ui_cx.frame_elements.data[0].size.computed_size[0] = state.gfx_cx->frame_width;
|
||||
state.ui_cx.frame_elements.data[0].size.computed_size[1] = state.gfx_cx->frame_height;
|
||||
|
||||
ui_element(&state.ui_cx, _String("Number 1"));
|
||||
ui_element(&state.ui_cx, _String("ui element 2"));
|
||||
|
|
@ -332,65 +188,24 @@ void ed_frame() {
|
|||
ui_prune(&state.ui_cx);
|
||||
|
||||
if (state.gpu_glyphs.size > 0) {
|
||||
sg_update_buffer(state.bind.vertex_buffers[1], &(sg_range) {
|
||||
.ptr = state.gpu_glyphs.data,
|
||||
.size = state.gpu_glyphs.size * sizeof(GpuGlyph)
|
||||
});
|
||||
gfx_update_buffer(state.gfx_cx, 2, state.gpu_glyphs.data, state.gpu_glyphs.size * sizeof(GpuGlyph));
|
||||
fprintf(stderr, "updated glyph buffer: %zu\n", state.gpu_glyphs.size);
|
||||
}
|
||||
|
||||
GpuUniformParams gpu_uniform_params = {
|
||||
.screen_size = {
|
||||
sapp_widthf(),
|
||||
sapp_heightf(),
|
||||
0,
|
||||
0
|
||||
(float)state.gfx_cx->frame_width,
|
||||
(float)state.gfx_cx->frame_height,
|
||||
},
|
||||
};
|
||||
|
||||
sg_begin_pass(&(sg_pass) { .action = state.pass_action, .swapchain = sglue_swapchain() });
|
||||
{
|
||||
sg_apply_pipeline(state.pip);
|
||||
sg_apply_bindings(&state.bind);
|
||||
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, &(sg_range) { .ptr = &gpu_uniform_params, .size = sizeof(GpuUniformParams) });
|
||||
sg_draw(0, 6, state.gpu_glyphs.size);
|
||||
}
|
||||
sg_end_pass();
|
||||
sg_commit();
|
||||
gfx_update_buffer(state.gfx_cx, 3, &gpu_uniform_params, sizeof(GpuUniformParams));
|
||||
}
|
||||
|
||||
void ed_cleanup() {
|
||||
sfetch_shutdown();
|
||||
sg_shutdown();
|
||||
}
|
||||
int main(int argc, char* argv[]) {
|
||||
ed_init(ed_frame);
|
||||
|
||||
void ed_event(const sapp_event *event) {
|
||||
switch (event->type) {
|
||||
case SAPP_EVENTTYPE_MOUSE_DOWN:
|
||||
if (event->mouse_button == SAPP_MOUSEBUTTON_LEFT) {
|
||||
sapp_lock_mouse(true);
|
||||
}
|
||||
break;
|
||||
|
||||
case SAPP_EVENTTYPE_MOUSE_UP:
|
||||
if (event->mouse_button == SAPP_MOUSEBUTTON_LEFT) {
|
||||
sapp_lock_mouse(false);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
while(keep_running) {
|
||||
gfx_run_events(state.gfx_cx);
|
||||
}
|
||||
}
|
||||
|
||||
sapp_desc sokol_main(int argc, char *argv[]) {
|
||||
return (sapp_desc) {
|
||||
.width = 640,
|
||||
.height = 480,
|
||||
.init_cb = ed_init,
|
||||
.frame_cb = ed_frame,
|
||||
.cleanup_cb = ed_cleanup,
|
||||
.event_cb = ed_event,
|
||||
.icon.sokol_default = true,
|
||||
.logger.func = slog_func,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,162 +0,0 @@
|
|||
#if defined(SOKOL_IMPL) && !defined(SOKOL_GLUE_IMPL)
|
||||
#define SOKOL_GLUE_IMPL
|
||||
#endif
|
||||
#ifndef SOKOL_GLUE_INCLUDED
|
||||
/*
|
||||
sokol_glue.h -- glue helper functions for sokol headers
|
||||
|
||||
Project URL: https://github.com/floooh/sokol
|
||||
|
||||
Do this:
|
||||
#define SOKOL_IMPL or
|
||||
#define SOKOL_GLUE_IMPL
|
||||
before you include this file in *one* C or C++ file to create the
|
||||
implementation.
|
||||
|
||||
...optionally provide the following macros to override defaults:
|
||||
|
||||
SOKOL_ASSERT(c) - your own assert macro (default: assert(c))
|
||||
SOKOL_GLUE_API_DECL - public function declaration prefix (default: extern)
|
||||
SOKOL_API_DECL - same as SOKOL_GLUE_API_DECL
|
||||
SOKOL_API_IMPL - public function implementation prefix (default: -)
|
||||
|
||||
If sokol_glue.h is compiled as a DLL, define the following before
|
||||
including the declaration or implementation:
|
||||
|
||||
SOKOL_DLL
|
||||
|
||||
On Windows, SOKOL_DLL will define SOKOL_GLUE_API_DECL as __declspec(dllexport)
|
||||
or __declspec(dllimport) as needed.
|
||||
|
||||
OVERVIEW
|
||||
========
|
||||
sokol_glue.h provides glue helper functions between sokol_gfx.h and sokol_app.h,
|
||||
so that sokol_gfx.h doesn't need to depend on sokol_app.h but can be
|
||||
used with different window system glue libraries.
|
||||
|
||||
PROVIDED FUNCTIONS
|
||||
==================
|
||||
|
||||
sg_environment sglue_environment(void)
|
||||
|
||||
Returns an sg_environment struct initialized by calling sokol_app.h
|
||||
functions. Use this in the sg_setup() call like this:
|
||||
|
||||
sg_setup(&(sg_desc){
|
||||
.environment = sglue_enviornment(),
|
||||
...
|
||||
});
|
||||
|
||||
sg_swapchain sglue_swapchain(void)
|
||||
|
||||
Returns an sg_swapchain struct initialized by calling sokol_app.h
|
||||
functions. Use this in sg_begin_pass() for a 'swapchain pass' like
|
||||
this:
|
||||
|
||||
sg_begin_pass(&(sg_pass){ .swapchain = sglue_swapchain(), ... });
|
||||
|
||||
LICENSE
|
||||
=======
|
||||
zlib/libpng license
|
||||
|
||||
Copyright (c) 2018 Andre Weissflog
|
||||
|
||||
This software is provided 'as-is', without any express or implied warranty.
|
||||
In no event will the authors be held liable for any damages arising from the
|
||||
use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software in a
|
||||
product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and must not
|
||||
be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
#define SOKOL_GLUE_INCLUDED
|
||||
|
||||
#if defined(SOKOL_API_DECL) && !defined(SOKOL_GLUE_API_DECL)
|
||||
#define SOKOL_GLUE_API_DECL SOKOL_API_DECL
|
||||
#endif
|
||||
#ifndef SOKOL_GLUE_API_DECL
|
||||
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_GLUE_IMPL)
|
||||
#define SOKOL_GLUE_API_DECL __declspec(dllexport)
|
||||
#elif defined(_WIN32) && defined(SOKOL_DLL)
|
||||
#define SOKOL_GLUE_API_DECL __declspec(dllimport)
|
||||
#else
|
||||
#define SOKOL_GLUE_API_DECL extern
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef SOKOL_GFX_INCLUDED
|
||||
#error "Please include sokol_gfx.h before sokol_glue.h"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
SOKOL_GLUE_API_DECL sg_environment sglue_environment(void);
|
||||
SOKOL_GLUE_API_DECL sg_swapchain sglue_swapchain(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
#endif /* SOKOL_GLUE_INCLUDED */
|
||||
|
||||
/*-- IMPLEMENTATION ----------------------------------------------------------*/
|
||||
#ifdef SOKOL_GLUE_IMPL
|
||||
#define SOKOL_GLUE_IMPL_INCLUDED (1)
|
||||
#include <string.h> /* memset */
|
||||
|
||||
#ifndef SOKOL_APP_INCLUDED
|
||||
#error "Please include sokol_app.h before the sokol_glue.h implementation"
|
||||
#endif
|
||||
|
||||
#ifndef SOKOL_API_IMPL
|
||||
#define SOKOL_API_IMPL
|
||||
#endif
|
||||
|
||||
|
||||
SOKOL_API_IMPL sg_environment sglue_environment(void) {
|
||||
sg_environment env;
|
||||
memset(&env, 0, sizeof(env));
|
||||
env.defaults.color_format = (sg_pixel_format) sapp_color_format();
|
||||
env.defaults.depth_format = (sg_pixel_format) sapp_depth_format();
|
||||
env.defaults.sample_count = sapp_sample_count();
|
||||
env.metal.device = sapp_metal_get_device();
|
||||
env.d3d11.device = sapp_d3d11_get_device();
|
||||
env.d3d11.device_context = sapp_d3d11_get_device_context();
|
||||
env.wgpu.device = sapp_wgpu_get_device();
|
||||
return env;
|
||||
}
|
||||
|
||||
SOKOL_API_IMPL sg_swapchain sglue_swapchain(void) {
|
||||
sg_swapchain swapchain;
|
||||
memset(&swapchain, 0, sizeof(swapchain));
|
||||
swapchain.width = sapp_width();
|
||||
swapchain.height = sapp_height();
|
||||
swapchain.sample_count = sapp_sample_count();
|
||||
swapchain.color_format = (sg_pixel_format)sapp_color_format();
|
||||
swapchain.depth_format = (sg_pixel_format)sapp_depth_format();
|
||||
swapchain.metal.current_drawable = sapp_metal_get_current_drawable();
|
||||
swapchain.metal.depth_stencil_texture = sapp_metal_get_depth_stencil_texture();
|
||||
swapchain.metal.msaa_color_texture = sapp_metal_get_msaa_color_texture();
|
||||
swapchain.d3d11.render_view = sapp_d3d11_get_render_view();
|
||||
swapchain.d3d11.resolve_view = sapp_d3d11_get_resolve_view();
|
||||
swapchain.d3d11.depth_stencil_view = sapp_d3d11_get_depth_stencil_view();
|
||||
swapchain.wgpu.render_view = sapp_wgpu_get_render_view();
|
||||
swapchain.wgpu.resolve_view = sapp_wgpu_get_resolve_view();
|
||||
swapchain.wgpu.depth_stencil_view = sapp_wgpu_get_depth_stencil_view();
|
||||
swapchain.gl.framebuffer = sapp_gl_get_framebuffer();
|
||||
return swapchain;
|
||||
}
|
||||
|
||||
#endif /* SOKOL_GLUE_IMPL */
|
||||
|
|
@ -1,343 +0,0 @@
|
|||
#if defined(SOKOL_IMPL) && !defined(SOKOL_LOG_IMPL)
|
||||
#define SOKOL_LOG_IMPL
|
||||
#endif
|
||||
#ifndef SOKOL_LOG_INCLUDED
|
||||
/*
|
||||
sokol_log.h -- common logging callback for sokol headers
|
||||
|
||||
Project URL: https://github.com/floooh/sokol
|
||||
|
||||
Example code: https://github.com/floooh/sokol-samples
|
||||
|
||||
Do this:
|
||||
#define SOKOL_IMPL or
|
||||
#define SOKOL_LOG_IMPL
|
||||
before you include this file in *one* C or C++ file to create the
|
||||
implementation.
|
||||
|
||||
Optionally provide the following defines when building the implementation:
|
||||
|
||||
SOKOL_ASSERT(c) - your own assert macro (default: assert(c))
|
||||
SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false))
|
||||
SOKOL_LOG_API_DECL - public function declaration prefix (default: extern)
|
||||
SOKOL_API_DECL - same as SOKOL_GFX_API_DECL
|
||||
SOKOL_API_IMPL - public function implementation prefix (default: -)
|
||||
|
||||
Optionally define the following for verbose output:
|
||||
|
||||
SOKOL_DEBUG - by default this is defined if _DEBUG is defined
|
||||
|
||||
|
||||
OVERVIEW
|
||||
========
|
||||
sokol_log.h provides a default logging callback for other sokol headers.
|
||||
|
||||
To use the default log callback, just include sokol_log.h and provide
|
||||
a function pointer to the 'slog_func' function when setting up the
|
||||
sokol library:
|
||||
|
||||
For instance with sokol_audio.h:
|
||||
|
||||
#include "sokol_log.h"
|
||||
...
|
||||
saudio_setup(&(saudio_desc){ .logger.func = slog_func });
|
||||
|
||||
Logging output goes to stderr and/or a platform specific logging subsystem
|
||||
(which means that in some scenarios you might see logging messages duplicated):
|
||||
|
||||
- Windows: stderr + OutputDebugStringA()
|
||||
- macOS/iOS/Linux: stderr + syslog()
|
||||
- Emscripten: console.info()/warn()/error()
|
||||
- Android: __android_log_write()
|
||||
|
||||
On Windows with sokol_app.h also note the runtime config items to make
|
||||
stdout/stderr output visible on the console for WinMain() applications
|
||||
via sapp_desc.win32_console_attach or sapp_desc.win32_console_create,
|
||||
however when running in a debugger on Windows, the logging output should
|
||||
show up on the debug output UI panel.
|
||||
|
||||
In debug mode, a log message might look like this:
|
||||
|
||||
[sspine][error][id:12] /Users/floh/projects/sokol/util/sokol_spine.h:3472:0:
|
||||
SKELETON_DESC_NO_ATLAS: no atlas object provided in sspine_skeleton_desc.atlas
|
||||
|
||||
The source path and line number is formatted like compiler errors, in some IDEs (like VSCode)
|
||||
such error messages are clickable.
|
||||
|
||||
In release mode, logging is less verbose as to not bloat the executable with string data, but you still get
|
||||
enough information to identify the type and location of an error:
|
||||
|
||||
[sspine][error][id:12][line:3472]
|
||||
|
||||
RULES FOR WRITING YOUR OWN LOGGING FUNCTION
|
||||
===========================================
|
||||
- must be re-entrant because it might be called from different threads
|
||||
- must treat **all** provided string pointers as optional (can be null)
|
||||
- don't store the string pointers, copy the string data instead
|
||||
- must not return for log level panic
|
||||
|
||||
LICENSE
|
||||
=======
|
||||
zlib/libpng license
|
||||
|
||||
Copyright (c) 2023 Andre Weissflog
|
||||
|
||||
This software is provided 'as-is', without any express or implied warranty.
|
||||
In no event will the authors be held liable for any damages arising from the
|
||||
use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software in a
|
||||
product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and must not
|
||||
be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
#define SOKOL_LOG_INCLUDED (1)
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(SOKOL_API_DECL) && !defined(SOKOL_LOG_API_DECL)
|
||||
#define SOKOL_LOG_API_DECL SOKOL_API_DECL
|
||||
#endif
|
||||
#ifndef SOKOL_LOG_API_DECL
|
||||
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_LOG_IMPL)
|
||||
#define SOKOL_LOG_API_DECL __declspec(dllexport)
|
||||
#elif defined(_WIN32) && defined(SOKOL_DLL)
|
||||
#define SOKOL_LOG_API_DECL __declspec(dllimport)
|
||||
#else
|
||||
#define SOKOL_LOG_API_DECL extern
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
Plug this function into the 'logger.func' struct item when initializing any of the sokol
|
||||
headers. For instance for sokol_audio.h it would loom like this:
|
||||
|
||||
saudio_setup(&(saudio_desc){
|
||||
.logger = {
|
||||
.func = slog_func
|
||||
}
|
||||
});
|
||||
*/
|
||||
SOKOL_LOG_API_DECL void slog_func(const char* tag, uint32_t log_level, uint32_t log_item, const char* message, uint32_t line_nr, const char* filename, void* user_data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
#endif // SOKOL_LOG_INCLUDED
|
||||
|
||||
// ██ ███ ███ ██████ ██ ███████ ███ ███ ███████ ███ ██ ████████ █████ ████████ ██ ██████ ███ ██
|
||||
// ██ ████ ████ ██ ██ ██ ██ ████ ████ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
|
||||
// ██ ██ ████ ██ ██████ ██ █████ ██ ████ ██ █████ ██ ██ ██ ██ ███████ ██ ██ ██ ██ ██ ██ ██
|
||||
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
|
||||
// ██ ██ ██ ██ ███████ ███████ ██ ██ ███████ ██ ████ ██ ██ ██ ██ ██ ██████ ██ ████
|
||||
//
|
||||
// >>implementation
|
||||
#ifdef SOKOL_LOG_IMPL
|
||||
#define SOKOL_LOG_IMPL_INCLUDED (1)
|
||||
|
||||
#ifndef SOKOL_API_IMPL
|
||||
#define SOKOL_API_IMPL
|
||||
#endif
|
||||
#ifndef SOKOL_DEBUG
|
||||
#ifndef NDEBUG
|
||||
#define SOKOL_DEBUG
|
||||
#endif
|
||||
#endif
|
||||
#ifndef SOKOL_ASSERT
|
||||
#include <assert.h>
|
||||
#define SOKOL_ASSERT(c) assert(c)
|
||||
#endif
|
||||
|
||||
#ifndef _SOKOL_PRIVATE
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define _SOKOL_PRIVATE __attribute__((unused)) static
|
||||
#else
|
||||
#define _SOKOL_PRIVATE static
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef _SOKOL_UNUSED
|
||||
#define _SOKOL_UNUSED(x) (void)(x)
|
||||
#endif
|
||||
|
||||
// platform detection
|
||||
#if defined(__APPLE__)
|
||||
#define _SLOG_APPLE (1)
|
||||
#elif defined(__EMSCRIPTEN__)
|
||||
#define _SLOG_EMSCRIPTEN (1)
|
||||
#elif defined(_WIN32)
|
||||
#define _SLOG_WINDOWS (1)
|
||||
#elif defined(__ANDROID__)
|
||||
#define _SLOG_ANDROID (1)
|
||||
#elif defined(__linux__) || defined(__unix__)
|
||||
#define _SLOG_LINUX (1)
|
||||
#else
|
||||
#error "sokol_log.h: unknown platform"
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> // abort
|
||||
#include <stdio.h> // fputs
|
||||
#include <stddef.h> // size_t
|
||||
|
||||
#if defined(_SLOG_EMSCRIPTEN)
|
||||
#include <emscripten/emscripten.h>
|
||||
#elif defined(_SLOG_WINDOWS)
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#elif defined(_SLOG_ANDROID)
|
||||
#include <android/log.h>
|
||||
#elif defined(_SLOG_LINUX) || defined(_SLOG_APPLE)
|
||||
#include <syslog.h>
|
||||
#endif
|
||||
|
||||
// size of line buffer (on stack!) in bytes including terminating zero
|
||||
#define _SLOG_LINE_LENGTH (512)
|
||||
|
||||
_SOKOL_PRIVATE char* _slog_append(const char* str, char* dst, char* end) {
|
||||
if (str) {
|
||||
char c;
|
||||
while (((c = *str++) != 0) && (dst < (end - 1))) {
|
||||
*dst++ = c;
|
||||
}
|
||||
}
|
||||
*dst = 0;
|
||||
return dst;
|
||||
}
|
||||
|
||||
_SOKOL_PRIVATE char* _slog_itoa(uint32_t x, char* buf, size_t buf_size) {
|
||||
const size_t max_digits_and_null = 11;
|
||||
if (buf_size < max_digits_and_null) {
|
||||
return 0;
|
||||
}
|
||||
char* p = buf + max_digits_and_null;
|
||||
*--p = 0;
|
||||
do {
|
||||
*--p = '0' + (x % 10);
|
||||
x /= 10;
|
||||
} while (x != 0);
|
||||
return p;
|
||||
}
|
||||
|
||||
#if defined(_SLOG_EMSCRIPTEN)
|
||||
EM_JS(void, slog_js_log, (uint32_t level, const char* c_str), {
|
||||
const str = UTF8ToString(c_str);
|
||||
switch (level) {
|
||||
case 0: console.error(str); break;
|
||||
case 1: console.error(str); break;
|
||||
case 2: console.warn(str); break;
|
||||
default: console.info(str); break;
|
||||
}
|
||||
});
|
||||
#endif
|
||||
|
||||
SOKOL_API_IMPL void slog_func(const char* tag, uint32_t log_level, uint32_t log_item, const char* message, uint32_t line_nr, const char* filename, void* user_data) {
|
||||
_SOKOL_UNUSED(user_data);
|
||||
|
||||
const char* log_level_str;
|
||||
switch (log_level) {
|
||||
case 0: log_level_str = "panic"; break;
|
||||
case 1: log_level_str = "error"; break;
|
||||
case 2: log_level_str = "warning"; break;
|
||||
default: log_level_str = "info"; break;
|
||||
}
|
||||
|
||||
// build log output line
|
||||
char line_buf[_SLOG_LINE_LENGTH];
|
||||
char* str = line_buf;
|
||||
char* end = line_buf + sizeof(line_buf);
|
||||
char num_buf[32];
|
||||
if (tag) {
|
||||
str = _slog_append("[", str, end);
|
||||
str = _slog_append(tag, str, end);
|
||||
str = _slog_append("]", str, end);
|
||||
}
|
||||
str = _slog_append("[", str, end);
|
||||
str = _slog_append(log_level_str, str, end);
|
||||
str = _slog_append("]", str, end);
|
||||
str = _slog_append("[id:", str, end);
|
||||
str = _slog_append(_slog_itoa(log_item, num_buf, sizeof(num_buf)), str, end);
|
||||
str = _slog_append("]", str, end);
|
||||
// if a filename is provided, build a clickable log message that's compatible with compiler error messages
|
||||
if (filename) {
|
||||
str = _slog_append(" ", str, end);
|
||||
#if defined(_MSC_VER)
|
||||
// MSVC compiler error format
|
||||
str = _slog_append(filename, str, end);
|
||||
str = _slog_append("(", str, end);
|
||||
str = _slog_append(_slog_itoa(line_nr, num_buf, sizeof(num_buf)), str, end);
|
||||
str = _slog_append("): ", str, end);
|
||||
#else
|
||||
// gcc/clang compiler error format
|
||||
str = _slog_append(filename, str, end);
|
||||
str = _slog_append(":", str, end);
|
||||
str = _slog_append(_slog_itoa(line_nr, num_buf, sizeof(num_buf)), str, end);
|
||||
str = _slog_append(":0: ", str, end);
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
str = _slog_append("[line:", str, end);
|
||||
str = _slog_append(_slog_itoa(line_nr, num_buf, sizeof(num_buf)), str, end);
|
||||
str = _slog_append("] ", str, end);
|
||||
}
|
||||
if (message) {
|
||||
str = _slog_append("\n\t", str, end);
|
||||
str = _slog_append(message, str, end);
|
||||
}
|
||||
str = _slog_append("\n\n", str, end);
|
||||
if (0 == log_level) {
|
||||
str = _slog_append("ABORTING because of [panic]\n", str, end);
|
||||
(void)str;
|
||||
}
|
||||
|
||||
// print to stderr?
|
||||
#if defined(_SLOG_LINUX) || defined(_SLOG_WINDOWS) || defined(_SLOG_APPLE)
|
||||
fputs(line_buf, stderr);
|
||||
#endif
|
||||
|
||||
// platform specific logging calls
|
||||
#if defined(_SLOG_WINDOWS)
|
||||
OutputDebugStringA(line_buf);
|
||||
#elif defined(_SLOG_ANDROID)
|
||||
int prio;
|
||||
switch (log_level) {
|
||||
case 0: prio = ANDROID_LOG_FATAL; break;
|
||||
case 1: prio = ANDROID_LOG_ERROR; break;
|
||||
case 2: prio = ANDROID_LOG_WARN; break;
|
||||
default: prio = ANDROID_LOG_INFO; break;
|
||||
}
|
||||
__android_log_write(prio, "SOKOL", line_buf);
|
||||
#elif defined(_SLOG_EMSCRIPTEN)
|
||||
slog_js_log(log_level, line_buf);
|
||||
#elif defined(_SLOG_LINUX) || defined(_SLOG_APPLE)
|
||||
int prio;
|
||||
switch (log_level) {
|
||||
case 0: prio = LOG_CRIT; break;
|
||||
case 1: prio = LOG_ERR; break;
|
||||
case 2: prio = LOG_WARNING; break;
|
||||
default: prio = LOG_INFO; break;
|
||||
}
|
||||
syslog(prio, "%s", line_buf);
|
||||
#endif
|
||||
if (0 == log_level) {
|
||||
abort();
|
||||
}
|
||||
}
|
||||
#endif // SOKOL_LOG_IMPL
|
||||
Loading…
Reference in New Issue