Rather than use a uniform, the code was modified so that the vertex
buffer for the mesh instances was not recreated from scratch. Now each
mesh can be assigned a max number of instances. On each modififcation
the instance data and the number of instances can be passed to the mesh.
Makeshift REPL so that one can evaluate expressions while the game is
running. I have a curses project which used lua to do something
similiar, I'd like to repurpose that at some point. For now, this is
satisfactory.
All of the common lisp code was translated into Chez Scheme. A grid
coordinate system was added; with the 'v' key one can toggle a grid
selector which may be manipulated with vi keys or the numpad.
Currently, when moving the selector there is an issue. The selector is
moved by updating one of two vertex buffers (one is for geometry, one is
for mesh instances). I plan on the second one to be static in the long
run, this is a 'quick and dirty solution'. Uniform buffers will
eventually be implemented. Right now, everything works with a bit of
error message spam.
Textures are stored in a global hashtable. Each mesh pipeline has access
to a single texture. The texture may be used as an atlas by creating
meshes with different texture coordinates. The current system should be
fine for text glyphs. However, if you have an atlas where each
subdivision is equal in its dimensions, the use of layers and the
VK_IMAGE_VIEW_TYPE_2D_ARRAY view type would be best. Some preliminary
code for this was completed, but for now inserting textures into the
hashmap defaults to VK_IMAGE_VIEW_TYPE_2D.
Set up uniform buffers for the camera. The camera still lacks a proper
controller on the lisp side, but you can create the matrix data in lisp.
The projection matrices use the "reverse-z" trick. When setting up depth
buffering in the (near) future, this needs to be considered.
Window resize events are now sent from the renderer to lisp.
On the lisp side, some math code has been written, but not yet
integrated into the project.
The renderer now allows instancing. The way this works is by having to
vertex buffers. One contains the normal vertex geometry data, the other
contains per-instance data.
The Vulkan renderer now has a mesh structure which utilizes vertex, index,
and staging buffers. On the lisp side, you can now provide a vertex type
when creating a pipeline and the appropriate vertex data when creating
the mesh. Meshes are associated with pipelines.
Currently there is one vertex type: pos2color3, which will
likely be modified and replaced. There is no instanced rendering yet,
so drawing a pipeline just involves drawing every mesh associated with
that pipeline.
The Vulkan bits are written in C. Then in common lisp you talk to the
renderer. On the common lisp side, the program was made to allow
interaction with the REPL while the game runs. Vertex buffers have not
been implemented yet, the Vulkan stuff is currently barebones.
