Гравицапа для GPU: OpenGL ES на Kotlin DSL на примере 3D-“Жизни” Конвея

Привет, Хабр! Наконец-то я закончил работу над новым большим блоком RedByteFX, тем самым, который в планах звучал скромно: “а ещё было бы неплохо OpenGL ES”. “Неплохо” растянулось на много вечеров и вылилось в версию 1.2.0, которая уже лежит в Maven Central. Если коротко: теперь на Kotlin DSL можно писать не только эффекты для Compose, но и полноценную 3D-графику и вычисления на GPU. Если подробно, то читайте дальше: я покажу всё на живом примере и сравню с тем, как пришлось бы писать без библиотеки.

Немного контекста. В первой статье я показывал, как RedByteFX превращает AGSL из “не трогай, это на Новый год” в обычный Kotlin-код. Тогда библиотека умела красить то, что уже нарисовал Compose, и только на Android 13+. Пепелац был, но летал без гравицапы.

В версии 1.2.0 у RedByteFX выросла вторая половина: тот же Kotlin DSL собирает GLSL ES 3.0–3.2. Это вершинные, фрагментные и compute-шейдеры, плюс рантайм поверх GLES и Compose-хосты GlSurface/GlCompute. Всё работает с API 24.

Рассказывать про это на очередном “волновом эффекте” скучно. Пораскинув мозгами над тем, что могло быть красивой демонстрацией и в то же время не совсем тривиальным, я пришел к выводу и написал реализацию игры: “Жизнь” Конвея, но не в двумерном пространстве, а в трёхмерном. Поколения считает compute-шейдер, тысячи клеток рисуются инстансами в вязкой светящейся жидкости. А по ходу статьи я честно сравниваю каждый шаг с тем, как то же самое пришлось бы писать по старинке, на голом GLES31 и GLSL в строковых литералах.

Репозиторий с игрой: github.com/i-redbyte/life3d. Библиотека: github.com/i-redbyte/redbytefx.

Что значит “по старинке”

Кто писал OpenGL ES на Android руками, помнит этот набор:

• шейдер живёт в строке, и опечатка в имени переменной всплывает в рантайме, в логе драйвера, на чужом телефоне;

• uniform-ы ищутся по строковому имени (glGetUniformLocation(program, "u_sise")), а неверное имя драйвер молча превращает в -1, и запись в него — тихий no-op;

• раскладку std140 считаешь на пальцах: float[27] в uniform-блоке занимает не 108 байт, а 432;

• ByteBuffer.allocateDirect(...).order(ByteOrder.nativeOrder()) — на каждый буфер;

• всё должно происходить на GL-потоке, а UI живёт на своём, и мост между ними строишь сам;

• GLSurfaceView, его жизненный цикл, потеря EGL-контекста и исключение на GL-потоке, которое роняет приложение целиком.

Ничего из этого не сложно по отдельности. Сложно всё это одновременно, каждый раз заново. RedByteFX забирает рутину, но оставляет вам полный контроль: итоговый GLSL всегда можно посмотреть.

Подключение

dependencies {    implementation("io.github.i-redbyte:redbytefx-core:1.2.0")    implementation("io.github.i-redbyte:redbytefx-stdlib:1.2.0")    implementation("io.github.i-redbyte:redbytefx-gl:1.2.0")    implementation("io.github.i-redbyte:redbytefx-gl-compose:1.2.0")    implementation("io.github.i-redbyte:redbytefx-3d:1.2.0")}

Compute-шейдерам нужен OpenGL ES 3.1, поэтому в манифест сразу пишем:

<uses-feature    android:glEsVersion="0x00030001"    android:required="true" />

Грабля №1, бесплатная. Эмулятор Android на Apple Silicon отдаёт только OpenGL ES 3.0. Compute там не заведётся. Отлаживался я на Galaxy S21. Эмулятор на маке в этой истории это пацак которому забыли выдать цак!

Игра в двух словах

