void onDraw(SkCanvas* canvas) override {
SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mode));
// gradient should appear over color bitmap
SkAutoTUnref<SkShader> shader0(new SkComposeShader(fLinearGradientShader,
fColorBitmapShader,
xfer));
// gradient should appear over alpha8 bitmap colorized by the paint color
SkAutoTUnref<SkShader> shader1(new SkComposeShader(fLinearGradientShader,
fAlpha8BitmapShader,
xfer));
SkShader* shaders[] = { shader0.get(), shader1.get() };
SkPaint paint;
paint.setColor(SK_ColorYELLOW);
const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength),
SkIntToScalar(squareLength));
for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
SkShader* shader = shaders[y];
canvas->save();
for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
paint.setAlpha(alpha);
paint.setShader(shader);
canvas->drawRect(r, paint);
canvas->translate(r.width() + 5, 0);
}
canvas->restore();
canvas->translate(0, r.height() + 5);
}
}
void onDraw(SkCanvas* canvas) override {
SkAutoTUnref<SkShader> shader0(make_shader(SkXfermode::kDstIn_Mode));
SkAutoTUnref<SkShader> shader1(make_shader(SkXfermode::kSrcOver_Mode));
SkShader* shaders[] = { shader0.get(), shader1.get() };
SkPaint paint;
paint.setColor(SK_ColorGREEN);
const SkRect r = SkRect::MakeXYWH(5, 5, 100, 100);
for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
SkShader* shader = shaders[y];
canvas->save();
for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
paint.setAlpha(0xFF);
paint.setShader(nullptr);
canvas->drawRect(r, paint);
paint.setAlpha(alpha);
paint.setShader(shader);
canvas->drawRect(r, paint);
canvas->translate(r.width() + 5, 0);
}
canvas->restore();
canvas->translate(0, r.height() + 5);
}
}
void canDetachAllShaders()
{
ShaderProgram shaderProgram;
Shader shader1(Shader::VERTEX_SHADER);
Shader shader2(Shader::FRAGMENT_SHADER);
QVERIFY(shaderProgram.attach(shader1));
QVERIFY(shaderProgram.attach(shader2));
QVERIFY(shaderProgram.has(shader1));
QVERIFY(shaderProgram.has(shader2));
shaderProgram.detachAllShaders();
QVERIFY(!shaderProgram.has(shader1));
QVERIFY(!shaderProgram.has(shader2));
}
//--------------------------------------------------------------------------
void GLShadersTests::tests()
{
GLVertexShader shader1("vert");
CPPUNIT_ASSERT(shader1.name() == "vert");
CPPUNIT_ASSERT(GL_VERTEX_SHADER == shader1.target());
GLFragmentShader shader2("frag");
CPPUNIT_ASSERT(shader2.name() == "frag");
CPPUNIT_ASSERT(GL_FRAGMENT_SHADER == shader2.target());
GLGeometryShader shader3;
CPPUNIT_ASSERT(shader3.name() == "");
CPPUNIT_ASSERT(GL_GEOMETRY_SHADER == shader3.target());
//--- Check initial state
CPPUNIT_ASSERT(shader1.m_shader_code == "");
CPPUNIT_ASSERT(shader1.m_error_msg == "");
CPPUNIT_ASSERT(!shader1.m_compiled);
CPPUNIT_ASSERT(0 == shader1.m_attached);
//--- Check initial state
CPPUNIT_ASSERT(shader2.code() == "");
CPPUNIT_ASSERT(shader2.error() == "");
CPPUNIT_ASSERT(!shader2.hasErrored());
CPPUNIT_ASSERT(!shader2.compiled());
CPPUNIT_ASSERT(0 == shader2.m_attached);
//--- Load from string
shader1.fromString("foobar");
CPPUNIT_ASSERT(!shader1.hasErrored());
CPPUNIT_ASSERT(shader1.code() == "foobar");
CPPUNIT_ASSERT(shader1.loaded());
CPPUNIT_ASSERT(!shader1.compiled());
try {
shader1.throw_if_not_loaded();
} catch(...) { CPPUNIT_FAIL("Exception should have not occured"); }
try {
shader1.throw_if_already_compiled();
CPPUNIT_FAIL("Exception should have occured");
} catch(...) { }
shader1.fromString("");
CPPUNIT_ASSERT(!shader1.hasErrored());
CPPUNIT_ASSERT(shader1.code() == "");
CPPUNIT_ASSERT(!shader1.loaded());
CPPUNIT_ASSERT(!shader1.compiled());
//--- Load from wrong file
CPPUNIT_ASSERT(shader3.code() == "");
CPPUNIT_ASSERT(!shader3.fromFile("this_file_does_not_exist"));
CPPUNIT_ASSERT(!shader3.compiled());
CPPUNIT_ASSERT(shader3.hasErrored());
CPPUNIT_ASSERT(shader3.code() == "");
CPPUNIT_ASSERT(!shader3.compiled());
CPPUNIT_ASSERT(shader3.error() != "");
CPPUNIT_ASSERT(!shader3.hasErrored());
try {
shader3.throw_if_not_loaded();
CPPUNIT_FAIL("Exception should have occured");
} catch(...) { }
try {
shader3.throw_if_already_compiled();
} catch(...) { CPPUNIT_FAIL("Exception should have not occured"); }
shader3.m_need_setup = false;
try {
shader3.throw_if_already_compiled();
CPPUNIT_FAIL("Exception should have occured");
} catch(...) { }
//---
shader2.attachProg(0);
CPPUNIT_ASSERT_EQUAL(0u, shader2.attached());
shader2.attachProg(42);
CPPUNIT_ASSERT_EQUAL(42u, shader2.attached());
//--- Try setup
shader1.m_error_msg = "";
shader1.fromString(""); shader1.m_compiled = true;
shader1.setup();
CPPUNIT_ASSERT(shader1.hasErrored());
CPPUNIT_ASSERT(shader1.error() != "");
shader1.setup();
//--- Try setup
shader1.m_error_msg = "";
shader1.fromString("ff"); shader1.m_compiled = true;
shader1.setup();
CPPUNIT_ASSERT(shader1.hasErrored());
CPPUNIT_ASSERT(shader1.error() != "");
shader1.setup();
// TODO shader1.begin();
}
int main(int argc, char** argv){
// Set interactive mode for debugging the program when started with arguments
bool interactive = false;
if(argc > 1) interactive = true;
// Initialize GLFW
if (!glfwInit()) fatalError("GLFW could not be initialized");
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create window
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, NAME, NULL, NULL);
if (window == NULL) fatalError("Failed to create GLFW window");
glfwMakeContextCurrent(window);
// Controls
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, keycallback);
// Start GLEW
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) fatalError("Failed to initialize GLEW");
glViewport(0, 0, WIDTH, HEIGHT);
// Load shaders
Shader shader1("shaders/basic.vertex", "shaders/basic.frag");
shader1.use();
glUniform1f(glGetUniformLocation(shader1.program, "first"), FIRST);
glUniform1f(glGetUniformLocation(shader1.program, "second"), SECOND);
glUniform1f(glGetUniformLocation(shader1.program, "third"), THIRD);
Shader shader2("shaders/basic.vertex", "shaders/advanced.frag");
// Raster scene settings
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f), -90.0f, 0.0f);
GLfloat vertices[] = {
-1.0f, -1.0f, 0.0f, -1.0f, -1.0f,
1.0f, -1.0f, 0.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 0.0f, -1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f
};
GLuint indices[] = {
0, 1, 2,
2, 1, 3
};
GLuint VAO, VBO, EBO;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*) (3* sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glGenBuffers(1, &EBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glBindVertexArray(0);
// FPS counter
bool isTicking = true;
int fpscount = 0;
GLfloat fpstime = 0.0f;
// Frame timings
GLfloat timeFromStart = START;
GLfloat lastFrame = (GLfloat) glfwGetTime();
GLfloat thisFrame = (GLfloat) glfwGetTime();
GLfloat deltaTime = thisFrame - lastFrame;
Shader shader = shader1;
int shaderNum = 1;
while(!glfwWindowShouldClose(window)){
thisFrame = (GLfloat) glfwGetTime();
deltaTime = thisFrame - lastFrame;
if(isTicking){
timeFromStart += deltaTime;
fpscount++;
fpstime += deltaTime;
if(fpstime > 1.0f) {
if(FPSlog){
std::cout << "FPS: " << (GLfloat) fpscount / fpstime << std::endl;
}
fpstime = 0.0f;
fpscount = 0;
}
}
// Handle Inputs if we are in interactive mode
//if (interactive) {
glfwPollEvents();
handleKeys(window, timeFromStart, isTicking, shader);
//}
glClearColor(0.05f, 0.05f, 0.05f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 model;
model = glm::scale(model, glm::vec3(SCALE, SCALE, SCALE));
glm::mat4 view;
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
glm::mat4 proj = glm::perspective(glm::radians(45.0f), (GLfloat) WIDTH / (GLfloat) HEIGHT, 0.1f, 100.0f);
glm::mat4 trans = proj * view * model;
if(timeFromStart > 40.0f && shaderNum == 1) {
shader = shader2;
shaderNum++;
}
shader.use();
glUniform1f(glGetUniformLocation(shader.program, "time"), timeFromStart);
glUniformMatrix4fv(glGetUniformLocation(shader.program, "transform"), 1, GL_FALSE, glm::value_ptr(trans));
glBindVertexArray(VAO);
// Draw
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glfwSwapBuffers(window);
lastFrame = thisFrame;
}
glfwTerminate();
return 0;
}
