initial checkin of SkSL compiler

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1984363002
CQ_EXTRA_TRYBOTS=client.skia.compile:Build-Ubuntu-GCC-x86_64-Release-CMake-Trybot,Build-Mac-Clang-x86_64-Release-CMake-Trybot

Review-Url: https://codereview.chromium.org/1984363002

3 files changed, 66 insertions, 2 deletions

diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 8716c63e65..c1cec9d96f 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -36,6 +36,10 @@
 #include "vk/GrVkInterface.h"
 #include "vk/GrVkTypes.h"
 
+#if USE_SKSL
+#include "SkSLCompiler.h"
+#endif
+
 #define VK_CALL(X) GR_VK_CALL(this->vkInterface(), X)
 #define VK_CALL_RET(RET, X) GR_VK_CALL_RET(this->vkInterface(), RET, X)
 #define VK_CALL_ERRCHECK(X) GR_VK_CALL_ERRCHECK(this->vkInterface(), X)
@@ -110,7 +114,11 @@ GrVkGpu::GrVkGpu(GrContext* context, const GrContextOptions& options,
     }
 #endif
 
+#if USE_SKSL
+    fCompiler = new SkSL::Compiler();
+#else
     fCompiler = shaderc_compiler_initialize();
+#endif
 
     fVkCaps.reset(new GrVkCaps(options, this->vkInterface(), backendCtx->fPhysicalDevice,
                                backendCtx->fFeatures, backendCtx->fExtensions));
