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.