У клетки в 3D 26 соседей (куб 3×3×3 без центра). Правило пишется в нотации B/S/C (в отличие от обычной “Жизни”, где клетка просто жива или мертва, здесь у клетки может быть несколько состояний, что и позволяет имитировать “тление” и создавать сложные структуры): при каком числе соседей клетка рождается, при каком выживает и сколько у неё состояний. Если состояний больше двух, умершая клетка не исчезает сразу, а несколько поколений “тлеет”: не считается соседом и не может родиться заново. Именно это делает из каши волны, оболочки и кораллы. Главная героиня — “Лава”, B6-8/S4-7/C10.

Мир — тор: решётка N³, у которой противоположные грани склеены. Классика “Жизни”: ушёл за край — пришёл с другой стороны.

Экранов два: настройки и поле. Бары в цвет приложения, тексты на двух языках, кнопка “Назад” возвращает к настройкам.

Теперь по раундам: старый подход против DSL.

Раунд 1. Шейдер

По старинке

private const val LIFE_COMPUTE = """#version 310 eslayout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;layout(std430, binding = 0) buffer world { float cells[]; };layout(std140, binding = 0) uniform rules { float birth[27]; float survive[27]; };uniform int u_size;uniform int u_read_offset;uniform int u_write_offset;void main() {    ...}"""val shader = GLES31.glCreateShader(GLES31.GL_COMPUTE_SHADER)GLES31.glShaderSource(shader, LIFE_COMPUTE)GLES31.glCompileShader(shader)val status = IntArray(1)GLES31.glGetShaderiv(shader, GLES31.GL_COMPILE_STATUS, status, 0)if (status[0] == 0) error(GLES31.glGetShaderInfoLog(shader))val program = GLES31.glCreateProgram()GLES31.glAttachShader(program, shader)GLES31.glLinkProgram(program)GLES31.glGetProgramiv(program, GLES31.GL_LINK_STATUS, status, 0)if (status[0] == 0) error(GLES31.glGetProgramInfoLog(program))val sizeLocation = GLES31.glGetUniformLocation(program, "u_size")val readLocation = GLES31.glGetUniformLocation(program, "u_read_offset")val writeLocation = GLES31.glGetUniformLocation(program, "u_write_offset")

Многоточие в main() — это ещё 40 строк GLSL, которые IDE считает просто текстом. Рефакторинг имени uniform-а? Поиск по строкам и молитва.

В RedByteFX

val program = shader(ShaderTarget.Gles31) {    size = uniformInt("size", 0)    readOffset = uniformInt("read_offset", 0)    writeOffset = uniformInt("write_offset", 0)    lateinit var birth: StorageArray<Flt<High>>    lateinit var survive: StorageArray<Flt<High>>    rules = uniformBlock("rules") {        birth = floatArray("birth", NEIGHBOUR_COUNTS)        survive = floatArray("survive", NEIGHBOUR_COUNTS)    }    lateinit var cells: StorageArray<Flt<High>>    world = storageBlock("world") {        cells = floatArray("cells")    }    compute(WORKGROUP_EDGE, WORKGROUP_EDGE, WORKGROUP_EDGE) {        val n = size.expr        val wrap = fn(0.intLit, 0.intLit, name = "wrap") { value, edge ->            ifElse(value lt 0.intLit, value + edge, ifElse(value ge edge, value - edge, value))        }        val block = local(0.intLit, "block")        repeat(3) { dz ->            repeat(3) { dy ->                repeat(3) { dx ->                    val neighbour = read(x + dx - 1.intLit, y + dy - 1.intLit, z + dz - 1.intLit)                    block.set(block.expr + ifElse(neighbour gt ALIVE, 1.intLit, 0.intLit))                }            }        }        val self = local(read(x, y, z), "self")        val alive = self.expr gt ALIVE        val neighbours = block.expr - ifElse(alive, 1.intLit, 0.intLit)        val lives = ifElse(alive, survive[neighbours] gt 0.5f, birth[neighbours] gt 0.5f)        cells[writeOffset.expr + here].store(nextValue)    }}

(Фрагмент сокращён: в репозитории ещё есть остывание клеток, “вспышка жизни” от тапа и режим бесконечного поля.)

Что изменилось по существу:

• Типы вместо строк. size — это Uniform<IntS>, а не "u_size". Тот же объект потом передаётся в controller.set(compute.size, n). Опечатку поймает компилятор Kotlin, а переименование можно легко сделать в IDE.

