Default shaders;

Tupfile.lua

@@ -444,6 +444,23 @@ for i, pattern in ipairs(res) do
   src.extra_inputs += pattern .. '.h'
 end
 
+-- shaders
+
+vert = 'etc/shaders/*.vert'
+frag = 'etc/shaders/*.frag'
+comp = 'etc/shaders/*.comp'
+
+function compileShaders(stage)
+  pattern = 'etc/shaders/*.' .. stage
+  symbol = 'lovr_shader_%B_' .. stage
+  tup.foreach_rule(pattern, 'glslangValidator --target-env vulkan1.1 --vn lovr_shader_%B_' .. stage .. ' -o %o %f', '%f.h')
+end
+
+compileShaders('vert')
+compileShaders('frag')
+compileShaders('comp')
+src.extra_inputs += 'etc/shaders/*.h'
+
 -- compile
 
 tup.foreach_rule(src, '^ CC %b^ $(cc) $(flags) $(cflags) $(cflags_%B) -o %o -c %f', '.obj/%B.o')

etc/shaders.h

@@ -0,0 +1,2 @@
+#include "shaders/unlit.vert.h"
+#include "shaders/unlit.frag.h"

etc/shaders/unlit.frag

@@ -0,0 +1,11 @@
+#version 460
+#extension GL_EXT_multiview : require
+
+layout(location = 0) in vec4 inColor;
+layout(location = 1) in vec2 inUV;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+  outColor = inColor;
+}

etc/shaders/unlit.vert

@@ -0,0 +1,41 @@
+#version 460
+#extension GL_EXT_multiview : require
+
+struct Camera {
+  mat4 view;
+  mat4 projection;
+  mat4 viewProjection;
+  mat4 inverseProjection;
+};
+
+struct PerDraw {
+  mat4 transform;
+  mat4 normalMatrix;
+  vec4 color;
+};
+
+layout(set = 0, binding = 0) uniform Cameras { Camera cameras[6]; };
+layout(set = 0, binding = 1) uniform Draws { PerDraw draws[6]; };
+layout(set = 0, binding = 2) uniform sampler defaultSampler;
+
+layout(location = 0) in vec4 inPosition;
+layout(location = 1) in vec4 inNormal;
+layout(location = 2) in vec4 inUV;
+layout(location = 3) in vec4 inColor;
+layout(location = 4) in vec4 inTangent;
+
+layout(location = 0) out vec4 outColor;
+layout(location = 1) out vec4 outUV;
+
+void main() {
+  uint drawId = gl_BaseInstance & 0xff;
+
+  outColor = vec4(1.);
+  outColor *= draws[drawId].color;
+  outColor *= inColor;
+
+  outUV = inUV;
+
+  gl_Position = cameras[gl_ViewIndex].viewProjection * (draws[drawId].transform * vec4(inPosition.xyz, 1.));
+  gl_PointSize = 1.f;
+}

src/api/api.h

@@ -31,6 +31,7 @@ extern StringEntry lovrCompareMode[];
 extern StringEntry lovrCoordinateSpace[];
 extern StringEntry lovrCullMode[];
 extern StringEntry lovrDefaultAttribute[];
+extern StringEntry lovrDefaultShader[];
 extern StringEntry lovrDevice[];
 extern StringEntry lovrDeviceAxis[];
 extern StringEntry lovrDeviceButton[];

src/api/l_graphics.c

@@ -50,6 +50,11 @@ StringEntry lovrCullMode[] = {
   { 0 }
 };
 
