auto now = std::chrono::system_clock::now();

auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(

now.time_since_epoch());

return static_cast<uint32_t>(duration.count());

constexpr size_t NROWS = 32;

constexpr size_t NCOLS = 64;

std::array<float, NROWS * NCOLS> screen;

struct Params {

float focalLength;

uint32_t screenWidth;

uint32_t screenHeight;

float sphereRadius;

float sphereCenterX;

float sphereCenterY;

float sphereCenterZ;

uint32_t time;

} params = {/* focal length */ 1.0,

NCOLS,

NROWS,

/* radius */ 1.0,

/* x */ 0.0,

/* y */ 0.0,

/* z */ 3.5,

0};

std::fill(begin(screen), end(screen), 0.0f);

Context ctx = createContext();

Tensor devScreen = createTensor(ctx, {NROWS, NCOLS}, kf32, screen.data());

uint32_t zeroTime = getCurrentTimeInMilliseconds();

Shape wgSize = {16, 16, 1};

KernelCode code = {kSDF, wgSize};

Kernel renderKernel = createKernel(ctx, code, Bindings{devScreen},

cdiv({NCOLS, NROWS, 1}, wgSize), params);

printf("\033[2J\033[H");

while (true) {

std::promise<void> promise;

std::future<void> future = promise.get_future();

dispatchKernel(ctx, renderKernel, promise);

wait(ctx, future);

toCPU(ctx, devScreen, screen.data(), sizeof(screen));

params.time = getCurrentTimeInMilliseconds() - zeroTime;

toGPU(ctx, params, renderKernel);

resetCommandBuffer(ctx.device, renderKernel);

static const char intensity[] =

"@B%8&WM#$Z0OQLCJUYX/"

"\\|()1{}I[]?lzcvunxrjft-+~<>i!_;:*\"^`',. ";

// static const char intensity[] = "@%#8$X71x*+=-:^~'.` ";

// Intensity = depth map, focus on depth of the objects

float min = 0.0;

float max = params.sphereRadius * 3;

for (size_t i = 0; i < screen.size(); ++i) {

screen[i] = (screen[i] - min) / (max - min);

}

std::array<char, screen.size()> raster;

for (size_t i = 0; i < screen.size(); ++i) {

size_t index =

std::min(sizeof(intensity) - 2,

std::max(0ul, static_cast<size_t>(screen[i] *

(sizeof(intensity) - 2))));

raster[i] = intensity[index];

}

char buffer[(NROWS + 2) * (NCOLS + 2)];

char *offset = buffer;

sprintf(offset, "+");

for (size_t col = 0; col < NCOLS; ++col) {

sprintf(offset + col + 1, "-");

}

sprintf(buffer + NCOLS + 1, "+\n");

offset += NCOLS + 3;

for (size_t row = 0; row < NROWS; ++row) {

sprintf(offset, "|");

for (size_t col = 0; col < NCOLS; ++col) {

sprintf(offset + col + 1, "%c", raster[row * NCOLS + col]);

}

sprintf(offset + NCOLS + 1, "|\n");

offset += NCOLS + 3;

}

sprintf(offset, "+");

for (size_t col = 0; col < NCOLS; ++col) {

sprintf(offset + col + 1, "-");

}

sprintf(offset + NCOLS + 1, "+\n");

printf("\033[H\033[HWorkgroup size: %zu %zu %zu \nNumber of Threads: %zu "

"%zu %d \n%s",

code.workgroupSize[0], code.workgroupSize[1], code.workgroupSize[2],

devScreen.shape[1], devScreen.shape[0], 1, buffer);

fflush(stdout);

}