• Ошибки до GPU. Попробуйте написать compute { } или объявить storage-буфер в программе под ShaderTarget.Gles30: DSL откажет ещё при сборке шейдера в Kotlin, а не в логе драйвера на устройстве пользователя.

• Нормальные абстракции. fn превращается в отдельную GLSL-функцию, local — в локальную переменную, repeat(3) — в настоящий for. Почему в шейдере свой wrap, а не %? Потому что в GLSL -1 % n не даёт n - 1, и тор рвётся по швам.

• Прозрачность. program.computeSource() отдаёт итоговый GLSL. Ничего не спрятано:

#version 310 esprecision highp float;uniform int u_size;uniform int u_read_offset;uniform int u_write_offset;layout(std140, binding = 0) uniform rules {  highp float birth[27];  highp float survive[27];} b_rules;layout(std430, binding = 0) buffer world {  highp float cells[];} b_world;layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;int wrap(int p0, int p1) {  return ((p0 < 0) ? (p0 + p1) : ((p0 >= p1) ? (p0 - p1) : p0));}void main() {  int block;  highp float self;  block = 0;  for (int i = 0; i < 3; ++i) {

Биндинги назначены, std140/std430 расставлены, а повторяющиеся подвыражения библиотека сама выносит в локальные переменные.

Раунд 2. Буферы и std140

Поле N³ лежит в одном storage-буфере, где две решётки подряд: поколение читает одну половину и пишет другую, потом половины меняются ролями. Плюс uniform-блок с правилами: 27 флагов рождения и 27 флагов выживания.

По старинке

val buffers = IntArray(2)GLES31.glGenBuffers(2, buffers, 0)val cells = ByteBuffer.allocateDirect(world.size * 4).order(ByteOrder.nativeOrder())cells.asFloatBuffer().put(world)GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, buffers[0])GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, cells.capacity(), cells, GLES31.GL_DYNAMIC_COPY)GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER, 0, buffers[0])val rules = ByteBuffer.allocateDirect(54 * 16).order(ByteOrder.nativeOrder())for (i in values.indices) rules.putFloat(i * 16, values[i])GLES31.glBindBuffer(GLES31.GL_UNIFORM_BUFFER, buffers[1])GLES31.glBufferData(GLES31.GL_UNIFORM_BUFFER, rules.capacity(), rules, GLES31.GL_STATIC_DRAW)GLES31.glBindBufferBase(GLES31.GL_UNIFORM_BUFFER, 0, buffers[1])

Видите i * 16? В std140 каждый элемент массива float выравнивается до 16 байт. Забудете — и правило “рождение при 5 соседях” превратится в “рождение при 1, 5 и 9”. Колония начнёт жить по законам, которые вы ей не давали.

В RedByteFX

controller.set(compute.world, world)controller.set(compute.rules, rule.uniformValues())

Плоский FloatArray на входе. Раскладку std140/std430, выравнивание, выделение буферов и их привязку библиотека делает сама. Повторные записи переиспользуют внутренние массивы и не аллоцируют новые.

Раунд 3. Запуск, потоки и чтение результата

По старинке

glSurfaceView.queueEvent {    GLES31.glUseProgram(program)    GLES31.glUniform1i(sizeLocation, n)    GLES31.glUniform1i(readLocation, read)    GLES31.glUniform1i(writeLocation, write)    GLES31.glDispatchCompute(n / 4, n / 4, n / 4)    GLES31.glMemoryBarrier(GLES31.GL_BUFFER_UPDATE_BARRIER_BIT)    GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, buffers[0])    val mapped = GLES31.glMapBufferRange(        GLES31.GL_SHADER_STORAGE_BUFFER, 0, cells.capacity(), GLES31.GL_MAP_READ_BIT,    ) as ByteBuffer    mapped.order(ByteOrder.nativeOrder()).asFloatBuffer().get(into)    GLES31.glUnmapBuffer(GLES31.GL_SHADER_STORAGE_BUFFER)    mainHandler.post { onGeneration(into) }}

Здесь притаилась классическая ловушка. Барьер для маппинга — GL_BUFFER_UPDATE_BARRIER_BIT. Многие ставят привычный GL_SHADER_STORAGE_BARRIER_BIT, и на одних GPU всё работает, а на других приходят данные прошлого поколения. Отлаживать такое — удовольствие уровня просидеть в эцихе с гвоздями пожизненно, до выплаты.

