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