+StringEntry lovrDefaultShader[] = {
+  [SHADER_UNLIT] = ENTRY("unlit"),
+  { 0 }
+};
+
 StringEntry lovrFieldType[] = {
   [FIELD_I8x4] = ENTRY("i8x4"),
   [FIELD_U8x4] = ENTRY("u8x4"),

src/api/l_graphics_pass.c

@@ -142,8 +142,16 @@ static int l_lovrPassSetDepthClamp(lua_State* L) {
 static int l_lovrPassSetShader(lua_State* L) {
   Pass* pass = luax_checktype(L, 1, Pass);
   switch (lua_type(L, 2)) {
-    case LUA_TNONE: case LUA_TNIL: lovrPassSetShader(pass, NULL); return 0;
-    default: lovrPassSetShader(pass, luax_checktype(L, 2, Shader)); return 0;
+    case LUA_TNONE:
+    case LUA_TNIL:
+      lovrPassSetShader(pass, NULL);
+      return 0;
+    case LUA_TSTRING:
+      lovrPassSetShader(pass, lovrGraphicsGetDefaultShader(luax_checkenum(L, 2, DefaultShader, NULL)));
+      return 0;
+    default:
+      lovrPassSetShader(pass, luax_checktype(L, 2, Shader));
+      return 0;
   }
 }
 

src/modules/graphics/graphics.c

@@ -7,6 +7,7 @@
 #include "core/spv.h"
 #include "core/os.h"
 #include "util.h"
+#include "shaders.h"
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
@@ -140,6 +141,7 @@ static struct {
   Buffer* defaultBuffer;
   Texture* defaultTexture;
   Sampler* defaultSampler;
+  Shader* defaultShaders[DEFAULT_SHADER_COUNT];
   map_t pipelineLookup;
   arr_t(gpu_pipeline*) pipelines;
   arr_t(Layout) layouts;
@@ -261,6 +263,9 @@ void lovrGraphicsDestroy() {
   lovrRelease(state.defaultBuffer, lovrBufferDestroy);
   lovrRelease(state.defaultTexture, lovrTextureDestroy);
   lovrRelease(state.defaultSampler, lovrSamplerDestroy);
+  for (uint32_t i = 0; i < COUNTOF(state.defaultShaders); i++) {
+    lovrRelease(state.defaultShaders[i], lovrShaderDestroy);
+  }
   for (uint32_t i = 0; i < COUNTOF(state.attachments); i++) {
     if (state.attachments[i].texture) {
       gpu_texture_destroy(state.attachments[i].texture);
@@ -862,6 +867,28 @@ static void lovrShaderInit(Shader* shader) {
   }
 }
 
+Shader* lovrGraphicsGetDefaultShader(DefaultShader type) {
+  if (state.defaultShaders[type]) {
+    return state.defaultShaders[type];
+  }
+
+  ShaderInfo info = { .type = SHADER_GRAPHICS };
+
+  switch (type) {
+    case SHADER_UNLIT:
+      info.stages[0] = lovrBlobCreate((void*) lovr_shader_unlit_vert, sizeof(lovr_shader_unlit_vert), "Unlit Vertex Shader");
+      info.stages[1] = lovrBlobCreate((void*) lovr_shader_unlit_frag, sizeof(lovr_shader_unlit_frag), "Unlit Fragment Shader");
+      info.label = "unlit";
+      break;
+    default: lovrUnreachable();
+  }
+
+  state.defaultShaders[type] = lovrShaderCreate(&info);
+  lovrRelease(info.stages[0], lovrBlobDestroy);
+  lovrRelease(info.stages[1], lovrBlobDestroy);
+  return state.defaultShaders[type];
+}
+
 Shader* lovrShaderCreate(ShaderInfo* info) {
   Shader* shader = calloc(1, sizeof(Shader) + gpu_sizeof_shader());
   lovrAssert(shader, "Out of memory");

src/modules/graphics/graphics.h

@@ -236,6 +236,11 @@ const SamplerInfo* lovrSamplerGetInfo(Sampler* sampler);
 
 // Shader
 
+typedef enum {
+  SHADER_UNLIT,
+  DEFAULT_SHADER_COUNT
+} DefaultShader;
+
 typedef enum {
   SHADER_GRAPHICS,
   SHADER_COMPUTE
@@ -262,6 +267,7 @@ typedef struct {
 } ShaderInfo;
 
 struct Blob* lovrGraphicsCompileShader(ShaderStage stage, struct Blob* source);
+Shader* lovrGraphicsGetDefaultShader(DefaultShader type);
 Shader* lovrShaderCreate(ShaderInfo* info);
 Shader* lovrShaderClone(Shader* parent, ShaderFlag* flags, uint32_t count);
 void lovrShaderDestroy(void* ref);