bool initTexture() { bool Validated(true); gli::gl GL; gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); gli::gl::format const Format = GL.translate(Texture.format()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glCreateTextures(GL_TEXTURE_2D_ARRAY, 1, &TextureName); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_R, GL_RED); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTextureParameteri(TextureName, GL_TEXTURE_BASE_LEVEL, 0); glTextureParameteri(TextureName, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(Texture.levels() - 1)); glTextureParameteri(TextureName, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTextureParameteri(TextureName, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTextureStorage3D(TextureName, static_cast<GLint>(Texture.levels()), Format.Internal, static_cast<GLsizei>(Texture[0].extent().x), static_cast<GLsizei>(Texture[0].extent().y), static_cast<GLsizei>(1)); for(gli::texture2d::size_type Level = 0; Level < Texture.levels(); ++Level) { glTextureSubImage3D(TextureName, static_cast<GLint>(Level), 0, 0, 0, static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), static_cast<GLsizei>(1), Format.External, Format.Type, Texture[Level].data()); } return Validated; }
bool initTexture() { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); for(gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, GLint(Level), GL_RGBA8, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GL_BGR, GL_UNSIGNED_BYTE, Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return true; }
bool initTexture() { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE_DXT5).c_str())); glGenTextures(1, &TextureName); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } return this->checkError("initTexture"); }
bool initTexture() { gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); gli::gl GL(gli::gl::PROFILE_GL33); gli::gl::format const& Format = GL.translate(Texture.format(), Texture.swizzles()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, Format.Swizzles[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, Format.Swizzles[1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, Format.Swizzles[2]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, Format.Swizzles[3]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), Format.Internal, GLsizei(Texture[0].extent().x), GLsizei(Texture[0].extent().y)); for(gli::texture2d::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexSubImage2D(GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), Format.External, Format.Type, Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return true; }
bool initTexture() { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); gli::gl GL; glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); gli::gl::format const Format = GL.translate(Texture.format()); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, GLint(Level), Format.Internal, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, Format.External, Format.Type, Texture[Level].data()); } return this->checkError("initTexture"); }
bool initTexture() { glGenTextures(1, &Texture2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return this->checkError("initTexture"); }
bool initTexture() { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); gli::gl GL; gli::gl::format const Format = GL.translate(Texture.format()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), Format.Internal, GLsizei(Texture[0].dimensions().x), GLsizei(Texture[0].dimensions().y)); for(gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexSubImage2D(GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), Format.External, Format.Type, Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return true; }
bool testError() { compiler Compiler; Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER, "--version 150 --profile core --define GEN_ERROR"); return !Compiler.check(); }
bool initProgram() { bool Validated = true; glGenProgramPipelines(1, &PipelineName); if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER); GLuint ContShaderName = Compiler.create(GL_TESS_CONTROL_SHADER, getDataDirectory() + SAMPLE_CONT_SHADER); GLuint EvalShaderName = Compiler.create(GL_TESS_EVALUATION_SHADER, getDataDirectory() + SAMPLE_EVAL_SHADER); GLuint GeomShaderName = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER); ProgramName[program::VERT] = glCreateProgram(); ProgramName[program::FRAG] = glCreateProgram(); glProgramParameteri(ProgramName[program::VERT], GL_PROGRAM_SEPARABLE, GL_TRUE); glProgramParameteri(ProgramName[program::FRAG], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::VERT], VertShaderName); glAttachShader(ProgramName[program::VERT], ContShaderName); glAttachShader(ProgramName[program::VERT], EvalShaderName); glAttachShader(ProgramName[program::VERT], GeomShaderName); glLinkProgram(ProgramName[program::VERT]); glAttachShader(ProgramName[program::FRAG], FragShaderName); glLinkProgram(ProgramName[program::FRAG]); Validated = Validated && Compiler.check_program(ProgramName[program::VERT]); Validated = Validated && Compiler.check_program(ProgramName[program::FRAG]); } if(Validated) { glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_TESS_CONTROL_SHADER_BIT | GL_TESS_EVALUATION_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, ProgramName[program::VERT]); glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]); } if(Validated) { UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP"); } return Validated; }
bool initProgram() { bool Validated(true); glGenProgramPipelines(pipeline::MAX, &PipelineName[0]); if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TEXTURE, "--version 420 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_TEXTURE, "--version 420 --profile core"); Validated = Validated && Compiler.check(); ProgramName[pipeline::TEXTURE] = glCreateProgram(); glProgramParameteri(ProgramName[pipeline::TEXTURE], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[pipeline::TEXTURE], VertShaderName); glAttachShader(ProgramName[pipeline::TEXTURE], FragShaderName); glLinkProgram(ProgramName[pipeline::TEXTURE]); Validated = Validated && Compiler.checkProgram(ProgramName[pipeline::TEXTURE]); } if(Validated) glUseProgramStages(PipelineName[pipeline::TEXTURE], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[pipeline::TEXTURE]); if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_SPLASH, "--version 420 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_SPLASH, "--version 420 --profile core"); Validated = Validated && Compiler.check(); ProgramName[pipeline::SPLASH] = glCreateProgram(); glProgramParameteri(ProgramName[pipeline::SPLASH], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[pipeline::SPLASH], VertShaderName); glAttachShader(ProgramName[pipeline::SPLASH], FragShaderName); glLinkProgram(ProgramName[pipeline::SPLASH]); Validated = Validated && Compiler.checkProgram(ProgramName[pipeline::SPLASH]); } if(Validated) glUseProgramStages(PipelineName[pipeline::SPLASH], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[pipeline::SPLASH]); return Validated; }
bool initTexture() { bool Validated(true); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D(GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize() * this->FramebufferScale); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DEPTHBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::STENCILBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_STENCIL_INDEX8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, nullptr); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
bool initProgram() { bool Validated(true); compiler Compiler; if(Validated) { GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SHADER_VERT_SOURCE_UPDATE); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SHADER_FRAG_SOURCE_UPDATE); ProgramName[program::UPDATE] = glCreateProgram(); glProgramParameteri(ProgramName[program::UPDATE], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::UPDATE], VertShaderName); glAttachShader(ProgramName[program::UPDATE], FragShaderName); glLinkProgram(ProgramName[program::UPDATE]); } if(Validated) { GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SHADER_VERT_SOURCE_BLIT); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SHADER_FRAG_SOURCE_BLIT); ProgramName[program::BLIT] = glCreateProgram(); glProgramParameteri(ProgramName[program::BLIT], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::BLIT], VertShaderName); glAttachShader(ProgramName[program::BLIT], FragShaderName); glLinkProgram(ProgramName[program::BLIT]); } if(Validated) { Validated = Validated && Compiler.check_program(ProgramName[program::UPDATE]); Validated = Validated && Compiler.check_program(ProgramName[program::BLIT]); } if(Validated) { glGenProgramPipelines(pipeline::MAX, &PipelineName[0]); glUseProgramStages(PipelineName[pipeline::UPDATE], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::UPDATE]); glUseProgramStages(PipelineName[pipeline::BLIT], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::BLIT]); } return Validated && this->checkError("initProgram - stage"); }
bool initProgram() { bool Validated(true); std::vector<GLuint> ShaderName(shader::MAX); compiler Compiler; if(Validated) { ShaderName[shader::VERT_TEXTURE] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TEXTURE, "--version 150 --profile core"); ShaderName[shader::FRAG_TEXTURE] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_TEXTURE, "--version 150 --profile core"); ProgramName[program::TEXTURE] = glCreateProgram(); glAttachShader(ProgramName[program::TEXTURE], ShaderName[shader::VERT_TEXTURE]); glAttachShader(ProgramName[program::TEXTURE], ShaderName[shader::FRAG_TEXTURE]); glBindAttribLocation(ProgramName[program::TEXTURE], semantic::attr::POSITION, "Position"); glBindAttribLocation(ProgramName[program::TEXTURE], semantic::attr::TEXCOORD, "Texcoord"); glBindFragDataLocation(ProgramName[program::TEXTURE], semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName[program::TEXTURE]); } if(Validated) { ShaderName[shader::VERT_SPLASH] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_SPLASH, "--version 150 --profile core"); ShaderName[shader::FRAG_SPLASH] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_SPLASH, "--version 150 --profile core"); ProgramName[program::SPLASH] = glCreateProgram(); glAttachShader(ProgramName[program::SPLASH], ShaderName[shader::VERT_SPLASH]); glAttachShader(ProgramName[program::SPLASH], ShaderName[shader::FRAG_SPLASH]); glBindFragDataLocation(ProgramName[program::TEXTURE], semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName[program::SPLASH]); } if(Validated) { Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName[program::TEXTURE]); Validated = Validated && Compiler.checkProgram(ProgramName[program::SPLASH]); } if(Validated) UniformTransform = glGetUniformBlockIndex(ProgramName[program::TEXTURE], "transform"); return Validated && this->checkError("initProgram"); }
bool initProgram() { bool Validated = true; glGenProgramPipelines(1, &PipelineName); // Create program if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 410 --profile core"); GLuint GeomShaderName = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + GEOM_SHADER_SOURCE, "--version 410 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 410 --profile core"); Validated = Validated && Compiler.check(); ProgramName[program::VERT] = glCreateProgram(); ProgramName[program::FRAG] = glCreateProgram(); glAttachShader(ProgramName[program::VERT], VertShaderName); glAttachShader(ProgramName[program::VERT], GeomShaderName); glAttachShader(ProgramName[program::FRAG], FragShaderName); glProgramParameteri(ProgramName[program::VERT], GL_PROGRAM_SEPARABLE, GL_TRUE); glProgramParameteri(ProgramName[program::FRAG], GL_PROGRAM_SEPARABLE, GL_TRUE); glLinkProgram(ProgramName[program::VERT]); glLinkProgram(ProgramName[program::FRAG]); Validated = Validated && Compiler.check_program(ProgramName[program::VERT]); Validated = Validated && Compiler.check_program(ProgramName[program::FRAG]); } if(Validated) { glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, ProgramName[program::VERT]); glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]); } // Get variables locations if(Validated) { UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP"); UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAG], "Diffuse"); } return Validated && this->checkError("initProgram"); }
bool initTexture() { bool Validated(true); gli::gl GL; gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GLint Swizzle[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA}; glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, Swizzle); gli::gl::format const Format = GL.translate(Texture.format()); for (gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, static_cast<GLint>(Level), Format.Internal, static_cast<GLsizei>(Texture[Level].dimensions().x), static_cast<GLsizei>(Texture[Level].dimensions().y), 0, Format.External, Format.Type, Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize() * this->FramebufferScale); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexStorage2D(GL_TEXTURE_2D, 1, GL_SRGB8_ALPHA8, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT24, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
void doOfflineListFiles(ClientThreadResource * res , ListenSocket clientSocket ,RuntimeErrorValidator * validator){ WIN32_FIND_DATA ffd; LARGE_INTEGER filesize; char szDir[MAX_PATH]; char * arrayFileSize; HANDLE hFind = INVALID_HANDLE_VALUE; DWORD lastError = 0; char * thePath = concat(res->heapHandler , 3 , getDataDirectory() , res->relativeWorkingDir , "*"); hFind = FindFirstFileA(thePath, &ffd); while( hFind != INVALID_HANDLE_VALUE && FindNextFileA(hFind, &ffd) != 0){ int result; if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){ char * msg = concat(res->heapHandler, 3, "drwxrwxrwx 1 ftp ftp 4096 Jul 11 2011 ", ffd.cFileName , CHARACTER_CRLF); sendBytes(clientSocket , msg , strlen(msg)); /*sendMessage( clientSocket , concat(res->heapHandler, 3, "drwxrwxrwx 1 ftp ftp 4096 Jul 11 2011 ", ffd.cFileName , CHARACTER_CRLF) , &result);*/ } else { filesize.LowPart = ffd.nFileSizeLow; filesize.HighPart = ffd.nFileSizeHigh; arrayFileSize = intToString( ffd.nFileSizeLow , res->heapHandler ); { char * msg = concat(res->heapHandler, 5 , "-rwxrwxrwx 1 ftp ftp " , arrayFileSize , "Jul 11 2011 " , ffd.cFileName , CHARACTER_CRLF); sendBytes(clientSocket , msg , strlen(msg)); } /*sendMessage( clientSocket , concat(res->heapHandler, 5 , "-rwxrwxrwx 1 ftp ftp " , arrayFileSize , "Jul 11 2011 " , ffd.cFileName , CHARACTER_CRLF) , &result);*/ } } if ( INVALID_HANDLE_VALUE == hFind ) { error("Error al leer lista de archivos (FindFirstFile)"); } lastError = GetLastError(); FindClose(hFind); if (lastError == 0 || lastError == ERROR_NO_MORE_FILES ) { res->resultMessage = buildResponseMessageType226(res->heapHandler); } else { res->resultMessage = concat(res->heapHandler , 2 , "426 accion no realizada, ocurrio un error" , CHARACTER_CRLF); } }
bool initProgram() { bool Validated = true; compiler Compiler; if(Validated) { GLuint VertexShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TRANSFORM); TransformProgramName = glCreateProgram(); glAttachShader(TransformProgramName, VertexShaderName); GLchar const * Strings[] = {"gl_Position", "block.Color"}; glTransformFeedbackVaryings(TransformProgramName, 2, Strings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(TransformProgramName); } if(Validated) { GLuint VertexShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_FEEDBACK); GLuint FragmentShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_FEEDBACK); FeedbackProgramName = glCreateProgram(); glAttachShader(FeedbackProgramName, VertexShaderName); glAttachShader(FeedbackProgramName, FragmentShaderName); glLinkProgram(FeedbackProgramName); } if(Validated) { TransformUniformMVP = glGetUniformLocation(TransformProgramName, "MVP"); Validated = Validated && (TransformUniformMVP >= 0); } if(Validated) { Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(TransformProgramName); Validated = Validated && Compiler.checkProgram(FeedbackProgramName); } return Validated && this->checkError("initProgram"); }
bool initProgram() { bool Validated = true; // Create program if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERTEX_SHADER_SOURCE); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAGMENT_SHADER_SOURCE); ProgramName = glCreateProgram(); glAttachShader(ProgramName, VertShaderName); glAttachShader(ProgramName, FragShaderName); glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position"); glLinkProgram(ProgramName); Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName); } // Get variables locations if(Validated) { UniformMVP = glGetUniformLocation(ProgramName, "MVP"); UniformDiffuse = glGetUniformLocation(ProgramName, "Diffuse"); } // Set some variables if(Validated) { // Bind the program for use glUseProgram(ProgramName); // Set uniform value glUniform4fv(UniformDiffuse, 1, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); // Unbind the program glUseProgram(0); } return Validated && this->checkError("initProgram"); }
bool initProgram() { bool Validated = true; compiler Compiler; GLuint VertTransformShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TRANSFORM, "--version 440 --profile core"); GLuint VertFeedbackShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_FEEDBACK, "--version 440 --profile core"); GLuint FragFeedbackShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_FEEDBACK, "--version 440 --profile core"); if(Validated) { ProgramName[program::TRANSFORM] = glCreateProgram(); glProgramParameteri(ProgramName[program::TRANSFORM], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::TRANSFORM], VertTransformShaderName); glLinkProgram(ProgramName[program::TRANSFORM]); } if(Validated) { ProgramName[program::FEEDBACK] = glCreateProgram(); glProgramParameteri(ProgramName[program::FEEDBACK], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::FEEDBACK], VertFeedbackShaderName); glAttachShader(ProgramName[program::FEEDBACK], FragFeedbackShaderName); glLinkProgram(ProgramName[program::FEEDBACK]); } if(Validated) { Validated = Validated && Compiler.check(); Validated = Validated && Compiler.check_program(ProgramName[program::TRANSFORM]); Validated = Validated && Compiler.check_program(ProgramName[program::FEEDBACK]); } if(Validated) { glGenProgramPipelines(program::MAX, &PipelineName[0]); glUseProgramStages(PipelineName[program::TRANSFORM], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::TRANSFORM]); glUseProgramStages(PipelineName[program::FEEDBACK], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::FEEDBACK]); } return Validated && this->checkError("initProgram"); }
bool initProgram() { bool Validated = true; compiler Compiler; if(Validated) { GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERTEX_SHADER_SOURCE); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAGMENT_SHADER_SOURCE); ProgramName = glCreateProgram(); glAttachShader(ProgramName, VertShaderName); glAttachShader(ProgramName, FragShaderName); glLinkProgram(ProgramName); } if(Validated) { Validated = Validated && Compiler.check(); Validated = Validated && Compiler.check_program(ProgramName); } if(Validated) { GLint ProgramVertSubroutine(0); GLint ProgramFragSubroutine(0); glGetProgramStageiv(ProgramName, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &ProgramVertSubroutine); glGetProgramStageiv(ProgramName, GL_FRAGMENT_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &ProgramFragSubroutine); UniformMVP = glGetUniformLocation(ProgramName, "MVP"); UniformDXT1 = glGetUniformLocation(ProgramName, "DiffuseDXT1"); UniformRGB8 = glGetUniformLocation(ProgramName, "DiffuseRGB8"); UniformDisplacement = glGetUniformLocation(ProgramName, "Displacement"); UniformDiffuse = glGetSubroutineUniformLocation(ProgramName, GL_FRAGMENT_SHADER, "Diffuse"); IndexDXT1 = glGetSubroutineIndex(ProgramName, GL_FRAGMENT_SHADER, "diffuseLQ"); IndexRGB8 = glGetSubroutineIndex(ProgramName, GL_FRAGMENT_SHADER, "diffuseHQ"); } return Validated; }
bool initProgram() { bool Validated = true; if(Validated) { std::string VertexSourceContent = this->loadFile(getDataDirectory() + VERT_SHADER_SOURCE); char const * VertexSourcePointer = VertexSourceContent.c_str(); ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer); } if(Validated) { std::string FragmentSourceContent = this->loadFile(getDataDirectory() + FRAG_SHADER_SOURCE); char const * FragmentSourcePointer = FragmentSourceContent.c_str(); ProgramName[program::FRAG] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer); } if(Validated) { compiler Compiler; Validated = Validated && Compiler.checkProgram(ProgramName[program::VERT]); Validated = Validated && Compiler.checkProgram(ProgramName[program::FRAG]); } if(Validated) { UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP"); UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAG], "Diffuse"); } if(Validated) { glGenProgramPipelines(1, &PipelineName); glBindProgramPipeline(PipelineName); glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]); glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]); } return Validated && this->checkError("initProgram"); }
bool initTexture() { bool Validated(true); gli::gl GL; gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); gli::gl::format const Format = GL.translate(Texture.format()); gli::gl::swizzles const Swizzles = GL.translate(Texture.swizzles()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_SWIZZLE_R, Swizzles[0]); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_SWIZZLE_G, Swizzles[1]); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_SWIZZLE_B, Swizzles[2]); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_SWIZZLE_A, Swizzles[3]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(Texture.levels()), Format.Internal, static_cast<GLsizei>(Texture.extent().x), static_cast<GLsizei>(Texture.extent().y)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexSubImage2D(GL_TEXTURE_2D, GLint(Level), 0, 0, static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), Format.External, Format.Type, Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize()); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(1), GL_RGBA8, static_cast<GLsizei>(WindowSize.x * this->Supersampling), static_cast<GLsizei>(WindowSize.y * this->Supersampling)); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
bool initProgram() { bool Validated = true; if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE); ProgramName = glCreateProgram(); glAttachShader(ProgramName, VertShaderName); glAttachShader(ProgramName, FragShaderName); glLinkProgram(ProgramName); Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName); } return Validated && this->checkError("initProgram");; }
bool initProgram() { compiler Compiler; bool Validated = true; if(Validated) { GLuint VertShader = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER1); GLuint ContShader = Compiler.create(GL_TESS_CONTROL_SHADER, getDataDirectory() + SAMPLE_CONT_SHADER1); GLuint EvalShader = Compiler.create(GL_TESS_EVALUATION_SHADER, getDataDirectory() + SAMPLE_EVAL_SHADER1); GLuint GeomShader = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER1); GLuint FragShader = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER1); ProgramName[0] = glCreateProgram(); glAttachShader(ProgramName[0], VertShader); glAttachShader(ProgramName[0], GeomShader); glAttachShader(ProgramName[0], ContShader); glAttachShader(ProgramName[0], EvalShader); glAttachShader(ProgramName[0], FragShader); glLinkProgram(ProgramName[0]); } if(Validated) { GLuint VertShader = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER2); GLuint GeomShader = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER2); GLuint FragShader = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER2); ProgramName[1] = glCreateProgram(); glAttachShader(ProgramName[1], VertShader); glAttachShader(ProgramName[1], GeomShader); glAttachShader(ProgramName[1], FragShader); glLinkProgram(ProgramName[1]); } if(Validated) { Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName[0]); Validated = Validated && Compiler.checkProgram(ProgramName[1]); } if(Validated) { UniformMVP[0] = glGetUniformLocation(ProgramName[0], "MVP"); UniformMVP[1] = glGetUniformLocation(ProgramName[1], "MVP"); } return Validated && this->checkError("initProgram"); }
bool initProgram() { bool Validated(true); glGenProgramPipelines(program::MAX, &PipelineName[0]); compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 420 --profile core"); GLuint FragShaderNameNorm = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE[program::NORM], "--version 420 --profile core"); GLuint FragShaderNameUint = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE[program::UINT], "--version 420 --profile core"); Validated = Validated && Compiler.check(); if(Validated) { ProgramName[program::NORM] = glCreateProgram(); glProgramParameteri(ProgramName[program::NORM], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::NORM], VertShaderName); glAttachShader(ProgramName[program::NORM], FragShaderNameNorm); glLinkProgram(ProgramName[program::NORM]); Validated = Validated && Compiler.check_program(ProgramName[program::NORM]); } if(Validated) { ProgramName[program::UINT] = glCreateProgram(); glProgramParameteri(ProgramName[program::UINT], GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(ProgramName[program::UINT], VertShaderName); glAttachShader(ProgramName[program::UINT], FragShaderNameUint); glLinkProgram(ProgramName[program::UINT]); Validated = Validated && Compiler.check_program(ProgramName[program::UINT]); } if(Validated) { glUseProgramStages(PipelineName[program::NORM], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::NORM]); glUseProgramStages(PipelineName[program::UINT], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::UINT]); } return Validated; }
bool initProgram() { bool Validated = true; compiler Compiler; if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 150 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 150 --profile core"); ProgramName = glCreateProgram(); glAttachShader(ProgramName, VertShaderName); glAttachShader(ProgramName, FragShaderName); glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position"); glBindAttribLocation(ProgramName, semantic::attr::NORMAL, "Normal"); glBindAttribLocation(ProgramName, semantic::attr::COLOR, "Color"); glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName); Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName); } if(Validated) { this->UniformPerDraw = glGetUniformBlockIndex(ProgramName, "per_draw"); this->UniformPerPass = glGetUniformBlockIndex(ProgramName, "per_pass"); this->UniformPerScene = glGetUniformBlockIndex(ProgramName, "per_scene"); glUniformBlockBinding(ProgramName, this->UniformPerDraw, uniform::PER_DRAW); glUniformBlockBinding(ProgramName, this->UniformPerPass, uniform::PER_PASS); glUniformBlockBinding(ProgramName, this->UniformPerPass, uniform::PER_SCENE); } return Validated; }
bool initTexture() { bool Validated(true); gli::gl GL(gli::gl::PROFILE_GL32); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); gli::gl::format const Format = GL.translate(Texture.format(), Texture.swizzles()); for (gli::texture2d::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, static_cast<GLint>(Level), Format.Internal, static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), 0, Format.External, Format.Type, Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize() * this->FramebufferScale); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
bool initTexture() { bool Validated(true); gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture.dimensions().x), GLsizei(Texture.dimensions().y)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D( GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].size()), Texture[Level].data()); } glm::vec2 WindowSize(this->getWindowSize()); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y)); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y)); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
bool testScreenspaceCoherence::initProgram() { bool Validated(true); glGenProgramPipelines(1, &this->PipelineName); glf::compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 420 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 420 --profile core"); Validated = Validated && Compiler.check(); this->ProgramName = glCreateProgram(); glProgramParameteri(this->ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(this->ProgramName, VertShaderName); glAttachShader(this->ProgramName, FragShaderName); glLinkProgram(this->ProgramName); Validated = Validated && glf::checkProgram(this->ProgramName); if(Validated) glUseProgramStages(this->PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName); return Validated; }
void PEFormat::processExport() { IMAGE_DATA_DIRECTORY *exportDirectory = getDataDirectory(IMAGE_DIRECTORY_ENTRY_EXPORT); IMAGE_EXPORT_DIRECTORY *directory = reinterpret_cast<IMAGE_EXPORT_DIRECTORY *>(getDataPointerOfRVA(exportDirectory->VirtualAddress)); size_t exportTableBase = exportDirectory->VirtualAddress; size_t exportTableSize = exportDirectory->Size; if(!directory) return; bool *checker = new bool[directory->NumberOfFunctions]; for(size_t i = 0; i < directory->NumberOfFunctions; i ++) checker[i] = false; uint32_t *addressOfFunctions = reinterpret_cast<uint32_t *>(getDataPointerOfRVA(directory->AddressOfFunctions)); uint32_t *addressOfNames = reinterpret_cast<uint32_t *>(getDataPointerOfRVA(directory->AddressOfNames)); uint16_t *ordinals = reinterpret_cast<uint16_t *>(getDataPointerOfRVA(directory->AddressOfNameOrdinals)); for(size_t i = 0; i < directory->NumberOfNames; i ++) { ExportFunction entry; if(addressOfNames && addressOfNames[i]) { entry.name.assign(reinterpret_cast<const char *>(getDataPointerOfRVA(addressOfNames[i]))); entry.nameHash = fnv1a(entry.name.c_str(), entry.name.length()); } entry.ordinal = ordinals[i]; entry.address = addressOfFunctions[entry.ordinal]; checker[entry.ordinal] = true; entry.ordinal += directory->Base; entry.forward = checkExportForwarder(entry.address, exportTableBase, exportTableSize); exports_.push_back(std::move(entry)); } for(size_t i = 0; i < directory->NumberOfFunctions; i ++) { if(checker[i] == true) continue; //entry without names ExportFunction entry; entry.ordinal = i + directory->Base; entry.address = addressOfFunctions[i]; entry.forward = checkExportForwarder(entry.address, exportTableBase, exportTableSize); exports_.push_back(std::move(entry)); } delete [] checker; }