joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "src/core/SkAutoMalloc.h" |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 9 | #include "src/gpu/GrShaderUtils.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 10 | #include "src/gpu/gl/GrGLGpu.h" |
| 11 | #include "src/gpu/gl/builders/GrGLShaderStringBuilder.h" |
| 12 | #include "src/sksl/SkSLCompiler.h" |
| 13 | #include "src/sksl/SkSLGLSLCodeGenerator.h" |
| 14 | #include "src/sksl/ir/SkSLProgram.h" |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 15 | |
halcanary | 4e44efe | 2016-08-04 10:47:16 -0700 | [diff] [blame] | 16 | // Print the source code for all shaders generated. |
Brian Salomon | 06ab383 | 2017-12-04 16:45:30 -0500 | [diff] [blame] | 17 | static const bool gPrintSKSL = false; |
| 18 | static const bool gPrintGLSL = false; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 19 | |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 20 | void print_shader_banner(SkSL::Program::Kind programKind) { |
Brian Salomon | 06ab383 | 2017-12-04 16:45:30 -0500 | [diff] [blame] | 21 | const char* typeName = "Unknown"; |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 22 | switch (programKind) { |
| 23 | case SkSL::Program::kVertex_Kind: typeName = "Vertex"; break; |
| 24 | case SkSL::Program::kGeometry_Kind: typeName = "Geometry"; break; |
| 25 | case SkSL::Program::kFragment_Kind: typeName = "Fragment"; break; |
| 26 | default: break; |
Brian Salomon | 06ab383 | 2017-12-04 16:45:30 -0500 | [diff] [blame] | 27 | } |
| 28 | SkDebugf("---- %s shader ----------------------------------------------------\n", typeName); |
| 29 | } |
| 30 | |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 31 | std::unique_ptr<SkSL::Program> GrSkSLtoGLSL(const GrGLContext& context, |
| 32 | SkSL::Program::Kind programKind, |
Brian Osman | 6c431d5 | 2019-04-15 16:31:54 -0400 | [diff] [blame] | 33 | const SkSL::String& sksl, |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 34 | const SkSL::Program::Settings& settings, |
| 35 | SkSL::String* glsl) { |
Ethan Nicholas | 068acd5 | 2017-05-26 14:53:23 -0400 | [diff] [blame] | 36 | SkSL::Compiler* compiler = context.compiler(); |
| 37 | std::unique_ptr<SkSL::Program> program; |
Ethan Nicholas | 068acd5 | 2017-05-26 14:53:23 -0400 | [diff] [blame] | 38 | program = compiler->convertProgram(programKind, sksl, settings); |
| 39 | if (!program || !compiler->toGLSL(*program, glsl)) { |
| 40 | SkDebugf("SKSL compilation error\n----------------------\n"); |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 41 | GrShaderUtils::PrintLineByLine("SKSL:", sksl); |
Ethan Nicholas | 068acd5 | 2017-05-26 14:53:23 -0400 | [diff] [blame] | 42 | SkDebugf("\nErrors:\n%s\n", compiler->errorText().c_str()); |
| 43 | SkDEBUGFAIL("SKSL compilation failed!\n"); |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 44 | return nullptr; |
| 45 | } |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 46 | |
| 47 | if (gPrintSKSL || gPrintGLSL) { |
| 48 | print_shader_banner(programKind); |
| 49 | if (gPrintSKSL) { |
| 50 | GrShaderUtils::PrintLineByLine("SKSL:", sksl); |
| 51 | } |
| 52 | if (gPrintGLSL) { |
| 53 | GrShaderUtils::PrintLineByLine("GLSL:", *glsl); |
| 54 | } |
Brian Salomon | 06ab383 | 2017-12-04 16:45:30 -0500 | [diff] [blame] | 55 | } |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 56 | |
Ethan Nicholas | 068acd5 | 2017-05-26 14:53:23 -0400 | [diff] [blame] | 57 | return program; |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 58 | } |
ethannicholas | 5961bc9 | 2016-10-12 06:39:56 -0700 | [diff] [blame] | 59 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 60 | GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx, |
| 61 | GrGLuint programId, |
| 62 | GrGLenum type, |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 63 | const SkSL::String& glsl, |
| 64 | GrGpu::Stats* stats) { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 65 | const GrGLInterface* gli = glCtx.interface(); |
| 66 | |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 67 | // Specify GLSL source to the driver. |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 68 | GrGLuint shaderId; |
| 69 | GR_GL_CALL_RET(gli, shaderId, CreateShader(type)); |
| 70 | if (0 == shaderId) { |
| 71 | return 0; |
| 72 | } |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 73 | const GrGLchar* source = glsl.c_str(); |
| 74 | GrGLint sourceLength = glsl.size(); |
| 75 | GR_GL_CALL(gli, ShaderSource(shaderId, 1, &source, &sourceLength)); |
joshualitt | 43466a1 | 2015-02-13 17:18:27 -0800 | [diff] [blame] | 76 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 77 | stats->incShaderCompilations(); |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 78 | GR_GL_CALL(gli, CompileShader(shaderId)); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 79 | |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 80 | // Calling GetShaderiv in Chromium is quite expensive. Assume success in release builds. |
cdalton | 1acea86 | 2015-06-02 13:05:52 -0700 | [diff] [blame] | 81 | bool checkCompiled = kChromium_GrGLDriver != glCtx.driver(); |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 82 | #ifdef SK_DEBUG |
| 83 | checkCompiled = true; |
| 84 | #endif |
| 85 | if (checkCompiled) { |
| 86 | GrGLint compiled = GR_GL_INIT_ZERO; |
| 87 | GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_COMPILE_STATUS, &compiled)); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 88 | |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 89 | if (!compiled) { |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 90 | SkDebugf("GLSL compilation error\n----------------------\n"); |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 91 | GrShaderUtils::PrintLineByLine("GLSL:", glsl); |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 92 | GrGLint infoLen = GR_GL_INIT_ZERO; |
| 93 | GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_INFO_LOG_LENGTH, &infoLen)); |
| 94 | SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger |
| 95 | if (infoLen > 0) { |
| 96 | // retrieve length even though we don't need it to workaround bug in Chromium cmd |
| 97 | // buffer param validation. |
| 98 | GrGLsizei length = GR_GL_INIT_ZERO; |
joshualitt | 43466a1 | 2015-02-13 17:18:27 -0800 | [diff] [blame] | 99 | GR_GL_CALL(gli, GetShaderInfoLog(shaderId, infoLen+1, &length, (char*)log.get())); |
ethannicholas | 5961bc9 | 2016-10-12 06:39:56 -0700 | [diff] [blame] | 100 | SkDebugf("Errors:\n%s\n", (const char*) log.get()); |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 101 | } |
Brian Salomon | 020dbe7 | 2018-02-22 15:03:17 -0500 | [diff] [blame] | 102 | // In Chrome we may have failed due to context-loss. So we should just continue along |
| 103 | // wihthout asserting until the GrContext gets abandoned. |
| 104 | if (kChromium_GrGLDriver != glCtx.driver()) { |
| 105 | SkDEBUGFAIL("GLSL compilation failed!"); |
| 106 | } |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 107 | GR_GL_CALL(gli, DeleteShader(shaderId)); |
| 108 | return 0; |
| 109 | } |
| 110 | } |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 111 | |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 112 | // Attach the shader, but defer deletion until after we have linked the program. |
| 113 | // This works around a bug in the Android emulator's GLES2 wrapper which |
| 114 | // will immediately delete the shader object and free its memory even though it's |
| 115 | // attached to a program, which then causes glLinkProgram to fail. |
| 116 | GR_GL_CALL(gli, AttachShader(programId, shaderId)); |
robertphillips | 754f4e9 | 2014-09-18 13:52:08 -0700 | [diff] [blame] | 117 | return shaderId; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 118 | } |
csmartdalton | b3772dc | 2016-07-13 08:47:54 -0700 | [diff] [blame] | 119 | |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 120 | void GrGLPrintShader(const GrGLContext& context, SkSL::Program::Kind programKind, |
| 121 | const SkSL::String& sksl, const SkSL::Program::Settings& settings) { |
| 122 | print_shader_banner(programKind); |
| 123 | GrShaderUtils::PrintLineByLine("SKSL:", sksl); |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 124 | SkSL::String glsl; |
Brian Osman | ac9be9d | 2019-05-01 10:29:34 -0400 | [diff] [blame^] | 125 | if (GrSkSLtoGLSL(context, programKind, sksl, settings, &glsl)) { |
| 126 | GrShaderUtils::PrintLineByLine("GLSL:", glsl); |
csmartdalton | b3772dc | 2016-07-13 08:47:54 -0700 | [diff] [blame] | 127 | } |
| 128 | } |