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 - name: Shader examples can be build
run: | run: |
wget https://github.com/floooh/sokol-tools-bin/archive/pre-feb2021-api-changes.tar.gz wget https://github.com/floooh/sokol-tools-bin/raw/master/bin/linux/sokol-shdc
tar -xf pre-feb2021-api-changes.tar.gz chmod +x ./sokol-shdc
for f in examples/sokol/02_cubes_glsl/cube_glsl \ for f in examples/sokol/02_cubes_glsl/cube_glsl \
examples/sokol/03_march_tracing_glsl/rt_glsl \ examples/sokol/03_march_tracing_glsl/rt_glsl \
examples/sokol/04_multi_shader_glsl/rt_glsl_puppy \ examples/sokol/04_multi_shader_glsl/rt_glsl_puppy \
@ -200,7 +200,7 @@ jobs:
examples/sokol/06_obj_viewer/gouraud \ examples/sokol/06_obj_viewer/gouraud \
; do \ ; do \
echo "compiling shader $f.glsl ..."; \ 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 done
for vfile in examples/sokol/0?*/*.v; do echo "compiling $vfile ..."; ./v $vfile ; 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 d3d11_texture: 0
} }
// commen if .dynamic is enabled // 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 ptr: buf
size: sz size: size_t(sz)
} }
sg_img := C.sg_make_image(&img_desc) 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 // Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) { fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) {
sz := w * h * 4 sz := w * h * 4
mut tmp_sbc := C.sg_image_content{} mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{ tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf ptr: buf
size: sz size: size_t(sz)
} }
C.sg_update_image(sg_img, &tmp_sbc) C.sg_update_image(sg_img, &tmp_sbc)
} }
@ -323,16 +323,21 @@ fn my_init(mut app App) {
// 3d pipeline // 3d pipeline
mut pipdesc := C.sg_pipeline_desc{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA) color_state := C.sg_color_state{
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA) blend: C.sg_blend_state{
pipdesc.depth_stencil = C.sg_depth_stencil_state{ enabled: true
depth_write_enabled: true src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
} }
pipdesc.rasterizer = C.sg_rasterizer_state{ pipdesc.colors[0] = color_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
app.pip_3d = sgl.make_pipeline(&pipdesc) app.pip_3d = sgl.make_pipeline(&pipdesc)
// create chessboard texture 256*256 RGBA // 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/. #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) #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 ( const (
win_width = 800 win_width = 800
@ -87,9 +87,9 @@ fn create_texture(w int, h int, buf &byte) C.sg_image {
d3d11_texture: 0 d3d11_texture: 0
} }
// comment if .dynamic is enabled // 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 ptr: buf
size: sz size: size_t(sz)
} }
sg_img := C.sg_make_image(&img_desc) 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 // Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) { fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) {
sz := w * h * 4 sz := w * h * 4
mut tmp_sbc := C.sg_image_content{} mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{ tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf ptr: buf
size: sz size: size_t(sz)
} }
C.sg_update_image(sg_img, &tmp_sbc) 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{} mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_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.@type = .vertexbuffer
// vert_buffer_desc.usage = .immutable // vert_buffer_desc.usage = .immutable
vert_buffer_desc.label = 'cube-vertices'.str 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{} mut index_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&index_buffer_desc, 0, sizeof(index_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.@type = .indexbuffer
index_buffer_desc.label = 'cube-indices'.str index_buffer_desc.label = 'cube-indices'.str
ibuf := gfx.make_buffer(&index_buffer_desc) ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader // 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{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -336,13 +346,12 @@ fn init_cube_glsl(mut app App) {
pipdesc.shader = shader pipdesc.shader = shader
pipdesc.index_type = .uint16 pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{ pipdesc.depth = C.sg_depth_state{
depth_write_enabled: true write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
} }
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str pipdesc.label = 'glsl_shader pipeline'.str
app.cube_bind.vertex_buffers[0] = vbuf app.cube_bind.vertex_buffers[0] = vbuf
@ -376,7 +385,11 @@ fn draw_cube_glsl(app App) {
//*************** //***************
// passing the view matrix as uniform // passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size // 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 // fs uniforms
time_ticks := f32(time.ticks() - app.ticks) / 1000 time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -386,7 +399,11 @@ fn draw_cube_glsl(app App) {
time_ticks, /* time as f32 */ time_ticks, /* time as f32 */
0 /* padding 4 Bytes == 1 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.draw(0, (3 * 2) * 6, 1)
gfx.end_pass() gfx.end_pass()
@ -461,11 +478,13 @@ fn frame(mut app App) {
// clear // clear
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_DONTCARE) // C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height) gfx.begin_default_pass(&pass_action, ws.width, ws.height)
@ -494,16 +513,22 @@ fn my_init(mut app App) {
// 3d pipeline // 3d pipeline
mut pipdesc := C.sg_pipeline_desc{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA) color_state := C.sg_color_state{
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA) blend: C.sg_blend_state{
pipdesc.depth_stencil = C.sg_depth_stencil_state{ enabled: true
depth_write_enabled: true src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
}
} }
pipdesc.rasterizer = C.sg_rasterizer_state{ pipdesc.colors[0] = color_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
app.pip_3d = sgl.make_pipeline(&pipdesc) app.pip_3d = sgl.make_pipeline(&pipdesc)
// create chessboard texture 256*256 RGBA // create chessboard texture 256*256 RGBA

72
examples/sokol/03_march_tracing_glsl/rt_glsl.v
View File

@ -44,7 +44,7 @@ import time
#flag -I @VROOT/. #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) #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 ( const (
win_width = 800 win_width = 800
@ -86,9 +86,9 @@ fn create_texture(w int, h int, buf &byte) C.sg_image {
d3d11_texture: 0 d3d11_texture: 0
} }
// comment if .dynamic is enabled // 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 ptr: buf
size: sz size: size_t(sz)
} }
sg_img := C.sg_make_image(&img_desc) 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 // Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) { fn update_text_texture(sg_img C.sg_image, w int, h int, buf &byte) {
sz := w * h * 4 sz := w * h * 4
mut tmp_sbc := C.sg_image_content{} mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{ tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf ptr: buf
size: sz size: size_t(sz)
} }
C.sg_update_image(sg_img, &tmp_sbc) 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{} mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_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.@type = .vertexbuffer
vert_buffer_desc.label = 'cube-vertices'.str vert_buffer_desc.label = 'cube-vertices'.str
vbuf := gfx.make_buffer(&vert_buffer_desc) 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{} mut index_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&index_buffer_desc, 0, sizeof(index_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.@type = .indexbuffer
index_buffer_desc.label = "cube-indices".str index_buffer_desc.label = "cube-indices".str
ibuf := gfx.make_buffer(&index_buffer_desc) ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader // 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{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -214,13 +224,12 @@ fn init_cube_glsl(mut app App) {
pipdesc.shader = shader pipdesc.shader = shader
pipdesc.index_type = .uint16 pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{ pipdesc.depth = C.sg_depth_state{
depth_write_enabled: true write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
} }
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str pipdesc.label = 'glsl_shader pipeline'.str
app.cube_bind.vertex_buffers[0] = vbuf app.cube_bind.vertex_buffers[0] = vbuf
@ -230,7 +239,7 @@ fn init_cube_glsl(mut app App) {
println('GLSL init DONE!') println('GLSL init DONE!')
} }
[inline] [inline]
fn vec4(x f32, y f32, z f32, w f32) m4.Vec4 { fn vec4(x f32, y f32, z f32, w f32) m4.Vec4 {
return m4.Vec4{e:[x, y, z, w]!} return m4.Vec4{e:[x, y, z, w]!}
} }
@ -274,7 +283,11 @@ fn draw_cube_glsl(app App) {
// *** vertex shadeer uniforms *** // *** vertex shadeer uniforms ***
// passing the view matrix as uniform // passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size // 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 *** // *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000 time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -286,9 +299,13 @@ fn draw_cube_glsl(app App) {
time_ticks, // time as f32 time_ticks, // time as f32
app.frame_count, // frame count app.frame_count, // frame count
0, 0,
0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h 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 // 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
gfx.draw(0, (3 * 2) * 6, 1) gfx.draw(0, (3 * 2) * 6, 1)
@ -302,11 +319,14 @@ fn frame(mut app App) {
// clear // clear
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height) gfx.begin_default_pass(&pass_action, ws.width, ws.height)

103
examples/sokol/04_multi_shader_glsl/rt_glsl.v
View File

@ -45,8 +45,8 @@ import time
#flag -I @VROOT/. #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_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) #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_march_shader_desc(gfx.Backend) &C.sg_shader_desc
fn C.rt_puppy_shader_desc() &C.sg_shader_desc fn C.rt_puppy_shader_desc(gfx.Backend) &C.sg_shader_desc
const ( const (
win_width = 800 win_width = 800
@ -90,9 +90,9 @@ fn create_texture(w int, h int, buf byteptr) C.sg_image {
d3d11_texture: 0 d3d11_texture: 0
} }
// comment if .dynamic is enabled // 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 ptr: buf
size: sz size: size_t(sz)
} }
sg_img := C.sg_make_image(&img_desc) 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 // Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf byteptr) { fn update_text_texture(sg_img C.sg_image, w int, h int, buf byteptr) {
sz := w * h * 4 sz := w * h * 4
mut tmp_sbc := C.sg_image_content{} mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{ tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf ptr: buf
size: sz size: size_t(sz)
} }
C.sg_update_image(sg_img, &tmp_sbc) 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{} mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_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.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.content = byteptr(vertices.data) 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.@type = .vertexbuffer
vert_buffer_desc.label = 'cube-vertices'.str vert_buffer_desc.label = 'cube-vertices'.str
vbuf := gfx.make_buffer(&vert_buffer_desc) 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{} mut index_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&index_buffer_desc, 0, sizeof(index_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.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.content = byteptr(indices.data) 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.@type = .indexbuffer
index_buffer_desc.label = 'cube-indices'.str index_buffer_desc.label = 'cube-indices'.str
ibuf := gfx.make_buffer(&index_buffer_desc) ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader // 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{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -220,13 +226,11 @@ fn init_cube_glsl_m(mut app App) {
pipdesc.shader = shader pipdesc.shader = shader
pipdesc.index_type = .uint16 pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{ pipdesc.depth = C.sg_depth_state{
depth_write_enabled: true write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
} }
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str pipdesc.label = 'glsl_shader pipeline'.str
mut bind := C.sg_bindings{} 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{} mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_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.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.content = byteptr(vertices.data) 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.@type = .vertexbuffer
vert_buffer_desc.label = 'cube-vertices'.str vert_buffer_desc.label = 'cube-vertices'.str
vbuf := gfx.make_buffer(&vert_buffer_desc) 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{} mut index_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&index_buffer_desc, 0, sizeof(index_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.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.content = byteptr(indices.data) 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.@type = .indexbuffer
index_buffer_desc.label = 'cube-indices'.str index_buffer_desc.label = 'cube-indices'.str
ibuf := gfx.make_buffer(&index_buffer_desc) ibuf := gfx.make_buffer(&index_buffer_desc)
// create shader // 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{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
@ -325,13 +335,12 @@ fn init_cube_glsl_p(mut app App) {
pipdesc.shader = shader pipdesc.shader = shader
pipdesc.index_type = .uint16 pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{ pipdesc.depth = C.sg_depth_state{
depth_write_enabled: true write_enabled: true
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state{
cull_mode: .back
} }
pipdesc.cull_mode = .back
pipdesc.label = 'glsl_shader pipeline'.str pipdesc.label = 'glsl_shader pipeline'.str
mut bind := C.sg_bindings{} mut bind := C.sg_bindings{}
@ -346,7 +355,7 @@ fn init_cube_glsl_p(mut app App) {
println('GLSL Puppy init DONE!') println('GLSL Puppy init DONE!')
} }
[inline] [inline]
fn vec4(x f32, y f32, z f32, w f32) m4.Vec4 { fn vec4(x f32, y f32, z f32, w f32) m4.Vec4 {
return m4.Vec4{e:[x, y, z, w]!} return m4.Vec4{e:[x, y, z, w]!}
} }
@ -387,7 +396,11 @@ fn draw_cube_glsl_m(app App) {
// *** vertex shadeer uniforms *** // *** vertex shadeer uniforms ***
// passing the view matrix as uniform // passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size // 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 *** // *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000 time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -403,7 +416,11 @@ fn draw_cube_glsl_m(app App) {
0, 0,
0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h 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 // 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
gfx.draw(0, (3 * 2) * 3, 1) gfx.draw(0, (3 * 2) * 3, 1)
@ -431,7 +448,11 @@ fn draw_cube_glsl_p(app App) {
// *** vertex shadeer uniforms *** // *** vertex shadeer uniforms ***
// passing the view matrix as uniform // passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size // 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 *** // *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000 time_ticks := f32(time.ticks() - app.ticks) / 1000
@ -447,7 +468,11 @@ fn draw_cube_glsl_p(app App) {
0, 0,
0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h 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 // 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
gfx.draw(0, (3 * 2) * 3, 1) gfx.draw(0, (3 * 2) * 3, 1)
@ -477,11 +502,13 @@ fn frame(mut app App) {
// clear // clear
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height) gfx.begin_default_pass(&pass_action, ws.width, ws.height)

138
examples/sokol/05_instancing_glsl/rt_glsl.v
View File

@ -12,7 +12,7 @@
* - compile the .glsl shared file with: * - compile the .glsl shared file with:
* linux : sokol-shdc --input rt_glsl_instancing.glsl --output rt_glsl_instancing.h --slang glsl330 * linux : sokol-shdc --input rt_glsl_instancing.glsl --output rt_glsl_instancing.h --slang glsl330
* windows: sokol-shdc.exe --input rt_glsl_instancing.glsl --output rt_glsl_instancing.h --slang glsl330 * windows: sokol-shdc.exe --input rt_glsl_instancing.glsl --output rt_glsl_instancing.h --slang glsl330
* *
* --slang parameter can be: * --slang parameter can be:
* - glsl330: desktop GL * - glsl330: desktop GL
* - glsl100: GLES2 / WebGL * - glsl100: GLES2 / WebGL
@ -57,20 +57,20 @@ mut:
mouse_x int = -1 mouse_x int = -1
mouse_y int = -1 mouse_y int = -1
mouse_down bool mouse_down bool
// glsl // glsl
cube_pip_glsl C.sg_pipeline cube_pip_glsl C.sg_pipeline
cube_bind C.sg_bindings cube_bind C.sg_bindings
pipe map[string]C.sg_pipeline pipe map[string]C.sg_pipeline
bind map[string]C.sg_bindings bind map[string]C.sg_bindings
// time // time
ticks i64 ticks i64
// instances // instances
inst_pos [num_inst]m4.Vec4 inst_pos [num_inst]m4.Vec4
// camera // camera
camera_x f32 camera_x f32
camera_z f32 camera_z f32
@ -81,7 +81,7 @@ mut:
******************************************************************************/ ******************************************************************************/
#flag -I @VROOT/. #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) #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 * Texture functions
@ -101,9 +101,9 @@ fn create_texture(w int, h int, buf byteptr) C.sg_image{
d3d11_texture: 0 d3d11_texture: 0
} }
// comment if .dynamic is enabled // 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 ptr: buf
size: sz size: size_t(sz)
} }
sg_img := C.sg_make_image(&img_desc) 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 // Use only if usage: .dynamic is enabled
fn update_text_texture(sg_img C.sg_image, w int, h int, buf byteptr){ fn update_text_texture(sg_img C.sg_image, w int, h int, buf byteptr){
sz := w * h * 4 sz := w * h * 4
mut tmp_sbc := C.sg_image_content{} mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content { tmp_sbc.subimage[0][0] = C.sg_range{
ptr: buf ptr: buf
size: sz size: size_t(sz)
} }
C.sg_update_image(sg_img, &tmp_sbc) C.sg_update_image(sg_img, &tmp_sbc)
} }
@ -143,12 +143,12 @@ struct Vertex_t {
y f32 y f32
z f32 z f32
color u32 color u32
//u u16 // for compatibility with D3D11 //u u16 // for compatibility with D3D11
//v u16 // for compatibility with D3D11 //v u16 // for compatibility with D3D11
u f32 u f32
v f32 v f32
} }
// march shader init // march shader init
fn init_cube_glsl_i(mut app App) { fn init_cube_glsl_i(mut app App) {
@ -191,22 +191,26 @@ fn init_cube_glsl_i(mut app App) {
mut vert_buffer_desc := C.sg_buffer_desc{} mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&vert_buffer_desc, 0, sizeof(vert_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.size = size_t(vertices.len * int(sizeof(Vertex_t)))
vert_buffer_desc.content = byteptr(vertices.data) 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.@type = .vertexbuffer
vert_buffer_desc.label = "cube-vertices".str vert_buffer_desc.label = "cube-vertices".str
vbuf := gfx.make_buffer(&vert_buffer_desc) vbuf := gfx.make_buffer(&vert_buffer_desc)
/* create an instance buffer for the cube */ /* create an instance buffer for the cube */
mut inst_buffer_desc := C.sg_buffer_desc{} mut inst_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&inst_buffer_desc, 0, sizeof(inst_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.@type = .vertexbuffer
inst_buffer_desc.usage = .stream inst_buffer_desc.usage = .stream
inst_buffer_desc.label = "instance-data".str inst_buffer_desc.label = "instance-data".str
inst_buf := gfx.make_buffer(&inst_buffer_desc) inst_buf := gfx.make_buffer(&inst_buffer_desc)
/* create an index buffer for the cube */ /* create an index buffer for the cube */
indices := [ indices := [
u16(0), 1, 2, 0, 2, 3, u16(0), 1, 2, 0, 2, 3,
@ -216,22 +220,25 @@ fn init_cube_glsl_i(mut app App) {
16, 17, 18, 16, 18, 19, 16, 17, 18, 16, 18, 19,
22, 21, 20, 23, 22, 20 22, 21, 20, 23, 22, 20
] ]
mut index_buffer_desc := C.sg_buffer_desc{} mut index_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&index_buffer_desc, 0, sizeof(index_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.size = size_t(indices.len * int(sizeof(u16)))
index_buffer_desc.content = byteptr(indices.data) 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.@type = .indexbuffer
index_buffer_desc.label = "cube-indices".str index_buffer_desc.label = "cube-indices".str
ibuf := gfx.make_buffer(&index_buffer_desc) ibuf := gfx.make_buffer(&index_buffer_desc)
/* create shader */ /* 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{} mut pipdesc := C.sg_pipeline_desc{}
unsafe {C.memset(&pipdesc, 0, sizeof(pipdesc))} unsafe {C.memset(&pipdesc, 0, sizeof(pipdesc))}
pipdesc.layout.buffers[0].stride = int(sizeof(Vertex_t)) pipdesc.layout.buffers[0].stride = int(sizeof(Vertex_t))
// the constants [C.ATTR_vs_m_pos, C.ATTR_vs_m_color0, C.ATTR_vs_m_texcoord0] are generated by sokol-shdc // the constants [C.ATTR_vs_m_pos, C.ATTR_vs_m_color0, C.ATTR_vs_m_texcoord0] are generated by sokol-shdc
pipdesc.layout.attrs[C.ATTR_vs_i_pos ].format = .float3 // x,y,z as f32 pipdesc.layout.attrs[C.ATTR_vs_i_pos ].format = .float3 // x,y,z as f32
pipdesc.layout.attrs[C.ATTR_vs_i_pos ].buffer_index = 0 pipdesc.layout.attrs[C.ATTR_vs_i_pos ].buffer_index = 0
@ -239,26 +246,25 @@ fn init_cube_glsl_i(mut app App) {
pipdesc.layout.attrs[C.ATTR_vs_i_pos ].buffer_index = 0 pipdesc.layout.attrs[C.ATTR_vs_i_pos ].buffer_index = 0
pipdesc.layout.attrs[C.ATTR_vs_i_texcoord0].format = .float2 // u,v as f32 pipdesc.layout.attrs[C.ATTR_vs_i_texcoord0].format = .float2 // u,v as f32
pipdesc.layout.attrs[C.ATTR_vs_i_pos ].buffer_index = 0 pipdesc.layout.attrs[C.ATTR_vs_i_pos ].buffer_index = 0
// instancing // instancing
// the constant ATTR_vs_i_inst_pos is generated by sokol-shdc // the constant ATTR_vs_i_inst_pos is generated by sokol-shdc
pipdesc.layout.buffers[1].stride = int(sizeof(m4.Vec4)) pipdesc.layout.buffers[1].stride = int(sizeof(m4.Vec4))
pipdesc.layout.buffers[1].step_func = .per_instance // we will pass a single parameter for each instance!! pipdesc.layout.buffers[1].step_func = .per_instance // we will pass a single parameter for each instance!!
pipdesc.layout.attrs[C.ATTR_vs_i_inst_pos ].format = .float4 pipdesc.layout.attrs[C.ATTR_vs_i_inst_pos ].format = .float4
pipdesc.layout.attrs[C.ATTR_vs_i_inst_pos ].buffer_index = 1 pipdesc.layout.attrs[C.ATTR_vs_i_inst_pos ].buffer_index = 1
pipdesc.shader = shader pipdesc.shader = shader
pipdesc.index_type = .uint16 pipdesc.index_type = .uint16
pipdesc.depth_stencil = C.sg_depth_stencil_state{ pipdesc.depth = C.sg_depth_state{
depth_write_enabled: true write_enabled: true
depth_compare_func : gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL) compare: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
}
pipdesc.rasterizer = C.sg_rasterizer_state {
cull_mode: .back
} }
pipdesc.cull_mode = .back
pipdesc.label = "glsl_shader pipeline".str pipdesc.label = "glsl_shader pipeline".str
mut bind := C.sg_bindings{} mut bind := C.sg_bindings{}
unsafe {C.memset(&bind, 0, sizeof(bind))} unsafe {C.memset(&bind, 0, sizeof(bind))}
bind.vertex_buffers[0] = vbuf // vertex buffer bind.vertex_buffers[0] = vbuf // vertex buffer
@ -267,21 +273,21 @@ fn init_cube_glsl_i(mut app App) {
bind.fs_images[C.SLOT_tex] = app.texture bind.fs_images[C.SLOT_tex] = app.texture
app.bind['inst'] = bind app.bind['inst'] = bind
app.pipe['inst'] = gfx.make_pipeline(&pipdesc) app.pipe['inst'] = gfx.make_pipeline(&pipdesc)
println("GLSL March init DONE!") println("GLSL March init DONE!")
} }
fn calc_tr_matrices(w f32, h f32, rx f32, ry f32, in_scale f32) m4.Mat4{ fn calc_tr_matrices(w f32, h f32, rx f32, ry f32, in_scale f32) m4.Mat4{
proj := m4.perspective(60, w/h, 0.01, 4000.0) proj := m4.perspective(60, w/h, 0.01, 4000.0)
view := m4.look_at(m4.Vec4{e:[f32(0.0),100,6,0]!}, m4.Vec4{e:[f32(0),0,0,0]!}, m4.Vec4{e:[f32(0),1.0,0,0]!}) view := m4.look_at(m4.Vec4{e:[f32(0.0),100,6,0]!}, m4.Vec4{e:[f32(0),0,0,0]!}, m4.Vec4{e:[f32(0),1.0,0,0]!})
view_proj := view * proj view_proj := view * proj
rxm := m4.rotate(m4.rad(rx), m4.Vec4{e:[f32(1),0,0,0]!}) rxm := m4.rotate(m4.rad(rx), m4.Vec4{e:[f32(1),0,0,0]!})
rym := m4.rotate(m4.rad(ry), m4.Vec4{e:[f32(0),1,0,0]!}) rym := m4.rotate(m4.rad(ry), m4.Vec4{e:[f32(0),1,0,0]!})
model := rym * rxm model := rym * rxm
scale_m := m4.scale(m4.Vec4{e:[in_scale, in_scale, in_scale, 1]!}) scale_m := m4.scale(m4.Vec4{e:[in_scale, in_scale, in_scale, 1]!})
res := (scale_m * model)* view_proj res := (scale_m * model)* view_proj
return res return res
} }
@ -296,13 +302,13 @@ fn draw_cube_glsl_i(mut app App){
//ratio := f32(ws.width) / ws.height //ratio := f32(ws.width) / ws.height
dw := f32(ws.width / 2) dw := f32(ws.width / 2)
dh := f32(ws.height / 2) dh := f32(ws.height / 2)
rot := [f32(app.mouse_y), f32(app.mouse_x)] rot := [f32(app.mouse_y), f32(app.mouse_x)]
tr_matrix := calc_tr_matrices(dw, dh, rot[0], rot[1], 2.3) tr_matrix := calc_tr_matrices(dw, dh, rot[0], rot[1], 2.3)
gfx.apply_pipeline(app.pipe['inst']) gfx.apply_pipeline(app.pipe['inst'])
gfx.apply_bindings(app.bind['inst']) gfx.apply_bindings(app.bind['inst'])
//*************** //***************
// Instancing // Instancing
//*************** //***************
@ -324,15 +330,23 @@ fn draw_cube_glsl_i(mut app App){
spare_param := f32(index % 10) 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]!} 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 // Uniforms
// *** vertex shadeer uniforms *** // *** vertex shadeer uniforms ***
// passing the view matrix as uniform // passing the view matrix as uniform
// res is a 4x4 matrix of f32 thus: 4*16 byte of size // 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 *** // *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000 time_ticks := f32(time.ticks() - app.ticks) / 1000
mut tmp_fs_params := [ mut tmp_fs_params := [
@ -342,10 +356,14 @@ fn draw_cube_glsl_i(mut app App){
//ws.height - app.mouse_y*2, // mouse y scaled //ws.height - app.mouse_y*2, // mouse y scaled
time_ticks, // time as f32 time_ticks, // time as f32
app.frame_count, // frame count app.frame_count, // frame count
0,0 // padding bytes , see "fs_params" struct paddings in rt_glsl.h 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 // 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) gfx.draw(0, (3 * 2) * 6, num_inst)
} }
@ -375,11 +393,13 @@ fn frame(mut app App) {
// clear // clear
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height) gfx.begin_default_pass(&pass_action, ws.width, ws.height)
@ -388,7 +408,7 @@ fn frame(mut app App) {
draw_cube_glsl_i(mut app) draw_cube_glsl_i(mut app)
draw_end_glsl(app) draw_end_glsl(app)
app.frame_count++ app.frame_count++
} }
/****************************************************************************** /******************************************************************************
* Init / Cleanup * Init / Cleanup
@ -431,7 +451,7 @@ fn my_init(mut app App) {
app.texture = create_texture(w, h, tmp_txt) app.texture = create_texture(w, h, tmp_txt)
free(tmp_txt) free(tmp_txt)
} }
// glsl // glsl
init_cube_glsl_i(mut app) init_cube_glsl_i(mut app)
app.init_flag = true app.init_flag = true
@ -462,7 +482,7 @@ fn my_event_manager(mut ev gg.Event, mut app App) {
app.mouse_y = int(touch_point.pos_y) app.mouse_y = int(touch_point.pos_y)
} }
} }
// keyboard // keyboard
if ev.typ == .key_down { if ev.typ == .key_down {
step := f32(1.0) step := f32(1.0)
@ -500,6 +520,6 @@ fn main(){
event_fn: my_event_manager event_fn: my_event_manager
}) })
app.ticks = time.ticks() app.ticks = time.ticks()
app.gg.run() app.gg.run()
} }

89
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 d3d11_texture: 0
} }
// comment if .dynamic is enabled // 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 ptr: buf
size: sz size: size_t(sz)
} }
sg_img := C.sg_make_image(&img_desc) sg_img := C.sg_make_image(&img_desc)
@ -65,25 +65,35 @@ pub fn (mut obj_part ObjPart) create_pipeline(in_part []int, shader C.sg_shader,
obj_buf := obj_part.get_buffer(in_part) obj_buf := obj_part.get_buffer(in_part)
res.n_vert = obj_buf.n_vertex res.n_vert = obj_buf.n_vertex
res.material = obj_part.part[in_part[0]].material res.material = obj_part.part[in_part[0]].material
// vertex buffer // vertex buffer
mut vert_buffer_desc := C.sg_buffer_desc{} mut vert_buffer_desc := C.sg_buffer_desc{}
unsafe { C.memset(&vert_buffer_desc, 0, sizeof(vert_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.@type = .vertexbuffer
vert_buffer_desc.label = 'vertbuf_part_${in_part:03}'.str vert_buffer_desc.label = 'vertbuf_part_${in_part:03}'.str
vbuf := gfx.make_buffer(&vert_buffer_desc) vbuf := gfx.make_buffer(&vert_buffer_desc)
// index buffer // index buffer
mut index_buffer_desc := C.sg_buffer_desc{} mut index_buffer_desc := C.sg_buffer_desc{}
unsafe {C.memset(&index_buffer_desc, 0, sizeof(index_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.@type = .indexbuffer
index_buffer_desc.label = "indbuf_part_${in_part:03}".str index_buffer_desc.label = "indbuf_part_${in_part:03}".str
ibuf := gfx.make_buffer(&index_buffer_desc) ibuf := gfx.make_buffer(&index_buffer_desc)
mut pipdesc := C.sg_pipeline_desc{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.layout.buffers[0].stride = int(sizeof(Vertex_pnct)) pipdesc.layout.buffers[0].stride = int(sizeof(Vertex_pnct))
@ -96,19 +106,23 @@ 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.layout.attrs[C.ATTR_vs_a_Texcoord0].format = .short2n // u,v as u16
pipdesc.index_type = .uint32 pipdesc.index_type = .uint32
pipdesc.blend.enabled = true color_state := C.sg_color_state{
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA) blend: C.sg_blend_state{
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA) enabled: true
src_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA)
pipdesc.depth_stencil = C.sg_depth_stencil_state{ dst_factor_rgb: gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA)
depth_write_enabled: true }
depth_compare_func: gfx.CompareFunc(C.SG_COMPAREFUNC_LESS_EQUAL)
} }
pipdesc.rasterizer = C.sg_rasterizer_state{ pipdesc.colors[0] = color_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 pipdesc.label = 'pip_part_${in_part:03}'.str
// shader // shader
pipdesc.shader = shader pipdesc.shader = shader
@ -128,9 +142,8 @@ 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) { pub fn (mut obj_part ObjPart) init_render_data(texture C.sg_image) {
// create shader // create shader
// One shader for all the model // 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{} mut part_dict := map[string][]int{}
for i, p in obj_part.part { for i, p in obj_part.part {
if p.faces.len > 0 { if p.faces.len > 0 {
@ -139,7 +152,7 @@ pub fn (mut obj_part ObjPart) init_render_data(texture C.sg_image) {
} }
obj_part.rend_data.clear() obj_part.rend_data.clear()
//println("Material dict: ${obj_part.mat_map.keys()}") //println("Material dict: ${obj_part.mat_map.keys()}")
for k, v in part_dict { for k, v in part_dict {
//println("$k => Parts $v") //println("$k => Parts $v")
@ -172,27 +185,27 @@ pub fn (mut obj_part ObjPart) init_render_data(texture C.sg_image) {
pub fn (obj_part ObjPart) bind_and_draw(rend_data_index int, in_data Shader_data) u32 { pub fn (obj_part ObjPart) bind_and_draw(rend_data_index int, in_data Shader_data) u32 {
// apply the pipline and bindings // apply the pipline and bindings
mut part_render_data := obj_part.rend_data[rend_data_index] mut part_render_data := obj_part.rend_data[rend_data_index]
// pass light position // pass light position
mut tmp_fs_params := obj.Tmp_fs_param{} mut tmp_fs_params := obj.Tmp_fs_param{}
tmp_fs_params.ligth = in_data.fs_data.ligth tmp_fs_params.ligth = in_data.fs_data.ligth
if part_render_data.material in obj_part.mat_map { if part_render_data.material in obj_part.mat_map {
mat_index := obj_part.mat_map[part_render_data.material] mat_index := obj_part.mat_map[part_render_data.material]
mat := obj_part.mat[mat_index] mat := obj_part.mat[mat_index]
// ambient // ambient
tmp_fs_params.ka = in_data.fs_data.ka tmp_fs_params.ka = in_data.fs_data.ka
if 'Ka' in mat.ks { if 'Ka' in mat.ks {
tmp_fs_params.ka = mat.ks['Ka'] tmp_fs_params.ka = mat.ks['Ka']
} }
// specular // specular
tmp_fs_params.ks = in_data.fs_data.ks tmp_fs_params.ks = in_data.fs_data.ks
if 'Ks' in mat.ks { if 'Ks' in mat.ks {
tmp_fs_params.ks = mat.ks['Ks'] tmp_fs_params.ks = mat.ks['Ks']
} }
// specular exponent Ns // specular exponent Ns
if 'Ns' in mat.ns { if 'Ns' in mat.ns {
tmp_fs_params.ks.e[3] = mat.ns['Ns'] / 1000.0 tmp_fs_params.ks.e[3] = mat.ns['Ns'] / 1000.0
@ -200,7 +213,7 @@ pub fn (obj_part ObjPart) bind_and_draw(rend_data_index int, in_data Shader_data
// defautl value is 10 // defautl value is 10
tmp_fs_params.ks.e[3] = f32(10) / 1000.0 tmp_fs_params.ks.e[3] = f32(10) / 1000.0
} }
// diffuse // diffuse
tmp_fs_params.kd = in_data.fs_data.kd tmp_fs_params.kd = in_data.fs_data.kd
if 'Kd' in mat.ks { if 'Kd' in mat.ks {
@ -212,11 +225,21 @@ pub fn (obj_part ObjPart) bind_and_draw(rend_data_index int, in_data Shader_data
tmp_fs_params.kd.e[3] = mat.ns['Tr'] tmp_fs_params.kd.e[3] = mat.ns['Tr']
} }
} }
gfx.apply_pipeline(part_render_data.pipeline) gfx.apply_pipeline(part_render_data.pipeline)
gfx.apply_bindings(part_render_data.bind) 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) gfx.draw(0, int(part_render_data.n_vert), 1)
return part_render_data.n_vert return part_render_data.n_vert
} }
@ -237,7 +260,7 @@ pub fn (mut obj_part ObjPart) calc_bbox() {
if v.e[0] > obj_part.max.e[0] { obj_part.max.e[0] = v.e[0] } if v.e[0] > obj_part.max.e[0] { obj_part.max.e[0] = v.e[0] }
if v.e[1] > obj_part.max.e[1] { obj_part.max.e[1] = v.e[1] } if v.e[1] > obj_part.max.e[1] { obj_part.max.e[1] = v.e[1] }
if v.e[2] > obj_part.max.e[2] { obj_part.max.e[2] = v.e[2] } if v.e[2] > obj_part.max.e[2] { obj_part.max.e[2] = v.e[2] }
if v.e[0] < obj_part.min.e[0] { obj_part.min.e[0] = v.e[0] } if v.e[0] < obj_part.min.e[0] { obj_part.min.e[0] = v.e[0] }
if v.e[1] < obj_part.min.e[1] { obj_part.min.e[1] = v.e[1] } if v.e[1] < obj_part.min.e[1] { obj_part.min.e[1] = v.e[1] }
if v.e[2] < obj_part.min.e[2] { obj_part.min.e[2] = v.e[2] } if v.e[2] < obj_part.min.e[2] { obj_part.min.e[2] = v.e[2] }

61
examples/sokol/06_obj_viewer/show_obj.v
View File

@ -52,8 +52,7 @@ import obj
#flag -I @VROOT/. #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) #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(gfx.Backend) &C.sg_shader_desc
fn C.gouraud_shader_desc() &C.sg_shader_desc
const ( const (
win_width = 600 win_width = 600
@ -74,11 +73,11 @@ mut:
// time // time
ticks i64 ticks i64
// model // model
obj_part &obj.ObjPart obj_part &obj.ObjPart
n_vertex u32 n_vertex u32
// init parameters // init parameters
file_name string file_name string
single_material_flag bool single_material_flag bool
@ -87,7 +86,7 @@ mut:
/****************************************************************************** /******************************************************************************
* Draw functions * Draw functions
******************************************************************************/ ******************************************************************************/
[inline] [inline]
fn vec4(x f32, y f32, z f32, w f32) m4.Vec4 { fn vec4(x f32, y f32, z f32, w f32) m4.Vec4 {
return m4.Vec4{e:[x, y, z, w]!} return m4.Vec4{e:[x, y, z, w]!}
} }
@ -99,7 +98,7 @@ fn calc_matrices(w f32, h f32, rx f32, ry f32, in_scale f32, pos m4.Vec4) obj.Ma
rxm := m4.rotate(m4.rad(rx), vec4(f32(1), 0, 0, 0)) rxm := m4.rotate(m4.rad(rx), vec4(f32(1), 0, 0, 0))
rym := m4.rotate(m4.rad(ry), vec4(f32(0), 1, 0, 0)) rym := m4.rotate(m4.rad(ry), vec4(f32(0), 1, 0, 0))
model_pos := m4.unit_m4().translate(pos) model_pos := m4.unit_m4().translate(pos)
model_m := (rym * rxm) * model_pos model_m := (rym * rxm) * model_pos
@ -108,7 +107,7 @@ fn calc_matrices(w f32, h f32, rx f32, ry f32, in_scale f32, pos m4.Vec4) obj.Ma
mv := scale_m * model_m // model view mv := scale_m * model_m // model view
nm := mv.inverse().transpose() // normal matrix nm := mv.inverse().transpose() // normal matrix
mvp := mv * view_proj // model view projection mvp := mv * view_proj // model view projection
return obj.Mats{mv:mv, mvp:mvp, nm:nm} return obj.Mats{mv:mv, mvp:mvp, nm:nm}
} }
@ -123,23 +122,23 @@ fn draw_model(app App, model_pos m4.Vec4) u32 {
mut scale := f32(1) mut scale := f32(1)
if app.obj_part.radius > 1 { if app.obj_part.radius > 1 {
scale = 1/(app.obj_part.radius) scale = 1/(app.obj_part.radius)
} else { } else {
scale = app.obj_part.radius scale = app.obj_part.radius
} }
scale *= 3 scale *= 3
// *** vertex shader uniforms *** // *** vertex shader uniforms ***
rot := [f32(app.mouse_y), f32(app.mouse_x)] rot := [f32(app.mouse_y), f32(app.mouse_x)]
mut zoom_scale := scale + f32(app.scroll_y) / (app.obj_part.radius*4) mut zoom_scale := scale + f32(app.scroll_y) / (app.obj_part.radius*4)
mats := calc_matrices(dw, dh, rot[0], rot[1] , zoom_scale, model_pos) mats := calc_matrices(dw, dh, rot[0], rot[1] , zoom_scale, model_pos)
mut tmp_vs_param := obj.Tmp_vs_param{ mut tmp_vs_param := obj.Tmp_vs_param{
mv: mats.mv, mv: mats.mv,
mvp: mats.mvp, mvp: mats.mvp,
nm: mats.nm nm: mats.nm
} }
// *** fragment shader uniforms *** // *** fragment shader uniforms ***
time_ticks := f32(time.ticks() - app.ticks) / 1000 time_ticks := f32(time.ticks() - app.ticks) / 1000
radius_light := f32(app.obj_part.radius) radius_light := f32(app.obj_part.radius)
@ -148,7 +147,7 @@ fn draw_model(app App, model_pos m4.Vec4) u32 {
mut tmp_fs_params := obj.Tmp_fs_param{} mut tmp_fs_params := obj.Tmp_fs_param{}
tmp_fs_params.ligth = m4.vec3(x_light, radius_light, z_light) tmp_fs_params.ligth = m4.vec3(x_light, radius_light, z_light)
sd := obj.Shader_data{ sd := obj.Shader_data{
vs_data: &tmp_vs_param vs_data: &tmp_vs_param
vs_len: int(sizeof(tmp_vs_param)) vs_len: int(sizeof(tmp_vs_param))
@ -156,7 +155,7 @@ fn draw_model(app App, model_pos m4.Vec4) u32 {
fs_len: int(sizeof(tmp_fs_params)) fs_len: int(sizeof(tmp_fs_params))
} }
return app.obj_part.bind_and_draw_all(sd) return app.obj_part.bind_and_draw_all(sd)
} }
fn frame(mut app App) { fn frame(mut app App) {
@ -165,11 +164,14 @@ fn frame(mut app App) {
// clear // clear
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
gfx.begin_default_pass(&pass_action, ws.width, ws.height) gfx.begin_default_pass(&pass_action, ws.width, ws.height)
@ -178,7 +180,7 @@ fn frame(mut app App) {
draw_start_glsl(app) draw_start_glsl(app)
draw_model(app, m4.Vec4{}) draw_model(app, m4.Vec4{})
// uncoment if you want a raw benchmark mode // uncoment if you want a raw benchmark mode
/* /*
mut n_vertex_drawn := u32(0) mut n_vertex_drawn := u32(0)
n_x_obj := 20 n_x_obj := 20
@ -189,9 +191,9 @@ fn frame(mut app App) {
} }
} }
} }
*/ */
draw_end_glsl(app) draw_end_glsl(app)
//println("v:$n_vertex_drawn") //println("v:$n_vertex_drawn")
app.frame_count++ app.frame_count++
} }
@ -227,7 +229,7 @@ fn my_init(mut app App) {
max_vertices: 128 * 65536 max_vertices: 128 * 65536
} }
sgl.setup(&sgl_desc) sgl.setup(&sgl_desc)
// 1x1 pixel white, default texture // 1x1 pixel white, default texture
unsafe { unsafe {
tmp_txt := malloc(4) tmp_txt := malloc(4)
@ -238,7 +240,7 @@ fn my_init(mut app App) {
app.texture = obj.create_texture(1, 1, tmp_txt) app.texture = obj.create_texture(1, 1, tmp_txt)
free(tmp_txt) free(tmp_txt)
} }
// glsl // glsl
app.obj_part.init_render_data(app.texture) app.obj_part.init_render_data(app.texture)
app.init_flag = true app.init_flag = true
@ -250,7 +252,7 @@ fn cleanup(mut app App) {
for _, mat in app.obj_part.texture { for _, mat in app.obj_part.texture {
obj.destroy_texture(mat) obj.destroy_texture(mat)
} }
*/ */
} }
/****************************************************************************** /******************************************************************************
@ -261,11 +263,11 @@ fn my_event_manager(mut ev gg.Event, mut app App) {
app.mouse_x = int(ev.mouse_x) app.mouse_x = int(ev.mouse_x)
app.mouse_y = int(ev.mouse_y) app.mouse_y = int(ev.mouse_y)
} }
if ev.scroll_y != 0 { if ev.scroll_y != 0 {
app.scroll_y += int(ev.scroll_y) app.scroll_y += int(ev.scroll_y)
} }
if ev.typ == .touches_began || ev.typ == .touches_moved { if ev.typ == .touches_began || ev.typ == .touches_moved {
if ev.num_touches > 0 { if ev.num_touches > 0 {
touch_point := ev.touches[0] touch_point := ev.touches[0]
@ -290,8 +292,9 @@ fn main() {
gg: 0 gg: 0
obj_part: 0 obj_part: 0
} }
app.file_name = "v.obj_" // default object is the v logo app.file_name = "v.obj_" // default object is the v logo
app.single_material_flag = false app.single_material_flag = false
$if !android { $if !android {
if os.args.len > 3 || (os.args.len >= 2 && os.args[1] in ['-h', '--help', '\\?', '-?']) { if os.args.len > 3 || (os.args.len >= 2 && os.args[1] in ['-h', '--help', '\\?', '-?']) {
@ -302,8 +305,8 @@ fn main() {
eprintln('single_material_flag: if true the viewer use for all the model\'s parts the default material\n') eprintln('single_material_flag: if true the viewer use for all the model\'s parts the default material\n')
exit(0) exit(0)
} }
if os.args.len >= 2 { if os.args.len >= 2 {
app.file_name = os.args[1] app.file_name = os.args[1]
} }
if os.args.len >= 3 { if os.args.len >= 3 {
@ -312,7 +315,7 @@ fn main() {
println("Loading model: $app.file_name") println("Loading model: $app.file_name")
println("Using single material: $app.single_material_flag") println("Using single material: $app.single_material_flag")
} }
app.gg = gg.new_context( app.gg = gg.new_context(
width: win_width width: win_width
height: win_height height: win_height

10
examples/sokol/fonts.v
View File

@ -15,11 +15,13 @@ mut:
fn main() { fn main() {
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
state := &AppState{ state := &AppState{

10
examples/sokol/freetype_raven.v
View File

@ -65,11 +65,13 @@ mut:
fn main() { fn main() {
mut color_action := C.sg_color_attachment_action{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
state := &AppState{ state := &AppState{

13
examples/sokol/particles/particles.v
View File

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

2162
thirdparty/sokol/sokol_app.h vendored
View File

File diff suppressed because it is too large Load Diff

762
thirdparty/sokol/sokol_audio.h vendored
View File

File diff suppressed because it is too large Load Diff

3605
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 #ifndef SOKOL_FONTSTASH_INCLUDED
/* /*
sokol_fontstash.h -- renderer for https://github.com/memononen/fontstash sokol_fontstash.h -- renderer for https://github.com/memononen/fontstash
@ -6,7 +9,7 @@
Project URL: https://github.com/floooh/sokol Project URL: https://github.com/floooh/sokol
Do this: Do this:
#define SOKOL_IMPL or
#define SOKOL_FONTSTASH_IMPL #define SOKOL_FONTSTASH_IMPL
before you include this file in *one* C or C++ file to create the 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_ASSERT(c) - your own assert macro (default: assert(c))
SOKOL_MALLOC(s) - your own malloc function (default: malloc(s)) SOKOL_MALLOC(s) - your own malloc function (default: malloc(s))
SOKOL_FREE(p) - your own free function (default: free(p)) 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_API_IMPL - public function implementation prefix (default: -)
SOKOL_LOG(msg) - your own logging function (default: puts(msg)) SOKOL_LOG(msg) - your own logging function (default: puts(msg))
SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false)) 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" #error "Please include sokol_gfx.h before sokol_fontstash.h"
#endif #endif
#ifndef SOKOL_API_DECL #if defined(SOKOL_API_DECL) && !defined(SOKOL_FONTSTASH_API_DECL)
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_IMPL) #define SOKOL_FONTSTASH_API_DECL SOKOL_API_DECL
#define SOKOL_API_DECL __declspec(dllexport) #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) #elif defined(_WIN32) && defined(SOKOL_DLL)
#define SOKOL_API_DECL __declspec(dllimport) #define SOKOL_FONTSTASH_API_DECL __declspec(dllimport)
#else #else
#define SOKOL_API_DECL extern #define SOKOL_FONTSTASH_API_DECL extern
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
SOKOL_API_DECL FONScontext* sfons_create(int width, int height, int flags); SOKOL_FONTSTASH_API_DECL FONScontext* sfons_create(int width, int height, int flags);
SOKOL_API_DECL void sfons_destroy(FONScontext* ctx); SOKOL_FONTSTASH_API_DECL void sfons_destroy(FONScontext* ctx);
SOKOL_API_DECL void sfons_flush(FONScontext* ctx); SOKOL_FONTSTASH_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 uint32_t sfons_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* 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].type = SG_UNIFORMTYPE_FLOAT4;
ub->uniforms[0].array_count = 8; ub->uniforms[0].array_count = 8;
shd_desc.fs.images[0].name = "tex"; 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.fs.images[0].sampler_type = SG_SAMPLERTYPE_FLOAT;
shd_desc.label = "sokol-fontstash-shader"; shd_desc.label = "sokol-fontstash-shader";
#if defined(SOKOL_GLCORE33) #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"; shd_desc.fs.entry = "main0";
switch (sg_query_backend()) { switch (sg_query_backend()) {
case SG_BACKEND_METAL_MACOS: case SG_BACKEND_METAL_MACOS:
shd_desc.vs.byte_code = _sfons_vs_bytecode_metal_macos; shd_desc.vs.bytecode = SG_RANGE(_sfons_vs_bytecode_metal_macos);
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_metal_macos); shd_desc.fs.bytecode = SG_RANGE(_sfons_fs_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);
break; break;
case SG_BACKEND_METAL_IOS: case SG_BACKEND_METAL_IOS:
shd_desc.vs.byte_code = _sfons_vs_bytecode_metal_ios; shd_desc.vs.bytecode = SG_RANGE(_sfons_vs_bytecode_metal_ios);
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_metal_ios); shd_desc.fs.bytecode = SG_RANGE(_sfons_fs_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);
break; break;
default: default:
shd_desc.vs.source = _sfons_vs_source_metal_sim; 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; break;
} }
#elif defined(SOKOL_D3D11) #elif defined(SOKOL_D3D11)
shd_desc.vs.byte_code = _sfons_vs_bytecode_hlsl4; shd_desc.vs.bytecode = SG_RANGE(_sfons_vs_bytecode_hlsl4);
shd_desc.vs.byte_code_size = sizeof(_sfons_vs_bytecode_hlsl4); shd_desc.fs.bytecode = SG_RANGE(_sfons_fs_bytecode_hlsl4);
shd_desc.fs.byte_code = _sfons_fs_bytecode_hlsl4;
shd_desc.fs.byte_code_size = sizeof(_sfons_fs_bytecode_hlsl4);
#elif defined(SOKOL_WGPU) #elif defined(SOKOL_WGPU)
shd_desc.vs.byte_code = _sfons_vs_bytecode_wgpu; shd_desc.vs.byte_code = _sfons_vs_bytecode_wgpu;
shd_desc.vs.byte_code_size = sizeof(_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; sg_pipeline_desc pip_desc;
memset(&pip_desc, 0, sizeof(pip_desc)); memset(&pip_desc, 0, sizeof(pip_desc));
pip_desc.shader = sfons->shd; pip_desc.shader = sfons->shd;
pip_desc.blend.enabled = true; pip_desc.colors[0].blend.enabled = true;
pip_desc.blend.src_factor_rgb = SG_BLENDFACTOR_SRC_ALPHA; pip_desc.colors[0].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.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
sfons->pip = sgl_make_pipeline(&pip_desc); 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; _sfons_t* sfons = (_sfons_t*) ctx->params.userPtr;
if (sfons->img_dirty) { if (sfons->img_dirty) {
sfons->img_dirty = false; sfons->img_dirty = false;
sg_image_content content; sg_image_data data;
memset(&content, 0, sizeof(content)); memset(&data, 0, sizeof(data));
content.subimage[0][0].ptr = ctx->texData; data.subimage[0][0].ptr = ctx->texData;
content.subimage[0][0].size = sfons->width * sfons->height; data.subimage[0][0].size = (size_t) (sfons->width * sfons->height);
sg_update_image(sfons->img, &content); 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) { 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 */ #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 #ifndef SOKOL_GL_INCLUDED
/* /*
sokol_gl.h -- OpenGL 1.x style rendering on top of sokol_gfx.h 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 Project URL: https://github.com/floooh/sokol
Do this: Do this:
#define SOKOL_IMPL or
#define SOKOL_GL_IMPL #define SOKOL_GL_IMPL
before you include this file in *one* C or C++ file to create the before you include this file in *one* C or C++ file to create the
implementation. implementation.
@ -25,7 +29,8 @@
SOKOL_ASSERT(c) - your own assert macro (default: assert(c)) SOKOL_ASSERT(c) - your own assert macro (default: assert(c))
SOKOL_MALLOC(s) - your own malloc function (default: malloc(s)) SOKOL_MALLOC(s) - your own malloc function (default: malloc(s))
SOKOL_FREE(p) - your own free function (default: free(p)) 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_API_IMPL - public function implementation prefix (default: -)
SOKOL_LOG(msg) - your own logging function (default: puts(msg)) SOKOL_LOG(msg) - your own logging function (default: puts(msg))
SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false)) SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false))
@ -35,7 +40,7 @@
SOKOL_DLL 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. or __declspec(dllimport) as needed.
Include the following headers before including sokol_gl.h: 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_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) 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 ...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 that the viewport or scissor rect are set at the right time relative
to other sokol-gl calls. to other sokol-gl calls.
@ -445,13 +457,16 @@
#error "Please include sokol_gfx.h before sokol_gl.h" #error "Please include sokol_gfx.h before sokol_gl.h"
#endif #endif
#ifndef SOKOL_API_DECL #if defined(SOKOL_API_DECL) && !defined(SOKOL_GL_API_DECL)
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_IMPL) #define SOKOL_GL_API_DECL SOKOL_API_DECL
#define SOKOL_API_DECL __declspec(dllexport) #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) #elif defined(_WIN32) && defined(SOKOL_DLL)
#define SOKOL_API_DECL __declspec(dllimport) #define SOKOL_GL_API_DECL __declspec(dllimport)
#else #else
#define SOKOL_API_DECL extern #define SOKOL_GL_API_DECL extern
#endif #endif
#endif #endif
@ -488,92 +503,94 @@ typedef struct sgl_desc_t {
} sgl_desc_t; } sgl_desc_t;
/* setup/shutdown/misc */ /* setup/shutdown/misc */
SOKOL_API_DECL void sgl_setup(const sgl_desc_t* desc); SOKOL_GL_API_DECL void sgl_setup(const sgl_desc_t* desc);
SOKOL_API_DECL void sgl_shutdown(void); SOKOL_GL_API_DECL void sgl_shutdown(void);
SOKOL_API_DECL sgl_error_t sgl_error(void); SOKOL_GL_API_DECL sgl_error_t sgl_error(void);
SOKOL_API_DECL void sgl_defaults(void); SOKOL_GL_API_DECL void sgl_defaults(void);
SOKOL_API_DECL float sgl_rad(float deg); SOKOL_GL_API_DECL float sgl_rad(float deg);
SOKOL_API_DECL float sgl_deg(float rad); SOKOL_GL_API_DECL float sgl_deg(float rad);
/* create and destroy pipeline objects */ /* create and destroy pipeline objects */
SOKOL_API_DECL sgl_pipeline sgl_make_pipeline(const sg_pipeline_desc* desc); SOKOL_GL_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 void sgl_destroy_pipeline(sgl_pipeline pip);
/* render state functions */ /* render state functions */
SOKOL_API_DECL void sgl_viewport(int x, int y, int w, int h, bool origin_top_left); SOKOL_GL_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_GL_API_DECL void sgl_viewportf(float x, float y, float w, float h, bool origin_top_left);
SOKOL_API_DECL void sgl_enable_texture(void); SOKOL_GL_API_DECL void sgl_scissor_rect(int x, int y, int w, int h, bool origin_top_left);
SOKOL_API_DECL void sgl_disable_texture(void); SOKOL_GL_API_DECL void sgl_scissor_rectf(float x, float y, float w, float h, bool origin_top_left);
SOKOL_API_DECL void sgl_texture(sg_image img); 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 */ /* pipeline stack functions */
SOKOL_API_DECL void sgl_default_pipeline(void); SOKOL_GL_API_DECL void sgl_default_pipeline(void);
SOKOL_API_DECL void sgl_load_pipeline(sgl_pipeline pip); SOKOL_GL_API_DECL void sgl_load_pipeline(sgl_pipeline pip);
SOKOL_API_DECL void sgl_push_pipeline(void); SOKOL_GL_API_DECL void sgl_push_pipeline(void);
SOKOL_API_DECL void sgl_pop_pipeline(void); SOKOL_GL_API_DECL void sgl_pop_pipeline(void);
/* matrix stack functions */ /* matrix stack functions */
SOKOL_API_DECL void sgl_matrix_mode_modelview(void); SOKOL_GL_API_DECL void sgl_matrix_mode_modelview(void);
SOKOL_API_DECL void sgl_matrix_mode_projection(void); SOKOL_GL_API_DECL void sgl_matrix_mode_projection(void);
SOKOL_API_DECL void sgl_matrix_mode_texture(void); SOKOL_GL_API_DECL void sgl_matrix_mode_texture(void);
SOKOL_API_DECL void sgl_load_identity(void); SOKOL_GL_API_DECL void sgl_load_identity(void);
SOKOL_API_DECL void sgl_load_matrix(const float m[16]); SOKOL_GL_API_DECL void sgl_load_matrix(const float m[16]);
SOKOL_API_DECL void sgl_load_transpose_matrix(const float m[16]); SOKOL_GL_API_DECL void sgl_load_transpose_matrix(const float m[16]);
SOKOL_API_DECL void sgl_mult_matrix(const float m[16]); SOKOL_GL_API_DECL void sgl_mult_matrix(const float m[16]);
SOKOL_API_DECL void sgl_mult_transpose_matrix(const float m[16]); SOKOL_GL_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_GL_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_GL_API_DECL void sgl_scale(float x, float y, float z);
SOKOL_API_DECL void sgl_translate(float x, float y, float z); SOKOL_GL_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_GL_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_GL_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_GL_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_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_API_DECL void sgl_push_matrix(void); SOKOL_GL_API_DECL void sgl_push_matrix(void);
SOKOL_API_DECL void sgl_pop_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) */ /* 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_GL_API_DECL void sgl_t2f(float u, float v);
SOKOL_API_DECL void sgl_c3f(float r, float g, float b); SOKOL_GL_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_GL_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_GL_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_GL_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_c1i(uint32_t rgba);
/* define primitives, each begin/end is one draw command */ /* define primitives, each begin/end is one draw command */
SOKOL_API_DECL void sgl_begin_points(void); SOKOL_GL_API_DECL void sgl_begin_points(void);
SOKOL_API_DECL void sgl_begin_lines(void); SOKOL_GL_API_DECL void sgl_begin_lines(void);
SOKOL_API_DECL void sgl_begin_line_strip(void); SOKOL_GL_API_DECL void sgl_begin_line_strip(void);
SOKOL_API_DECL void sgl_begin_triangles(void); SOKOL_GL_API_DECL void sgl_begin_triangles(void);
SOKOL_API_DECL void sgl_begin_triangle_strip(void); SOKOL_GL_API_DECL void sgl_begin_triangle_strip(void);
SOKOL_API_DECL void sgl_begin_quads(void); SOKOL_GL_API_DECL void sgl_begin_quads(void);
SOKOL_API_DECL void sgl_v2f(float x, float y); SOKOL_GL_API_DECL void sgl_v2f(float x, float y);
SOKOL_API_DECL void sgl_v3f(float x, float y, float z); SOKOL_GL_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_GL_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_GL_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_GL_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_GL_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_GL_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_GL_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_GL_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_GL_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_GL_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_GL_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_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_API_DECL void sgl_v3f_c1i(float x, float y, float z, uint32_t rgba); SOKOL_GL_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_GL_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_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_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_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_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_API_DECL void sgl_v2f_t2f_c1i(float x, float y, float u, float v, uint32_t rgba); SOKOL_GL_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_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_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_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_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_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_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_GL_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_end(void);
/* render everything */ /* render everything */
SOKOL_API_DECL void sgl_draw(void); SOKOL_GL_API_DECL void sgl_draw(void);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
@ -2070,12 +2087,12 @@ static void _sgl_init_pool(_sgl_pool_t* pool, int num) {
pool->size = num + 1; pool->size = num + 1;
pool->queue_top = 0; pool->queue_top = 0;
/* generation counters indexable by pool slot index, slot 0 is reserved */ /* 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); pool->gen_ctrs = (uint32_t*) SOKOL_MALLOC(gen_ctrs_size);
SOKOL_ASSERT(pool->gen_ctrs); SOKOL_ASSERT(pool->gen_ctrs);
memset(pool->gen_ctrs, 0, gen_ctrs_size); memset(pool->gen_ctrs, 0, gen_ctrs_size);
/* it's not a bug to only reserve 'num' here */ /* 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); SOKOL_ASSERT(pool->free_queue);
/* never allocate the zero-th pool item since the invalid id is 0 */ /* never allocate the zero-th pool item since the invalid id is 0 */
for (int i = pool->size-1; i >= 1; i--) { 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 */ /* 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)); 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); _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); _sgl.pip_pool.pips = (_sgl_pipeline_t*) SOKOL_MALLOC(pool_byte_size);
SOKOL_ASSERT(_sgl.pip_pool.pips); SOKOL_ASSERT(_sgl.pip_pool.pips);
memset(_sgl.pip_pool.pips, 0, pool_byte_size); 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.shader = _sgl.shd;
} }
desc.index_type = SG_INDEXTYPE_NONE; desc.index_type = SG_INDEXTYPE_NONE;
desc.blend.color_format = _sgl.desc.color_format; desc.sample_count = _sgl.desc.sample_count;
desc.blend.depth_format = _sgl.desc.depth_format; if (desc.face_winding == _SG_FACEWINDING_DEFAULT) {
desc.rasterizer.sample_count = _sgl.desc.sample_count; desc.face_winding = _sgl.desc.face_winding;
if (desc.rasterizer.face_winding == _SG_FACEWINDING_DEFAULT) {
desc.rasterizer.face_winding = _sgl.desc.face_winding;
} }
if (desc.blend.color_write_mask == _SG_COLORMASK_DEFAULT) { desc.depth.pixel_format = _sgl.desc.depth_format;
desc.blend.color_write_mask = SG_COLORMASK_RGB; 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); _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_vertices = _sgl.desc.max_vertices;
_sgl.num_uniforms = _sgl.desc.max_commands; _sgl.num_uniforms = _sgl.desc.max_commands;
_sgl.num_commands = _sgl.num_uniforms; _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); 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); 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); SOKOL_ASSERT(_sgl.commands);
_sgl_setup_pipeline_pool(&_sgl.desc); _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; sg_buffer_desc vbuf_desc;
memset(&vbuf_desc, 0, sizeof(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.type = SG_BUFFERTYPE_VERTEXBUFFER;
vbuf_desc.usage = SG_USAGE_STREAM; vbuf_desc.usage = SG_USAGE_STREAM;
vbuf_desc.label = "sgl-vertex-buffer"; 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.pixel_format = SG_PIXELFORMAT_RGBA8;
img_desc.min_filter = SG_FILTER_NEAREST; img_desc.min_filter = SG_FILTER_NEAREST;
img_desc.mag_filter = SG_FILTER_NEAREST; img_desc.mag_filter = SG_FILTER_NEAREST;
img_desc.content.subimage[0][0].ptr = pixels; img_desc.data.subimage[0][0] = SG_RANGE(pixels);
img_desc.content.subimage[0][0].size = sizeof(pixels);
img_desc.label = "sgl-default-texture"; img_desc.label = "sgl-default-texture";
_sgl.def_img = sg_make_image(&img_desc); _sgl.def_img = sg_make_image(&img_desc);
SOKOL_ASSERT(SG_INVALID_ID != _sgl.def_img.id); 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].type = SG_UNIFORMTYPE_FLOAT4;
ub->uniforms[0].array_count = 8; ub->uniforms[0].array_count = 8;
shd_desc.fs.images[0].name = "tex"; 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.fs.images[0].sampler_type = SG_SAMPLERTYPE_FLOAT;
shd_desc.label = "sgl-shader"; shd_desc.label = "sgl-shader";
#if defined(SOKOL_GLCORE33) #if defined(SOKOL_GLCORE33)
@ -2710,16 +2726,12 @@ SOKOL_API_IMPL void sgl_setup(const sgl_desc_t* desc) {
shd_desc.fs.entry = "main0"; shd_desc.fs.entry = "main0";
switch (sg_query_backend()) { switch (sg_query_backend()) {
case SG_BACKEND_METAL_MACOS: case SG_BACKEND_METAL_MACOS:
shd_desc.vs.byte_code = _sgl_vs_bytecode_metal_macos; shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_metal_macos);
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_metal_macos); shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_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);
break; break;
case SG_BACKEND_METAL_IOS: case SG_BACKEND_METAL_IOS:
shd_desc.vs.byte_code = _sgl_vs_bytecode_metal_ios; shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_metal_ios);
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_metal_ios); shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_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);
break; break;
default: default:
shd_desc.vs.source = _sgl_vs_source_metal_sim; 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; break;
} }
#elif defined(SOKOL_D3D11) #elif defined(SOKOL_D3D11)
shd_desc.vs.byte_code = _sgl_vs_bytecode_hlsl4; shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_hlsl4);
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_hlsl4); shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_bytecode_hlsl4);
shd_desc.fs.byte_code = _sgl_fs_bytecode_hlsl4;
shd_desc.fs.byte_code_size = sizeof(_sgl_fs_bytecode_hlsl4);
#elif defined(SOKOL_WGPU) #elif defined(SOKOL_WGPU)
shd_desc.vs.byte_code = _sgl_vs_bytecode_wgpu; shd_desc.vs.bytecode = SG_RANGE(_sgl_vs_bytecode_wgpu);
shd_desc.vs.byte_code_size = sizeof(_sgl_vs_bytecode_wgpu); shd_desc.fs.bytecode = SG_RANGE(_sgl_fs_bytecode_wgpu);
shd_desc.fs.byte_code = _sgl_fs_bytecode_wgpu;
shd_desc.fs.byte_code_size = sizeof(_sgl_fs_bytecode_wgpu);
#else #else
shd_desc.vs.source = _sgl_vs_src_dummy; shd_desc.vs.source = _sgl_vs_src_dummy;
shd_desc.fs.source = _sgl_fs_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 */ /* create default pipeline object */
sg_pipeline_desc def_pip_desc; sg_pipeline_desc def_pip_desc;
memset(&def_pip_desc, 0, sizeof(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); _sgl.def_pip = _sgl_make_pipeline(&def_pip_desc);
sg_pop_debug_group(); 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_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_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT(!_sgl.in_begin); 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_API_IMPL void sgl_enable_texture(void) {
SOKOL_ASSERT(_SGL_INIT_COOKIE == _sgl.init_cookie); SOKOL_ASSERT(_SGL_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT(!_sgl.in_begin); 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); _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_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT((_sgl.cur_matrix_mode >= 0) && (_sgl.cur_matrix_mode < SGL_NUM_MATRIXMODES)); SOKOL_ASSERT((_sgl.cur_matrix_mode >= 0) && (_sgl.cur_matrix_mode < SGL_NUM_MATRIXMODES));
_sgl.matrix_dirty = true; _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_INIT_COOKIE == _sgl.init_cookie);
SOKOL_ASSERT((_sgl.cur_matrix_mode >= 0) && (_sgl.cur_matrix_mode < SGL_NUM_MATRIXMODES)); SOKOL_ASSERT((_sgl.cur_matrix_mode >= 0) && (_sgl.cur_matrix_mode < SGL_NUM_MATRIXMODES));
_sgl.matrix_dirty = true; _sgl.matrix_dirty = true;
@ -3228,7 +3244,8 @@ SOKOL_API_IMPL void sgl_draw(void) {
uint32_t cur_img_id = SG_INVALID_ID; uint32_t cur_img_id = SG_INVALID_ID;
int cur_uniform_index = -1; int cur_uniform_index = -1;
sg_push_debug_group("sokol-gl"); 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; _sgl.bind.vertex_buffers[0] = _sgl.vbuf;
for (int i = 0; i < _sgl.cur_command; i++) { for (int i = 0; i < _sgl.cur_command; i++) {
const _sgl_command_t* cmd = &_sgl.commands[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; cur_img_id = args->img.id;
} }
if (cur_uniform_index != args->uniform_index) { 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; cur_uniform_index = args->uniform_index;
} }
/* FIXME: what if number of vertices doesn't match the primitive type? */ /* 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{} mut pipdesc := C.sg_pipeline_desc{}
unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) } unsafe { C.memset(&pipdesc, 0, sizeof(pipdesc)) }
pipdesc.blend.enabled = true
pipdesc.blend.src_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_SRC_ALPHA) color_state := C.sg_color_state{
pipdesc.blend.dst_factor_rgb = gfx.BlendFactor(C.SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA) 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) g.timage_pip = sgl.make_pipeline(&pipdesc)
// //
if g.config.init_fn != voidptr(0) { if g.config.init_fn != voidptr(0) {
@ -203,6 +210,7 @@ fn gg_init_sokol_window(user_data voidptr) {
if g.native_rendering { if g.native_rendering {
return return
} }
for i in 0 .. g.image_cache.len { for i in 0 .. g.image_cache.len {
g.image_cache[i].init_sokol_image() g.image_cache[i].init_sokol_image()
} }
@ -216,6 +224,7 @@ fn gg_frame_fn(user_data voidptr) {
if ctx.native_rendering { if ctx.native_rendering {
// return // return
} }
if ctx.ui_mode && !ctx.needs_refresh { if ctx.ui_mode && !ctx.needs_refresh {
// Draw 3 more frames after the "stop refresh" command // Draw 3 more frames after the "stop refresh" command
ctx.ticks++ ctx.ticks++
@ -334,7 +343,7 @@ pub fn new_context(cfg Config) &Context {
sample_count: cfg.sample_count sample_count: cfg.sample_count
high_dpi: true high_dpi: true
fullscreen: cfg.fullscreen fullscreen: cfg.fullscreen
native_render: cfg.native_rendering __v_native_render: cfg.native_rendering
} }
if cfg.use_ortho { if cfg.use_ortho {
} else { } 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) { 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 { if c.a != 255 {
sgl.load_pipeline(ctx.timage_pip) 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) { 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 { if ctx.scale == 1 {
ctx.draw_circle_with_segments(x, y, r, 10, c) ctx.draw_circle_with_segments(x, y, r, 10, c)
} else { } else {

5
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() { void darwin_window_refresh() {
//[g_view setNeedsDisplay:YES]; //[g_view setNeedsDisplay:YES];
// update UI on the main thread TODO separate fn // 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]; [g_view setNeedsDisplay:YES];
}); });
*/
//puts("refresh"); //puts("refresh");
//[g_view drawRect:NSMakeRect(0,0,2000,2000)]; //[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) label: &byte(0)
d3d11_texture: 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 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 = C.sg_make_image(&img_desc)
img.simg_ok = true img.simg_ok = true

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

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

16
vlib/sokol/gfx/gfx.v
View File

@ -75,18 +75,18 @@ pub fn destroy_pass(pass C.sg_pass) {
} }
[inline] [inline]
pub fn update_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int) { pub fn update_buffer(buf C.sg_buffer, data &C.sg_range) {
C.sg_update_buffer(buf, ptr, num_bytes) C.sg_update_buffer(buf, data)
} }
[inline] [inline]
pub fn update_image(img C.sg_image, content &C.sg_image_content) { pub fn update_image(img C.sg_image, data &C.sg_image_data) {
C.sg_update_image(img, content) C.sg_update_image(img, data)
} }
[inline] [inline]
pub fn append_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int) int { pub fn append_buffer(buf C.sg_buffer, data &C.sg_range) int {
return C.sg_append_buffer(buf, ptr, num_bytes) return C.sg_append_buffer(buf, data)
} }
[inline] [inline]
@ -126,8 +126,8 @@ pub fn apply_bindings(bindings &C.sg_bindings) {
} }
[inline] [inline]
pub fn apply_uniforms(stage int, ub_index int, data voidptr, num_bytes int) { pub fn apply_uniforms(stage int, ub_index int, data &C.sg_range) {
C.sg_apply_uniforms(stage, ub_index, data, num_bytes) C.sg_apply_uniforms(stage, ub_index, data)
} }
[inline] [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_shader(shd C.sg_shader)
fn C.sg_destroy_pipeline(pip C.sg_pipeline) fn C.sg_destroy_pipeline(pip C.sg_pipeline)
fn C.sg_destroy_pass(pass C.sg_pass) 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_buffer(buf C.sg_buffer, data &C.sg_range)
fn C.sg_update_image(img C.sg_image, content &C.sg_image_content) fn C.sg_update_image(img C.sg_image, data &C.sg_image_data)
fn C.sg_append_buffer(buf C.sg_buffer, ptr voidptr, num_bytes int) int 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 fn C.sg_query_buffer_overflow(buf C.sg_buffer) bool
// rendering functions // rendering functions
fn C.sg_begin_default_pass(actions &C.sg_pass_action, width int, height int) 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_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_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_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_pipeline(pip C.sg_pipeline)
fn C.sg_apply_bindings(bindings &C.sg_bindings) fn C.sg_apply_bindings(bindings &C.sg_bindings)
// stage == sg_shader_stage // 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_draw(base_element int, num_elements int, num_instances int)
fn C.sg_end_pass() fn C.sg_end_pass()
fn C.sg_commit() fn C.sg_commit()

191
vlib/sokol/gfx/gfx_structs.v
View File

@ -36,7 +36,7 @@ pub struct C.sg_context_desc {
*/ */
sample_count int sample_count int
gl C.sg_gl_context_desc gl C.sg_gl_context_desc
metal C.sg_mtl_context_desc metal C.sg_metal_context_desc
d3d11 C.sg_d3d11_context_desc d3d11 C.sg_d3d11_context_desc
color_format PixelFormat color_format PixelFormat
depth_format PixelFormat depth_format PixelFormat
@ -46,7 +46,7 @@ pub struct C.sg_gl_context_desc {
gl_force_gles2 bool gl_force_gles2 bool
} }
pub struct C.sg_mtl_context_desc { pub struct C.sg_metal_context_desc {
device voidptr device voidptr
renderpass_descriptor_cb fn () voidptr renderpass_descriptor_cb fn () voidptr
drawable_cb fn () voidptr drawable_cb fn () voidptr
@ -59,18 +59,31 @@ pub struct C.sg_d3d11_context_desc {
depth_stencil_view_cb fn () voidptr 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 struct C.sg_pipeline_desc {
pub mut: pub mut:
_start_canary u32 _start_canary u32
layout C.sg_layout_desc shader C.sg_shader
shader C.sg_shader layout C.sg_layout_desc
primitive_type PrimitiveType depth C.sg_depth_state
index_type IndexType stencil C.sg_stencil_state
depth_stencil C.sg_depth_stencil_state color_count int
blend C.sg_blend_state colors [4]C.sg_color_state // C.SG_MAX_COLOR_ATTACHMENTS
rasterizer C.sg_rasterizer_state primitive_type PrimitiveType
label byteptr index_type IndexType
_end_canary u32 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 { 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) { 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 { 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) { 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 { 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 { 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 { 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].name = name.str
desc.vs.images[index].@type = ._2d desc.vs.images[index].image_type = ._2d
return desc return desc
} }
pub fn (mut desc C.sg_shader_desc) set_frag_image(index int, name string) &C.sg_shader_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].name = name.str
desc.fs.images[index].@type = ._2d desc.fs.images[index].image_type = ._2d
return desc 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 desc.vs.uniform_blocks[block_index].size = size
return desc 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 desc.fs.uniform_blocks[block_index].size = size
return desc return desc
} }
@ -189,8 +218,7 @@ pub mut:
pub struct C.sg_shader_stage_desc { pub struct C.sg_shader_stage_desc {
pub mut: pub mut:
source byteptr source byteptr
byte_code &byte bytecode C.sg_range
byte_code_size int
entry byteptr entry byteptr
uniform_blocks [4]C.sg_shader_uniform_block_desc uniform_blocks [4]C.sg_shader_uniform_block_desc
images [12]C.sg_shader_image_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 { 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].name = name.str
desc.images[index].@type = ._2d desc.images[index].image_type = ._2d
return *desc return *desc
} }
pub struct C.sg_shader_uniform_block_desc { pub struct C.sg_shader_uniform_block_desc {
pub mut: pub mut:
size int size size_t
uniforms [16]C.sg_shader_uniform_desc uniforms [16]C.sg_shader_uniform_desc
} }
@ -218,7 +246,7 @@ pub mut:
pub struct C.sg_shader_image_desc { pub struct C.sg_shader_image_desc {
pub mut: pub mut:
name byteptr name byteptr
@type ImageType image_type ImageType
} }
pub struct C.sg_shader_info { pub struct C.sg_shader_info {
@ -228,6 +256,20 @@ pub struct C.sg_context {
id u32 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 struct C.sg_shader {
pub: pub:
id u32 id u32
@ -240,8 +282,8 @@ pub fn (s C.sg_shader) free() {
pub struct C.sg_pass_desc { pub struct C.sg_pass_desc {
pub mut: pub mut:
_start_canary u32 _start_canary u32
color_attachments [4]C.sg_attachment_desc color_attachments [4]C.sg_pass_attachment_desc
depth_stencil_attachment C.sg_attachment_desc depth_stencil_attachment C.sg_pass_attachment_desc
label byteptr label byteptr
_end_canary u32 _end_canary u32
} }
@ -270,10 +312,10 @@ pub fn (p C.sg_pass) free() {
pub struct C.sg_buffer_desc { pub struct C.sg_buffer_desc {
pub mut: pub mut:
_start_canary u32 _start_canary u32
size int size size_t
@type BufferType @type BufferType
usage Usage usage Usage
content byteptr data C.sg_range
label byteptr label byteptr
// GL specific // GL specific
gl_buffers [2]u32 gl_buffers [2]u32
@ -307,12 +349,7 @@ pub mut:
render_target bool render_target bool
width int width int
height int height int
depth DepthLayers num_slices int
// depth int
// union {
// int depth;
// int layers;
// };
num_mipmaps int num_mipmaps int
usage Usage usage Usage
pixel_format PixelFormat pixel_format PixelFormat
@ -326,14 +363,18 @@ pub mut:
max_anisotropy u32 max_anisotropy u32
min_lod f32 min_lod f32
max_lod f32 max_lod f32
content C.sg_image_content data C.sg_image_data
label byteptr label byteptr
// GL specific // GL specific
gl_textures [2]u32 gl_textures [2]u32
gl_texture_target u32
// Metal specific // Metal specific
mtl_textures [2]voidptr mtl_textures [2]voidptr
// D3D11 specific // D3D11 specific
d3d11_texture voidptr d3d11_texture voidptr
d3d11_shader_resource_view voidptr
// WebGPU specific
wgpu_texture voidptr
_end_canary u32 _end_canary u32
} }
@ -354,26 +395,23 @@ pub fn (i C.sg_image) free() {
C.sg_destroy_image(i) C.sg_destroy_image(i)
} }
pub struct C.sg_image_content { pub struct C.sg_image_data {
pub mut: pub mut:
subimage [6][16]C.sg_subimage_content //subimage [C.SG_CUBEFACE_NUM][C.SG_MAX_MIPMAPS]C.sg_range
} subimage [6][16]C.sg_range
pub struct C.sg_subimage_content {
pub mut:
ptr voidptr // pointer to subimage data
size int // size in bytes of pointed-to subimage data
} }
pub struct C.sg_features { pub struct C.sg_features {
pub: pub:
instancing bool // hardware instancing supported instancing bool // hardware instancing supported
origin_top_left bool // framebuffer and texture origin is in top left corner 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 multiple_render_targets bool // offscreen render passes can have multiple render targets attached
msaa_render_targets bool // offscreen render passes support MSAA antialiasing msaa_render_targets bool // offscreen render passes support MSAA antialiasing
imagetype_3d bool // creation of SG_IMAGETYPE_3D images is supported imagetype_3d bool // creation of SG_IMAGETYPE_3D images is supported
imagetype_array bool // creation of SG_IMAGETYPE_ARRAY 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 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 { pub struct C.sg_limits {
@ -406,18 +444,25 @@ pub mut:
format VertexFormat format VertexFormat
} }
pub struct C.sg_depth_stencil_state { pub struct C.sg_stencil_state {
stencil_front C.sg_stencil_state enabled bool
stencil_back C.sg_stencil_state front C.sg_stencil_face_state
depth_compare_func CompareFunc back C.sg_stencil_face_state
depth_write_enabled bool read_mask byte
stencil_enabled bool write_mask byte
stencil_read_mask byte ref byte
stencil_write_mask byte
stencil_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 fail_op StencilOp
depth_fail_op StencilOp depth_fail_op StencilOp
pass_op StencilOp pass_op StencilOp
@ -433,28 +478,12 @@ pub mut:
src_factor_alpha BlendFactor src_factor_alpha BlendFactor
dst_factor_alpha BlendFactor dst_factor_alpha BlendFactor
op_alpha BlendOp 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 struct C.sg_color_attachment_action {
pub mut: pub mut:
action Action 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 struct C.sg_depth_attachment_action {
pub mut: pub mut:
action Action action Action
val f32 value f32
} }
pub struct C.sg_stencil_attachment_action { pub struct C.sg_stencil_attachment_action {
pub mut: pub mut:
action Action action Action
val byte value byte
} }
pub struct C.sg_pixelformat_info { pub struct C.sg_pixelformat_info {
@ -487,7 +516,7 @@ pub:
depth bool // pixel format is a depth format depth bool // pixel format is a depth format
} }
pub struct C.sg_attachment_desc { pub struct C.sg_pass_attachment_desc {
pub mut: pub mut:
image C.sg_image image C.sg_image
mip_level int 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 { 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{ mut color_action := C.sg_color_attachment_action{
action: gfx.Action(C.SG_ACTION_CLEAR) 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.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{} mut pass_action := C.sg_pass_action{}
pass_action.colors[0] = color_action pass_action.colors[0] = color_action
return pass_action return pass_action

8
vlib/sokol/sapp/sapp.v
View File

@ -10,7 +10,7 @@ pub const (
__global ( g_desc C.sapp_desc ) __global ( g_desc C.sapp_desc )
pub fn create_desc() C.sg_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() device: metal_get_device()
renderpass_descriptor_cb: metal_get_renderpass_descriptor renderpass_descriptor_cb: metal_get_renderpass_descriptor
drawable_cb: metal_get_drawable drawable_cb: metal_get_drawable
@ -23,7 +23,7 @@ pub fn create_desc() C.sg_desc {
} }
return C.sg_desc{ return C.sg_desc{
context: C.sg_context_desc{ context: C.sg_context_desc{
metal: mtl_desc metal: metal_desc
d3d11: d3d11_desc d3d11: d3d11_desc
} }
image_pool_size: 1000 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) // special run-function for SOKOL_NO_ENTRY (in standard mode this is an empty stub)
[inline] [inline]
pub fn run(desc &C.sapp_desc) int { pub fn run(desc &C.sapp_desc) {
g_desc = 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) // 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 fn C.sapp_isvalid() bool
/* returns the current framebuffer width in pixels */ /* returns the current framebuffer width in pixels */
fn C.sapp_width() int fn C.sapp_width() int
fn C.sapp_widthf() f32
/* returns the current framebuffer height in pixels */ /* returns the current framebuffer height in pixels */
fn C.sapp_height() int 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 */ /* returns true when high_dpi was requested and actually running in a high-dpi scenario */
fn C.sapp_high_dpi() bool fn C.sapp_high_dpi() bool
/* returns the dpi scaling factor (window pixels to framebuffer pixels) */ /* 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 () cleanup_cb fn ()
event_cb fn (&C.sapp_event) //&sapp_event) event_cb fn (&C.sapp_event) //&sapp_event)
fail_cb fn (&byte) fail_cb fn (&byte)
user_data voidptr // these are the user-provided callbacks with user data user_data voidptr // these are the user-provided callbacks with user data
init_userdata_cb fn (voidptr) init_userdata_cb fn (voidptr)
frame_userdata_cb fn (voidptr) frame_userdata_cb fn (voidptr)
cleanup_userdata_cb fn (voidptr) cleanup_userdata_cb fn (voidptr)
event_userdata_cb fn (&C.sapp_event, voidptr) event_userdata_cb fn (&C.sapp_event, voidptr)
fail_userdata_cb fn (&char, voidptr) fail_userdata_cb fn (&char, voidptr)
width int // the preferred width of the window / canvas width int // the preferred width of the window / canvas
height int // the preferred height of the window / canvas height int // the preferred height of the window / canvas
sample_count int // MSAA sample count sample_count int // MSAA sample count
@ -20,18 +22,26 @@ pub:
high_dpi bool // whether the rendering canvas is full-resolution on HighDPI displays high_dpi bool // whether the rendering canvas is full-resolution on HighDPI displays
fullscreen bool // whether the window should be created in fullscreen mode 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) 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 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 enable_clipboard bool // enable clipboard access, default is false
clipboard_size int // max size of clipboard content in bytes 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_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_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_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()) 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 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 /* V patches */
native_render bool __v_native_render bool // V patch to allow for native rendering
} }
pub struct Event { 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 */ /* render state functions */
fn C.sgl_viewport(x int, y int, w int, h int, origin_top_left bool) 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_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_enable_texture()
fn C.sgl_disable_texture() fn C.sgl_disable_texture()
fn C.sgl_texture(img C.sg_image) fn C.sgl_texture(img C.sg_image)

12
vlib/x/ttf/render_sokol_cpu.v
View File

@ -10,7 +10,7 @@ module ttf
* *
* Note: * Note:
* *
* TODO: * TODO:
**********************************************************************/ **********************************************************************/
import math import math
import gg import gg
@ -131,9 +131,9 @@ pub fn (mut tf_skl TTF_render_Sokol) create_texture() {
d3d11_texture: 0 d3d11_texture: 0
} }
// comment for dynamic // 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 ptr: tf_skl.bmp.buf
size: sz size: size_t(sz)
} }
simg := C.sg_make_image(&img_desc) 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 // Use only if usage: .dynamic
pub fn (mut tf_skl TTF_render_Sokol) update_text_texture() { pub fn (mut tf_skl TTF_render_Sokol) update_text_texture() {
sz := tf_skl.bmp.width * tf_skl.bmp.height * tf_skl.bmp.bp sz := tf_skl.bmp.width * tf_skl.bmp.height * tf_skl.bmp.bp
mut tmp_sbc := C.sg_image_content{} mut tmp_sbc := C.sg_image_data{}
tmp_sbc.subimage[0][0] = C.sg_subimage_content{ tmp_sbc.subimage[0][0] = C.sg_range{
ptr: tf_skl.bmp.buf ptr: tf_skl.bmp.buf
size: sz size: size_t(sz)
} }
C.sg_update_image(tf_skl.sg_img, &tmp_sbc) C.sg_update_image(tf_skl.sg_img, &tmp_sbc)
} }