vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

sokol: update to floooh/sokol@c602d83 (#9607)

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.github/workflows/ci.yml vendored
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

31
examples/sokol/01_cubes/cube.v
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

87
examples/sokol/02_cubes_glsl/cube_glsl.v
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

66
examples/sokol/03_march_tracing_glsl/rt_glsl.v
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)

101
examples/sokol/04_multi_shader_glsl/rt_glsl.v
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)

70
examples/sokol/05_instancing_glsl/rt_glsl.v
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)

61
examples/sokol/06_obj_viewer/obj/rend.v
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
}

15
examples/sokol/06_obj_viewer/show_obj.v
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', '\\?', '-?']) {

10
examples/sokol/fonts.v
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{

10
examples/sokol/freetype_raven.v
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{

13
examples/sokol/particles/particles.v
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)
}

2130
thirdparty/sokol/sokol_app.h vendored
View File

File diff suppressed because it is too large Load Diff

576
thirdparty/sokol/sokol_audio.h vendored
View File

File diff suppressed because it is too large Load Diff

3399
thirdparty/sokol/sokol_gfx.h vendored
View File

File diff suppressed because it is too large Load Diff

67
thirdparty/sokol/util/sokol_fontstash.h vendored
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 */

252
thirdparty/sokol/util/sokol_gl.h vendored
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? */

29
vlib/gg/gg.v
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 {

3
vlib/gg/gg_darwin.m
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(), ^{
[g_view setNeedsDisplay:YES];
});
*/
//puts("refresh");
//[g_view drawRect:NSMakeRect(0,0,2000,2000)];

4
vlib/gg/image.v
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

1
vlib/sokol/gfx/enums.v
View File

@ -133,6 +133,7 @@ pub enum CubeFace {
pos_z
neg_z
num
_force_u32 = 0x7fffffff
}
pub enum ShaderStage {

16
vlib/sokol/gfx/gfx.v
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]

10
vlib/sokol/gfx/gfx_funcs.v
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()

165
vlib/sokol/gfx/gfx_structs.v
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,16 +59,29 @@ 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
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
depth_stencil C.sg_depth_stencil_state
blend C.sg_blend_state
rasterizer C.sg_rasterizer_state
cull_mode CullMode
face_winding FaceWinding
sample_count int
blend_color C.sg_color
alpha_to_coverage_enabled bool
label byteptr
_end_canary u32
}
@ -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,15 +395,10 @@ 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 {
@ -374,6 +410,8 @@ pub:
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

10
vlib/sokol/gfx/gfx_utils.v
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

8
vlib/sokol/sapp/sapp.v
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)

2
vlib/sokol/sapp/sapp_funcs.v
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) */

18
vlib/sokol/sapp/sapp_structs.v
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 {

2
vlib/sokol/sgl/sgl_funcs.v
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)

10
vlib/x/ttf/render_sokol_cpu.v
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)
}