pull/9631/head
Larpon 2021-04-07 20:39:23 +02:00 committed by GitHub
parent 9541eb816b
commit 8caabf0e9e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 4825 additions and 2965 deletions

View File

@ -190,8 +190,8 @@ jobs:
- name: Shader examples can be build
run: |
wget https://github.com/floooh/sokol-tools-bin/archive/pre-feb2021-api-changes.tar.gz
tar -xf pre-feb2021-api-changes.tar.gz
wget https://github.com/floooh/sokol-tools-bin/raw/master/bin/linux/sokol-shdc
chmod +x ./sokol-shdc
for f in examples/sokol/02_cubes_glsl/cube_glsl \
examples/sokol/03_march_tracing_glsl/rt_glsl \
examples/sokol/04_multi_shader_glsl/rt_glsl_puppy \
@ -200,7 +200,7 @@ jobs:
examples/sokol/06_obj_viewer/gouraud \
; do \
echo "compiling shader $f.glsl ..."; \
sokol-tools-bin-pre-feb2021-api-changes/bin/linux/sokol-shdc --input $f.glsl --output $f.h --slang glsl330 ; \
./sokol-shdc --input $f.glsl --output $f.h --slang glsl330 ; \
done
for vfile in examples/sokol/0?*/*.v; do echo "compiling $vfile ..."; ./v $vfile ; done

View File

@ -54,9 +54,9 @@ fn create_texture(w int, h int, buf &byte) C.sg_image {
d3d11_texture: 0
}
// commen if .dynamic is enabled
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
sg_img := C.sg_make_image(&img_desc)
@ -70,10 +70,10 @@ fn destroy_texture(sg_img C.sg_image) {
// Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) {
sz := w * h * 4
mut tmp_sbc := C.sg_image_content{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{
mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
C.sg_update_image(sg_img, &tmp_sbc)
}
@ -323,16 +323,21 @@ fn my_init(mut app App) {
// 3d pipeline
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
color_state := C.sg_color_state{
blend: C.sg_blend_state{
enabled: true
src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
pipdesc.colors[0] = color_state
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
app.pip_3d = sgl.make_pipeline(&pipdesc)
// create chessboard texture 256*256 RGBA

View File

@ -43,7 +43,7 @@ import gg.m4
#flag -I @VROOT/.
#include "cube_glsl.h" #Please use sokol-shdc to generate the necessary cube_glsl.h file from cube_glsl.glsl (see the instructions at the top of this file)
fn C.cube_shader_desc() &C.sg_shader_desc
fn C.cube_shader_desc(gfx.Backend) &C.sg_shader_desc
const (
win_width = 800
@ -87,9 +87,9 @@ fn create_texture(w int, h int, buf &byte) C.sg_image {
d3d11_texture: 0
}
// comment if .dynamic is enabled
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
sg_img := C.sg_make_image(&img_desc)
@ -103,10 +103,10 @@ fn destroy_texture(sg_img C.sg_image) {
// Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) {
sz := w * h * 4
mut tmp_sbc := C.sg_image_content{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{
mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
C.sg_update_image(sg_img, &tmp_sbc)
}
@ -295,8 +295,13 @@ fn init_cube_glsl(mut app App) {
mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc)) }
vert_buffer_desc.size = vertices.len * int(sizeof(Vertex_t))
vert_buffer_desc.content = &byte(vertices.data)
vert_buffer_desc.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.data = C.sg_range{
ptr: vertices.data
size: size_t(vertices.len * int(sizeof(Vertex_t)))
}
vert_buffer_desc.@type = .vertexbuffer
// vert_buffer_desc.usage = .immutable
vert_buffer_desc.label = 'cube-vertices'.str
@ -314,14 +319,19 @@ fn init_cube_glsl(mut app App) {
mut index_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&index_buffer_desc, 0, sizeof(index_buffer_desc)) }
index_buffer_desc.size = indices.len * int(sizeof(u16))
index_buffer_desc.content = &byte(indices.data)
index_buffer_desc.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.data = C.sg_range{
ptr: indices.data
size: size_t(indices.len * int(sizeof(u16)))
}
index_buffer_desc.@type = .indexbuffer
index_buffer_desc.label = 'cube-indices'.str
ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader
shader := gfx.make_shader(C.cube_shader_desc())
shader := gfx.make_shader(C.cube_shader_desc(C.sg_query_backend()))
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -336,13 +346,12 @@ fn init_cube_glsl(mut app App) {
pipdesc.shader = shader
pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str
app.cube_bind.vertex_buffers[0] = vbuf
@ -376,7 +385,11 @@ fn draw_cube_glsl(app App) {
//***************
// passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params, &tr_matrix, 4 * 16)
vs_uniforms_range := C.sg_range{
ptr: &tr_matrix
size: size_t(4 * 16)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params, &vs_uniforms_range)
// fs uniforms
time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -386,7 +399,11 @@ fn draw_cube_glsl(app App) {
time_ticks, /* time as f32 */
0 /* padding 4 Bytes == 1 f32 */,
]!
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &text_res, 4 * 4)
fs_uniforms_range := C.sg_range{
ptr: &text_res
size: size_t(4 * 4)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &fs_uniforms_range)
gfx.draw(0, (3 * 2) * 6, 1)
gfx.end_pass()
@ -461,11 +478,13 @@ fn frame(mut app App) {
// clear
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_DONTCARE) // C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 1.0
g: 1.0
b: 1.0
a: 1.0
}
}
color_action.val[0] = 1
color_action.val[1] = 1
color_action.val[2] = 1
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height)
@ -494,16 +513,22 @@ fn my_init(mut app App) {
// 3d pipeline
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
color_state := C.sg_color_state{
blend: C.sg_blend_state{
enabled: true
src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
pipdesc.colors[0] = color_state
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
app.pip_3d = sgl.make_pipeline(&pipdesc)
// create chessboard texture 256*256 RGBA

View File

@ -44,7 +44,7 @@ import time
#flag -I @VROOT/.
#include "rt_glsl.h" #Please use sokol-shdc to generate the necessary rt_glsl.h file from rt_glsl.glsl (see the instructions at the top of this file)
fn C.rt_shader_desc() &C.sg_shader_desc
fn C.rt_shader_desc(gfx.Backend) &C.sg_shader_desc
const (
win_width = 800
@ -86,9 +86,9 @@ fn create_texture(w int, h int, buf &byte) C.sg_image {
d3d11_texture: 0
}
// comment if .dynamic is enabled
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
sg_img := C.sg_make_image(&img_desc)
@ -102,10 +102,10 @@ fn destroy_texture(sg_img C.sg_image) {
// Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) {
sz := w * h * 4
mut tmp_sbc := C.sg_image_content{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{
mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
C.sg_update_image(sg_img, &tmp_sbc)
}
@ -174,8 +174,13 @@ fn init_cube_glsl(mut app App) {
mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc)) }
vert_buffer_desc.size = vertices.len * int(sizeof(Vertex_t))
vert_buffer_desc.content = &byte(vertices.data)
vert_buffer_desc.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.data = C.sg_range{
ptr: vertices.data
size: size_t(vertices.len * int(sizeof(Vertex_t)))
}
vert_buffer_desc.@type = .vertexbuffer
vert_buffer_desc.label = 'cube-vertices'.str
vbuf := gfx.make_buffer(&vert_buffer_desc)
@ -192,14 +197,19 @@ fn init_cube_glsl(mut app App) {
mut index_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&index_buffer_desc, 0, sizeof(index_buffer_desc))}
index_buffer_desc.size = indices.len * int(sizeof(u16))
index_buffer_desc.content = &byte(indices.data)
index_buffer_desc.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.data = C.sg_range{
ptr: indices.data
size: size_t(indices.len * int(sizeof(u16)))
}
index_buffer_desc.@type = .indexbuffer
index_buffer_desc.label = "cube-indices".str
ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader
shader := gfx.make_shader(C.rt_shader_desc())
shader := gfx.make_shader(C.rt_shader_desc(C.sg_query_backend()))
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -214,13 +224,12 @@ fn init_cube_glsl(mut app App) {
pipdesc.shader = shader
pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str
app.cube_bind.vertex_buffers[0] = vbuf
@ -274,7 +283,11 @@ fn draw_cube_glsl(app App) {
// *** vertex shadeer uniforms ***
// passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params, &tr_matrix, 4 * 16)
vs_uniforms_range := C.sg_range{
ptr: &tr_matrix
size: size_t(4 * 16)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params, &vs_uniforms_range)
// *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -288,7 +301,11 @@ fn draw_cube_glsl(app App) {
0,
0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h
]!
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &tmp_fs_params, int(sizeof(tmp_fs_params)))
fs_uniforms_range := C.sg_range{
ptr: &tmp_fs_params
size: size_t(sizeof(tmp_fs_params))
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &fs_uniforms_range)
// 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
gfx.draw(0, (3 * 2) * 6, 1)
@ -302,11 +319,14 @@ fn frame(mut app App) {
// clear
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 0.0
g: 0.0
b: 0.0
a: 1.0
}
}
color_action.val[0] = 0
color_action.val[1] = 0
color_action.val[2] = 0
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height)

View File

@ -45,8 +45,8 @@ import time
#flag -I @VROOT/.
#include "rt_glsl_march.h" #Please use sokol-shdc to generate the necessary rt_glsl_march.h file from rt_glsl_march.glsl (see the instructions at the top of this file)
#include "rt_glsl_puppy.h" #Please use sokol-shdc to generate the necessary rt_glsl_puppy.h file from rt_glsl_puppy.glsl (see the instructions at the top of this file)
fn C.rt_march_shader_desc() &C.sg_shader_desc
fn C.rt_puppy_shader_desc() &C.sg_shader_desc
fn C.rt_march_shader_desc(gfx.Backend) &C.sg_shader_desc
fn C.rt_puppy_shader_desc(gfx.Backend) &C.sg_shader_desc
const (
win_width = 800
@ -90,9 +90,9 @@ fn create_texture(w int, h int, buf byteptr) C.sg_image {
d3d11_texture: 0
}
// comment if .dynamic is enabled
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
sg_img := C.sg_make_image(&img_desc)
@ -106,10 +106,10 @@ fn destroy_texture(sg_img C.sg_image) {
// Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf byteptr) {
sz := w * h * 4
mut tmp_sbc := C.sg_image_content{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{
mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
C.sg_update_image(sg_img, &tmp_sbc)
}
@ -178,8 +178,11 @@ fn init_cube_glsl_m(mut app App) {
mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc)) }
vert_buffer_desc.size = vertices.len * int(sizeof(Vertex_t))
vert_buffer_desc.content = byteptr(vertices.data)
vert_buffer_desc.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.data = C.sg_range{
ptr: vertices.data
size: size_t(vertices.len * int(sizeof(Vertex_t)))
}
vert_buffer_desc.@type = .vertexbuffer
vert_buffer_desc.label = 'cube-vertices'.str
vbuf := gfx.make_buffer(&vert_buffer_desc)
@ -198,14 +201,17 @@ fn init_cube_glsl_m(mut app App) {
mut index_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&index_buffer_desc, 0, sizeof(index_buffer_desc)) }
index_buffer_desc.size = indices.len * int(sizeof(u16))
index_buffer_desc.content = byteptr(indices.data)
index_buffer_desc.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.data = C.sg_range{
ptr: indices.data
size: size_t(indices.len * int(sizeof(u16)))
}
index_buffer_desc.@type = .indexbuffer
index_buffer_desc.label = 'cube-indices'.str
ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader
shader := gfx.make_shader(C.rt_march_shader_desc())
shader := gfx.make_shader(C.rt_march_shader_desc(C.sg_query_backend()))
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -220,13 +226,11 @@ fn init_cube_glsl_m(mut app App) {
pipdesc.shader = shader
pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str
mut bind := C.sg_bindings{}
@ -282,8 +286,11 @@ fn init_cube_glsl_p(mut app App) {
mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc)) }
vert_buffer_desc.size = vertices.len * int(sizeof(Vertex_t))
vert_buffer_desc.content = byteptr(vertices.data)
vert_buffer_desc.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.data = C.sg_range{
ptr: vertices.data
size: size_t(vertices.len * int(sizeof(Vertex_t)))
}
vert_buffer_desc.@type = .vertexbuffer
vert_buffer_desc.label = 'cube-vertices'.str
vbuf := gfx.make_buffer(&vert_buffer_desc)
@ -303,14 +310,17 @@ fn init_cube_glsl_p(mut app App) {
mut index_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&index_buffer_desc, 0, sizeof(index_buffer_desc)) }
index_buffer_desc.size = indices.len * int(sizeof(u16))
index_buffer_desc.content = byteptr(indices.data)
index_buffer_desc.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.data = C.sg_range{
ptr: indices.data
size: size_t(indices.len * int(sizeof(u16)))
}
index_buffer_desc.@type = .indexbuffer
index_buffer_desc.label = 'cube-indices'.str
ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader
shader := gfx.make_shader(C.rt_puppy_shader_desc())
shader := gfx.make_shader(C.rt_puppy_shader_desc(C.sg_query_backend()))
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -325,13 +335,12 @@ fn init_cube_glsl_p(mut app App) {
pipdesc.shader = shader
pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str
mut bind := C.sg_bindings{}
@ -387,7 +396,11 @@ fn draw_cube_glsl_m(app App) {
// *** vertex shadeer uniforms ***
// passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params_m, &tr_matrix, 4 * 16)
vs_uniforms_range := C.sg_range{
ptr: &tr_matrix
size: size_t(4 * 16)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params_m, &vs_uniforms_range)
// *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -403,7 +416,11 @@ fn draw_cube_glsl_m(app App) {
0,
0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h
]!
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params_m, &tmp_fs_params, int(sizeof(tmp_fs_params)))
fs_uniforms_range := C.sg_range{
ptr: &tmp_fs_params
size: size_t(sizeof(tmp_fs_params))
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params_p, &fs_uniforms_range)
// 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
gfx.draw(0, (3 * 2) * 3, 1)
@ -431,7 +448,11 @@ fn draw_cube_glsl_p(app App) {
// *** vertex shadeer uniforms ***
// passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params_p, &tr_matrix, 4 * 16)
vs_uniforms_range := C.sg_range{
ptr: &tr_matrix
size: size_t(4 * 16)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params_p, &vs_uniforms_range)
// *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -447,7 +468,11 @@ fn draw_cube_glsl_p(app App) {
0,
0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h
]!
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params_p, &tmp_fs_params, int(sizeof(tmp_fs_params)))
fs_uniforms_range := C.sg_range{
ptr: &tmp_fs_params
size: size_t(sizeof(tmp_fs_params))
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params_p, &fs_uniforms_range)
// 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
gfx.draw(0, (3 * 2) * 3, 1)
@ -477,11 +502,13 @@ fn frame(mut app App) {
// clear
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 0.0
g: 0.0
b: 0.0
a: 1.0
}
}
color_action.val[0] = 0
color_action.val[1] = 0
color_action.val[2] = 0
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height)