@@ -176,7 +184,11 @@ GrVkGpu::~GrVkGpu() {
 
     VK_CALL(DestroyCommandPool(fDevice, fCmdPool, nullptr));
 
+#if USE_SKSL
+    delete fCompiler;
+#else
     shaderc_compiler_release(fCompiler);
+#endif
 
 #ifdef ENABLE_VK_LAYERS
     if (fCallback) {
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 3373abd0f8..542917e9d0 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -8,6 +8,8 @@
 #ifndef GrVkGpu_DEFINED
 #define GrVkGpu_DEFINED
 
+#define USE_SKSL 1
+
 #include "GrGpu.h"
 #include "GrGpuFactory.h"
 #include "vk/GrVkBackendContext.h"
@@ -18,7 +20,14 @@
 #include "GrVkVertexBuffer.h"
 #include "GrVkUtil.h"
 
+#if USE_SKSL
+namespace SkSL {
+    class Compiler;
+}
+#else
 #include "shaderc/shaderc.h"
+#endif
+
 #include "vk/GrVkDefines.h"
 
 class GrPipeline;
@@ -111,9 +120,15 @@ public:
                                bool byRegion,
                                VkImageMemoryBarrier* barrier) const;
 
+#if USE_SKSL
+    SkSL::Compiler* shaderCompiler() const {
+        return fCompiler;
+    }
+#else
     shaderc_compiler_t shadercCompiler() const {
         return fCompiler;
     }
+#endif
 
     void submitSecondaryCommandBuffer(const GrVkSecondaryCommandBuffer*,
                                       const GrVkRenderPass*,
@@ -242,10 +257,13 @@ private:
     VkDebugReportCallbackEXT               fCallback;
 #endif
 
+#if USE_SKSL
+    SkSL::Compiler* fCompiler;
+#else
     // Shaderc compiler used for compiling glsl in spirv. We only want to create the compiler once
     // since there is significant overhead to the first compile of any compiler.
     shaderc_compiler_t fCompiler;
-
+#endif
 
     typedef GrGpu INHERITED;
 };
diff --git a/src/gpu/vk/GrVkPipelineStateBuilder.cpp b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
index a191505a38..323ea66946 100644
--- a/src/gpu/vk/GrVkPipelineStateBuilder.cpp
+++ b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
@@ -9,6 +9,9 @@
 
 #include "vk/GrVkGpu.h"
 #include "vk/GrVkRenderPass.h"
+#if USE_SKSL
+#include "SkSLCompiler.h"
+#endif
 
 GrVkPipelineState* GrVkPipelineStateBuilder::CreatePipelineState(
                                                                GrVkGpu* gpu,
@@ -72,6 +75,15 @@ VkShaderStageFlags visibility_to_vk_stage_flags(uint32_t visibility) {
     return flags;
 }
 
+#if USE_SKSL
+SkSL::Program::Kind vk_shader_stage_to_skiasl_kind(VkShaderStageFlagBits stage) {
+    if (VK_SHADER_STAGE_VERTEX_BIT == stage) {
+        return SkSL::Program::kVertex_Kind;
+    }
+    SkASSERT(VK_SHADER_STAGE_FRAGMENT_BIT == stage);
+    return SkSL::Program::kFragment_Kind;
+}
+#else
 shaderc_shader_kind vk_shader_stage_to_shaderc_kind(VkShaderStageFlagBits stage) {
     if (VK_SHADER_STAGE_VERTEX_BIT == stage) {
         return shaderc_glsl_vertex_shader;
@@ -79,7 +91,10 @@ shaderc_shader_kind vk_shader_stage_to_shaderc_kind(VkShaderStageFlagBits stage)
     SkASSERT(VK_SHADER_STAGE_FRAGMENT_BIT == stage);
     return shaderc_glsl_fragment_shader;
 }
+#endif
 
+#include <fstream>
+#include <sstream>
 bool GrVkPipelineStateBuilder::CreateVkShaderModule(const GrVkGpu* gpu,
                                                     VkShaderStageFlagBits stage,
                                                     const GrGLSLShaderBuilder& builder,
@@ -99,13 +114,28 @@ bool GrVkPipelineStateBuilder::CreateVkShaderModule(const GrVkGpu* gpu,
     moduleCreateInfo.pNext = nullptr;
     moduleCreateInfo.flags = 0;
 
+#if USE_SKSL
+    std::string code;
+#else
     shaderc_compilation_result_t result = nullptr;
+#endif
 
     if (gpu->vkCaps().canUseGLSLForShaderModule()) {
         moduleCreateInfo.codeSize = strlen(shaderString.c_str());
         moduleCreateInfo.pCode = (const uint32_t*)shaderString.c_str();
     } else {
 
+#if USE_SKSL
+        bool result = gpu->shaderCompiler()->toSPIRV(vk_shader_stage_to_skiasl_kind(stage), 
+                                                     std::string(shaderString.c_str()),
+                                                     &code);
+        if (!result) {
+            SkDebugf("%s\n", gpu->shaderCompiler()->errorText().c_str());
+            return false;
+        }
+        moduleCreateInfo.codeSize = code.size();
+        moduleCreateInfo.pCode = (const uint32_t*) code.c_str();
+#else
         shaderc_compiler_t compiler = gpu->shadercCompiler();
 
         shaderc_compile_options_t options = shaderc_compile_options_initialize();
@@ -125,18 +155,22 @@ bool GrVkPipelineStateBuilder::CreateVkShaderModule(const GrVkGpu* gpu,
             SkDebugf("%s\n", shaderc_result_get_error_message(result));
             return false;
         }
-#endif
+#endif // SK_DEBUG
 
         moduleCreateInfo.codeSize = shaderc_result_get_length(result);
         moduleCreateInfo.pCode = (const uint32_t*)shaderc_result_get_bytes(result);
+#endif // USE_SKSL
     }
 
     VkResult err = GR_VK_CALL(gpu->vkInterface(), CreateShaderModule(gpu->device(),
                                                                      &moduleCreateInfo,
                                                                      nullptr,
                                                                      shaderModule));
+
     if (!gpu->vkCaps().canUseGLSLForShaderModule()) {
+#if !USE_SKSL
         shaderc_result_release(result);
+#endif
     }
     if (err) {
         return false;