paniq

using import struct
typedef FILE

let
    FILE* = (mutable pointer FILE)
    SEEK_SET = 0
    SEEK_CUR = 1
    SEEK_END = 2

paniq

using import ..tukan.libc
using import ..tukan.ode
using import ..tukan.sdl

let NUM_CONTACTS = 3

let world = (dWorldCreate)
assert (world != null)

paniq

#-------------------------------------------------------------------------------
    implicit cube-to-simplex subdivision

fn cube-simplex (pred)
    """"ivec3 ivec3 ivec3 ivec3 <- ivec3
        for three coordinate predicates
        r: y <= z, g: z < x, b: x < y
        return the two defining vertices of the simplex that the coordinate is in
        and the four planes required for computing barycentric coordinates
        the resulting simplex has the corners (0 0 0) v1 v2 (1 1 1)

paniq

#!/usr/bin/env scopes

using import glm
using import glsl
using import itertools
using import ..tukan.gl
using import ..tukan.bitmap
using import ..tukan.random
using import .testfragment

paniq

struct NumberParser {
    enum {
        NPF_Sign             = (1 << 0),
        NPF_Negative         = (1 << 1),
        NPF_Base             = (1 << 2),
        NPF_Dot              = (1 << 3),
        NPF_Exponent         = (1 << 4),
        NPF_ExponentSign     = (1 << 5),
        NPF_ExponentNegative = (1 << 6),
        NPF_Inf              = (1 << 7),

paniq

inline gen-include-options! (name)
    print "gen-include-options!" name

let modules... =
    'app
    'gfx
    'time
    'audio
    'args

paniq

using import enum

enum UTF8
    # an invalid state was encountered
    Invalid : i8
    # a codepoint has been read successfully
    Codepoint : u32

# declare i8   @llvm.ctlz.i8  (i8   <src>, i1 <is_zero_undef>)
let llvm.ctlz.i8 =

paniq

# implementation of 
    https://gist.github.com/paniq/856241af5d8a69a76a5b7e941b2533f0

using import Array

let IdIndexT = u32
let GenT = u32

# must be at least 1

paniq

Twisting Pool Queue

by Leonard Ritter leonard.ritter@duangle.com, 2019-05-12

An implementation written in Scopes can be found here

We have the task of distributing IDs to objects in a pool that we can use to look up their contents. We want to ensure that:

• Insert, access, and remove are operations with O(1) complexity.
• The object array is compact, i.e. without any gaps, so we can parallelize work on it with full occupancy.

paniq

""""Twisting Pool Allocator
    =======================
    written by Leonard Ritter (leonard.ritter@duangle.com)

    ported and expanded from the C version (https://gist.github.com/paniq/d867c6b5ea9c68a352a1)

    This file is in the public domain

    I don't know if I was the first one to stumble upon this technique, so
    I can't guarantee there's no patent on it, but let's hope there's not,