View File

@ -81,7 +81,7 @@ mut:
******************************************************************************/
#flag -I @VROOT/.
#include "rt_glsl_instancing.h" #Please use sokol-shdc to generate the necessary rt_glsl_march.h file from rt_glsl_march.glsl (see the instructions at the top of this file)
fn C.instancing_shader_desc() &C.sg_shader_desc
fn C.instancing_shader_desc(gfx.Backend) &C.sg_shader_desc
/******************************************************************************
* Texture functions
@ -101,9 +101,9 @@ fn create_texture(w int, h int, buf byteptr) C.sg_image{
d3d11_texture: 0
}
// comment if .dynamic is enabled
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
sg_img := C.sg_make_image(&img_desc)
@ -117,10 +117,10 @@ fn destroy_texture(sg_img C.sg_image){
// Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf byteptr){
sz := w * h * 4
mut tmp_sbc := C.sg_image_content{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content {
mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
C.sg_update_image(sg_img, &tmp_sbc)
}
@ -191,8 +191,11 @@ fn init_cube_glsl_i(mut app App) {
mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc))}
vert_buffer_desc.size = vertices.len * int(sizeof(Vertex_t))
vert_buffer_desc.content = byteptr(vertices.data)
vert_buffer_desc.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.data = C.sg_range{
ptr: vertices.data
size: size_t(vertices.len * int(sizeof(Vertex_t)))
}
vert_buffer_desc.@type = .vertexbuffer
vert_buffer_desc.label = "cube-vertices".str
vbuf := gfx.make_buffer(&vert_buffer_desc)
@ -200,7 +203,8 @@ fn init_cube_glsl_i(mut app App) {
/* create an instance buffer for the cube */
mut inst_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&inst_buffer_desc, 0, sizeof(inst_buffer_desc))}
inst_buffer_desc.size = num_inst * int(sizeof(m4.Vec4))
inst_buffer_desc.size = size_t(num_inst * int(sizeof(m4.Vec4)))
inst_buffer_desc.@type = .vertexbuffer
inst_buffer_desc.usage = .stream
inst_buffer_desc.label = "instance-data".str
@ -219,14 +223,17 @@ fn init_cube_glsl_i(mut app App) {
mut index_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&index_buffer_desc, 0, sizeof(index_buffer_desc))}
index_buffer_desc.size = indices.len * int(sizeof(u16))
index_buffer_desc.content = byteptr(indices.data)
index_buffer_desc.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.data = C.sg_range{
ptr: indices.data
size: size_t(indices.len * int(sizeof(u16)))
}
index_buffer_desc.@type = .indexbuffer
index_buffer_desc.label = "cube-indices".str
ibuf := gfx.make_buffer(&index_buffer_desc)
/* create shader */
shader := gfx.make_shader(C.instancing_shader_desc())
shader := gfx.make_shader(C.instancing_shader_desc(C.sg_query_backend()))
mut pipdesc := C.sg_pipeline_desc{}
unsafe {C.memset(&pipdesc, 0, sizeof(pipdesc))}
@ -250,13 +257,12 @@ fn init_cube_glsl_i(mut app App) {
pipdesc.shader = shader
pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func : gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state {
cull_mode: .back
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .back
pipdesc.label = "glsl_shader pipeline".str
mut bind := C.sg_bindings{}
@ -324,13 +330,21 @@ fn draw_cube_glsl_i(mut app App){
spare_param := f32(index % 10)
app.inst_pos[index] = m4.Vec4{e:[f32((x - cx - app.camera_x) * cube_size),y ,f32( (z - cz - app.camera_z) * cube_size),spare_param]!}
}
gfx.update_buffer(app.bind['inst'].vertex_buffers[1], &app.inst_pos , num_inst * int(sizeof(m4.Vec4)) )
range := C.sg_range{
ptr: &app.inst_pos
size: size_t(num_inst * int(sizeof(m4.Vec4)))
}
gfx.update_buffer(app.bind['inst'].vertex_buffers[1], &range )
// Uniforms
// *** vertex shadeer uniforms ***
// passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params_i, &tr_matrix, 4*16 )
vs_uniforms_range := C.sg_range{
ptr: &tr_matrix
size: size_t(4 * 16)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params_i, &vs_uniforms_range)
/*
// *** fragment shader uniforms ***
@ -344,7 +358,11 @@ fn draw_cube_glsl_i(mut app App){
app.frame_count, // frame count
0,0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h
]!
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params_i, &tmp_fs_params, int(sizeof(tmp_fs_params)))
fs_uniforms_range := C.sg_range{
ptr: &tmp_fs_params
size: size_t(sizeof(tmp_fs_params))
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &fs_uniforms_range)
*/
// 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw for num_inst times
gfx.draw(0, (3 * 2) * 6, num_inst)
@ -375,11 +393,13 @@ fn frame(mut app App) {
// clear
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 0.0
g: 0.0
b: 0.0
a: 1.0
}
}
color_action.val[0] = 0
color_action.val[1] = 0
color_action.val[2] = 0
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height)

View File

