desk2/client/webgl_draw.js

function schedule_draw(state, context) {
    if (!state.timers.raf) {
        window.requestAnimationFrame(() => {
            draw(state, context)
        });
        state.timers.raf = true;
    }
}

function upload_if_needed(gl, buffer_kind, serializer) {
    if (serializer.need_gpu_allocate) {
        if (config.debug_print) console.debug('gpu allocate');
        gl.bufferData(buffer_kind, serializer.size, gl.DYNAMIC_DRAW);
        serializer.need_gpu_allocate = false;
        serializer.gpu_upload_from = 0;
    }

    if (serializer.gpu_upload_from < serializer.offset) {
        if (config.debug_print) console.debug('gpu upload');
        const upload_offset = serializer.gpu_upload_from;
        const upload_size = serializer.offset - upload_offset;
        gl.bufferSubData(buffer_kind, upload_offset, new Uint8Array(serializer.buffer, upload_offset, upload_size));
        serializer.gpu_upload_from = serializer.offset;
    }
}

function upload_square_rgba16ui_texture(gl, serializer, texture_size) {
    const bpp = 2 * 4;
    const data_size = serializer.offset;
    const data_pixels = data_size / bpp; // data_size % bpp is expected to always be zero here

    const rows = Math.ceil(data_pixels / texture_size);
    const last_row = data_pixels % texture_size;
    const whole_upload = (rows - 1) * texture_size * bpp;

    // Upload whole rows
    if (rows > 1) {
        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, texture_size, rows - 1, gl.RGBA_INTEGER, gl.UNSIGNED_SHORT, new Uint16Array(serializer.buffer, 0, whole_upload / 2));
    }

    // Upload last row
    if (last_row > 0) {        
        const last_row_upload = last_row * bpp;
        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, rows - 1, last_row, 1, gl.RGBA_INTEGER, gl.UNSIGNED_SHORT, new Uint16Array(serializer.buffer, whole_upload, last_row_upload / 2));
    }
}

