1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrGLShaderStringBuilder.h"
#include "GrSKSLPrettyPrint.h"
#include "SkAutoMalloc.h"
#include "SkSLCompiler.h"
#include "SkSLGLSLCodeGenerator.h"
#include "SkTraceEvent.h"
#include "gl/GrGLGpu.h"
#include "ir/SkSLProgram.h"
#define GL_CALL(X) GR_GL_CALL(gpu->glInterface(), X)
#define GL_CALL_RET(R, X) GR_GL_CALL_RET(gpu->glInterface(), R, X)
// Print the source code for all shaders generated.
static const bool gPrintSKSL = false;
static const bool gPrintGLSL = false;
static void print_source_lines_with_numbers(const char* source,
std::function<void(const char*)> println) {
SkTArray<SkString> lines;
SkStrSplit(source, "\n", kStrict_SkStrSplitMode, &lines);
for (int i = 0; i < lines.count(); ++i) {
SkString& line = lines[i];
line.prependf("%4i\t", i + 1);
println(line.c_str());
}
}
// Prints shaders one line at the time. This ensures they don't get truncated by the adb log.
static void print_sksl_line_by_line(const char** skslStrings, int* lengths, int count,
std::function<void(const char*)> println = [](const char* ln) {
SkDebugf("%s\n", ln);
}) {
SkSL::String sksl = GrSKSLPrettyPrint::PrettyPrint(skslStrings, lengths, count, false);
println("SKSL:");
print_source_lines_with_numbers(sksl.c_str(), println);
}
static void print_glsl_line_by_line(const SkSL::String& glsl,
std::function<void(const char*)> println = [](const char* ln) {
SkDebugf("%s\n", ln);
}) {
println("GLSL:");
print_source_lines_with_numbers(glsl.c_str(), println);
}
void print_shader_banner(GrGLenum type) {
const char* typeName = "Unknown";
switch (type) {
case GR_GL_VERTEX_SHADER: typeName = "Vertex"; break;
case GR_GL_GEOMETRY_SHADER: typeName = "Geometry"; break;
case GR_GL_FRAGMENT_SHADER: typeName = "Fragment"; break;
}
SkDebugf("---- %s shader ----------------------------------------------------\n", typeName);
}
std::unique_ptr<SkSL::Program> GrSkSLtoGLSL(const GrGLContext& context, GrGLenum type,
const char** skslStrings, int* lengths, int count,
const SkSL::Program::Settings& settings,
SkSL::String* glsl) {
// Trace event for shader preceding driver compilation
bool traceShader;
TRACE_EVENT_CATEGORY_GROUP_ENABLED("skia.gpu", &traceShader);
if (traceShader) {
SkString shaderDebugString;
print_sksl_line_by_line(skslStrings, lengths, count, [&](const char* ln) {
shaderDebugString.append(ln);
shaderDebugString.append("\n");
});
TRACE_EVENT_INSTANT1("skia.gpu", "skia_gpu::GLShader",
TRACE_EVENT_SCOPE_THREAD, "shader",
TRACE_STR_COPY(shaderDebugString.c_str()));
}
SkSL::String sksl;
#ifdef SK_DEBUG
sksl = GrSKSLPrettyPrint::PrettyPrint(skslStrings, lengths, count, false);
#else
for (int i = 0; i < count; i++) {
sksl.append(skslStrings[i], lengths[i]);
}
#endif
SkSL::Compiler* compiler = context.compiler();
std::unique_ptr<SkSL::Program> program;
SkSL::Program::Kind programKind;
switch (type) {
case GR_GL_VERTEX_SHADER: programKind = SkSL::Program::kVertex_Kind; break;
case GR_GL_FRAGMENT_SHADER: programKind = SkSL::Program::kFragment_Kind; break;
case GR_GL_GEOMETRY_SHADER: programKind = SkSL::Program::kGeometry_Kind; break;
default: SK_ABORT("unsupported shader kind");
}
program = compiler->convertProgram(programKind, sksl, settings);
if (!program || !compiler->toGLSL(*program, glsl)) {
SkDebugf("SKSL compilation error\n----------------------\n");
print_sksl_line_by_line(skslStrings, lengths, count);
SkDebugf("\nErrors:\n%s\n", compiler->errorText().c_str());
SkDEBUGFAIL("SKSL compilation failed!\n");
return nullptr;
}
if (gPrintSKSL) {
print_shader_banner(type);
print_sksl_line_by_line(skslStrings, lengths, count);
}
return program;
}
GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx,
GrGLuint programId,
GrGLenum type,
const char* glsl,
int glslLength,
GrGpu::Stats* stats,
const SkSL::Program::Settings& settings) {
const GrGLInterface* gli = glCtx.interface();
// Specify GLSL source to the driver.
GrGLuint shaderId;
GR_GL_CALL_RET(gli, shaderId, CreateShader(type));
if (0 == shaderId) {
return 0;
}
GR_GL_CALL(gli, ShaderSource(shaderId, 1, &glsl, &glslLength));
stats->incShaderCompilations();
GR_GL_CALL(gli, CompileShader(shaderId));
// Calling GetShaderiv in Chromium is quite expensive. Assume success in release builds.
bool checkCompiled = kChromium_GrGLDriver != glCtx.driver();
#ifdef SK_DEBUG
checkCompiled = true;
#endif
if (checkCompiled) {
GrGLint compiled = GR_GL_INIT_ZERO;
GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_COMPILE_STATUS, &compiled));
if (!compiled) {
SkDebugf("GLSL compilation error\n----------------------\n");
print_glsl_line_by_line(glsl);
GrGLint infoLen = GR_GL_INIT_ZERO;
GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_INFO_LOG_LENGTH, &infoLen));
SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
if (infoLen > 0) {
// retrieve length even though we don't need it to workaround bug in Chromium cmd
// buffer param validation.
GrGLsizei length = GR_GL_INIT_ZERO;
GR_GL_CALL(gli, GetShaderInfoLog(shaderId, infoLen+1, &length, (char*)log.get()));
SkDebugf("Errors:\n%s\n", (const char*) log.get());
}
// In Chrome we may have failed due to context-loss. So we should just continue along
// wihthout asserting until the GrContext gets abandoned.
if (kChromium_GrGLDriver != glCtx.driver()) {
SkDEBUGFAIL("GLSL compilation failed!");
}
GR_GL_CALL(gli, DeleteShader(shaderId));
return 0;
}
}
if (gPrintGLSL) {
print_shader_banner(type);
print_glsl_line_by_line(glsl);
}
// Attach the shader, but defer deletion until after we have linked the program.
// This works around a bug in the Android emulator's GLES2 wrapper which
// will immediately delete the shader object and free its memory even though it's
// attached to a program, which then causes glLinkProgram to fail.
GR_GL_CALL(gli, AttachShader(programId, shaderId));
return shaderId;
}
void GrGLPrintShader(const GrGLContext& context, GrGLenum type, const char** skslStrings,
int* lengths, int count, const SkSL::Program::Settings& settings) {
print_sksl_line_by_line(skslStrings, lengths, count);
SkSL::String glsl;
if (GrSkSLtoGLSL(context, type, skslStrings, lengths, count, settings, &glsl)) {
print_glsl_line_by_line(glsl);
}
}
|