В RedByteFX

val computeController = rememberGlController(compute.program)GlCompute(controller = computeController, modifier = Modifier.size(1.dp), overlay = {})controller.set(compute.readOffset, read)controller.set(compute.writeOffset, write)controller.dispatch(groups, groups, groups)controller.read(compute.world, into) { count -> onGeneration() }

Что здесь происходит за кадром:

• GlCompute — невидимый хост с EGL-контекстом нужной версии. Он сам ставит на паузу и возобновляет работу вместе с жизненным циклом экрана.

• set, dispatch и read можно звать с любого потока. Они ставятся в очередь GL-потока и применяются в том порядке, в котором вы их сделали.

• dispatch ставит барьер для последующих шейдеров, а read перед маппингом ставит именно GL_BUFFER_UPDATE_BARRIER_BIT. Ловушка выше просто не случается.

• Если контекст пересоздан, последние значения uniform-ов и блоков применяются к новой программе заново.

• Статус линковки — это Compose-State (controller.linkState). Не тянет устройство ES 3.1? Получите GlLinkState.Failed и покажете вежливый экран вместо падения.

Грабля №2, уже моя. Записи set(...) в GlController склеиваются: если записать uniform дважды до того, как GL-поток их применил, применится последнее значение. Так UI-поток никогда не ждёт драйвер, и для анимации это идеально. Но для поколений это ловушка: тик N+1 мог переписать смещения раньше, чем отработал dispatch тика N, и оба поколения читали одну половину. Получалась “Жизнь” с амнезией. Лечится одним флагом: новый тик стартует, только когда предыдущее поколение вернулось с GPU.

fun tick(): Boolean {    if (!inFlight.compareAndSet(false, true)) return false    val started = epoch    val previous = latest    val read = current    val write = if (read == 0) total else 0    gpu.offsets(read, write)    gpu.dispatch(n / WORKGROUP_EDGE)    gpu.readBack(readBack) {        if (started == epoch) {            latest = Generation.of(readBack, write, n, previous.origin, previous.number + 1)            latestAt = clock()            current = write            inFlight.set(false)        }    }    return true}

(Упрощено. epoch выбрасывает поколение, которое прилетело уже после нажатия “Заново”.)

Мораль: абстракция снимает рутину, но не отменяет мышление. Зато думать приходится о логике игры, а не о байтах.

Раунд 4. Тесты

По старинке

Шейдер в строке протестировать можно одним способом: запустить приложение и посмотреть. Unit-тест на JVM даже не скомпилирует его, потому что нет драйвера.

В RedByteFX

Шейдер собирается на JVM, поэтому обычные unit-тесты проверяют его структуру:

@Testfun theGenerationRunsInFourCubedWorkgroups() {    val source = lifeCompute().program.computeSource()    assertTrue(source, source.contains("local_size_x = 4, local_size_y = 4, local_size_z = 4"))}

А главное — рантайм GlProgramRuntime работает и без Compose, с любым EGL-контекстом. Поэтому в проекте есть тест, который на реальном GPU прогоняет поколение и сравнивает каждую клетку с эталоном на Kotlin, требуя точного совпадения:

val runtime = GlProgramRuntime(compute.program, Gles30Device())runtime.link()runtime.set(compute.world, world)runtime.set(compute.rules, rule.uniformValues())runtime.set(compute.size, n)runtime.set(compute.readOffset, 0)runtime.set(compute.writeOffset, total)runtime.dispatch(groups, groups, groups)runtime.read(compute.world, back)assertArrayEquals(CpuLife.step(seed, n, rule), back.copyOfRange(total, 2 * total), 0f)

Эталон — пять строк when на Kotlin. На Samsung Galaxy S21 шейдер совпадает с ним до бита для всех правил. Когда кто-то спрашивает “а оно точно правильно считает?”, ответ занимает одну команду: ./gradlew connectedDebugAndroidTest.

Раунд 5. Отрисовка тысяч клеток

Клетки — это инстансы сферы. Каждой нужны координаты и состояние, а всем вместе — один draw call.

По старинке