@ -32,9 +32,9 @@ pub fn create_texture(w int, h int, buf &byte) C.sg_image {
d3d11_texture: 0
}
// comment if .dynamic is enabled
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: buf
size: sz
size: size_t(sz)
}
sg_img := C.sg_make_image(&img_desc)
@ -69,8 +69,13 @@ pub fn (mut obj_part ObjPart) create_pipeline(in_part []int, shader C.sg_shader,
// vertex buffer
mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc)) }
vert_buffer_desc.size = obj_buf.vbuf.len * int(sizeof(Vertex_pnct))
vert_buffer_desc.content = &byte(obj_buf.vbuf.data)
vert_buffer_desc.size = size_t(obj_buf.vbuf.len * int(sizeof(Vertex_pnct)))
vert_buffer_desc.data = C.sg_range{
ptr: obj_buf.vbuf.data
size: size_t(obj_buf.vbuf.len * int(sizeof(Vertex_pnct)))
}
vert_buffer_desc.@type = .vertexbuffer
vert_buffer_desc.label = 'vertbuf_part_${in_part:03}'.str
vbuf := gfx.make_buffer(&vert_buffer_desc)
@ -78,8 +83,13 @@ pub fn (mut obj_part ObjPart) create_pipeline(in_part []int, shader C.sg_shader,
// index buffer
mut index_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&index_buffer_desc, 0, sizeof(index_buffer_desc))}
index_buffer_desc.size = obj_buf.ibuf.len * int(sizeof(u32))
index_buffer_desc.content = &byte(obj_buf.ibuf.data)
index_buffer_desc.size = size_t(obj_buf.ibuf.len * int(sizeof(u32)))
index_buffer_desc.data = C.sg_range{
ptr: obj_buf.ibuf.data
size: size_t(obj_buf.ibuf.len * int(sizeof(u32)))
}
index_buffer_desc.@type = .indexbuffer
index_buffer_desc.label = "indbuf_part_${in_part:03}".str
ibuf := gfx.make_buffer(&index_buffer_desc)
@ -96,17 +106,21 @@ pub fn (mut obj_part ObjPart) create_pipeline(in_part []int, shader C.sg_shader,
// pipdesc.layout.attrs[C.ATTR_vs_a_Texcoord0].format = .short2n // u,v as u16
pipdesc.index_type = .uint32
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
color_state := C.sg_color_state{
blend: C.sg_blend_state{
enabled: true
src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
}
pipdesc.colors[0] = color_state
pipdesc.depth_stencil = C.sg_depth_stencil_state{
depth_write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .front //.back
pipdesc.depth = C.sg_depth_state{
write_enabled: true
compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.cull_mode = .front
pipdesc.label = 'pip_part_${in_part:03}'.str
// shader
@ -128,8 +142,7 @@ pub fn (mut obj_part ObjPart) create_pipeline(in_part []int, shader C.sg_shader,
pub fn (mut obj_part ObjPart) init_render_data(texture C.sg_image) {
// create shader
// One shader for all the model
shader := gfx.make_shader(C.gouraud_shader_desc())
//shader := gfx.make_shader(C.gouraud_shader_desc(gfx.query_backend()))
shader := gfx.make_shader(C.gouraud_shader_desc(gfx.query_backend()))
mut part_dict := map[string][]int{}
for i, p in obj_part.part {
@ -215,8 +228,18 @@ pub fn (obj_part ObjPart) bind_and_draw(rend_data_index int, in_data Shader_data
gfx.apply_pipeline(part_render_data.pipeline)
gfx.apply_bindings(part_render_data.bind)
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params, in_data.vs_data, in_data.vs_len)
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &tmp_fs_params, in_data.fs_len)
vs_uniforms_range := C.sg_range{
ptr: in_data.vs_data
size: size_t(in_data.vs_len)
}
fs_uniforms_range := C.sg_range{
ptr: &tmp_fs_params
size: size_t(in_data.fs_len)
}
gfx.apply_uniforms(C.SG_SHADERSTAGE_VS, C.SLOT_vs_params, &vs_uniforms_range)
gfx.apply_uniforms(C.SG_SHADERSTAGE_FS, C.SLOT_fs_params, &fs_uniforms_range)
gfx.draw(0, int(part_render_data.n_vert), 1)
return part_render_data.n_vert
}

View File

@ -52,8 +52,7 @@ import obj
#flag -I @VROOT/.
#include "gouraud.h" #Please use sokol-shdc to generate the necessary rt_glsl.h file from rt_glsl.glsl (see the instructions at the top of this file)
//fn C.gouraud_shader_desc(gfx.Backend) &C.sg_shader_desc
fn C.gouraud_shader_desc() &C.sg_shader_desc
fn C.gouraud_shader_desc(gfx.Backend) &C.sg_shader_desc
const (
win_width = 600
@ -165,11 +164,14 @@ fn frame(mut app App) {
// clear
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 0.0
g: 0.0
b: 0.0
a: 1.0
}
}
color_action.val[0] = 0
color_action.val[1] = 0
color_action.val[2] = 0
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height)
@ -292,6 +294,7 @@ fn main() {
}
app.file_name = "v.obj_" // default object is the v logo
app.single_material_flag = false
$if !android {
if os.args.len > 3 || (os.args.len >= 2 && os.args[1] in ['-h', '--help', '\\?', '-?']) {

View File

@ -15,11 +15,13 @@ mut:
fn main() {
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 0.3
g: 0.3
b: 0.32
a: 1.0
}
}
color_action.val[0] = 0.3
color_action.val[1] = 0.3
color_action.val[2] = 0.32
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
state := &AppState{

View File

@ -65,11 +65,13 @@ mut:
fn main() {
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color{
r: 1.0
g: 1.0
b: 1.0
a: 1.0
}
}
color_action.val[0] = 1
color_action.val[1] = 1
color_action.val[2] = 1
color_action.val[3] = 1.0
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
state := &AppState{

View File

@ -81,9 +81,16 @@ fn init(user_data voidptr) {
sgl.setup(&sgl_desc)
mut pipdesc := C.sg_pipeline_desc{}
unsafe {C.memset(&pipdesc, 0, sizeof(pipdesc))}
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
color_state := C.sg_color_state{
blend: C.sg_blend_state{
enabled: true
src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
}
pipdesc.colors[0] = color_state
app.alpha_pip = sgl.make_pipeline(&pipdesc)
}

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

View File

@ -1,3 +1,6 @@
#if defined(SOKOL_IMPL) && !defined(SOKOL_FONTSTASH_IMPL)
#define SOKOL_FONTSTASH_IMPL
#endif
#ifndef SOKOL_FONTSTASH_INCLUDED
/*
sokol_fontstash.h -- renderer for https://github.com/memononen/fontstash
@ -6,7 +9,7 @@
Project URL: https://github.com/floooh/sokol
Do this:
#define SOKOL_IMPL or
#define SOKOL_FONTSTASH_IMPL
before you include this file in *one* C or C++ file to create the
@ -27,7 +30,8 @@
SOKOL_ASSERT(c) - your own assert macro (default: assert(c))
SOKOL_MALLOC(s) - your own malloc function (default: malloc(s))
SOKOL_FREE(p) - your own free function (default: free(p))
SOKOL_API_DECL - public function declaration prefix (default: extern)
SOKOL_FONTSTASH_API_DECL - public function declaration prefix (default: extern)
SOKOL_API_DECL - same as SOKOL_FONTSTASH_API_DECL
SOKOL_API_IMPL - public function implementation prefix (default: -)
SOKOL_LOG(msg) - your own logging function (default: puts(msg))
SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false))
@ -159,23 +163,26 @@
#error "Please include sokol_gfx.h before sokol_fontstash.h"
#endif
#ifndef SOKOL_API_DECL
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_IMPL)
#define SOKOL_API_DECL __declspec(dllexport)
#if defined(SOKOL_API_DECL) && !defined(SOKOL_FONTSTASH_API_DECL)
#define SOKOL_FONTSTASH_API_DECL SOKOL_API_DECL
#endif
#ifndef SOKOL_FONTSTASH_API_DECL
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_FONTSTASH_IMPL)
#define SOKOL_FONTSTASH_API_DECL __declspec(dllexport)
#elif defined(_WIN32) && defined(SOKOL_DLL)
#define SOKOL_API_DECL __declspec(dllimport)
#define SOKOL_FONTSTASH_API_DECL __declspec(dllimport)
#else
#define SOKOL_API_DECL extern
#define SOKOL_FONTSTASH_API_DECL extern
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
SOKOL_API_DECL FONScontext* sfons_create(int width, int height, int flags);
SOKOL_API_DECL void sfons_destroy(FONScontext* ctx);
SOKOL_API_DECL void sfons_flush(FONScontext* ctx);
SOKOL_API_DECL uint32_t sfons_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_FONTSTASH_API_DECL FONScontext* sfons_create(int width, int height, int flags);
SOKOL_FONTSTASH_API_DECL void sfons_destroy(FONScontext* ctx);
SOKOL_FONTSTASH_API_DECL void sfons_flush(FONScontext* ctx);
SOKOL_FONTSTASH_API_DECL uint32_t sfons_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
#ifdef __cplusplus
} /* extern "C" */
@ -1603,7 +1610,7 @@ static int _sfons_render_create(void* user_ptr, int width, int height) {
ub->uniforms[0].type = SG_UNIFORMTYPE_FLOAT4;
ub->uniforms[0].array_count = 8;
shd_desc.fs.images[0].name = "tex";
shd_desc.fs.images[0].type = SG_IMAGETYPE_2D;
shd_desc.fs.images[0].image_type = SG_IMAGETYPE_2D;
shd_desc.fs.images[0].sampler_type = SG_SAMPLERTYPE_FLOAT;
shd_desc.label = "sokol-fontstash-shader";
#if defined(SOKOL_GLCORE33)
@ -1617,16 +1624,12 @@ static int _sfons_render_create(void* user_ptr, int width, int height) {
shd_desc.fs.entry = "main0";
switch (sg_query_backend()) {
case SG_BACKEND_METAL_MACOS:
shd_desc.vs.byte_code = _sfons_vs_bytecode_metal_macos;
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_metal_macos);
shd_desc.fs.byte_code = _sfons_fs_bytecode_metal_macos;
shd_desc.fs.byte_code_size = sizeof(_sfons_fs_bytecode_metal_macos);
shd_desc.vs.bytecode = SG_RANGE(_sfons_vs_bytecode_metal_macos);
shd_desc.fs.bytecode = SG_RANGE(_sfons_fs_bytecode_metal_macos);
break;
case SG_BACKEND_METAL_IOS:
shd_desc.vs.byte_code = _sfons_vs_bytecode_metal_ios;
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_metal_ios);
shd_desc.fs.byte_code = _sfons_fs_bytecode_metal_ios;
shd_desc.fs.byte_code_size = sizeof(_sfons_fs_bytecode_metal_ios);
shd_desc.vs.bytecode = SG_RANGE(_sfons_vs_bytecode_metal_ios);
shd_desc.fs.bytecode = SG_RANGE(_sfons_fs_bytecode_metal_ios);
break;
default:
shd_desc.vs.source = _sfons_vs_source_metal_sim;
@ -1634,10 +1637,8 @@ static int _sfons_render_create(void* user_ptr, int width, int height) {
break;
}
#elif defined(SOKOL_D3D11)
shd_desc.vs.byte_code = _sfons_vs_bytecode_hlsl4;
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_hlsl4);
shd_desc.fs.byte_code = _sfons_fs_bytecode_hlsl4;
shd_desc.fs.byte_code_size = sizeof(_sfons_fs_bytecode_hlsl4);
shd_desc.vs.bytecode = SG_RANGE(_sfons_vs_bytecode_hlsl4);
shd_desc.fs.bytecode = SG_RANGE(_sfons_fs_bytecode_hlsl4);
#elif defined(SOKOL_WGPU)
shd_desc.vs.byte_code = _sfons_vs_bytecode_wgpu;
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_wgpu);
@ -1656,9 +1657,9 @@ static int _sfons_render_create(void* user_ptr, int width, int height) {
sg_pipeline_desc pip_desc;
memset(&pip_desc, 0, sizeof(pip_desc));
pip_desc.shader = sfons->shd;
pip_desc.blend.enabled = true;
pip_desc.blend.src_factor_rgb = SG_BLENDFACTOR_SRC_ALPHA;
pip_desc.blend.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
pip_desc.colors[0].blend.enabled = true;
pip_desc.colors[0].blend.src_factor_rgb = SG_BLENDFACTOR_SRC_ALPHA;
pip_desc.colors[0].blend.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
sfons->pip = sgl_make_pipeline(&pip_desc);
}
@ -1769,16 +1770,16 @@ SOKOL_API_IMPL void sfons_flush(FONScontext* ctx) {
_sfons_t* sfons = (_sfons_t*) ctx->params.userPtr;
if (sfons->img_dirty) {
sfons->img_dirty = false;
sg_image_content content;
memset(&content, 0, sizeof(content));
content.subimage[0][0].ptr = ctx->texData;
content.subimage[0][0].size = sfons->width * sfons->height;
sg_update_image(sfons->img, &content);
sg_image_data data;
memset(&data, 0, sizeof(data));
data.subimage[0][0].ptr = ctx->texData;
data.subimage[0][0].size = (size_t) (sfons->width * sfons->height);
sg_update_image(sfons->img, &data);
}
}
SOKOL_API_IMPL uint32_t sfons_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
return (r) | (g<<8) | (b<<16) | (a<<24);
return ((uint32_t)r) | ((uint32_t)g<<8) | ((uint32_t)b<<16) | ((uint32_t)a<<24);
}
#endif /* SOKOL_FONTSTASH_IMPL */

View File

@ -1,3 +1,6 @@
#if defined(SOKOL_IMPL) && !defined(SOKOL_GL_IMPL)
#define SOKOL_GL_IMPL
#endif
#ifndef SOKOL_GL_INCLUDED
/*
sokol_gl.h -- OpenGL 1.x style rendering on top of sokol_gfx.h
@ -5,6 +8,7 @@
Project URL: https://github.com/floooh/sokol
Do this:
#define SOKOL_IMPL or
#define SOKOL_GL_IMPL
before you include this file in *one* C or C++ file to create the
implementation.
@ -25,7 +29,8 @@
SOKOL_ASSERT(c) - your own assert macro (default: assert(c))
SOKOL_MALLOC(s) - your own malloc function (default: malloc(s))
SOKOL_FREE(p) - your own free function (default: free(p))
SOKOL_API_DECL - public function declaration prefix (default: extern)
SOKOL_GL_API_DECL - public function declaration prefix (default: extern)
SOKOL_API_DECL - same as SOKOL_GL_API_DECL
SOKOL_API_IMPL - public function implementation prefix (default: -)
SOKOL_LOG(msg) - your own logging function (default: puts(msg))
SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false))
@ -35,7 +40,7 @@
SOKOL_DLL
On Windows, SOKOL_DLL will define SOKOL_API_DECL as __declspec(dllexport)
On Windows, SOKOL_DLL will define SOKOL_GL_API_DECL as __declspec(dllexport)
or __declspec(dllimport) as needed.
Include the following headers before including sokol_gl.h:
@ -201,6 +206,13 @@
sgl_viewport(int x, int y, int w, int h, bool origin_top_left)
sgl_scissor_rect(int x, int y, int w, int h, bool origin_top_left)
...or call these alternatives which take float arguments (this might allow
to avoid casting between float and integer in more strongly typed languages
when floating point pixel coordinates are used):
sgl_viewportf(float x, float y, float w, float h, bool origin_top_left)
sgl_scissor_rectf(float x, float y, float w, float h, bool origin_top_left)
...these calls add a new command to the internal command queue, so
that the viewport or scissor rect are set at the right time relative
to other sokol-gl calls.
@ -445,13 +457,16 @@
#error "Please include sokol_gfx.h before sokol_gl.h"
#endif
#ifndef SOKOL_API_DECL
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_IMPL)
#define SOKOL_API_DECL __declspec(dllexport)
#if defined(SOKOL_API_DECL) && !defined(SOKOL_GL_API_DECL)
#define SOKOL_GL_API_DECL SOKOL_API_DECL
#endif
#ifndef SOKOL_GL_API_DECL
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_GL_IMPL)
#define SOKOL_GL_API_DECL __declspec(dllexport)
#elif defined(_WIN32) && defined(SOKOL_DLL)
#define SOKOL_API_DECL __declspec(dllimport)
#define SOKOL_GL_API_DECL __declspec(dllimport)
#else
#define SOKOL_API_DECL extern
#define SOKOL_GL_API_DECL extern
#endif
#endif
@ -488,92 +503,94 @@ typedef struct sgl_desc_t {
} sgl_desc_t;
/* setup/shutdown/misc */
SOKOL_API_DECL void sgl_setup(const sgl_desc_t* desc);
SOKOL_API_DECL void sgl_shutdown(void);
SOKOL_API_DECL sgl_error_t sgl_error(void);
SOKOL_API_DECL void sgl_defaults(void);
SOKOL_API_DECL float sgl_rad(float deg);
SOKOL_API_DECL float sgl_deg(float rad);
SOKOL_GL_API_DECL void sgl_setup(const sgl_desc_t* desc);
SOKOL_GL_API_DECL void sgl_shutdown(void);
SOKOL_GL_API_DECL sgl_error_t sgl_error(void);
SOKOL_GL_API_DECL void sgl_defaults(void);
SOKOL_GL_API_DECL float sgl_rad(float deg);
SOKOL_GL_API_DECL float sgl_deg(float rad);
/* create and destroy pipeline objects */
SOKOL_API_DECL sgl_pipeline sgl_make_pipeline(const sg_pipeline_desc* desc);
SOKOL_API_DECL void sgl_destroy_pipeline(sgl_pipeline pip);
SOKOL_GL_API_DECL sgl_pipeline sgl_make_pipeline(const sg_pipeline_desc* desc);
SOKOL_GL_API_DECL void sgl_destroy_pipeline(sgl_pipeline pip);
/* render state functions */
SOKOL_API_DECL void sgl_viewport(int x, int y, int w, int h, bool origin_top_left);
SOKOL_API_DECL void sgl_scissor_rect(int x, int y, int w, int h, bool origin_top_left);
SOKOL_API_DECL void sgl_enable_texture(void);
SOKOL_API_DECL void sgl_disable_texture(void);
SOKOL_API_DECL void sgl_texture(sg_image img);
SOKOL_GL_API_DECL void sgl_viewport(int x, int y, int w, int h, bool origin_top_left);
SOKOL_GL_API_DECL void sgl_viewportf(float x, float y, float w, float h, bool origin_top_left);
SOKOL_GL_API_DECL void sgl_scissor_rect(int x, int y, int w, int h, bool origin_top_left);
SOKOL_GL_API_DECL void sgl_scissor_rectf(float x, float y, float w, float h, bool origin_top_left);
SOKOL_GL_API_DECL void sgl_enable_texture(void);
SOKOL_GL_API_DECL void sgl_disable_texture(void);
SOKOL_GL_API_DECL void sgl_texture(sg_image img);
/* pipeline stack functions */
SOKOL_API_DECL void sgl_default_pipeline(void);
SOKOL_API_DECL void sgl_load_pipeline(sgl_pipeline pip);
SOKOL_API_DECL void sgl_push_pipeline(void);
SOKOL_API_DECL void sgl_pop_pipeline(void);
SOKOL_GL_API_DECL void sgl_default_pipeline(void);
SOKOL_GL_API_DECL void sgl_load_pipeline(sgl_pipeline pip);
SOKOL_GL_API_DECL void sgl_push_pipeline(void);
SOKOL_GL_API_DECL void sgl_pop_pipeline(void);
/* matrix stack functions */
SOKOL_API_DECL void sgl_matrix_mode_modelview(void);
SOKOL_API_DECL void sgl_matrix_mode_projection(void);
SOKOL_API_DECL void sgl_matrix_mode_texture(void);
SOKOL_API_DECL void sgl_load_identity(void);
SOKOL_API_DECL void sgl_load_matrix(const float m[16]);
SOKOL_API_DECL void sgl_load_transpose_matrix(const float m[16]);
SOKOL_API_DECL void sgl_mult_matrix(const float m[16]);
SOKOL_API_DECL void sgl_mult_transpose_matrix(const float m[16]);
SOKOL_API_DECL void sgl_rotate(float angle_rad, float x, float y, float z);
SOKOL_API_DECL void sgl_scale(float x, float y, float z);
SOKOL_API_DECL void sgl_translate(float x, float y, float z);
SOKOL_API_DECL void sgl_frustum(float l, float r, float b, float t, float n, float f);
SOKOL_API_DECL void sgl_ortho(float l, float r, float b, float t, float n, float f);
SOKOL_API_DECL void sgl_perspective(float fov_y, float aspect, float z_near, float z_far);
SOKOL_API_DECL void sgl_lookat(float eye_x, float eye_y, float eye_z, float center_x, float center_y, float center_z, float up_x, float up_y, float up_z);
SOKOL_API_DECL void sgl_push_matrix(void);
SOKOL_API_DECL void sgl_pop_matrix(void);
SOKOL_GL_API_DECL void sgl_matrix_mode_modelview(void);
SOKOL_GL_API_DECL void sgl_matrix_mode_projection(void);
SOKOL_GL_API_DECL void sgl_matrix_mode_texture(void);
SOKOL_GL_API_DECL void sgl_load_identity(void);
SOKOL_GL_API_DECL void sgl_load_matrix(const float m[16]);
SOKOL_GL_API_DECL void sgl_load_transpose_matrix(const float m[16]);
SOKOL_GL_API_DECL void sgl_mult_matrix(const float m[16]);
SOKOL_GL_API_DECL void sgl_mult_transpose_matrix(const float m[16]);
SOKOL_GL_API_DECL void sgl_rotate(float angle_rad, float x, float y, float z);
SOKOL_GL_API_DECL void sgl_scale(float x, float y, float z);
SOKOL_GL_API_DECL void sgl_translate(float x, float y, float z);
SOKOL_GL_API_DECL void sgl_frustum(float l, float r, float b, float t, float n, float f);
SOKOL_GL_API_DECL void sgl_ortho(float l, float r, float b, float t, float n, float f);
SOKOL_GL_API_DECL void sgl_perspective(float fov_y, float aspect, float z_near, float z_far);
SOKOL_GL_API_DECL void sgl_lookat(float eye_x, float eye_y, float eye_z, float center_x, float center_y, float center_z, float up_x, float up_y, float up_z);
SOKOL_GL_API_DECL void sgl_push_matrix(void);
SOKOL_GL_API_DECL void sgl_pop_matrix(void);
/* these functions only set the internal 'current texcoord / color' (valid inside or outside begin/end) */
SOKOL_API_DECL void sgl_t2f(float u, float v);
SOKOL_API_DECL void sgl_c3f(float r, float g, float b);
SOKOL_API_DECL void sgl_c4f(float r, float g, float b, float a);
SOKOL_API_DECL void sgl_c3b(uint8_t r, uint8_t g, uint8_t b);
SOKOL_API_DECL void sgl_c4b(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_API_DECL void sgl_c1i(uint32_t rgba);
SOKOL_GL_API_DECL void sgl_t2f(float u, float v);
SOKOL_GL_API_DECL void sgl_c3f(float r, float g, float b);
SOKOL_GL_API_DECL void sgl_c4f(float r, float g, float b, float a);
SOKOL_GL_API_DECL void sgl_c3b(uint8_t r, uint8_t g, uint8_t b);
SOKOL_GL_API_DECL void sgl_c4b(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_GL_API_DECL void sgl_c1i(uint32_t rgba);
/* define primitives, each begin/end is one draw command */
SOKOL_API_DECL void sgl_begin_points(void);
SOKOL_API_DECL void sgl_begin_lines(void);
SOKOL_API_DECL void sgl_begin_line_strip(void);
SOKOL_API_DECL void sgl_begin_triangles(void);
SOKOL_API_DECL void sgl_begin_triangle_strip(void);
SOKOL_API_DECL void sgl_begin_quads(void);
SOKOL_API_DECL void sgl_v2f(float x, float y);
SOKOL_API_DECL void sgl_v3f(float x, float y, float z);
SOKOL_API_DECL void sgl_v2f_t2f(float x, float y, float u, float v);
SOKOL_API_DECL void sgl_v3f_t2f(float x, float y, float z, float u, float v);
SOKOL_API_DECL void sgl_v2f_c3f(float x, float y, float r, float g, float b);
SOKOL_API_DECL void sgl_v2f_c3b(float x, float y, uint8_t r, uint8_t g, uint8_t b);
SOKOL_API_DECL void sgl_v2f_c4f(float x, float y, float r, float g, float b, float a);
SOKOL_API_DECL void sgl_v2f_c4b(float x, float y, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_API_DECL void sgl_v2f_c1i(float x, float y, uint32_t rgba);
SOKOL_API_DECL void sgl_v3f_c3f(float x, float y, float z, float r, float g, float b);
SOKOL_API_DECL void sgl_v3f_c3b(float x, float y, float z, uint8_t r, uint8_t g, uint8_t b);
SOKOL_API_DECL void sgl_v3f_c4f(float x, float y, float z, float r, float g, float b, float a);
SOKOL_API_DECL void sgl_v3f_c4b(float x, float y, float z, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_API_DECL void sgl_v3f_c1i(float x, float y, float z, uint32_t rgba);
SOKOL_API_DECL void sgl_v2f_t2f_c3f(float x, float y, float u, float v, float r, float g, float b);
SOKOL_API_DECL void sgl_v2f_t2f_c3b(float x, float y, float u, float v, uint8_t r, uint8_t g, uint8_t b);
SOKOL_API_DECL void sgl_v2f_t2f_c4f(float x, float y, float u, float v, float r, float g, float b, float a);
SOKOL_API_DECL void sgl_v2f_t2f_c4b(float x, float y, float u, float v, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_API_DECL void sgl_v2f_t2f_c1i(float x, float y, float u, float v, uint32_t rgba);
SOKOL_API_DECL void sgl_v3f_t2f_c3f(float x, float y, float z, float u, float v, float r, float g, float b);
SOKOL_API_DECL void sgl_v3f_t2f_c3b(float x, float y, float z, float u, float v, uint8_t r, uint8_t g, uint8_t b);
SOKOL_API_DECL void sgl_v3f_t2f_c4f(float x, float y, float z, float u, float v, float r, float g, float b, float a);
SOKOL_API_DECL void sgl_v3f_t2f_c4b(float x, float y, float z, float u, float v, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_API_DECL void sgl_v3f_t2f_c1i(float x, float y, float z, float u, float v, uint32_t rgba);
SOKOL_API_DECL void sgl_end(void);
SOKOL_GL_API_DECL void sgl_begin_points(void);
SOKOL_GL_API_DECL void sgl_begin_lines(void);
SOKOL_GL_API_DECL void sgl_begin_line_strip(void);
SOKOL_GL_API_DECL void sgl_begin_triangles(void);
SOKOL_GL_API_DECL void sgl_begin_triangle_strip(void);
SOKOL_GL_API_DECL void sgl_begin_quads(void);
SOKOL_GL_API_DECL void sgl_v2f(float x, float y);
SOKOL_GL_API_DECL void sgl_v3f(float x, float y, float z);
SOKOL_GL_API_DECL void sgl_v2f_t2f(float x, float y, float u, float v);
SOKOL_GL_API_DECL void sgl_v3f_t2f(float x, float y, float z, float u, float v);
SOKOL_GL_API_DECL void sgl_v2f_c3f(float x, float y, float r, float g, float b);
SOKOL_GL_API_DECL void sgl_v2f_c3b(float x, float y, uint8_t r, uint8_t g, uint8_t b);
SOKOL_GL_API_DECL void sgl_v2f_c4f(float x, float y, float r, float g, float b, float a);
SOKOL_GL_API_DECL void sgl_v2f_c4b(float x, float y, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_GL_API_DECL void sgl_v2f_c1i(float x, float y, uint32_t rgba);
SOKOL_GL_API_DECL void sgl_v3f_c3f(float x, float y, float z, float r, float g, float b);
SOKOL_GL_API_DECL void sgl_v3f_c3b(float x, float y, float z, uint8_t r, uint8_t g, uint8_t b);
SOKOL_GL_API_DECL void sgl_v3f_c4f(float x, float y, float z, float r, float g, float b, float a);
SOKOL_GL_API_DECL void sgl_v3f_c4b(float x, float y, float z, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_GL_API_DECL void sgl_v3f_c1i(float x, float y, float z, uint32_t rgba);
SOKOL_GL_API_DECL void sgl_v2f_t2f_c3f(float x, float y, float u, float v, float r, float g, float b);
SOKOL_GL_API_DECL void sgl_v2f_t2f_c3b(float x, float y, float u, float v, uint8_t r, uint8_t g, uint8_t b);
SOKOL_GL_API_DECL void sgl_v2f_t2f_c4f(float x, float y, float u, float v, float r, float g, float b, float a);
SOKOL_GL_API_DECL void sgl_v2f_t2f_c4b(float x, float y, float u, float v, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_GL_API_DECL void sgl_v2f_t2f_c1i(float x, float y, float u, float v, uint32_t rgba);
SOKOL_GL_API_DECL void sgl_v3f_t2f_c3f(float x, float y, float z, float u, float v, float r, float g, float b);
SOKOL_GL_API_DECL void sgl_v3f_t2f_c3b(float x, float y, float z, float u, float v, uint8_t r, uint8_t g, uint8_t b);
SOKOL_GL_API_DECL void sgl_v3f_t2f_c4f(float x, float y, float z, float u, float v, float r, float g, float b, float a);
SOKOL_GL_API_DECL void sgl_v3f_t2f_c4b(float x, float y, float z, float u, float v, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
SOKOL_GL_API_DECL void sgl_v3f_t2f_c1i(float x, float y, float z, float u, float v, uint32_t rgba);
SOKOL_GL_API_DECL void sgl_end(void);
/* render everything */
SOKOL_API_DECL void sgl_draw(void);
SOKOL_GL_API_DECL void sgl_draw(void);
#ifdef __cplusplus
} /* extern "C" */
@ -2070,12 +2087,12 @@ static void _sgl_init_pool(_sgl_pool_t* pool, int num) {
pool->size = num + 1;
pool->queue_top = 0;
/* generation counters indexable by pool slot index, slot 0 is reserved */
size_t gen_ctrs_size = sizeof(uint32_t) * pool->size;
size_t gen_ctrs_size = sizeof(uint32_t) * (size_t)pool->size;
pool->gen_ctrs = (uint32_t*) SOKOL_MALLOC(gen_ctrs_size);
SOKOL_ASSERT(pool->gen_ctrs);
memset(pool->gen_ctrs, 0, gen_ctrs_size);
/* it's not a bug to only reserve 'num' here */
pool->free_queue = (int*) SOKOL_MALLOC(sizeof(int)*num);
pool->free_queue = (int*) SOKOL_MALLOC(sizeof(int) * (size_t)num);
SOKOL_ASSERT(pool->free_queue);
/* never allocate the zero-th pool item since the invalid id is 0 */
for (int i = pool->size-1; i >= 1; i--) {
@ -2134,7 +2151,7 @@ static void _sgl_setup_pipeline_pool(const sgl_desc_t* desc) {
/* note: the pools here will have an additional item, since slot 0 is reserved */
SOKOL_ASSERT((desc->pipeline_pool_size > 0) && (desc->pipeline_pool_size < _SGL_MAX_POOL_SIZE));
_sgl_init_pool(&_sgl.pip_pool.pool, desc->pipeline_pool_size);
size_t pool_byte_size = sizeof(_sgl_pipeline_t) * _sgl.pip_pool.pool.size;
size_t pool_byte_size = sizeof(_sgl_pipeline_t) * (size_t)_sgl.pip_pool.pool.size;
_sgl.pip_pool.pips = (_sgl_pipeline_t*) SOKOL_MALLOC(pool_byte_size);
SOKOL_ASSERT(_sgl.pip_pool.pips);
memset(_sgl.pip_pool.pips, 0, pool_byte_size);
@ -2237,14 +2254,14 @@ static void _sgl_init_pipeline(sgl_pipeline pip_id, const sg_pipeline_desc* in_d
desc.shader = _sgl.shd;
}
desc.index_type = SG_INDEXTYPE_NONE;
desc.blend.color_format = _sgl.desc.color_format;
desc.blend.depth_format = _sgl.desc.depth_format;
desc.rasterizer.sample_count = _sgl.desc.sample_count;
if (desc.rasterizer.face_winding == _SG_FACEWINDING_DEFAULT) {
desc.rasterizer.face_winding = _sgl.desc.face_winding;
desc.sample_count = _sgl.desc.sample_count;
if (desc.face_winding == _SG_FACEWINDING_DEFAULT) {
desc.face_winding = _sgl.desc.face_winding;
}
if (desc.blend.color_write_mask == _SG_COLORMASK_DEFAULT) {
desc.blend.color_write_mask = SG_COLORMASK_RGB;
desc.depth.pixel_format = _sgl.desc.depth_format;
desc.colors[0].pixel_format = _sgl.desc.color_format;
if (desc.colors[0].write_mask == _SG_COLORMASK_DEFAULT) {
desc.colors[0].write_mask = SG_COLORMASK_RGB;
}
_sgl_pipeline_t* pip = _sgl_lookup_pipeline(pip_id.id);
@ -2639,11 +2656,11 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
_sgl.num_vertices = _sgl.desc.max_vertices;
_sgl.num_uniforms = _sgl.desc.max_commands;
_sgl.num_commands = _sgl.num_uniforms;
_sgl.vertices = (_sgl_vertex_t*) SOKOL_MALLOC(_sgl.num_vertices * sizeof(_sgl_vertex_t));
_sgl.vertices = (_sgl_vertex_t*) SOKOL_MALLOC((size_t)_sgl.num_vertices * sizeof(_sgl_vertex_t));
SOKOL_ASSERT(_sgl.vertices);
_sgl.uniforms = (_sgl_uniform_t*) SOKOL_MALLOC(_sgl.num_uniforms * sizeof(_sgl_uniform_t));
_sgl.uniforms = (_sgl_uniform_t*) SOKOL_MALLOC((size_t)_sgl.num_uniforms * sizeof(_sgl_uniform_t));
SOKOL_ASSERT(_sgl.uniforms);
_sgl.commands = (_sgl_command_t*) SOKOL_MALLOC(_sgl.num_commands * sizeof(_sgl_command_t));
_sgl.commands = (_sgl_command_t*) SOKOL_MALLOC((size_t)_sgl.num_commands * sizeof(_sgl_command_t));
SOKOL_ASSERT(_sgl.commands);
_sgl_setup_pipeline_pool(&_sgl.desc);
@ -2652,7 +2669,7 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
sg_buffer_desc vbuf_desc;
memset(&vbuf_desc, 0, sizeof(vbuf_desc));
vbuf_desc.size = _sgl.num_vertices * sizeof(_sgl_vertex_t);
vbuf_desc.size = (size_t)_sgl.num_vertices * sizeof(_sgl_vertex_t);
vbuf_desc.type = SG_BUFFERTYPE_VERTEXBUFFER;
vbuf_desc.usage = SG_USAGE_STREAM;
vbuf_desc.label = "sgl-vertex-buffer";
@ -2672,8 +2689,7 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
img_desc.pixel_format = SG_PIXELFORMAT_RGBA8;
img_desc.min_filter = SG_FILTER_NEAREST;
img_desc.mag_filter = SG_FILTER_NEAREST;
img_desc.content.subimage[0][0].ptr = pixels;
img_desc.content.subimage[0][0].size = sizeof(pixels);
img_desc.data.subimage[0][0] = SG_RANGE(pixels);
img_desc.label = "sgl-default-texture";
_sgl.def_img = sg_make_image(&img_desc);
SOKOL_ASSERT(SG_INVALID_ID != _sgl.def_img.id);
@ -2696,7 +2712,7 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
ub->uniforms[0].type = SG_UNIFORMTYPE_FLOAT4;
ub->uniforms[0].array_count = 8;
shd_desc.fs.images[0].name = "tex";
shd_desc.fs.images[0].type = SG_IMAGETYPE_2D;
shd_desc.fs.images[0].image_type = SG_IMAGETYPE_2D;
shd_desc.fs.images[0].sampler_type = SG_SAMPLERTYPE_FLOAT;
shd_desc.label = "sgl-shader";
#if defined(SOKOL_GLCORE33)
@ -2710,16 +2726,12 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
shd_desc.fs.entry = "main0";
switch (sg_query_backend()) {
case SG_BACKEND_METAL_MACOS:
shd_desc.vs.byte_code = _sgl_vs_bytecode_metal_macos;
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_metal_macos);
shd_desc.fs.byte_code = _sgl_fs_bytecode_metal_macos;
shd_desc.fs.byte_code_size = sizeof(_sgl_fs_bytecode_metal_macos);
shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_metal_macos);
shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_bytecode_metal_macos);
break;
case SG_BACKEND_METAL_IOS:
shd_desc.vs.byte_code = _sgl_vs_bytecode_metal_ios;
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_metal_ios);
shd_desc.fs.byte_code = _sgl_fs_bytecode_metal_ios;
shd_desc.fs.byte_code_size = sizeof(_sgl_fs_bytecode_metal_ios);
shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_metal_ios);
shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_bytecode_metal_ios);
break;
default:
shd_desc.vs.source = _sgl_vs_source_metal_sim;
@ -2727,15 +2739,11 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
break;
}
#elif defined(SOKOL_D3D11)
shd_desc.vs.byte_code = _sgl_vs_bytecode_hlsl4;
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_hlsl4);
shd_desc.fs.byte_code = _sgl_fs_bytecode_hlsl4;
shd_desc.fs.byte_code_size = sizeof(_sgl_fs_bytecode_hlsl4);
shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_hlsl4);
shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_bytecode_hlsl4);
#elif defined(SOKOL_WGPU)
shd_desc.vs.byte_code = _sgl_vs_bytecode_wgpu;
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_wgpu);
shd_desc.fs.byte_code = _sgl_fs_bytecode_wgpu;
shd_desc.fs.byte_code_size = sizeof(_sgl_fs_bytecode_wgpu);
shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_wgpu);
shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_bytecode_wgpu);
#else
shd_desc.vs.source = _sgl_vs_src_dummy;
shd_desc.fs.source = _sgl_fs_src_dummy;
@ -2746,7 +2754,7 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
/* create default pipeline object */
sg_pipeline_desc def_pip_desc;
memset(&def_pip_desc, 0, sizeof(def_pip_desc));
def_pip_desc.depth_stencil.depth_write_enabled = true;
def_pip_desc.depth.write_enabled = true;
_sgl.def_pip = _sgl_make_pipeline(&def_pip_desc);
sg_pop_debug_group();
@ -2861,6 +2869,10 @@ SOKOL_API_IMPL void sgl_viewport(int x, int y, int w, int h, bool origin_top_lef
}
}
SOKOL_API_IMPL void sgl_viewportf(float x, float y, float w, float h, bool origin_top_left) {
sgl_viewport((int)x, (int)y, (int)w, (int)h, origin_top_left);
}
SOKOL_API_IMPL void sgl_scissor_rect(int x, int y, int w, int h, bool origin_top_left) {
SOKOL_ASSERT(_SGL_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT(!_sgl.in_begin);
@ -2875,6 +2887,10 @@ SOKOL_API_IMPL void sgl_scissor_rect(int x, int y, int w, int h, bool origin_top
}
}
SOKOL_API_IMPL void sgl_scissor_rectf(float x, float y, float w, float h, bool origin_top_left) {
sgl_scissor_rect((int)x, (int)y, (int)w, (int)h, origin_top_left);
}
SOKOL_API_IMPL void sgl_enable_texture(void) {
SOKOL_ASSERT(_SGL_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT(!_sgl.in_begin);
@ -3193,7 +3209,7 @@ SOKOL_API_IMPL void sgl_lookat(float eye_x, float eye_y, float eye_z, float cent
_sgl_lookat(_sgl_matrix(), eye_x, eye_y, eye_z, center_x, center_y, center_z, up_x, up_y, up_z);
}
SOKOL_API_DECL void sgl_push_matrix(void) {
SOKOL_GL_API_DECL void sgl_push_matrix(void) {
SOKOL_ASSERT(_SGL_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT((_sgl.cur_matrix_mode >= 0) && (_sgl.cur_matrix_mode < SGL_NUM_MATRIXMODES));
_sgl.matrix_dirty = true;
@ -3208,7 +3224,7 @@ SOKOL_API_DECL void sgl_push_matrix(void) {
}
}
SOKOL_API_DECL void sgl_pop_matrix(void) {
SOKOL_GL_API_DECL void sgl_pop_matrix(void) {
SOKOL_ASSERT(_SGL_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT((_sgl.cur_matrix_mode >= 0) && (_sgl.cur_matrix_mode < SGL_NUM_MATRIXMODES));
_sgl.matrix_dirty = true;
@ -3228,7 +3244,8 @@ SOKOL_API_IMPL void sgl_draw(void) {
uint32_t cur_img_id = SG_INVALID_ID;
int cur_uniform_index = -1;
sg_push_debug_group("sokol-gl");
sg_update_buffer(_sgl.vbuf, _sgl.vertices, _sgl.cur_vertex * sizeof(_sgl_vertex_t));
const sg_range range = { _sgl.vertices, (size_t)_sgl.cur_vertex * sizeof(_sgl_vertex_t) };
sg_update_buffer(_sgl.vbuf, &range);
_sgl.bind.vertex_buffers[0] = _sgl.vbuf;
for (int i = 0; i < _sgl.cur_command; i++) {
const _sgl_command_t* cmd = &_sgl.commands[i];
@ -3261,7 +3278,8 @@ SOKOL_API_IMPL void sgl_draw(void) {
cur_img_id = args->img.id;
}
if (cur_uniform_index != args->uniform_index) {
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, &_sgl.uniforms[args->uniform_index], sizeof(_sgl_uniform_t));
const sg_range ub_range = { &_sgl.uniforms[args->uniform_index], sizeof(_sgl_uniform_t) };
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, &ub_range);
cur_uniform_index = args->uniform_index;
}
/* FIXME: what if number of vertices doesn't match the primitive type? */

View File

@ -191,9 +191,16 @@ fn gg_init_sokol_window(user_data voidptr) {
//
mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
color_state := C.sg_color_state{
blend: C.sg_blend_state{
enabled: true
src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
}
pipdesc.colors[0] = color_state
g.timage_pip = sgl.make_pipeline(&pipdesc)
//
if g.config.init_fn != voidptr(0) {
@ -203,6 +210,7 @@ fn gg_init_sokol_window(user_data voidptr) {
if g.native_rendering {
return
}
for i in 0 .. g.image_cache.len {
g.image_cache[i].init_sokol_image()
}
@ -216,6 +224,7 @@ fn gg_frame_fn(user_data voidptr) {
if ctx.native_rendering {
// return
}
if ctx.ui_mode && !ctx.needs_refresh {
// Draw 3 more frames after the "stop refresh" command
ctx.ticks++
@ -334,7 +343,7 @@ pub fn new_context(cfg Config) &Context {
sample_count: cfg.sample_count
high_dpi: true
fullscreen: cfg.fullscreen
native_render: cfg.native_rendering
__v_native_render: cfg.native_rendering
}
if cfg.use_ortho {
} else {
@ -422,6 +431,12 @@ pub fn (ctx &Context) draw_empty_square(x f32, y f32, s f32, c gx.Color) {
}
pub fn (ctx &Context) draw_circle_line(x f32, y f32, r int, segments int, c gx.Color) {
$if macos {
if ctx.native_rendering {
C.darwin_draw_circle(x - r + 1, ctx.height - (y + r + 3), r, c)
return
}
}
if c.a != 255 {
sgl.load_pipeline(ctx.timage_pip)
}
@ -440,12 +455,6 @@ pub fn (ctx &Context) draw_circle_line(x f32, y f32, r int, segments int, c gx.C
}
pub fn (ctx &Context) draw_circle(x f32, y f32, r f32, c gx.Color) {
$if macos {
if ctx.native_rendering {
C.darwin_draw_circle(x - r + 1, ctx.height - (y + r + 3), r, c)
return
}
}
if ctx.scale == 1 {
ctx.draw_circle_with_segments(x, y, r, 10, c)
} else {

View File

@ -80,9 +80,12 @@ void darwin_draw_rect(float x, float y, float width, float height, gx__Color c)
void darwin_window_refresh() {
//[g_view setNeedsDisplay:YES];
// update UI on the main thread TODO separate fn
dispatch_async(dispatch_get_main_queue(), ^{
/*
dispatch_async(dispatch_get_main_queue(), ^{
[g_view setNeedsDisplay:YES];
});
*/
//puts("refresh");
//[g_view drawRect:NSMakeRect(0,0,2000,2000)];

View File

@ -149,9 +149,9 @@ pub fn (mut img Image) init_sokol_image() &Image {
label: &byte(0)
d3d11_texture: 0
}
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: img.data
size: img.nr_channels * img.width * img.height
size: size_t(img.nr_channels * img.width * img.height)
}
img.simg = C.sg_make_image(&img_desc)
img.simg_ok = true

View File

@ -126,13 +126,14 @@ pub enum ImageType {
}
pub enum CubeFace {
pos_x
neg_x
pos_y
neg_y
pos_z
neg_z
num
pos_x
neg_x
pos_y
neg_y
pos_z
neg_z
num
_force_u32 = 0x7fffffff
}
pub enum ShaderStage {

View File

@ -75,18 +75,18 @@ pub fn destroy_pass(pass C.sg_pass) {
}
[inline]
pub fn update_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int) {
C.sg_update_buffer(buf, ptr, num_bytes)
pub fn update_buffer(buf C.sg_buffer, data &C.sg_range) {
C.sg_update_buffer(buf, data)
}
[inline]
pub fn update_image(img C.sg_image, content &C.sg_image_content) {
C.sg_update_image(img, content)
pub fn update_image(img C.sg_image, data &C.sg_image_data) {
C.sg_update_image(img, data)
}
[inline]
pub fn append_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int) int {
return C.sg_append_buffer(buf, ptr, num_bytes)
pub fn append_buffer(buf C.sg_buffer, data &C.sg_range) int {
return C.sg_append_buffer(buf, data)
}
[inline]
@ -126,8 +126,8 @@ pub fn apply_bindings(bindings &C.sg_bindings) {
}
[inline]
pub fn apply_uniforms(stage int, ub_index int, data voidptr, num_bytes int) {
C.sg_apply_uniforms(stage, ub_index, data, num_bytes)
pub fn apply_uniforms(stage int, ub_index int, data &C.sg_range) {
C.sg_apply_uniforms(stage, ub_index, data)
}
[inline]

View File

@ -16,20 +16,22 @@ fn C.sg_destroy_image(img C.sg_image)
fn C.sg_destroy_shader(shd C.sg_shader)
fn C.sg_destroy_pipeline(pip C.sg_pipeline)
fn C.sg_destroy_pass(pass C.sg_pass)
fn C.sg_update_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int)
fn C.sg_update_image(img C.sg_image, content &C.sg_image_content)
fn C.sg_append_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int) int
fn C.sg_update_buffer(buf C.sg_buffer, data &C.sg_range)
fn C.sg_update_image(img C.sg_image, data &C.sg_image_data)
fn C.sg_append_buffer(buf C.sg_buffer, data &C.sg_range) int
fn C.sg_query_buffer_overflow(buf C.sg_buffer) bool
// rendering functions
fn C.sg_begin_default_pass(actions &C.sg_pass_action, width int, height int)
fn C.sg_begin_pass(pass C.sg_pass, actions &C.sg_pass_action)
fn C.sg_apply_viewport(x int, y int, width int, height int, origin_top_left bool)
fn C.sg_apply_viewportf(x f32, y f32, width f32, height f32, origin_top_left bool)
fn C.sg_apply_scissor_rect(x int, y int, width int, height int, origin_top_left bool)
fn C.sg_apply_scissor_rectf(x f32, y f32, width f32, height f32, origin_top_left bool)
fn C.sg_apply_pipeline(pip C.sg_pipeline)
fn C.sg_apply_bindings(bindings &C.sg_bindings)
// stage == sg_shader_stage
fn C.sg_apply_uniforms(stage int, ub_index int, data voidptr, num_bytes int)
fn C.sg_apply_uniforms(stage int, ub_index int, data &C.sg_range)
fn C.sg_draw(base_element int, num_elements int, num_instances int)
fn C.sg_end_pass()
fn C.sg_commit()

View File

@ -36,7 +36,7 @@ pub struct C.sg_context_desc {
*/
sample_count int
gl C.sg_gl_context_desc
metal C.sg_mtl_context_desc
metal C.sg_metal_context_desc
d3d11 C.sg_d3d11_context_desc
color_format PixelFormat
depth_format PixelFormat
@ -46,7 +46,7 @@ pub struct C.sg_gl_context_desc {
gl_force_gles2 bool
}
pub struct C.sg_mtl_context_desc {
pub struct C.sg_metal_context_desc {
device voidptr
renderpass_descriptor_cb fn () voidptr
drawable_cb fn () voidptr
@ -59,18 +59,31 @@ pub struct C.sg_d3d11_context_desc {
depth_stencil_view_cb fn () voidptr
}
pub struct C.sg_color_state {
pub mut:
pixel_format PixelFormat
write_mask ColorMask
blend C.sg_blend_state
}
pub struct C.sg_pipeline_desc {
pub mut:
_start_canary u32
layout C.sg_layout_desc
shader C.sg_shader
primitive_type PrimitiveType
index_type IndexType
depth_stencil C.sg_depth_stencil_state
blend C.sg_blend_state
rasterizer C.sg_rasterizer_state
label byteptr
_end_canary u32
_start_canary u32
shader C.sg_shader
layout C.sg_layout_desc
depth C.sg_depth_state
stencil C.sg_stencil_state
color_count int
colors [4]C.sg_color_state // C.SG_MAX_COLOR_ATTACHMENTS
primitive_type PrimitiveType
index_type IndexType
cull_mode CullMode
face_winding FaceWinding
sample_count int
blend_color C.sg_color
alpha_to_coverage_enabled bool
label byteptr
_end_canary u32
}
pub struct C.sg_pipeline_info {
@ -106,19 +119,35 @@ pub fn (mut b C.sg_bindings) set_frag_image(index int, img C.sg_image) {
}
pub fn (b &C.sg_bindings) update_vert_buffer(index int, data voidptr, element_size int, element_count int) {
C.sg_update_buffer(b.vertex_buffers[index], data, element_size * element_count)
range := C.sg_range{
ptr: data
size: size_t(element_size * element_count)
}
C.sg_update_buffer(b.vertex_buffers[index], &range)
}
pub fn (b &C.sg_bindings) append_vert_buffer(index int, data voidptr, element_size int, element_count int) int {
return C.sg_append_buffer(b.vertex_buffers[index], data, element_size * element_count)
range := C.sg_range{
ptr: data
size: size_t(element_size * element_count)
}
return C.sg_append_buffer(b.vertex_buffers[index], &range)
}
pub fn (b &C.sg_bindings) update_index_buffer(data voidptr, element_size int, element_count int) {
C.sg_update_buffer(b.index_buffer, data, element_size * element_count)
range := C.sg_range{
ptr: data
size: size_t(element_size * element_count)
}
C.sg_update_buffer(b.index_buffer, &range)
}
pub fn (b &C.sg_bindings) append_index_buffer(data voidptr, element_size int, element_count int) int {
return C.sg_append_buffer(b.index_buffer, data, element_size * element_count)
range := C.sg_range{
ptr: data
size: size_t(element_size * element_count)
}
return C.sg_append_buffer(b.index_buffer, &range)
}
pub struct C.sg_shader_desc {
@ -143,22 +172,22 @@ pub fn (mut desc C.sg_shader_desc) set_frag_src(src string) &C.sg_shader_desc {
pub fn (mut desc C.sg_shader_desc) set_vert_image(index int, name string) &C.sg_shader_desc {
desc.vs.images[index].name = name.str
desc.vs.images[index].@type = ._2d
desc.vs.images[index].image_type = ._2d
return desc
}
pub fn (mut desc C.sg_shader_desc) set_frag_image(index int, name string) &C.sg_shader_desc {
desc.fs.images[index].name = name.str
desc.fs.images[index].@type = ._2d
desc.fs.images[index].image_type = ._2d
return desc
}
pub fn (mut desc C.sg_shader_desc) set_vert_uniform_block_size(block_index int, size int) &C.sg_shader_desc {
pub fn (mut desc C.sg_shader_desc) set_vert_uniform_block_size(block_index int, size size_t) &C.sg_shader_desc {
desc.vs.uniform_blocks[block_index].size = size
return desc
}
pub fn (mut desc C.sg_shader_desc) set_frag_uniform_block_size(block_index int, size int) &C.sg_shader_desc {
pub fn (mut desc C.sg_shader_desc) set_frag_uniform_block_size(block_index int, size size_t) &C.sg_shader_desc {
desc.fs.uniform_blocks[block_index].size = size
return desc
}
@ -189,8 +218,7 @@ pub mut:
pub struct C.sg_shader_stage_desc {
pub mut:
source byteptr
byte_code &byte
byte_code_size int
bytecode C.sg_range
entry byteptr
uniform_blocks [4]C.sg_shader_uniform_block_desc
images [12]C.sg_shader_image_desc
@ -198,13 +226,13 @@ pub mut:
pub fn (mut desc C.sg_shader_stage_desc) set_image(index int, name string) C.sg_shader_stage_desc {
desc.images[index].name = name.str
desc.images[index].@type = ._2d
desc.images[index].image_type = ._2d
return *desc
}
pub struct C.sg_shader_uniform_block_desc {
pub mut:
size int
size size_t
uniforms [16]C.sg_shader_uniform_desc
}
@ -218,7 +246,7 @@ pub mut:
pub struct C.sg_shader_image_desc {
pub mut:
name byteptr
@type ImageType
image_type ImageType
}
pub struct C.sg_shader_info {
@ -228,6 +256,20 @@ pub struct C.sg_context {
id u32
}
pub struct C.sg_range {
pub mut:
ptr voidptr
size size_t
}
pub struct C.sg_color {
pub mut:
r f32
g f32
b f32
a f32
}
pub struct C.sg_shader {
pub:
id u32
@ -240,8 +282,8 @@ pub fn (s C.sg_shader) free() {
pub struct C.sg_pass_desc {
pub mut:
_start_canary u32
color_attachments [4]C.sg_attachment_desc
depth_stencil_attachment C.sg_attachment_desc
color_attachments [4]C.sg_pass_attachment_desc
depth_stencil_attachment C.sg_pass_attachment_desc
label byteptr
_end_canary u32
}
@ -270,10 +312,10 @@ pub fn (p C.sg_pass) free() {
pub struct C.sg_buffer_desc {
pub mut:
_start_canary u32
size int
size size_t
@type BufferType
usage Usage
content byteptr
data C.sg_range
label byteptr
// GL specific
gl_buffers [2]u32
@ -307,12 +349,7 @@ pub mut:
render_target bool
width int
height int
depth DepthLayers
// depth int
// union {
// int depth;
// int layers;
// };
num_slices int
num_mipmaps int
usage Usage
pixel_format PixelFormat
@ -326,14 +363,18 @@ pub mut:
max_anisotropy u32
min_lod f32
max_lod f32
content C.sg_image_content
data C.sg_image_data
label byteptr
// GL specific
gl_textures [2]u32
gl_texture_target u32
// Metal specific
mtl_textures [2]voidptr
// D3D11 specific
d3d11_texture voidptr
d3d11_shader_resource_view voidptr
// WebGPU specific
wgpu_texture voidptr
_end_canary u32
}
@ -354,26 +395,23 @@ pub fn (i C.sg_image) free() {
C.sg_destroy_image(i)
}
pub struct C.sg_image_content {
pub struct C.sg_image_data {
pub mut:
subimage [6][16]C.sg_subimage_content
}
pub struct C.sg_subimage_content {
pub mut:
ptr voidptr // pointer to subimage data
size int // size in bytes of pointed-to subimage data
//subimage [C.SG_CUBEFACE_NUM][C.SG_MAX_MIPMAPS]C.sg_range
subimage [6][16]C.sg_range
}
pub struct C.sg_features {
pub:
instancing bool // hardware instancing supported
origin_top_left bool // framebuffer and texture origin is in top left corner
multiple_render_targets bool // offscreen render passes can have multiple render targets attached
msaa_render_targets bool // offscreen render passes support MSAA antialiasing
imagetype_3d bool // creation of SG_IMAGETYPE_3D images is supported
imagetype_array bool // creation of SG_IMAGETYPE_ARRAY images is supported
image_clamp_to_border bool // border color and clamp-to-border UV-wrap mode is supported
instancing bool // hardware instancing supported
origin_top_left bool // framebuffer and texture origin is in top left corner
multiple_render_targets bool // offscreen render passes can have multiple render targets attached
msaa_render_targets bool // offscreen render passes support MSAA antialiasing
imagetype_3d bool // creation of SG_IMAGETYPE_3D images is supported
imagetype_array bool // creation of SG_IMAGETYPE_ARRAY images is supported
image_clamp_to_border bool // border color and clamp-to-border UV-wrap mode is supported
mrt_independent_blend_state bool // multiple-render-target rendering can use per-render-target blend state
mrt_independent_write_mask bool // multiple-render-target rendering can use per-render-target color write masks
}
pub struct C.sg_limits {
@ -406,18 +444,25 @@ pub mut:
format VertexFormat
}
pub struct C.sg_depth_stencil_state {
stencil_front C.sg_stencil_state
stencil_back C.sg_stencil_state
depth_compare_func CompareFunc
depth_write_enabled bool
stencil_enabled bool
stencil_read_mask byte
stencil_write_mask byte
stencil_ref byte
pub struct C.sg_stencil_state {
enabled bool
front C.sg_stencil_face_state
back C.sg_stencil_face_state
read_mask byte
write_mask byte
ref byte
}
pub struct C.sg_stencil_state {
pub struct C.sg_depth_state {
pixel_format PixelFormat
compare CompareFunc
write_enabled bool
bias f32
bias_slope_scale f32
bias_clamp f32
}
pub struct C.sg_stencil_face_state {
fail_op StencilOp
depth_fail_op StencilOp
pass_op StencilOp
@ -433,28 +478,12 @@ pub mut:
src_factor_alpha BlendFactor
dst_factor_alpha BlendFactor
op_alpha BlendOp
color_write_mask byte
color_attachment_count int
color_format PixelFormat
depth_format PixelFormat
blend_color [4]f32
}
pub struct C.sg_rasterizer_state {
pub mut:
alpha_to_coverage_enabled bool
cull_mode CullMode
face_winding FaceWinding
sample_count int
depth_bias f32
depth_bias_slope_scale f32
depth_bias_clamp f32
}
pub struct C.sg_color_attachment_action {
pub mut:
action Action
val [4]f32
value C.sg_color
}
/*
@ -468,13 +497,13 @@ pub fn (mut action C.sg_color_attachment_action) set_color_values(r, g, b, a f32
pub struct C.sg_depth_attachment_action {
pub mut:
action Action
val f32
value f32
}
pub struct C.sg_stencil_attachment_action {
pub mut:
action Action
val byte
value byte
}
pub struct C.sg_pixelformat_info {
@ -487,7 +516,7 @@ pub:
depth bool // pixel format is a depth format
}
pub struct C.sg_attachment_desc {
pub struct C.sg_pass_attachment_desc {
pub mut:
image C.sg_image
mip_level int

View File

@ -3,12 +3,14 @@ module gfx
pub fn create_clear_pass(r f32, g f32, b f32, a f32) C.sg_pass_action {
mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR)
value: C.sg_color {
r: r
g: g
b: b
a: a
}
}
// color_action.set_color_values(r, g, b, a)
color_action.val[0] = r
color_action.val[1] = g
color_action.val[2] = b
color_action.val[3] = a
mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action
return pass_action

View File

@ -10,7 +10,7 @@ pub const (
__global ( g_desc C.sapp_desc )
pub fn create_desc() C.sg_desc {
mtl_desc := C.sg_mtl_context_desc{
metal_desc := C.sg_metal_context_desc{
device: metal_get_device()
renderpass_descriptor_cb: metal_get_renderpass_descriptor
drawable_cb: metal_get_drawable
@ -23,7 +23,7 @@ pub fn create_desc() C.sg_desc {
}
return C.sg_desc{
context: C.sg_context_desc{
metal: mtl_desc
metal: metal_desc
d3d11: d3d11_desc
}
image_pool_size: 1000
@ -140,9 +140,9 @@ pub fn get_clipboard_string() byteptr {
// special run-function for SOKOL_NO_ENTRY (in standard mode this is an empty stub)
[inline]
pub fn run(desc &C.sapp_desc) int {
pub fn run(desc &C.sapp_desc) {
g_desc = desc
return C.sapp_run(desc)
C.sapp_run(desc)
}
// GL: return true when GLES2 fallback is active (to detect fallback from GLES3)

View File

@ -4,8 +4,10 @@ module sapp
fn C.sapp_isvalid() bool
/* returns the current framebuffer width in pixels */
fn C.sapp_width() int
fn C.sapp_widthf() f32
/* returns the current framebuffer height in pixels */
fn C.sapp_height() int
fn C.sapp_heightf() f32
/* returns true when high_dpi was requested and actually running in a high-dpi scenario */
fn C.sapp_high_dpi() bool
/* returns the dpi scaling factor (window pixels to framebuffer pixels) */

View File

@ -7,12 +7,14 @@ pub:
cleanup_cb fn ()
event_cb fn (&C.sapp_event) //&sapp_event)
fail_cb fn (&byte)
user_data voidptr // these are the user-provided callbacks with user data
init_userdata_cb fn (voidptr)
frame_userdata_cb fn (voidptr)
cleanup_userdata_cb fn (voidptr)
event_userdata_cb fn (&C.sapp_event, voidptr)
fail_userdata_cb fn (&char, voidptr)
width int // the preferred width of the window / canvas
height int // the preferred height of the window / canvas
sample_count int // MSAA sample count
@ -20,18 +22,26 @@ pub:
high_dpi bool // whether the rendering canvas is full-resolution on HighDPI displays
fullscreen bool // whether the window should be created in fullscreen mode
alpha bool // whether the framebuffer should have an alpha channel (ignored on some platforms)
window_title &byte // the window title as UTF-8 encoded string
window_title &char // the window title as UTF-8 encoded string
user_cursor bool // if true, user is expected to manage cursor image in SAPP_EVENTTYPE_UPDATE_CURSOR
enable_clipboard bool // enable clipboard access, default is false
clipboard_size int // max size of clipboard content in bytes
html5_canvas_name &byte // the name (id) of the HTML5 canvas element, default is "canvas"
enable_dragndrop bool // enable file dropping (drag'n'drop), default is false
max_dropped_files int // max number of dropped files to process (default: 1)
max_dropped_file_path_length int // max length in bytes of a dropped UTF-8 file path (default: 2048)
/* backend-specific options */
gl_force_gles2 bool // if true, setup GLES2/WebGL even if GLES3/WebGL2 is available
win32_console_utf8 bool // if true, set the output console codepage to UTF-8
win32_console_create bool // if true, attach stdout/stderr to a new console window
win32_console_attach bool // if true, attach stdout/stderr to parent process
html5_canvas_name &char // the name (id) of the HTML5 canvas element, default is "canvas"
html5_canvas_resize bool // if true, the HTML5 canvas size is set to sapp_desc.width/height, otherwise canvas size is tracked
html5_preserve_drawing_buffer bool // HTML5 only: whether to preserve default framebuffer content between frames
html5_premultiplied_alpha bool // HTML5 only: whether the rendered pixels use premultiplied alpha convention
html5_ask_leave_site bool // initial state of the internal html5_ask_leave_site flag (see sapp_html5_ask_leave_site())
ios_keyboard_resizes_canvas bool // if true, showing the iOS keyboard shrinks the canvas
gl_force_gles2 bool // if true, setup GLES2/WebGL even if GLES3/WebGL2 is available
native_render bool
/* V patches */
__v_native_render bool // V patch to allow for native rendering
}
pub struct Event {

View File

@ -14,7 +14,9 @@ fn C.sgl_destroy_pipeline(pip C.sgl_pipeline)
/* render state functions */
fn C.sgl_viewport(x int, y int, w int, h int, origin_top_left bool)
fn C.sgl_viewportf(x f32, y f32, w f32, h f32, origin_top_left bool)
fn C.sgl_scissor_rect(x int, y int, w int, h int, origin_top_left bool)
fn C.sgl_scissor_rectf(x f32, y f32, w f32, h f32, origin_top_left bool)
fn C.sgl_enable_texture()
fn C.sgl_disable_texture()
fn C.sgl_texture(img C.sg_image)

View File

@ -131,9 +131,9 @@ pub fn (mut tf_skl TTF_render_Sokol) create_texture() {
d3d11_texture: 0
}
// comment for dynamic
img_desc.content.subimage[0][0] = C.sg_subimage_content{
img_desc.data.subimage[0][0] = C.sg_range{
ptr: tf_skl.bmp.buf
size: sz
size: size_t(sz)
}
simg := C.sg_make_image(&img_desc)
@ -148,10 +148,10 @@ pub fn (tf_skl TTF_render_Sokol) destroy_texture() {
// Use only if usage: .dynamic
pub fn (mut tf_skl TTF_render_Sokol) update_text_texture() {
sz := tf_skl.bmp.width * tf_skl.bmp.height * tf_skl.bmp.bp
mut tmp_sbc := C.sg_image_content{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{
mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_range{
ptr: tf_skl.bmp.buf
size: sz
size: size_t(sz)
}
C.sg_update_image(tf_skl.sg_img, &tmp_sbc)
}