void
OpenGL::InitShaders()
{
DeinitShaders();
solid_shader = CompileProgram(solid_vertex_shader, solid_fragment_shader);
solid_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
solid_shader->BindAttribLocation(Attribute::POSITION, "position");
solid_shader->BindAttribLocation(Attribute::COLOR, "color");
LinkProgram(*solid_shader);
solid_projection = solid_shader->GetUniformLocation("projection");
solid_modelview = solid_shader->GetUniformLocation("modelview");
solid_shader->Use();
glUniformMatrix4fv(solid_modelview, 1, GL_FALSE,
glm::value_ptr(glm::mat4()));
texture_shader = CompileProgram(texture_vertex_shader, texture_fragment_shader);
texture_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
texture_shader->BindAttribLocation(Attribute::POSITION, "position");
texture_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord");
LinkProgram(*texture_shader);
texture_projection = texture_shader->GetUniformLocation("projection");
texture_texture = texture_shader->GetUniformLocation("texture");
texture_shader->Use();
glUniform1i(texture_texture, 0);
invert_shader = CompileProgram(invert_vertex_shader, invert_fragment_shader);
invert_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
invert_shader->BindAttribLocation(Attribute::POSITION, "position");
invert_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord");
LinkProgram(*invert_shader);
invert_projection = invert_shader->GetUniformLocation("projection");
invert_texture = invert_shader->GetUniformLocation("texture");
invert_shader->Use();
glUniform1i(invert_texture, 0);
alpha_shader = CompileProgram(alpha_vertex_shader, alpha_fragment_shader);
alpha_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
alpha_shader->BindAttribLocation(Attribute::POSITION, "position");
alpha_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord");
alpha_shader->BindAttribLocation(Attribute::COLOR, "color");
LinkProgram(*alpha_shader);
alpha_projection = alpha_shader->GetUniformLocation("projection");
alpha_texture = alpha_shader->GetUniformLocation("texture");
alpha_shader->Use();
glUniform1i(alpha_texture, 0);
glVertexAttrib4f(Attribute::TRANSLATE, 0, 0, 0, 0);
}
GLuint GLCanvas::LoadCompileLinkShaders() {
std::cout << "load, compile, & link shaders" << std::endl;
std::string v_string = ReadFile("shadows.vs");
char *v = (char*) v_string.c_str();
std::string f_string = ReadFile("shadows.fs");
char *f = (char*) f_string.c_str();
CompileProgram(v, &vertex_shader);
CompileProgram(f, &fragment_shader);
LinkProgram(program);
HandleGLError("Failed to compile or link shaders");
return glGetUniformLocationARB(program,"ShadowMap");
}
bool DSPointLightingPassShader::Init()
{
if (!CompileProgram("PointLightPass")) {
return false;
}
if (!DSLightingPassShader::Init()) {
return false;
}
m_pointLightLocation.Color = GetUniformLocation("gPointLight.Base.Color");
m_pointLightLocation.AmbientIntensity = GetUniformLocation("gPointLight.Base.AmbientIntensity");
m_pointLightLocation.Position = GetUniformLocation("gPointLight.Position");
m_pointLightLocation.DiffuseIntensity = GetUniformLocation("gPointLight.Base.DiffuseIntensity");
m_pointLightLocation.Atten.Constant = GetUniformLocation("gPointLight.Atten.Constant");
m_pointLightLocation.Atten.Linear = GetUniformLocation("gPointLight.Atten.Linear");
m_pointLightLocation.Atten.Exp = GetUniformLocation("gPointLight.Atten.Exp");
if (m_pointLightLocation.Color == INVALID_UNIFORM_LOCATION ||
m_pointLightLocation.AmbientIntensity == INVALID_UNIFORM_LOCATION ||
m_pointLightLocation.Position == INVALID_UNIFORM_LOCATION ||
m_pointLightLocation.DiffuseIntensity == INVALID_UNIFORM_LOCATION ||
m_pointLightLocation.Atten.Constant == INVALID_UNIFORM_LOCATION ||
m_pointLightLocation.Atten.Linear == INVALID_UNIFORM_LOCATION ||
m_pointLightLocation.Atten.Exp == INVALID_UNIFORM_LOCATION) {
return false;
}
return true;
}
void SetUp() override
{
ANGLETest::SetUp();
glGenTextures(2, mTextures);
mProgram = CompileProgram(
"attribute vec2 a_position;\n"
"varying vec2 v_texcoord;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(a_position, 0.0, 1.0);\n"
" v_texcoord = (a_position + 1.0) * 0.5;\n"
"}\n",
"precision mediump float;\n"
"uniform sampler2D u_texture;\n"
"varying vec2 v_texcoord;\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D(u_texture, v_texcoord);\n"
"}\n");
ASSERT_NE(0u, mProgram);
if (extensionEnabled("GL_CHROMIUM_copy_compressed_texture"))
{
glCompressedCopyTextureCHROMIUM =
reinterpret_cast<PFNGLCOMPRESSEDCOPYTEXTURECHROMIUMPROC>(
eglGetProcAddress("glCompressedCopyTextureCHROMIUM"));
}
}
bool Shader::LoadFromMemory(const std::string& shader)
{
// Save the shader code
myFragmentShader = shader;
// Create the shaders and the program
return CompileProgram();
}
/**
* シェーダコンパイル
*/
BOOL CShaderConverter::CompileShader(
const SShaderConfig& config,
LPCSTR lpszObjDir)
{
// 頂点プログラムをコンパイル
BOOL b0 = CompileProgram(
TRUE,
config,
lpszObjDir);
// ピクセルプログラムをコンパイル
BOOL b1 = CompileProgram(
FALSE,
config,
lpszObjDir);
return (b0 && b1);
}
Shader::Shader(const Shader& copy) :
myShaderProgram (0),
myCurrentTexture(copy.myCurrentTexture),
myTextures (copy.myTextures),
myFragmentShader(copy.myFragmentShader)
{
// Create the shaders and the program
if (copy.myShaderProgram)
CompileProgram();
}
GLuint CompileProgramFromFile(const char *vertexPath, const char *fragmentPath)
{
std::string vsource;
PreProcessShader(vertexPath, vsource);
std::string fsource;
PreProcessShader(fragmentPath, fsource);
return CompileProgram(vsource.c_str(), fsource.c_str());
}
GLuint CompileProgramFromFiles(const std::string &vsPath, const std::string &fsPath)
{
std::string vsSource = ReadFileToString(vsPath);
std::string fsSource = ReadFileToString(fsPath);
if (vsSource.empty() || fsSource.empty())
{
return 0;
}
return CompileProgram(vsSource, fsSource);
}
bool NullTechnique::Init()
{
if (!CompileProgram("NullTechnique")) {
return false;
}
m_WVPLocation = GetUniformLocation("gWVP");
if (m_WVPLocation == INVALID_UNIFORM_LOCATION) {
return false;
}
return true;
}
bool StaticNullShader::Init()
{
if (!CompileProgram("StaticNullShader")) {
return false;
}
m_WVPLocation = GetUniformLocation("gWVP");
if (m_WVPLocation == INVALID_UNIFORM_LOCATION) {
return false;
}
return true;
}
GLuint ShaderManager::GetProgram(std::string const& name)
{
auto iter = shadercache_.find(name);
if (iter != shadercache_.end())
{
return iter->second;
}
else
{
GLuint program = CompileProgram(name);
shadercache_[name] = program;
return program;
}
}
bool StaticShadowMapShader::Init()
{
if (!CompileProgram("StaticShadowMap")) {
return false;
}
m_WVPLocation = GetUniformLocation("gWVP");
m_textureLocation = GetUniformLocation("gShadowMap");
if (m_WVPLocation == INVALID_UNIFORM_LOCATION ||
m_textureLocation == INVALID_UNIFORM_LOCATION) {
return false;
}
return true;
}
bool StaticModelShader::Init()
{
if (!CompileProgram("StaticModelGeometryPass"))
return false;
//glfxGenerateSampler(m_effect, "Sampler");
m_WVPLocation = GetUniformLocation("gWVP");
m_worldLocation = GetUniformLocation("gWorld");
m_colorSamplerLocation = GetUniformLocation("gColorTexture");
m_normalSamplerLocation = GetUniformLocation("gNormalTexture");
// Valide les uniforms
if (m_WVPLocation == INVALID_UNIFORM_LOCATION ||
m_worldLocation == INVALID_UNIFORM_LOCATION)
return false;
return true;
}
bool StaticShadowVolumeShader::Init()
{
if (!CompileProgram("StaticShadowVolume")) {
return false;
}
m_VPLocation = GetUniformLocation("gVP");
m_WorldMatrixLocation = GetUniformLocation("gWorld");
m_lightPosLocation = GetUniformLocation("gLightPos");
if (m_VPLocation == INVALID_UNIFORM_LOCATION ||
m_WorldMatrixLocation == INVALID_UNIFORM_LOCATION ||
m_lightPosLocation == INVALID_UNIFORM_LOCATION) {
return false;
}
return true;
}
bool Shader::LoadFromFile(const std::string& filename)
{
// Open the file
std::ifstream file(filename.c_str());
if (!file)
{
Err() << "Failed to open shader file \"" << filename << "\"" << std::endl;
return false;
}
// Read the shader code from the file
std::string line;
while (std::getline(file, line))
myFragmentShader += line + "\n";
// Create the shaders and the program
return CompileProgram();
}
bool DSGeomPassTech::Init()
{
if (!CompileProgram("GeometryPass")) {
return false;
}
m_WVPLocation = GetUniformLocation("gWVP");
m_WorldMatrixLocation = GetUniformLocation("gWorld");
m_colorTextureUnitLocation = GetUniformLocation("gColorMap");
if (m_WVPLocation == INVALID_UNIFORM_LOCATION ||
m_WorldMatrixLocation == INVALID_UNIFORM_LOCATION ||
m_colorTextureUnitLocation == INVALID_UNIFORM_LOCATION) {
return false;
}
return true;
}
void Init(GLFWwindow*) override {
const std::string vs =
R"(#version 450
in vec4 a_position;
void main(){
gl_Position = a_position;
})";
// Writes a fixed detph value and green.
// Section 15.2.3 of the GL 4.5 specification says that conversion is not
// done but clamping is so the output depth should be in [0.0, 1.0]
const std::string depthFs =
R"(#version 450
layout(location = 0) out vec4 fragColor;
void main(){
gl_FragDepth = 42.0f; // Works with 1.0f
fragColor = vec4(0.0, 1.0, 0.0, 1.0);
})";
mDepthProgram = CompileProgram(vs, depthFs);
glGenTextures(1, &mColorTexture);
glBindTexture(GL_TEXTURE_2D, mColorTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 640, 480);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glGenTextures(1, &mDepthTexture);
glBindTexture(GL_TEXTURE_2D, mDepthTexture);
// Works with DEPTH_COMPONENT24
glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F, 640, 480);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glGenFramebuffers(1, &mFramebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mColorTexture, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, mDepthTexture, 0);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
assert(glGetError() == GL_NO_ERROR);
}
virtual void SetUp()
{
ANGLETest::SetUp();
const std::string testVertexShaderSource = SHADER_SOURCE
(
attribute highp vec4 aPosition;
void main(void)
{
gl_Position = aPosition;
}
);
const std::string testFragmentShaderSource = SHADER_SOURCE
(
uniform highp vec4 color;
void main(void)
{
gl_FragColor = color;
}
);
mProgram = CompileProgram(testVertexShaderSource, testFragmentShaderSource);
if (mProgram == 0)
{
FAIL() << "shader compilation failed.";
}
mColorLocation = glGetUniformLocation(mProgram, "color");
glUseProgram(mProgram);
glClearColor(0, 0, 0, 0);
glClearDepthf(0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
}
static int ProgramMode(int adx, int argc, FChS * argv[])
{
FAssert(adx < argc);
FObject nam = MakeStringS(argv[adx]);
adx += 1;
R.CommandLine = MakePair(MakeInvocation(adx, argv), MakeCommandLine(argc - adx, argv + adx));
FObject port;
{
FDontWait dw;
port = OpenInputFile(nam);
if (TextualPortP(port) == 0)
{
#ifdef FOMENT_WINDOWS
printf("error: unable to open program: %S\n", argv[adx - 1]);
#endif // FOMENT_WINDOWS
#ifdef FOMENT_UNIX
printf("error: unable to open program: %s\n", argv[adx - 1]);
#endif // FOMENT_UNIX
return(Usage());
}
}
FCh ch;
// Skip #!/usr/local/bin/foment
if (PeekCh(port, &ch) && ch == '#')
ReadLine(port);
FObject proc = CompileProgram(nam, port);
ExecuteThunk(proc);
ExitFoment();
return(0);
}
virtual void SetUp()
{
ANGLETest::SetUp();
const std::string &vertexShader = "void main() { gl_Position = vec4(1); }";
const std::string &fragShader =
"precision mediump float;\n"
"uniform float uniF;\n"
"uniform int uniI;\n"
"void main() { gl_FragColor = vec4(uniF + float(uniI)); }";
mProgram = CompileProgram(vertexShader, fragShader);
ASSERT_NE(mProgram, 0u);
mUniformFLocation = glGetUniformLocation(mProgram, "uniF");
ASSERT_NE(mUniformFLocation, -1);
mUniformILocation = glGetUniformLocation(mProgram, "uniI");
ASSERT_NE(mUniformILocation, -1);
ASSERT_GL_NO_ERROR();
}
void SetUp() override
{
ANGLETest::SetUp();
const std::string vsSource =
"precision highp float;\n"
"attribute vec4 position;\n"
"varying vec2 texcoord;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = position;\n"
" texcoord = (position.xy * 0.5) + 0.5;\n"
" texcoord.y = 1.0 - texcoord.y;\n"
"}\n";
const std::string textureFSSource =
"precision highp float;\n"
"uniform sampler2D tex;\n"
"varying vec2 texcoord;\n"
"\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D(tex, texcoord);\n"
"}\n";
mTextureProgram = CompileProgram(vsSource, textureFSSource);
if (mTextureProgram == 0)
{
FAIL() << "shader compilation failed.";
}
mTextureUniformLocation = glGetUniformLocation(mTextureProgram, "tex");
ASSERT_GL_NO_ERROR();
}
void SetUp() override
{
ANGLETest::SetUp();
// TODO(fjhenigman): Factor out this shader and others like it in other tests, into
// ANGLETest.
const std::string vertexShader =
"attribute vec3 a_position;\n"
"varying vec2 v_texCoord;\n"
"void main() {\n"
" v_texCoord = a_position.xy * 0.5 + 0.5;\n"
" gl_Position = vec4(a_position, 1);\n"
"}\n";
const std::string fragmentShader =
"precision mediump float;\n"
"varying vec2 v_texCoord;\n"
"uniform sampler2D u_texture;\n"
"void main() {\n"
" gl_FragColor = texture2D(u_texture, v_texCoord);\n"
"}\n";
mProgram = CompileProgram(vertexShader, fragmentShader);
glUseProgram(mProgram);
GLint uniformLoc = glGetUniformLocation(mProgram, "u_texture");
ASSERT_NE(-1, uniformLoc);
glUniform1i(uniformLoc, 0);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
// fill framebuffer with unique pixels
mFBData.fill(fbTag);
GLTexture fbTexture;
mFBData.toTexture2D(GL_TEXTURE_2D, fbTexture);
drawQuad(mProgram, "a_position", 0.0f, 1.0f, true);
}
void SetUp() override
{
ANGLETest::SetUp();
const std::string vsSource =
R"(precision highp float;
attribute vec4 position;
varying vec2 texcoord;
void main()
{
gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5;
texcoord.y = 1.0 - texcoord.y;
})";
const std::string textureFSSource =
R"(precision highp float;
uniform sampler2D tex;
varying vec2 texcoord;
void main()
{
gl_FragColor = texture2D(tex, texcoord);
})";
const std::string textureFSSourceNoSampling =
R"(precision highp float;
void main()
{
gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);
})";
mTextureProgram = CompileProgram(vsSource, textureFSSource);
ASSERT_NE(0u, mTextureProgram) << "shader compilation failed.";
mTextureUniformLocation = glGetUniformLocation(mTextureProgram, "tex");
ASSERT_NE(-1, mTextureUniformLocation);
mTextureProgramNoSampling = CompileProgram(vsSource, textureFSSourceNoSampling);
ASSERT_NE(0u, mTextureProgramNoSampling) << "shader compilation failed.";
mD3D11Module = LoadLibrary(TEXT("d3d11.dll"));
ASSERT_NE(nullptr, mD3D11Module);
PFN_D3D11_CREATE_DEVICE createDeviceFunc = reinterpret_cast<PFN_D3D11_CREATE_DEVICE>(
GetProcAddress(mD3D11Module, "D3D11CreateDevice"));
EGLWindow *window = getEGLWindow();
EGLDisplay display = window->getDisplay();
if (eglDisplayExtensionEnabled(display, "EGL_EXT_device_query"))
{
PFNEGLQUERYDISPLAYATTRIBEXTPROC eglQueryDisplayAttribEXT =
reinterpret_cast<PFNEGLQUERYDISPLAYATTRIBEXTPROC>(
eglGetProcAddress("eglQueryDisplayAttribEXT"));
PFNEGLQUERYDEVICEATTRIBEXTPROC eglQueryDeviceAttribEXT =
reinterpret_cast<PFNEGLQUERYDEVICEATTRIBEXTPROC>(
eglGetProcAddress("eglQueryDeviceAttribEXT"));
EGLDeviceEXT device = 0;
{
EGLAttrib result = 0;
EXPECT_EGL_TRUE(eglQueryDisplayAttribEXT(display, EGL_DEVICE_EXT, &result));
device = reinterpret_cast<EGLDeviceEXT>(result);
}
if (eglDeviceExtensionEnabled(device, "EGL_ANGLE_device_d3d"))
{
EGLAttrib result = 0;
if (eglQueryDeviceAttribEXT(device, EGL_D3D11_DEVICE_ANGLE, &result))
{
mD3D11Device = reinterpret_cast<ID3D11Device *>(result);
mD3D11Device->AddRef();
}
else if (eglQueryDeviceAttribEXT(device, EGL_D3D9_DEVICE_ANGLE, &result))
{
mD3D9Device = reinterpret_cast<IDirect3DDevice9 *>(result);
mD3D9Device->AddRef();
}
}
}
else
{
ASSERT_TRUE(
SUCCEEDED(createDeviceFunc(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, nullptr,
0, D3D11_SDK_VERSION, &mD3D11Device, nullptr, nullptr)));
}
}
bool GLShader::setup(const char *vp, const char *fp, const char *fp2)
{
int err;
if ( ! HasGLSL())
{
Logger::log (LOG_ERROR,"%s doesn't support GLSL\n", glGetString(GL_RENDERER));
return false;
}
// printf("compiling vertex shader..\n");
err = CompileProgram(GL_VERTEX_SHADER_ARB, (GLcharARB*) vp, &vertShader);
if (0 != err)
{
Logger::log (LOG_ERROR,"----Vertex Shader could not compile\n");
Logger::log(LOG_DEBUG," VERTEX:\n\n%s\n\n ",vp);
Logger::log(LOG_DEBUG,"FRAGMENT: \n\n%s\n\n",fp);
return false;
}
// printf("compiling fragment shader..\n");
err = CompileProgram(GL_FRAGMENT_SHADER_ARB, (GLcharARB*)fp, &fragShader);
if (0 != err)
{
Logger::log (LOG_ERROR,"----Fragment Shader could not compile\n");
Logger::log(LOG_DEBUG,"VERTEX: \n\n%s\n\n ",vp);
Logger::log(LOG_DEBUG,"FRAGMENT: \n\n%s\n\n",fp);
return false;
}
if (fp2) if (strlen(fp2))
{
// printf("compiling fragment shader 2..\n");
err = CompileProgram(GL_FRAGMENT_SHADER_ARB, (GLcharARB*)fp2, &fragShader2);
if (0 != err)
{
Logger::log (LOG_ERROR,"Fragment Shader 2 could not compile\n");
return false;
}
}
program = glCreateProgramObjectARB();
glAttachObjectARB(program,fragShader);
glAttachObjectARB(program,vertShader);
if (fp2) if (strlen(fp2)) glAttachObjectARB(program,fragShader2);
//printf("Linking..\n");
err = LinkProgram(program);
if (GL_NO_ERROR != err)
{
return false;
}
//printf("ok\n\n");
loaded = true;
return true;
}
virtual bool initialize()
{
// Check whether the GL_ANGLE_multiview extension is supported. If not, abort
// initialization.
const char *allExtensions = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
const std::string paddedExtensions = std::string(" ") + allExtensions + std::string(" ");
if (paddedExtensions.find(std::string(" GL_ANGLE_multiview ")) == std::string::npos)
{
std::cout << "GL_ANGLE_multiview is not available." << std::endl;
return false;
}
// A view covers horizontally half of the screen.
int viewWidth = getWindow()->getWidth() / 2;
int viewHeight = getWindow()->getHeight();
// Create color and depth texture arrays with two layers to which we render each view.
glGenTextures(1, &mColorTexture);
glBindTexture(GL_TEXTURE_2D_ARRAY, mColorTexture);
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, viewWidth, viewHeight, 2, 0, GL_RGBA,
GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glGenTextures(1, &mDepthTexture);
glBindTexture(GL_TEXTURE_2D_ARRAY, mDepthTexture);
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_DEPTH_COMPONENT32F, viewWidth, viewHeight, 2, 0,
GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
// Generate multiview framebuffer for layered rendering.
glGenFramebuffers(1, &mMultiviewFBO);
glBindFramebuffer(GL_FRAMEBUFFER, mMultiviewFBO);
glFramebufferTextureMultiviewLayeredANGLE(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
mColorTexture, 0, 0, 2);
glFramebufferTextureMultiviewLayeredANGLE(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
mDepthTexture, 0, 0, 2);
GLenum drawBuffer = GL_COLOR_ATTACHMENT0;
glDrawBuffers(1, &drawBuffer);
// Check that the framebuffer is complete. Abort initialization otherwise.
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
return false;
}
// Create multiview program and query the uniform locations.
// The program has two code paths based on the gl_ViewID_OVR attribute which tells us which
// view is currently being rendered to. Based on it we decide which eye's camera matrix to
// use.
const std::string multiviewVS =
"#version 300 es\n"
"#extension GL_OVR_multiview : require\n"
"layout(num_views = 2) in;\n"
"layout(location=0) in vec3 posIn;\n"
"layout(location=1) in vec3 normalIn;\n"
"uniform mat4 uPerspective;\n"
"uniform mat4 uCameraLeftEye;\n"
"uniform mat4 uCameraRightEye;\n"
"uniform mat4 uTranslation;\n"
"out vec3 oNormal;\n"
"void main()\n"
"{\n"
" vec4 p = uTranslation * vec4(posIn,1.);\n"
" if (gl_ViewID_OVR == 0u) {\n"
" p = uCameraLeftEye * p;\n"
" } else {\n"
" p = uCameraRightEye * p;\n"
" }\n"
" oNormal = normalIn;\n"
" gl_Position = uPerspective * p;\n"
"}\n";
const std::string multiviewFS =
"#version 300 es\n"
"#extension GL_OVR_multiview : require\n"
"precision mediump float;\n"
"out vec4 color;\n"
"in vec3 oNormal;\n"
"void main()\n"
"{\n"
" vec3 col = 0.5 * oNormal + vec3(0.5);\n"
" color = vec4(col, 1.);\n"
"}\n";
mMultiviewProgram = CompileProgram(multiviewVS, multiviewFS);
if (!mMultiviewProgram)
{
return false;
}
mMultiviewPersperiveUniformLoc = glGetUniformLocation(mMultiviewProgram, "uPerspective");
mMultiviewLeftEyeCameraUniformLoc =
glGetUniformLocation(mMultiviewProgram, "uCameraLeftEye");
mMultiviewRightEyeCameraUniformLoc =
glGetUniformLocation(mMultiviewProgram, "uCameraRightEye");
mMultiviewTranslationUniformLoc = glGetUniformLocation(mMultiviewProgram, "uTranslation");
// Create a normal program to combine both layers of the color array texture.
const std::string combineVS =
"#version 300 es\n"
"in vec2 vIn;\n"
"out vec2 uv;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(vIn, 0., 1.);\n"
" uv = vIn * .5 + vec2(.5);\n"
"}\n";
const std::string combineFS =
"#version 300 es\n"
"precision mediump float;\n"
"precision mediump sampler2DArray;\n"
"uniform sampler2DArray uMultiviewTex;\n"
"in vec2 uv;\n"
"out vec4 color;\n"
"void main()\n"
"{\n"
" float scaledX = 2.0 * uv.x;\n"
" float layer = floor(scaledX);\n"
" vec2 adjustedUV = vec2(fract(scaledX), uv.y);\n"
" vec3 texColor = texture(uMultiviewTex, vec3(adjustedUV, layer)).rgb;\n"
" color = vec4(texColor, 1.);\n"
"}\n";
mCombineProgram = CompileProgram(combineVS, combineFS);
if (!mCombineProgram)
{
return false;
}
// Generate a quad which covers the whole screen.
glGenVertexArrays(1, &mQuadVAO);
glBindVertexArray(mQuadVAO);
glGenBuffers(1, &mQuadVBO);
glBindBuffer(GL_ARRAY_BUFFER, mQuadVBO);
const float kQuadPositionData[] = {1.f, -1.f, 1.f, 1.f, -1.f, -1.f, -1.f, 1.f};
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 8, kQuadPositionData, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
// Generate a cube.
GenerateCubeGeometry(1.0f, &mCube);
glGenVertexArrays(1, &mCubeVAO);
glBindVertexArray(mCubeVAO);
glGenBuffers(1, &mCubePosVBO);
glBindBuffer(GL_ARRAY_BUFFER, mCubePosVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(angle::Vector3) * mCube.positions.size(),
mCube.positions.data(), GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
glEnableVertexAttribArray(0);
glGenBuffers(1, &mCubeNormalVBO);
glBindBuffer(GL_ARRAY_BUFFER, mCubeNormalVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(angle::Vector3) * mCube.normals.size(),
mCube.normals.data(), GL_STATIC_DRAW);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
glEnableVertexAttribArray(1);
glGenBuffers(1, &mCubeIBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mCubeIBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * mCube.indices.size(),
mCube.indices.data(), GL_STATIC_DRAW);
glBindVertexArray(0);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
return true;
}
int Shader::CompileProgram(const byte* vs, const byte* fs, const byte* gs)
{
return CompileProgram((const char*) vs, (const char*) fs, (const char*) gs);
}
// --------------------------------------------------------------------------------------------------------------------
bool DynamicStreamingD3D11UpdateSubresource::Init(size_t _maxVertexCount)
{
D3D11_INPUT_ELEMENT_DESC elements[] =
{
{ "ATTR", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
if (!CompileProgram(L"streaming_vb_d3d11_vs.hlsl", &mVertexShader,
L"streaming_vb_d3d11_ps.hlsl", &mPixelShader,
ArraySize(elements), elements, &mInputLayout)) {
return false;
}
// Constant Buffer
HRESULT hr = CreateConstantBuffer(sizeof(Constants), nullptr, &mConstantBuffer);
if (FAILED(hr)) {
return false;
}
// Render States
{
D3D11_RASTERIZER_DESC desc;
desc.FillMode = D3D11_FILL_SOLID;
desc.CullMode = D3D11_CULL_NONE;
desc.FrontCounterClockwise = FALSE;
desc.DepthBias = 0;
desc.SlopeScaledDepthBias = 0.0f;
desc.DepthBiasClamp = 0.0f;
desc.DepthClipEnable = FALSE;
desc.ScissorEnable = FALSE;
desc.MultisampleEnable = FALSE;
desc.AntialiasedLineEnable = FALSE;
hr = g_d3d_device->CreateRasterizerState(&desc, &mRasterizerState);
if (FAILED(hr)) {
return false;
}
}
{
D3D11_BLEND_DESC desc;
desc.AlphaToCoverageEnable = FALSE;
desc.IndependentBlendEnable = FALSE;
D3D11_RENDER_TARGET_BLEND_DESC& rtDesc = desc.RenderTarget[0];
rtDesc.BlendEnable = TRUE;
rtDesc.SrcBlend = D3D11_BLEND_SRC_ALPHA;
rtDesc.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtDesc.BlendOp = D3D11_BLEND_OP_ADD;
rtDesc.SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
rtDesc.DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
rtDesc.BlendOpAlpha = D3D11_BLEND_OP_ADD;
rtDesc.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
hr = g_d3d_device->CreateBlendState(&desc, &mBlendState);
if (FAILED(hr)) {
return false;
}
}
{
D3D11_DEPTH_STENCIL_DESC desc;
desc.DepthEnable = FALSE;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
desc.DepthFunc = D3D11_COMPARISON_LESS;
desc.StencilEnable = FALSE;
desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
hr = g_d3d_device->CreateDepthStencilState(&desc, &mDepthStencilState);
if (FAILED(hr)) {
return false;
}
}
{
D3D11_SAMPLER_DESC desc;
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
desc.MipLODBias = 0.0f;
desc.MaxAnisotropy = 0;
desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
desc.BorderColor[0] = 0.0f;
desc.BorderColor[1] = 0.0f;
desc.BorderColor[2] = 0.0f;
desc.BorderColor[3] = 0.0f;
desc.MinLOD = 0;
desc.MaxLOD = D3D11_FLOAT32_MAX;
hr = g_d3d_device->CreateSamplerState(&desc, &mSamplerState);
if (FAILED(hr)) {
return false;
}
}
// Dynamic vertex buffer
mParticleBufferSize = kTripleBuffer * sizeof(Vec2) * _maxVertexCount;
hr = CreateDynamicVertexBuffer(mParticleBufferSize, nullptr, D3D11_USAGE_DEFAULT, 0, &mDynamicVertexBuffer);
if (FAILED(hr)) {
return false;
}
return true;
}
bool PointSpritesBenchmark::initializeBenchmark()
{
std::stringstream vstrstr;
// Verify "numVaryings" is within MAX_VARYINGS limit
GLint maxVaryings;
glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
if (mParams.numVaryings > static_cast<unsigned int>(maxVaryings))
{
std::cerr << "Varying count (" << mParams.numVaryings << ")"
<< " exceeds maximum varyings: " << maxVaryings << std::endl;
return false;
}
vstrstr << "attribute vec2 vPosition;\n"
"uniform float uPointSize;\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
vstrstr << "varying vec4 v" << varCount << ";\n";
}
vstrstr << "void main()\n"
"{\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
vstrstr << " v" << varCount << " = vec4(1.0);\n";
}
vstrstr << " gl_Position = vec4(vPosition, 0, 1.0);\n"
" gl_PointSize = uPointSize;\n"
"}";
std::stringstream fstrstr;
fstrstr << "precision mediump float;\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
fstrstr << "varying vec4 v" << varCount << ";\n";
}
fstrstr << "void main()\n"
"{\n"
" vec4 colorOut = vec4(1.0, 0.0, 0.0, 1.0);\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
fstrstr << " colorOut.r += v" << varCount << ".r;\n";
}
fstrstr << " gl_FragColor = colorOut;\n"
"}\n";
mProgram = CompileProgram(vstrstr.str(), fstrstr.str());
if (!mProgram)
{
return false;
}
// Use the program object
glUseProgram(mProgram);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
std::vector<float> vertexPositions(mParams.count * 2);
for (size_t pointIndex = 0; pointIndex < vertexPositions.size(); ++pointIndex)
{
vertexPositions[pointIndex] = RandomBetween(-1.0f, 1.0f);
}
glGenBuffers(1, &mBuffer);
glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
glBufferData(GL_ARRAY_BUFFER, vertexPositions.size() * sizeof(float), &vertexPositions[0], GL_STATIC_DRAW);
int positionLocation = glGetAttribLocation(mProgram, "vPosition");
if (positionLocation == -1)
{
return false;
}
glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(positionLocation);
// Set the viewport
glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
int pointSizeLocation = glGetUniformLocation(mProgram, "uPointSize");
if (pointSizeLocation == -1)
{
return false;
}
glUniform1f(pointSizeLocation, mParams.size);
GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR)
{
return false;
}
return true;
}