val data = ByteBuffer.allocateDirect(instances.size * 4).order(ByteOrder.nativeOrder())data.asFloatBuffer().put(instances)GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, instanceBuffer)GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, data.capacity(), data, GLES30.GL_STREAM_DRAW)for (column in 0 until 4) {    val location = modelLocation + column    GLES30.glEnableVertexAttribArray(location)    GLES30.glVertexAttribPointer(location, 4, GLES30.GL_FLOAT, false, 64, column * 16)    GLES30.glVertexAttribDivisor(location, 1)}GLES30.glDrawElementsInstanced(GLES30.GL_TRIANGLES, indexCount, GLES30.GL_UNSIGNED_SHORT, 0, count)

И после этого не забыть вернуть divisor в ноль, иначе следующий меш нарисуется очень креативно.

В RedByteFX

frame.draw(backgroundMesh, model = background, pipeline = liquidPipeline)frame.draw(cellMesh, instances = drawn.instances, pipeline = cellPipeline)

instances — плоский FloatArray, по 16 чисел на инстанс. Библиотека держит отдельный инстанс-буфер на каждый меш, раскладывает данные по атрибутам model0..model3 с divisor 1 и прибирает за собой состояние. GlPipeline(depthMask = false) — это “фон не пишет глубину” одной строкой вместо пачки glDepthMask/glEnable/glDisable. Сфера и квад — готовые примитивы sphere(1f, 6, 10) и quad(2f, 2f).

Матрицы считает redbytefx-3d прямо в переиспользуемые массивы, без аллокаций на кадр:

lookAt(eye[0], eye[1], eye[2], camera.targetX, camera.targetY, camera.targetZ, 0f, 1f, 0f, viewMatrix)perspective(OrbitCamera.verticalFov(frame.aspect), frame.aspect, NEAR, FAR, projection)

В вершинном шейдере матрица инстанса нам вообще не нужна. В первый столбец мы кладём (x, y, z, value) и сами решаем, что с этим делать. Шейдер наш, мы тут правительство:

val column0 = attributeVec4("model0")val cell = vec3(column0.x, column0.y, column0.z)val value = column0.wval grow = smoothstep(0f, 1f, phase.expr)val life = ifElse(value lt -0.5f, fadingLife, ifElse(value lt 1.5f, grow, 1f.lit))

Новорождённая клетка вырастает за поколение, умершая сжимается в тёмного “призрака” и тает. Свет взят из stdlib, без единой формулы, переписанной из учебника:

val diffuse = wrapLambert(n, lightDir, 0.3f)val rim = fresnel(n, toEye, 2.4f)

fresnel даёт светящийся ободок, и непрозрачные сферы выглядят влажными, без блендинга.

А вот правило “Волны” (B4/S4/C5): волна расходится от искры и оставляет гаснущий след.

Раунд 6. Kotlin как макроязык для GLSL

Первый фон-“жидкость” я собрал за пять минут из stdlib: domainWarp + fbm. На эмуляторе вышла вязкая жидкость. На Galaxy S21 — плитка в ванной:

Грабля №3. Шумы строятся на хеше fract(sin(x) * 43758.5), а мобильные GPU считают sin от больших аргументов неточно. Лечится жидкостью, где все аргументы синуса маленькие:

private fun liquidFlow(point: Expr<Vec2<Flt<High>>>, time: Expr<Flt<High>>): Expr<Flt<High>> {    var q = point    for (pass in 1..LIQUID_PASSES) {        val k = pass.toFloat()        val push = vec2(            sin(q.y * (0.9f + 0.2f * k) + time * 0.23f + k),            cos(q.x * (0.8f + 0.25f * k) - time * 0.19f + k * 1.7f),        )        q = q + push * (0.55f / k)    }    return sin(q.x * 1.3f + q.y * 0.7f) * 0.5f + 0.5f}

Главное тут не математика, а то, как это написано. Это обычная Kotlin-функция с обычным for. Цикл выполняется при сборке шейдера и разворачивается в пять проходов выражений, а функцию можно переиспользовать, параметризовать и покрыть тестом. По старинке пришлось бы либо копировать куски GLSL пять раз, либо склеивать строки через buildString, прощаясь с подсветкой и здравым смыслом.

