/********************************************************************** * * Sokol 3d cube demo * * Copyright (c) 2021 Dario Deledda. All rights reserved. * Use of this source code is governed by an MIT license * that can be found in the LICENSE file. * * HOW TO COMPILE SHADERS: * Run `v shader .` in this directory to compile the shaders. * For more info and help with shader compilation see `docs.md` and `v help shader`. * * TODO: * - add instancing **********************************************************************/ import gg import gx // import math import sokol.sapp import sokol.gfx import sokol.sgl import time import gg.m4 // GLSL Include and functions #flag -I @VMODROOT/. #include "cube_glsl.h" # Should be generated with `v shader .` (see the instructions at the top of this file) fn C.cube_shader_desc(gfx.Backend) &gfx.ShaderDesc const ( win_width = 800 win_height = 800 bg_color = gx.white ) struct App { mut: gg &gg.Context = unsafe { nil } pip_3d sgl.Pipeline texture gfx.Image init_flag bool frame_count int mouse_x int = -1 mouse_y int = -1 // glsl cube_pip_glsl gfx.Pipeline cube_bind gfx.Bindings // time ticks i64 } /****************************************************************************** * * Texture functions * ******************************************************************************/ fn create_texture(w int, h int, buf &byte) gfx.Image { sz := w * h * 4 mut img_desc := gfx.ImageDesc{ width: w height: h num_mipmaps: 0 min_filter: .linear mag_filter: .linear // usage: .dynamic wrap_u: .clamp_to_edge wrap_v: .clamp_to_edge label: &u8(0) d3d11_texture: 0 } // comment if .dynamic is enabled img_desc.data.subimage[0][0] = gfx.Range{ ptr: buf size: usize(sz) } sg_img := gfx.make_image(&img_desc) return sg_img } fn destroy_texture(sg_img gfx.Image) { gfx.destroy_image(sg_img) } // Use only if usage: .dynamic is enabled fn update_text_texture(sg_img gfx.Image, w int, h int, buf &byte) { sz := w * h * 4 mut tmp_sbc := gfx.ImageData{} tmp_sbc.subimage[0][0] = gfx.Range{ ptr: buf size: usize(sz) } gfx.update_image(sg_img, &tmp_sbc) } /****************************************************************************** * * Draw functions * ******************************************************************************/ fn draw_triangle() { sgl.defaults() sgl.begin_triangles() { // vfmt off sgl.v2f_c3b( 0.0, 0.5, 255, 0 , 0 ) sgl.v2f_c3b(-0.5, -0.5, 0, 0 , 255) sgl.v2f_c3b( 0.5, -0.5, 0, 255, 0 ) // vfmt on } sgl.end() } // vertex specification for a cube with colored sides and texture coords fn cube() { sgl.begin_quads() { // vfmt off sgl.c3f(1.0, 0.0, 0.0) // edge color // edge coordinates // x,y,z, texture cord: u,v sgl.v3f_t2f(-1.0, 1.0, -1.0, -1.0, 1.0) sgl.v3f_t2f( 1.0, 1.0, -1.0, 1.0, 1.0) sgl.v3f_t2f( 1.0, -1.0, -1.0, 1.0, -1.0) sgl.v3f_t2f(-1.0, -1.0, -1.0, -1.0, -1.0) sgl.c3f(0.0, 1.0, 0.0) sgl.v3f_t2f(-1.0, -1.0, 1.0, -1.0, 1.0) sgl.v3f_t2f( 1.0, -1.0, 1.0, 1.0, 1.0) sgl.v3f_t2f( 1.0, 1.0, 1.0, 1.0, -1.0) sgl.v3f_t2f(-1.0, 1.0, 1.0, -1.0, -1.0) sgl.c3f(0.0, 0.0, 1.0) sgl.v3f_t2f(-1.0, -1.0, 1.0, -1.0, 1.0) sgl.v3f_t2f(-1.0, 1.0, 1.0, 1.0, 1.0) sgl.v3f_t2f(-1.0, 1.0, -1.0, 1.0, -1.0) sgl.v3f_t2f(-1.0, -1.0, -1.0, -1.0, -1.0) sgl.c3f(1.0, 0.5, 0.0) sgl.v3f_t2f(1.0, -1.0, 1.0, -1.0, 1.0) sgl.v3f_t2f(1.0, -1.0, -1.0, 1.0, 1.0) sgl.v3f_t2f(1.0, 1.0, -1.0, 1.0, -1.0) sgl.v3f_t2f(1.0, 1.0, 1.0, -1.0, -1.0) sgl.c3f(0.0, 0.5, 1.0) sgl.v3f_t2f( 1.0, -1.0, -1.0, -1.0, 1.0) sgl.v3f_t2f( 1.0, -1.0, 1.0, 1.0, 1.0) sgl.v3f_t2f(-1.0, -1.0, 1.0, 1.0, -1.0) sgl.v3f_t2f(-1.0, -1.0, -1.0, -1.0, -1.0) sgl.c3f(1.0, 0.0, 0.5) sgl.v3f_t2f(-1.0, 1.0, -1.0, -1.0, 1.0) sgl.v3f_t2f(-1.0, 1.0, 1.0, 1.0, 1.0) sgl.v3f_t2f( 1.0, 1.0, 1.0, 1.0, -1.0) sgl.v3f_t2f( 1.0, 1.0, -1.0, -1.0, -1.0) // vfmt on } sgl.end() } fn draw_cubes(app App) { rot := [f32(1.0) * (app.frame_count % 360), 0.5 * f32(app.frame_count % 360)] // rot := [f32(app.mouse_x), f32(app.mouse_y)] sgl.defaults() sgl.load_pipeline(app.pip_3d) sgl.matrix_mode_projection() sgl.perspective(sgl.rad(45.0), 1.0, 0.1, 100.0) sgl.matrix_mode_modelview() sgl.translate(0.0, 0.0, -12.0) sgl.rotate(sgl.rad(rot[0]), 1.0, 0.0, 0.0) sgl.rotate(sgl.rad(rot[1]), 0.0, 1.0, 0.0) cube() sgl.push_matrix() { sgl.translate(0.0, 0.0, 3.0) sgl.scale(0.5, 0.5, 0.5) sgl.rotate(-2.0 * sgl.rad(rot[0]), 1.0, 0.0, 0.0) sgl.rotate(-2.0 * sgl.rad(rot[1]), 0.0, 1.0, 0.0) cube() sgl.push_matrix() { sgl.translate(0.0, 0.0, 3.0) sgl.scale(0.5, 0.5, 0.5) // vfmt off sgl.rotate(-3.0 * sgl.rad(2 * rot[0]), 1.0, 0.0, 0.0) sgl.rotate( 3.0 * sgl.rad(2 * rot[1]), 0.0, 0.0, 1.0) // vfmt on cube() } sgl.pop_matrix() } sgl.pop_matrix() } fn cube_texture(r f32, g f32, b f32) { sgl.begin_quads() { sgl.c3f(r, g, b) // edge color // edge coord // x,y,z, texture cord: u,v // vfmt off sgl.v3f_t2f(-1.0, 1.0, -1.0, 0.0 , 0.25) sgl.v3f_t2f( 1.0, 1.0, -1.0, 0.25, 0.25) sgl.v3f_t2f( 1.0, -1.0, -1.0, 0.25, 0.0 ) sgl.v3f_t2f(-1.0, -1.0, -1.0, 0.0 , 0.0 ) sgl.c3f(r, g, b) sgl.v3f_t2f(-1.0, -1.0, 1.0, 0.0 , 0.25) sgl.v3f_t2f( 1.0, -1.0, 1.0, 0.25, 0.25) sgl.v3f_t2f( 1.0, 1.0, 1.0, 0.25, 0.0 ) sgl.v3f_t2f(-1.0, 1.0, 1.0, 0.0 , 0.0 ) sgl.c3f(r, g, b) sgl.v3f_t2f(-1.0, -1.0, 1.0, 0.0 , 0.25) sgl.v3f_t2f(-1.0, 1.0, 1.0, 0.25, 0.25) sgl.v3f_t2f(-1.0, 1.0, -1.0, 0.25, 0.0 ) sgl.v3f_t2f(-1.0, -1.0, -1.0, 0.0 , 0.0 ) sgl.c3f(r, g, b) sgl.v3f_t2f(1.0, -1.0, 1.0, 0.0 , 0.25) sgl.v3f_t2f(1.0, -1.0, -1.0, 0.25, 0.25) sgl.v3f_t2f(1.0, 1.0, -1.0, 0.25, 0.0 ) sgl.v3f_t2f(1.0, 1.0, 1.0, 0.0 , 0.0 ) sgl.c3f(r, g, b) sgl.v3f_t2f( 1.0, -1.0, -1.0, 0.0 , 0.25) sgl.v3f_t2f( 1.0, -1.0, 1.0, 0.25, 0.25) sgl.v3f_t2f(-1.0, -1.0, 1.0, 0.25, 0.0 ) sgl.v3f_t2f(-1.0, -1.0, -1.0, 0.0 , 0.0 ) sgl.c3f(r, g, b) sgl.v3f_t2f(-1.0, 1.0, -1.0, 0.0 , 0.25) sgl.v3f_t2f(-1.0, 1.0, 1.0, 0.25, 0.25) sgl.v3f_t2f( 1.0, 1.0, 1.0, 0.25, 0.0 ) sgl.v3f_t2f( 1.0, 1.0, -1.0, 0.0 , 0.0 ) // vfmt on } sgl.end() } /* Cube vertex buffer with packed vertex formats for color and texture coords. Note that a vertex format which must be portable across all backends must only use the normalized integer formats (BYTE4N, UBYTE4N, SHORT2N, SHORT4N), which can be converted to floating point formats in the vertex shader inputs. The reason is that D3D11 cannot convert from non-normalized formats to floating point inputs (only to integer inputs), and WebGL2 / GLES2 don't support integer vertex shader inputs. */ struct Vertex_t { x f32 y f32 z f32 color u32 // u u16 // v u16 u f32 v f32 } fn init_cube_glsl(mut app App) { // cube vertex buffer // d := u16(32767/8) // for compatibility with D3D11, 32767 stand for 1 d := f32(1.0) // 0.05) c := u32(0xFFFFFF_FF) // color RGBA8 // vfmt off vertices := [ // Face 0 Vertex_t{-1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{ 1.0, -1.0, -1.0, c, d, 0}, Vertex_t{ 1.0, 1.0, -1.0, c, d, d}, Vertex_t{-1.0, 1.0, -1.0, c, 0, d}, // Face 1 Vertex_t{-1.0, -1.0, 1.0, c, 0, 0}, Vertex_t{ 1.0, -1.0, 1.0, c, d, 0}, Vertex_t{ 1.0, 1.0, 1.0, c, d, d}, Vertex_t{-1.0, 1.0, 1.0, c, 0, d}, // Face 2 Vertex_t{-1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{-1.0, 1.0, -1.0, c, d, 0}, Vertex_t{-1.0, 1.0, 1.0, c, d, d}, Vertex_t{-1.0, -1.0, 1.0, c, 0, d}, // Face 3 Vertex_t{ 1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{ 1.0, 1.0, -1.0, c, d, 0}, Vertex_t{ 1.0, 1.0, 1.0, c, d, d}, Vertex_t{ 1.0, -1.0, 1.0, c, 0, d}, // Face 4 Vertex_t{-1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{-1.0, -1.0, 1.0, c, d, 0}, Vertex_t{ 1.0, -1.0, 1.0, c, d, d}, Vertex_t{ 1.0, -1.0, -1.0, c, 0, d}, // Face 5 Vertex_t{-1.0, 1.0, -1.0, c, 0, 0}, Vertex_t{-1.0, 1.0, 1.0, c, d, 0}, Vertex_t{ 1.0, 1.0, 1.0, c, d, d}, Vertex_t{ 1.0, 1.0, -1.0, c, 0, d}, ] // vfmt on mut vert_buffer_desc := gfx.BufferDesc{ label: c'cube-vertices' } unsafe { vmemset(&vert_buffer_desc, 0, int(sizeof(vert_buffer_desc))) } vert_buffer_desc.size = usize(vertices.len * int(sizeof(Vertex_t))) vert_buffer_desc.data = gfx.Range{ ptr: vertices.data size: usize(vertices.len * int(sizeof(Vertex_t))) } vert_buffer_desc.@type = .vertexbuffer // vert_buffer_desc.usage = .immutable vbuf := gfx.make_buffer(&vert_buffer_desc) // create an index buffer for the cube // vfmt off indices := [ u16(0), 1, 2, 0, 2, 3, 6, 5, 4, 7, 6, 4, 8, 9, 10, 8, 10, 11, 14, 13, 12, 15, 14, 12, 16, 17, 18, 16, 18, 19, 22, 21, 20, 23, 22, 20, ] // vfmt on mut index_buffer_desc := gfx.BufferDesc{ label: c'cube-indices' } unsafe { vmemset(&index_buffer_desc, 0, int(sizeof(index_buffer_desc))) } index_buffer_desc.size = usize(indices.len * int(sizeof(u16))) index_buffer_desc.data = gfx.Range{ ptr: indices.data size: usize(indices.len * int(sizeof(u16))) } index_buffer_desc.@type = .indexbuffer ibuf := gfx.make_buffer(&index_buffer_desc) // create shader shader := gfx.make_shader(C.cube_shader_desc(C.sg_query_backend())) mut pipdesc := gfx.PipelineDesc{} unsafe { vmemset(&pipdesc, 0, int(sizeof(pipdesc))) } pipdesc.layout.buffers[0].stride = int(sizeof(Vertex_t)) // the constants [C.ATTR_vs_pos, C.ATTR_vs_color0, C.ATTR_vs_texcoord0] are generated bysokol-shdc pipdesc.layout.attrs[C.ATTR_vs_pos].format = .float3 // x,y,z as f32 pipdesc.layout.attrs[C.ATTR_vs_color0].format = .ubyte4n // color as u32 pipdesc.layout.attrs[C.ATTR_vs_texcoord0].format = .float2 // u,v as f32 // pipdesc.layout.attrs[C.ATTR_vs_texcoord0].format = .short2n // u,v as u16 pipdesc.shader = shader pipdesc.index_type = .uint16 pipdesc.depth = gfx.DepthState{ write_enabled: true compare: .less_equal } pipdesc.cull_mode = .back pipdesc.label = 'glsl_shader pipeline'.str app.cube_bind.vertex_buffers[0] = vbuf app.cube_bind.index_buffer = ibuf app.cube_bind.fs_images[C.SLOT_tex] = app.texture app.cube_pip_glsl = gfx.make_pipeline(&pipdesc) println('GLSL init DONE!') } fn draw_cube_glsl(app App) { if app.init_flag == false { return } // clear ws := gg.window_size_real_pixels() mut color_action := gfx.ColorAttachmentAction{ action: unsafe { gfx.Action(C.SG_ACTION_DONTCARE) } // C.SG_ACTION_CLEAR) value: gfx.Color{ r: 1.0 g: 1.0 b: 1.0 a: 1.0 } } mut pass_action := gfx.PassAction{} pass_action.colors[0] = color_action gfx.begin_default_pass(&pass_action, ws.width, ws.height) { rot := [f32(app.mouse_y), f32(app.mouse_x)] // ratio := f32(ws.width)/ws.height dw := f32(ws.width / 2) dh := f32(ws.height / 2) tr_matrix := m4.calc_tr_matrices(dw, dh, rot[0], rot[1], 2.0) gfx.apply_viewport(ws.width / 2, 0, ws.width / 2, ws.height / 2, true) // apply the pipeline and bindings gfx.apply_pipeline(app.cube_pip_glsl) gfx.apply_bindings(app.cube_bind) // Uniforms: // passing the view matrix as uniform // res is a 4x4 matrix of f32 thus: 4*16 byte of size vs_uniforms_range := gfx.Range{ ptr: &tr_matrix size: usize(4 * 16) } gfx.apply_uniforms(.vs, C.SLOT_vs_params, &vs_uniforms_range) // fs uniforms time_ticks := f32(time.ticks() - app.ticks) / 1000 mut text_res := [ f32(512), 512, /* x,y resolution to pass to FS */ time_ticks, /* time as f32 */ 0 /* padding 4 Bytes == 1 f32 */, ]! fs_uniforms_range := gfx.Range{ ptr: unsafe { &text_res } size: usize(4 * 4) } gfx.apply_uniforms(.fs, C.SLOT_fs_params, &fs_uniforms_range) gfx.draw(0, (3 * 2) * 6, 1) } gfx.end_pass() gfx.commit() } fn draw_texture_cubes(app App) { rot := [f32(app.mouse_x), f32(app.mouse_y)] sgl.defaults() sgl.load_pipeline(app.pip_3d) sgl.enable_texture() sgl.texture(app.texture) sgl.matrix_mode_projection() sgl.perspective(sgl.rad(45.0), 1.0, 0.1, 100.0) sgl.matrix_mode_modelview() sgl.translate(0.0, 0.0, -12.0) sgl.rotate(sgl.rad(rot[0]), 1.0, 0.0, 0.0) sgl.rotate(sgl.rad(rot[1]), 0.0, 1.0, 0.0) cube_texture(1, 1, 1) sgl.push_matrix() { sgl.translate(0.0, 0.0, 3.0) sgl.scale(0.5, 0.5, 0.5) sgl.rotate(-2.0 * sgl.rad(rot[0]), 1.0, 0.0, 0.0) sgl.rotate(-2.0 * sgl.rad(rot[1]), 0.0, 1.0, 0.0) cube_texture(1, 1, 1) sgl.push_matrix() { sgl.translate(0.0, 0.0, 3.0) sgl.scale(0.5, 0.5, 0.5) // vfmt off sgl.rotate(-3.0 * sgl.rad(2 * rot[0]), 1.0, 0.0, 0.0) sgl.rotate( 3.0 * sgl.rad(2 * rot[1]), 0.0, 0.0, 1.0) // vfmt on cube_texture(1, 1, 1) } sgl.pop_matrix() } sgl.pop_matrix() sgl.disable_texture() } fn frame(mut app App) { ws := gg.window_size_real_pixels() ratio := f32(ws.width) / ws.height dw := ws.width dh := ws.height ww := int(dh / 3) // not a bug hh := int(dh / 3) x0 := int(f32(dw) * 0.05) // x1 := dw/2 y0 := 0 y1 := int(f32(dh) * 0.5) // app.gg.begin() app.gg.begin() { sgl.defaults() // 2d triangle sgl.viewport(x0, y0, ww, hh, true) draw_triangle() // colored cubes with viewport sgl.viewport(x0, y1, ww, hh, true) draw_cubes(app) // textured cubed with viewport sgl.viewport(0, int(dh / 5), dw, int(dh * ratio), true) draw_texture_cubes(app) } app.gg.end() // glsl cube draw_cube_glsl(app) app.frame_count++ } /****************************************************************************** * Init / Cleanup ******************************************************************************/ fn my_init(mut app App) { // set max vertices, // for a large number of the same type of object it is better use the instances!! desc := sapp.create_desc() gfx.setup(&desc) sgl_desc := sgl.Desc{ max_vertices: 50 * 65536 } sgl.setup(&sgl_desc) // 3d pipeline mut pipdesc := gfx.PipelineDesc{} unsafe { vmemset(&pipdesc, 0, int(sizeof(pipdesc))) } color_state := gfx.ColorState{ blend: gfx.BlendState{ enabled: true src_factor_rgb: .src_alpha dst_factor_rgb: .one_minus_src_alpha } } pipdesc.colors[0] = color_state pipdesc.depth = gfx.DepthState{ write_enabled: true compare: .less_equal } pipdesc.cull_mode = .back app.pip_3d = sgl.make_pipeline(&pipdesc) // create chessboard texture 256*256 RGBA w := 256 h := 256 sz := w * h * 4 tmp_txt := unsafe { malloc(sz) } mut i := 0 for i < sz { unsafe { y := (i >> 0x8) >> 5 // 8 cell x := (i & 0xFF) >> 5 // 8 cell // upper left corner if x == 0 && y == 0 { tmp_txt[i] = u8(0xFF) tmp_txt[i + 1] = u8(0) tmp_txt[i + 2] = u8(0) tmp_txt[i + 3] = u8(0xFF) } // low right corner else if x == 7 && y == 7 { tmp_txt[i + 0] = u8(0) tmp_txt[i + 1] = u8(0xFF) tmp_txt[i + 2] = u8(0) tmp_txt[i + 3] = u8(0xFF) } else { col := if ((x + y) & 1) == 1 { 0xFF } else { 128 } tmp_txt[i + 0] = u8(col) // red tmp_txt[i + 1] = u8(col) // green tmp_txt[i + 2] = u8(col) // blue tmp_txt[i + 3] = u8(0xFF) // alpha } i += 4 } } app.texture = create_texture(w, h, tmp_txt) unsafe { free(tmp_txt) } // glsl init_cube_glsl(mut app) app.init_flag = true } /****************************************************************************** * event ******************************************************************************/ fn my_event_manager(mut ev gg.Event, mut app App) { if ev.typ == .mouse_move { app.mouse_x = int(ev.mouse_x) app.mouse_y = int(ev.mouse_y) } if ev.typ == .touches_began || ev.typ == .touches_moved { if ev.num_touches > 0 { touch_point := ev.touches[0] app.mouse_x = int(touch_point.pos_x) app.mouse_y = int(touch_point.pos_y) } } } fn main() { // App init mut app := &App{ gg: 0 } mut a := [5]int{} a[0] = 2 println(a) app.gg = gg.new_context( width: win_width height: win_height create_window: true window_title: '3D Cube Demo' user_data: app bg_color: bg_color frame_fn: frame init_fn: my_init event_fn: my_event_manager ) app.ticks = time.ticks() app.gg.run() }