function draw(state, context) {
    const cpu_before = performance.now();

    state.timers.raf = false;

    const gl = context.gl;
    const width = window.innerWidth;
    const height = window.innerHeight;
    
    let query = null;

    if (context.gpu_timer_ext !== null) {
        query = gl.createQuery();
        gl.beginQuery(context.gpu_timer_ext.TIME_ELAPSED_EXT, query);
    }
       
    gl.viewport(0, 0, context.canvas.width, context.canvas.height);
    gl.clearColor(context.bgcolor.r, context.bgcolor.g, context.bgcolor.b, 1);
    gl.clearDepth(0.0);
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);


    locations = context.locations['sdf'].main;
    buffers = context.buffers['sdf'];

    gl.useProgram(context.programs['sdf'].main);


    bvh_clip(state, context); 
    const segment_count = geometry_write_instances(state, context);

    // TODO: maybe have a pool of buffers (pow2?) and select an appropriate one
    gl.bindBuffer(gl.ARRAY_BUFFER, buffers['b_instance']);
    gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array(context.instance_data.buffer, 0, segment_count * config.bytes_per_instance), gl.DYNAMIC_DRAW);

    gl.uniform2f(locations['u_res'], context.canvas.width, context.canvas.height);
    gl.uniform2f(locations['u_scale'], state.canvas.zoom, state.canvas.zoom);
    gl.uniform2f(locations['u_translation'], state.canvas.offset.x, state.canvas.offset.y);
    gl.uniform1i(locations['u_stroke_count'], state.events.length);
    gl.uniform1i(locations['u_debug_mode'], state.debug.red);
    gl.uniform1i(locations['u_stroke_data'], 0);
    gl.uniform1i(locations['u_stroke_texture_size'], config.stroke_texture_size);

    gl.enableVertexAttribArray(locations['a_ab']);
    gl.enableVertexAttribArray(locations['a_stroke_id']);

    gl.vertexAttribPointer(locations['a_ab'],         4, gl.FLOAT,        false, config.bytes_per_instance, 0);
    gl.vertexAttribIPointer(locations['a_stroke_id'], 1, gl.INT,                 config.bytes_per_instance, 4 * 4);

    gl.vertexAttribDivisor(locations['a_ab'], 1);
    gl.vertexAttribDivisor(locations['a_stroke_id'], 1);

    gl.bindTexture(gl.TEXTURE_2D, context.textures['stroke_data']);
    // TODO: this is stable data, only upload new strokes as they arrive
    upload_square_rgba16ui_texture(gl, context.stroke_data, config.stroke_texture_size);
    gl.activeTexture(gl.TEXTURE0);

    gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, segment_count); // TODO: based on clipping results
    
    document.getElementById('debug-stats').innerHTML = `
    <span>Segments onscreen: ${segment_count}</span>
    <span>Canvas offset: (${state.canvas.offset.x}, ${state.canvas.offset.y})</span>
    <span>Canvas zoom: ${Math.round(state.canvas.zoom * 100000) / 100000}</span>`;


    /*
    const after_clip = performance.now();

    gl.bindBuffer(gl.ARRAY_BUFFER, lod.data_buffer);
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, lod.index_buffer);

    upload_if_needed(gl, gl.ARRAY_BUFFER, lod.vertices);
    upload_if_needed(gl, gl.ELEMENT_ARRAY_BUFFER, lod.indices);
   
   
    if (index_count > 0) {
        // DEPTH PREPASS
        if (state.debug.do_prepass) {
            gl.drawBuffers([gl.NONE]);

            locations = context.locations['sdf'].opaque;

            gl.useProgram(context.programs['sdf'].opaque);

            gl.uniform2f(locations['u_res'], context.canvas.width, context.canvas.height);
            gl.uniform2f(locations['u_scale'], state.canvas.zoom, state.canvas.zoom);
            gl.uniform2f(locations['u_translation'], state.canvas.offset.x, state.canvas.offset.y);
            gl.uniform1i(locations['u_stroke_count'], state.stroke_count);

            gl.enableVertexAttribArray(locations['a_pos']);
            gl.enableVertexAttribArray(locations['a_line']);
            gl.enableVertexAttribArray(locations['a_stroke_id']);

            gl.vertexAttribPointer(locations['a_pos'],        3, gl.FLOAT,         false, config.bytes_per_point, 0);
            gl.vertexAttribPointer(locations['a_line'],       4, gl.FLOAT,         false, config.bytes_per_point, 4 * 3);
            gl.vertexAttribIPointer(locations['a_stroke_id'], 1, gl.INT,                  config.bytes_per_point, 4 * 3 + 4 * 4 + 4);

            gl.drawElements(gl.TRIANGLES, index_count, gl.UNSIGNED_INT, 0);
        }

        // MAIN PASS
        gl.drawBuffers([gl.BACK]);

        locations = context.locations['sdf'].main;

        gl.useProgram(context.programs['sdf'].main);

        gl.uniform2f(locations['u_res'], context.canvas.width, context.canvas.height);
        gl.uniform2f(locations['u_scale'], state.canvas.zoom, state.canvas.zoom);
        gl.uniform2f(locations['u_translation'], state.canvas.offset.x, state.canvas.offset.y);
        gl.uniform1i(locations['u_stroke_count'], state.stroke_count);
        gl.uniform1i(locations['u_debug_mode'], state.debug.red);

        gl.enableVertexAttribArray(locations['a_pos']);
        gl.enableVertexAttribArray(locations['a_line']);
        gl.enableVertexAttribArray(locations['a_color']);
        gl.enableVertexAttribArray(locations['a_stroke_id']);

        gl.vertexAttribPointer(locations['a_pos'],        3, gl.FLOAT,         false, config.bytes_per_point, 0);
        gl.vertexAttribPointer(locations['a_line'],       4, gl.FLOAT,         false, config.bytes_per_point, 4 * 3);
        gl.vertexAttribPointer(locations['a_color'],      3, gl.UNSIGNED_BYTE, true,  config.bytes_per_point, 4 * 3 + 4 * 4);
        gl.vertexAttribIPointer(locations['a_stroke_id'], 1, gl.INT,                  config.bytes_per_point, 4 * 3 + 4 * 4 + 4);

        //index_buffer.reverse();
        gl.drawElements(gl.TRIANGLES, index_count, gl.UNSIGNED_INT, 0);
    }
*/
    /*
    // Dynamic data (stroke previews that are currently in progress)
    const dynamic_points = context.dynamic_serializer.offset / config.bytes_per_point;

    if (dynamic_points > 0) {
        gl.drawBuffers([gl.BACK]);

        locations = context.locations['sdf'].main;

        gl.useProgram(context.programs['sdf'].main);

        gl.uniform2f(locations['u_res'], context.canvas.width, context.canvas.height);
        gl.uniform2f(locations['u_scale'], state.canvas.zoom, state.canvas.zoom);
        gl.uniform2f(locations['u_translation'], state.canvas.offset.x, state.canvas.offset.y);
        gl.uniform1i(locations['u_stroke_count'], state.stroke_count);
        gl.uniform1i(locations['u_debug_mode'], state.debug.red);

        gl.clear(gl.DEPTH_BUFFER_BIT);

        gl.bindBuffer(gl.ARRAY_BUFFER, buffers['b_packed_dynamic']);
        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffers['b_packed_dynamic_index']);

        gl.enableVertexAttribArray(locations['a_pos']);
        gl.enableVertexAttribArray(locations['a_line']);
        gl.enableVertexAttribArray(locations['a_color']);
        gl.enableVertexAttribArray(locations['a_stroke_id']);

        gl.vertexAttribPointer(locations['a_pos'],        3, gl.FLOAT,         false, config.bytes_per_point, 0);
        gl.vertexAttribPointer(locations['a_line'],       4, gl.FLOAT,         false, config.bytes_per_point, 4 * 3);
        gl.vertexAttribPointer(locations['a_color'],      3, gl.UNSIGNED_BYTE, true,  config.bytes_per_point, 4 * 3 + 4 * 4);
        gl.vertexAttribIPointer(locations['a_stroke_id'], 1, gl.INT,                  config.bytes_per_point, 4 * 3 + 4 * 4 + 4);

        const dynamic_indices = [];
        let base = 0;

        for (const player_id in state.players) {
            // player has the same data as their current stroke: points, color, width
            const player = state.players[player_id];
            if (player.points.length > 1) {
                for (let i = 0; i < player.points.length - 1; ++i) {
                    dynamic_indices.push(base + 0);
                    dynamic_indices.push(base + 1);
                    dynamic_indices.push(base + 2);
                    dynamic_indices.push(base + 3);
                    dynamic_indices.push(base + 2);
                    dynamic_indices.push(base + 1);

                    base += 4;
                }
            }
        }


        if (context.need_dynamic_upload) {
            gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array(context.dynamic_serializer.buffer, 0, context.dynamic_serializer.offset), gl.DYNAMIC_DRAW);
            gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint32Array(dynamic_indices), gl.DYNAMIC_DRAW);
            context.need_dynamic_upload = false;
        }

        gl.drawElements(gl.TRIANGLES, dynamic_indices.length, gl.UNSIGNED_INT, 0);
    }
*/

    if (state.debug.draw_bvh) {
        const points = new Float32Array(state.bvh.nodes.length * 6 * 2);

        for (let i = 0; i < state.bvh.nodes.length; ++i) {
            const box = state.bvh.nodes[i].bbox;
            
            points[i * 12 + 0] = box.x1;
            points[i * 12 + 1] = box.y1;
            points[i * 12 + 2] = box.x2;
            points[i * 12 + 3] = box.y1;
            points[i * 12 + 4] = box.x1;
            points[i * 12 + 5] = box.y2;

            points[i * 12 + 6] = box.x2;
            points[i * 12 + 7] = box.y2;
            points[i * 12 + 8] = box.x1;
            points[i * 12 + 9] = box.y2;
            points[i * 12 + 10] = box.x2;
            points[i * 12 + 11] = box.y1;
        }

        locations = context.locations['debug'];
        buffers = context.buffers['debug'];

        gl.useProgram(context.programs['debug']);
        gl.bindBuffer(gl.ARRAY_BUFFER, buffers['b_packed']);

        gl.uniform2f(locations['u_res'], context.canvas.width, context.canvas.height);
        gl.uniform2f(locations['u_scale'], state.canvas.zoom, state.canvas.zoom);
        gl.uniform2f(locations['u_translation'], state.canvas.offset.x, state.canvas.offset.y);

        gl.enableVertexAttribArray(locations['a_pos']);
        gl.vertexAttribPointer(locations['a_pos'], 2, gl.FLOAT, false, 8, 0);
       
        gl.clear(gl.DEPTH_BUFFER_BIT);
        gl.bufferData(gl.ARRAY_BUFFER, points, gl.STATIC_DRAW);
        gl.drawArrays(gl.TRIANGLES, 0, points.length / 2);
    }
  
    if (context.gpu_timer_ext) {
        gl.endQuery(context.gpu_timer_ext.TIME_ELAPSED_EXT);

        const next_tick = () => {
            if (query) {
                // At some point in the future, after returning control to the browser
                const available = gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
                const disjoint = gl.getParameter(context.gpu_timer_ext.GPU_DISJOINT_EXT);

                if (available && !disjoint) {
                    // See how much time the rendering of the object took in nanoseconds.
                    const timeElapsed = gl.getQueryParameter(query, gl.QUERY_RESULT);
                    //console.debug(timeElapsed / 1000000);
                    document.querySelector('.debug-timings .gpu').innerHTML = 'Last GPU Frametime: ' + Math.round(timeElapsed / 10000) / 100 + 'ms';
                }

                if (available || disjoint) {
                    // Clean up the query object.
                    gl.deleteQuery(query);
                    // Don't re-enter this polling loop.
                    query = null;
                } else if (!available) {
                    setTimeout(next_tick, 0);
                }
            }
        }

        setTimeout(next_tick, 0);
    }
    
    const cpu_after = performance.now();


    document.querySelector('.debug-timings .cpu').innerHTML = 'Last CPU Frametime: ' + Math.round((cpu_after - cpu_before) * 100) / 100 + 'ms';
}