В DSL у вас два вида циклов, и это фича. repeat из DSL — настоящий for на GPU (как подсчёт соседей). Kotlin-for — развёртка во время сборки (как жидкость). Выбираете по задаче.

Раунд 7. Compose

По старинке

AndroidView(factory = { context ->    GLSurfaceView(context).apply {        setEGLContextClientVersion(3)        preserveEGLContextOnPause = true        setRenderer(LifeRenderer())    }})

Дальше вручную: DisposableEffect с наблюдателем за жизненным циклом, чтобы звать onPause/onResume; мост между потоками; пересоздание ресурсов после потери контекста. И try-catch на GL-потоке, потому что исключение там убивает процесс, а не показывает ошибку.

В RedByteFX

GlSurface(    controller = sceneController,    mesh = renderer.backgroundMesh,    modifier = Modifier        .fillMaxSize()        .fieldGestures(camera) { renderer.touchedAt = System.nanoTime() }        .pointerInput(engine) {            detectTapGestures { tap ->                val point = camera.pick(tap.x, tap.y, size.width.toFloat(), size.height.toFloat())                engine.spark(torusCell(worldToCell(point), engine.n))            }        },    onFrame = renderer::draw,)

(Немного упрощено относительно репозитория.)

GlSurface — обычный composable:

• он сам следит за жизненным циклом и сохраняет EGL-контекст на паузе: после возврата из фона ничего не перелинковывается;

• исключение в onFrame не роняет приложение: отрисовка останавливается, ошибка публикуется в controller.failure и показывается через failureOverlay;

• модификаторы Compose — жесты, pointerInput, отступы — работают как с любым другим composable.

Тап рождает “вспышку жизни”: точка касания превращается в луч из камеры, луч — в клетку тора, и в следующем поколении вокруг неё оживает облако.

Цвета клеток передаются в шейдер двумя uniform-ами. Кроме однотонных, есть градиент “Сияние” и свой градиент, собранный в отдельном диалоге. Весь интерфейс подстраивается под выбранный цвет:

Первый блин, кю!

Первая версия игры выглядела вот так:

“Что-то, как-то не так…”, подумал я. Немного порывшись и помучав нейронку, я нашел, что были виноваты две вещи.

1. Правила. Классические 3D-правила с двумя состояниями либо засыпают всё пространство, либо заливают его кашей, так что каша принимает форму контейнера. Правила с затуханием (C > 2) дают форму.

2. Подача. Камера смотрела на тор снаружи, а тор это мир без краёв. Честно его рисовать как бесконечную периодическую среду: камера внутри, клетки повторяются через каждые N по каждой оси, дальние тонут в тумане. Готовим ровно столько инстансов, сколько видно, но не больше 16 000. Лимит держится без сортировки: гистограмма расстояний за один проход, и лишние дальние “скорлупки” отрезаются.

Куба больше нет. Эцилоп больше не имеет право бить меня по ночам. Никогда.

Итоговое сравнение

Честные ограничения

• Нужен OpenGL ES 3.1 для compute. Почти все устройства с 2016 года, но эмулятора на Apple Silicon нету (или я не нашел).

• Два контекста — два мира. GlCompute и GlSurface не делят буферы, поэтому результат поколения читается на CPU. Для поля 48³ это около 885 КБ на поколение, при шести поколениях в секунду — копейки, но для гигантских полей понадобится общий контекст.

• DSL нужно освоить один раз. Выражения вместо операторов, ifElse вместо if, два вида циклов. Это цена входа, и, по-моему, она окупается уже на втором шейдере.

Итоги

Из 26 соседей, двух половин буфера и пяти строк when получилась игра, на которую можно залипнуть минут на двадцать, а то и час. При этом:

• ни одной строки шейдера в строковом литерале;

• ни одного glGetUniformLocation, allocateDirect и ручного выравнивания;

• шейдер покрыт тестами, включая побитовую проверку на живом GPU;

• итоговый GLSL открыт и читается как написанный руками.

Если первая статья была про то, что AGSL можно писать по-человечески, то эта про то, что и OpenGL ES можно. Пепелац теперь летает с гравицапой.

• Игра: github.com/i-redbyte/life3d

• Библиотека: github.com/i-redbyte/redbytefx

Приходите в issues: показывайте, что собрали, и ругайте по делу. Ку!