You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
220 lines
7.4 KiB
220 lines
7.4 KiB
//
|
|
// Copyright 2014 The ANGLE Project Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
//
|
|
|
|
// Based on Stencil_Test.c from
|
|
// Book: OpenGL(R) ES 2.0 Programming Guide
|
|
// Authors: Aaftab Munshi, Dan Ginsburg, Dave Shreiner
|
|
// ISBN-10: 0321502795
|
|
// ISBN-13: 9780321502797
|
|
// Publisher: Addison-Wesley Professional
|
|
// URLs: http://safari.informit.com/9780321563835
|
|
// http://www.opengles-book.com
|
|
|
|
#include "SampleApplication.h"
|
|
|
|
#include "util/shader_utils.h"
|
|
|
|
class StencilOperationsSample : public SampleApplication
|
|
{
|
|
public:
|
|
StencilOperationsSample(int argc, char **argv)
|
|
: SampleApplication("StencilOperations", argc, argv)
|
|
{}
|
|
|
|
bool initialize() override
|
|
{
|
|
constexpr char kVS[] = R"(attribute vec4 a_position;
|
|
void main()
|
|
{
|
|
gl_Position = a_position;
|
|
})";
|
|
|
|
constexpr char kFS[] = R"(precision mediump float;
|
|
uniform vec4 u_color;
|
|
void main()
|
|
{
|
|
gl_FragColor = u_color;
|
|
})";
|
|
|
|
mProgram = CompileProgram(kVS, kFS);
|
|
if (!mProgram)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get the attribute locations
|
|
mPositionLoc = glGetAttribLocation(mProgram, "a_position");
|
|
|
|
// Get the sampler location
|
|
mColorLoc = glGetUniformLocation(mProgram, "u_color");
|
|
|
|
// Set the clear color
|
|
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
// Set the stencil clear value
|
|
glClearStencil(0x01);
|
|
|
|
// Set the depth clear value
|
|
glClearDepthf(0.75f);
|
|
|
|
// Enable the depth and stencil tests
|
|
glEnable(GL_DEPTH_TEST);
|
|
glEnable(GL_STENCIL_TEST);
|
|
|
|
return true;
|
|
}
|
|
|
|
void destroy() override { glDeleteProgram(mProgram); }
|
|
|
|
void draw() override
|
|
{
|
|
GLfloat vertices[] = {
|
|
-0.75f, 0.25f, 0.50f, // Quad #0
|
|
-0.25f, 0.25f, 0.50f, -0.25f, 0.75f, 0.50f, -0.75f, 0.75f, 0.50f,
|
|
0.25f, 0.25f, 0.90f, // Quad #1
|
|
0.75f, 0.25f, 0.90f, 0.75f, 0.75f, 0.90f, 0.25f, 0.75f, 0.90f,
|
|
-0.75f, -0.75f, 0.50f, // Quad #2
|
|
-0.25f, -0.75f, 0.50f, -0.25f, -0.25f, 0.50f, -0.75f, -0.25f, 0.50f,
|
|
0.25f, -0.75f, 0.50f, // Quad #3
|
|
0.75f, -0.75f, 0.50f, 0.75f, -0.25f, 0.50f, 0.25f, -0.25f, 0.50f,
|
|
-1.00f, -1.00f, 0.00f, // Big Quad
|
|
1.00f, -1.00f, 0.00f, 1.00f, 1.00f, 0.00f, -1.00f, 1.00f, 0.00f,
|
|
};
|
|
|
|
GLubyte indices[][6] = {
|
|
{0, 1, 2, 0, 2, 3}, // Quad #0
|
|
{4, 5, 6, 4, 6, 7}, // Quad #1
|
|
{8, 9, 10, 8, 10, 11}, // Quad #2
|
|
{12, 13, 14, 12, 14, 15}, // Quad #3
|
|
{16, 17, 18, 16, 18, 19}, // Big Quad
|
|
};
|
|
|
|
static const size_t testCount = 4;
|
|
GLfloat colors[testCount][4] = {
|
|
{1.0f, 0.0f, 0.0f, 1.0f},
|
|
{0.0f, 1.0f, 0.0f, 1.0f},
|
|
{0.0f, 0.0f, 1.0f, 1.0f},
|
|
{1.0f, 1.0f, 0.0f, 0.0f},
|
|
};
|
|
|
|
GLuint stencilValues[testCount] = {
|
|
0x7, // Result of test 0
|
|
0x0, // Result of test 1
|
|
0x2, // Result of test 2
|
|
0xff // Result of test 3. We need to fill this value in at run-time
|
|
};
|
|
|
|
// Set the viewport
|
|
glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
|
|
|
|
// Clear the color, depth, and stencil buffers. At this point, the stencil
|
|
// buffer will be 0x1 for all pixels
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
|
|
|
|
// Use the program object
|
|
glUseProgram(mProgram);
|
|
|
|
// Load the vertex data
|
|
glVertexAttribPointer(mPositionLoc, 3, GL_FLOAT, GL_FALSE, 0, vertices);
|
|
glEnableVertexAttribArray(mPositionLoc);
|
|
|
|
// Test 0:
|
|
//
|
|
// Initialize upper-left region. In this case, the stencil-buffer values will
|
|
// be replaced because the stencil test for the rendered pixels will fail the
|
|
// stencil test, which is
|
|
//
|
|
// ref mask stencil mask
|
|
// ( 0x7 & 0x3 ) < ( 0x1 & 0x7 )
|
|
//
|
|
// The value in the stencil buffer for these pixels will be 0x7.
|
|
glStencilFunc(GL_LESS, 0x7, 0x3);
|
|
glStencilOp(GL_REPLACE, GL_DECR, GL_DECR);
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[0]);
|
|
|
|
// Test 1:
|
|
//
|
|
// Initialize the upper-right region. Here, we'll decrement the stencil-buffer
|
|
// values where the stencil test passes but the depth test fails. The stencil test is
|
|
//
|
|
// ref mask stencil mask
|
|
// ( 0x3 & 0x3 ) > ( 0x1 & 0x3 )
|
|
//
|
|
// but where the geometry fails the depth test. The stencil values for these pixels
|
|
// will be 0x0.
|
|
glStencilFunc(GL_GREATER, 0x3, 0x3);
|
|
glStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[1]);
|
|
|
|
// Test 2:
|
|
//
|
|
// Initialize the lower-left region. Here we'll increment (with saturation) the
|
|
// stencil value where both the stencil and depth tests pass. The stencil test for
|
|
// these pixels will be
|
|
//
|
|
// ref mask stencil mask
|
|
// ( 0x1 & 0x3 ) == ( 0x1 & 0x3 )
|
|
//
|
|
// The stencil values for these pixels will be 0x2.
|
|
glStencilFunc(GL_EQUAL, 0x1, 0x3);
|
|
glStencilOp(GL_KEEP, GL_INCR, GL_INCR);
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[2]);
|
|
|
|
// Test 3:
|
|
//
|
|
// Finally, initialize the lower-right region. We'll invert the stencil value
|
|
// where the stencil tests fails. The stencil test for these pixels will be
|
|
//
|
|
// ref mask stencil mask
|
|
// ( 0x2 & 0x1 ) == ( 0x1 & 0x1 )
|
|
//
|
|
// The stencil value here will be set to ~((2^s-1) & 0x1), (with the 0x1 being
|
|
// from the stencil clear value), where 's' is the number of bits in the stencil
|
|
// buffer
|
|
glStencilFunc(GL_EQUAL, 0x2, 0x1);
|
|
glStencilOp(GL_INVERT, GL_KEEP, GL_KEEP);
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[3]);
|
|
|
|
// Since we don't know at compile time how many stencil bits are present, we'll
|
|
// query, and update the value correct value in the stencilValues arrays for the
|
|
// fourth tests. We'll use this value later in rendering.
|
|
GLint stencilBitCount = 0;
|
|
glGetIntegerv(GL_STENCIL_BITS, &stencilBitCount);
|
|
stencilValues[3] = ~(((1 << stencilBitCount) - 1) & 0x1) & 0xff;
|
|
|
|
// Use the stencil buffer for controlling where rendering will occur. We disable
|
|
// writing to the stencil buffer so we can test against them without modifying
|
|
// the values we generated.
|
|
glStencilMask(0x0);
|
|
|
|
for (size_t i = 0; i < testCount; ++i)
|
|
{
|
|
glStencilFunc(GL_EQUAL, stencilValues[i], 0xff);
|
|
glUniform4fv(mColorLoc, 1, colors[i]);
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[4]);
|
|
}
|
|
|
|
// Reset the stencil mask
|
|
glStencilMask(0xFF);
|
|
}
|
|
|
|
private:
|
|
// Handle to a program object
|
|
GLuint mProgram;
|
|
|
|
// Attribute locations
|
|
GLint mPositionLoc;
|
|
|
|
// Uniform locations
|
|
GLint mColorLoc;
|
|
};
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
StencilOperationsSample app(argc, argv);
|
|
return app.run();
|
|
}
|