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; }