Apsis::Primitives::FragmentShader Apsis::Primitives::FragmentShader::fromFile(const char* path) {
FILE* f = fopen(path, "rb");
if (f == NULL) {
throw "Shader not found.";
}
fseek(f, 0, SEEK_END);
unsigned long file_length = ftell(f);
fseek(f, 0, SEEK_SET);
if (file_length == 0) {
return FragmentShader("");
}
char* source = new char[file_length + 1];
if (source == NULL) {
throw "Memory depleted";
}
fread(source, 1, file_length, f);
source[file_length] = 0;
fclose(f);
FragmentShader& ret = FragmentShader(source);
delete [] source;
return ret;
}
void Program::Init(const char *name, const Shader::Defines &defines)
{
string sn(name);
sn += ".geom";
ifstream f(sn.c_str());
if(f.good())
Init(VertexShader(name, defines), GeometryShader(name, defines), FragmentShader(name, defines), name);
else
Init(VertexShader(name, defines), FragmentShader(name, defines), name);
f.close();
}
static Program make(void)
{
Program prog;
prog << VertexShader(ObjectDesc("Mesh"),
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = "
" ProjectionMatrix*CameraMatrix*ModelMatrix*Position;"
"}"
);
prog << FragmentShader(ObjectDesc("Mesh"),
"#version 330\n"
"out vec3 fragColor;"
"void main(void)"
"{"
" fragColor = vec3(0.1);"
"}"
);
prog.Link();
return prog;
}
void BoundsVisualiser::CompileShaders()
{
std::string vertexShaderCode = VertexShader();
std::string fragmentShaderCode = FragmentShader();
GLuint vertexShader = Eegeo::Helpers::ShaderCompiler::CompileShader(vertexShaderCode, GL_VERTEX_SHADER);
GLuint fragmentShader = Eegeo::Helpers::ShaderCompiler::CompileShader(fragmentShaderCode, GL_FRAGMENT_SHADER);
m_pShader = new Shader;
m_pShader->m_programHandle = glCreateProgram();
glAttachShader(m_pShader->m_programHandle, vertexShader);
glAttachShader(m_pShader->m_programHandle, fragmentShader);
glLinkProgram(m_pShader->m_programHandle);
GLint linkSuccess;
glGetProgramiv(m_pShader->m_programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE)
{
GLchar messages[256];
glGetProgramInfoLog(m_pShader->m_programHandle, sizeof(messages), 0, &messages[0]);
Eegeo_TTY("%s\n", &messages[0]);
return;
}
Eegeo_GL(glUseProgram(m_pShader->m_programHandle));
m_pShader->m_positionSlot = glGetAttribLocation(m_pShader->m_programHandle, "pos");
m_pShader->m_mvpUniform = glGetUniformLocation(m_pShader->m_programHandle, "mvp");
}
Program RaytraceProg::make(void)
{
Program prog;
ResourceFile vs_source("glsl", "raytrace", ".vs.glsl");
prog << VertexShader(GLSLSource::FromStream(vs_source));
ResourceFile fs_rs_source("glsl", "raysample", ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(fs_rs_source));
ResourceFile fs_rt_source("glsl", "raytrace", ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(fs_rt_source));
ResourceFile fs_pk_source("glsl", "pack", ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(fs_pk_source));
ResourceFile fs_en_source("glsl", "encode", ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(fs_en_source));
prog.Link().Use();
return std::move(prog);
}
Program RenderProg::make(const AppData& app_data)
{
Program prog;
ResourceFile vs_source("glsl", "render", ".vs.glsl");
prog << VertexShader(GLSLSource::FromStream(vs_source));
ResourceFile pk_source("glsl", "pack", ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(pk_source));
ResourceFile dc_source("glsl", "decode", ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(dc_source));
std::string fs_name("render-");
fs_name.append(app_data.finish_shader);
ResourceFile fs_source("glsl", fs_name, ".fs.glsl");
prog << FragmentShader(GLSLSource::FromStream(fs_source));
prog.Link().Use();
Optional<Uniform<GLfloat>>(prog, "Near").TrySet(app_data.cam_near);
Optional<Uniform<GLfloat>>(prog, "Far").TrySet(app_data.cam_far);
Optional<Uniform<Vec3f>>(prog, "LightPos").TrySet(Vec3f(
app_data.light_x,
app_data.light_y,
app_data.light_z
));
Optional<Uniform<GLfloat>>(prog, "HighLight").TrySet(app_data.high_light);
Optional<Uniform<GLfloat>>(prog, "AmbiLight").TrySet(app_data.ambi_light);
Optional<Uniform<GLfloat>>(prog, "PlanetRadius").TrySet(app_data.planet_radius);
Optional<Uniform<GLfloat>>(prog, "AtmThickness").TrySet(app_data.atm_thickness);
return std::move(prog);
}
static Program make_prog(void)
{
Program prog(ObjectDesc("Screen"));
prog.AttachShader(VertexShader(
ObjectDesc("Screen vertex"),
StrLit(
"#version 330\n"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Position;"
" vertTexCoord = TexCoord;"
"}"
)
)).AttachShader(FragmentShader(
ObjectDesc("Screen fragment"),
StrLit(
"#version 330\n"
"uniform sampler2D Background, NormalMap;"
"in vec2 vertTexCoord;"
"out vec3 fragColor;"
"void main(void)"
"{"
" vec4 nm = texture(NormalMap, vertTexCoord);"
" vec2 offs = nm.xy*0.05+vec2(0.004, 0.004)*nm.w;"
" vec4 c = texture(Background, vertTexCoord+offs);"
" float l = clamp(nm.w+pow(dot(nm.xy,vec2(0.2,0.2)), 9.0), 0.3, 1.1);"
" fragColor = c.rgb*mix(1.2, 0.8, l);"
"}"
)
)).Link().Use();
return std::move(prog);
}
glsl::Text2D::Text2D(const std::string& texture_file)
: texture(Texture2D::TEXTURE_2D),
program("texture_shader", VertexShader("./resources/texture.vert"), FragmentShader("./resources/texture.frag")),
vbo_vertex(GL_ARRAY_BUFFER, GL_STATIC_DRAW),
vbo_uv(GL_ARRAY_BUFFER, GL_STATIC_DRAW) {
// Initialize texture
texture.loadDDS(texture_file);
vao.bind();
// 1rst attribute buffer : vertices
vbo_vertex.bind();
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0 );
// 2nd attribute buffer : UVs
vbo_uv.bind();
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0 );
vao.unbind();
}
RippleTexProg(GLuint ripple_tex_size)
: tex_1(prog(), "Tex1")
, tex_2(prog(), "Tex2")
, new_drop(prog(), "NewDrop")
{
AttachShader(VertexShader(
ObjectDesc("Ripple texture vertex shader"),
StrLit(
"#version 330\n"
"void main(void)"
"{"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);"
"}"
)
));
AttachShader(GeometryShader(
ObjectDesc("Ripple texture geometry shader"),
StrLit(
"#version 330\n"
"layout (points) in;"
"layout (triangle_strip, max_vertices = 4) out;"
"uniform int TexSize;"
"out vec2 geomTexCoord;"
"void make_vertex(vec2 pos, vec2 tc)"
"{"
" gl_Position = vec4(pos, 0.0, 1.0);"
" geomTexCoord = tc;"
" EmitVertex();"
"}"
"void main(void)"
"{"
" float rts = TexSize;"
" make_vertex(vec2(-1.0,-1.0), vec2( 0, 0));"
" make_vertex(vec2(-1.0, 1.0), vec2( 0, rts));"
" make_vertex(vec2( 1.0,-1.0), vec2(rts, 0));"
" make_vertex(vec2( 1.0, 1.0), vec2(rts, rts));"
" EndPrimitive();"
"}"
)
));
AttachShader(FragmentShader(
ObjectDesc("Ripple texture fragment shader"),
StrLit(
"#version 330\n"
"uniform ivec2 NewDrop;"
"uniform sampler2D Tex1, Tex2;"
"uniform int TexSize;"
"in vec2 geomTexCoord;"
"layout (location = 0) out vec4 fragBump;"
"layout (location = 1) out float fragHeight;"
"ivec2 wrap_tc(ivec2 tc)"
"{"
" if(tc.x < 0) tc.x = TexSize-1;"
" if(tc.x >= TexSize) tc.x = 0;"
" if(tc.y < 0) tc.y = TexSize-1;"
" if(tc.y >= TexSize) tc.y = 0;"
" return tc;"
"}"
"float height_at(sampler2D tex, ivec2 tc, float factor)"
"{"
" return texelFetch(tex, wrap_tc(tc), 0).r * factor;"
"}"
"void main(void)"
"{"
" ivec2 TC = ivec2(geomTexCoord);"
" float ch = height_at(Tex2, TC, 1.0);"
" float xp1 = height_at(Tex2, TC+ivec2( 1, 0), 0.25);"
" float xm1 = height_at(Tex2, TC+ivec2(-1, 0), 0.25);"
" float yp1 = height_at(Tex2, TC+ivec2( 0, 1), 0.25);"
" float ym1 = height_at(Tex2, TC+ivec2( 0,-1), 0.25);"
" fragHeight = xp1 + xm1 + yp1 + ym1;"
" fragHeight += height_at(Tex2, TC+ivec2( 1,-1), 0.25);"
" fragHeight += height_at(Tex2, TC+ivec2( 1, 1), 0.25);"
" fragHeight += height_at(Tex2, TC+ivec2(-1,-1), 0.25);"
" fragHeight += height_at(Tex2, TC+ivec2(-1, 1), 0.25);"
" fragHeight -= height_at(Tex1, TC, 1.0);"
" vec2 d = NewDrop - TC;"
" fragHeight += length(d)<8?1.0:0.0;"
" vec3 fragNormal = vec3("
" (xm1 - ch) + (ch - xp1),"
" (ym1 - ch) + (ch - yp1),"
" 0.1"
" );"
" fragBump = vec4("
" normalize(fragNormal),"
" fragHeight"
" );"
"}"
)
));
Link();
ProgramUniform<GLint>(prog(), "TexSize").Set(ripple_tex_size);
}
WaterProg(void)
: projection_matrix(prog(), "ProjectionMatrix")
, camera_matrix(prog(), "CameraMatrix")
, camera_position(prog(), "CameraPosition")
, light_position(prog(), "LightPosition")
, ripple_tex(prog(), "RippleTex")
, env_tex(prog(), "EnvTex")
{
AttachShader(VertexShader(
ObjectDesc("Water vertex shader"),
StrLit(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"uniform vec3 LightPosition, CameraPosition;"
"mat4 Matrix = ProjectionMatrix*CameraMatrix;"
"in vec3 Position;"
"in vec3 Normal;"
"in vec3 Tangent;"
"in vec2 TexCoord;"
"out vec3 vertNormal, vertTangent, vertBitangent;"
"out vec3 vertLightDir, vertViewDir;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Matrix * vec4(Position, 1.0);"
" vertNormal = Normal;"
" vertTangent = Tangent;"
" vertBitangent = cross(Normal, Tangent);"
" vertLightDir = LightPosition - Position;"
" vertViewDir = CameraPosition - Position;"
" vertTexCoord = TexCoord * 16.0;"
"}"
)
));
AttachShader(FragmentShader(
ObjectDesc("Water fragment shader"),
StrLit(
"#version 330\n"
"uniform sampler2D RippleTex;"
"uniform samplerCube EnvTex;"
"in vec3 vertNormal, vertTangent, vertBitangent;"
"in vec3 vertLightDir, vertViewDir;"
"in vec2 vertTexCoord;"
"layout (location = 0) out vec4 fragColor;"
"const vec3 LightColor = vec3(1.0, 1.0, 0.95);"
"const vec3 BgColor = vec3(0.4, 0.4, 0.4);"
"void main(void)"
"{"
" vec4 texBump = texture(RippleTex, vertTexCoord);"
" vec3 fragNormal = normalize("
" texBump.x * vertTangent+"
" texBump.y * vertBitangent+"
" texBump.z * vertNormal"
" );"
" vec3 fragLightDir = normalize(vertLightDir);"
" vec3 fragLightRefl = reflect(-fragLightDir, fragNormal);"
" vec3 fragViewDir = normalize(vertViewDir);"
" vec3 fragViewRefl = reflect(-fragViewDir, fragNormal);"
" vec3 fragViewRefr = refract("
" -normalize(fragViewDir+vec3(0.0, 1.0, 0.0)),"
" fragNormal,"
" 1.2"
" );"
" float Diffuse = max(dot(fragNormal, fragLightDir), 0.0);"
" float Specular = clamp(pow(dot(fragViewDir, fragLightRefl)+0.1, 64.0), 0.0, 2.0);"
" float Transparency = max(dot(fragNormal, fragViewDir)+0.3, 0.0);"
" float Visibility = min(16.0 / dot(vertViewDir, vertViewDir), 1.0);"
" vec3 SkyColor = texture(EnvTex, fragViewRefl).rgb;"
" vec3 GroundColor = texture(EnvTex, fragViewRefr).rgb;"
" vec3 WaterColor = "
" mix("
" 0.7*SkyColor,"
" 0.8*GroundColor*LightColor*Diffuse,"
" Transparency"
" )+"
" 0.2*LightColor*Diffuse+"
" 0.05*LightColor*Specular;"
" fragColor = vec4("
" mix(BgColor, WaterColor, Visibility),"
" 1.0"
" );"
"}"
)
));
Link();
}
virtual const char *fragmentShader() const {
return FragmentShader();
}
static Program make_prog(void)
{
Program prog(ObjectDesc("Flow map"));
prog.AttachShader(VertexShader(
ObjectDesc("Flow map vertex"),
StrLit(
"#version 330\n"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Position;"
" vertTexCoord = TexCoord;"
"}"
)
)).AttachShader(FragmentShader(
ObjectDesc("Flow map fragment"),
StrLit(
"#version 330\n"
"uniform sampler2D HMap1, HMap2;"
"uniform sampler2D FlowMap;"
"uniform int HMapSize;"
"uniform float Time;"
"float TS = 1.0/HMapSize;"
"in vec2 vertTexCoord;"
"layout (location = 0) out vec4 fragBump;"
"layout (location = 1) out float fragHeight;"
"ivec2 clamp_tc(ivec2 tc)"
"{"
" return clamp(tc, ivec2(0, 0), ivec2(HMapSize, HMapSize));"
"}"
"float height_at("
" sampler2D tex, "
" float xoffs,"
" float yoffs,"
" float steer,"
" float flow, "
" float factor"
")"
"{"
" vec2 TC = vertTexCoord + vec2(xoffs, yoffs)*TS;"
" return texture(tex, TC+vec2(steer, flow)*TS).r*factor;"
"}"
"void main(void)"
"{"
" vec2 FC = gl_FragCoord.xy+vec2(-HMapSize/2, -HMapSize+4);"
" float s = 2.71*sin(1.1*Time+0.03*length(FC));"
" float f = 1.62*sin(2.0*Time-0.05*length(FC));"
" vec2 TC = vertTexCoord+TS*vec2(s, f)+vec2(0.0, Time*0.1);"
" vec4 fm = texture(FlowMap, TC);"
" s = 0.1*s+(0.5-fm.r)*3.0;"
" f = 0.3*f+(fm.g-0.5)*4.0;"
" float ch = height_at(HMap2, 0, 0, s, f, 1.00);"
" s *= 1.5;"
" f *= 1.618;"
" float xp1 = height_at(HMap2, 1, 0, s, f, 0.25);"
" float xm1 = height_at(HMap2,-1, 0, s, f, 0.25);"
" float yp1 = height_at(HMap2, 0, 1, s, f, 0.25);"
" float ym1 = height_at(HMap2, 0,-1, s, f, 0.25);"
" vec3 fragNormal = vec3("
" (xm1 - ch) + (ch - xp1),"
" (ym1 - ch) + (ch - yp1),"
" 0.2"
" );"
" fragHeight = xp1 + xm1 + yp1 + ym1;"
" fragHeight += height_at(HMap2, 1,-1, s, f, 0.25);"
" fragHeight += height_at(HMap2, 1, 1, s, f, 0.25);"
" fragHeight += height_at(HMap2,-1,-1, s, f, 0.25);"
" fragHeight += height_at(HMap2,-1, 1, s, f, 0.25);"
" f *= 1.618;"
" s -= fragNormal.x*3.0;"
" fragHeight -= height_at(HMap1, 0, 0, s, f, 1.00);"
" fragHeight += (fm.b-0.5)*0.09;"
" if(FC.y > 0.0)"
" fragHeight += min(pow(sin(Time+length(10*FC)), 16.0), 0.3);"
" fragBump = vec4(normalize(fragNormal),clamp(fragHeight, 0.0, 1.0));"
"}"
)
)).Link().Use();
return std::move(prog);
}
int main( int args, char *argv[])
{
//Platform init code
GLFWwindow* window;
if (!glfwInit())
return 0;
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL);
if (!window)
{
glfwTerminate();
return 0;
}
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK)
{
glfwTerminate();
return 0;
}
//End of platform init code
const GLchar FragmentSource[] = {
"#version 330 core \n"
"out vec4 fcolor; \n"
"void main(){ \n"
" fcolor = vec4( 1,0,0,0); \n"
"} \n"
};
const GLchar VertexSource[] = {
"#version 330 core \n"
"layout(location = 0) in vec2 in_position; \n"
"layout(location = 1) in vec2 in_size; \n"
" \n"
"uniform sce_camera{ \n"
" vec2 camera; \n"
" float zoom; \n"
"}; \n"
" \n"
"void main(){ \n"
" gl_Position = vec4( in_position + camera, 0, 1 ); \n"
"} \n"
};
Engine::CShader VertexShader( Engine::VertexShader );
if( !VertexShader.Compile( VertexSource ) ){
std::cout << VertexShader.Log() << std::endl;
}
Engine::CShader FragmentShader( Engine::FragmentShader );
if( !FragmentShader.Compile( FragmentSource ) ){
std::cout << FragmentShader.Log() << std::endl;
}
Engine::CProgram SpriteProgram;
SpriteProgram.Attach( &VertexShader );
SpriteProgram.Attach( &FragmentShader );
if( !SpriteProgram.Link())
{
std::cout << SpriteProgram.Log() << std::endl;
}
Engine::CSCECamera Camera;
Engine::CSCEInstance Instance( &Camera );
const size_t sprite_count = 128;
SSprite *SpritesOfGods = new SSprite[sprite_count];
for( size_t i = 0; i < sprite_count; i++ )
SpritesOfGods[i].position = glm::vec2( 0,0 );
GPUSpriteStorage* SpriteStorage = new GPUSpriteStorage();
GPUSpriteInstance* SpriteInstance = new GPUSpriteInstance();
GPUSpriteRenderer* SpriteRenderer = new GPUSpriteRenderer();
SpriteRenderer->Program().Attach( &VertexShader );
SpriteRenderer->Program().Attach( &FragmentShader );
if( !SpriteRenderer->Program().Link())
{
std::cout << SpriteRenderer->Program().Log() << std::endl;
}
Instance.Initialize( SpriteRenderer );
Instance.Camera()->Position() = glm::vec2( 0.25, 0.25 );
Instance.Camera()->UpdateGpuBuffer();
//Upload sprites....
SpriteStorage->Upload( SpritesOfGods, sprite_count );
//Enable the sprites in an instance
SpriteInstance->Enable( SpriteStorage );
glPointSize( 10.0f );
while (!glfwWindowShouldClose(window))
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
SpriteRenderer->Enable( );
SpriteRenderer->Render( SpriteInstance, Engine::Points, SpriteStorage->Size() );
SpriteRenderer->Disable( );
glfwSwapBuffers(window);
glfwPollEvents();
}
//PLATFORM
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
static Program make(void)
{
Program prog;
prog << VertexShader(ObjectDesc("Draw"),
"#version 330\n"
"uniform mat4 CameraMatrix;"
"in vec4 Position;"
"out vec3 vertColor;"
"void main(void)"
"{"
" gl_Position = CameraMatrix * Position;"
" vertColor = normalize(vec3(1)-Position.rgb);"
"}"
);
prog << GeometryShader(ObjectDesc("Draw"),
"#version 330\n"
"layout(points) in;"
"layout(triangle_strip, max_vertices = 4) out;"
"uniform mat4 ProjectionMatrix;"
"in vec3 vertColor[1];"
"out vec3 geomColor;"
"void main(void)"
"{"
" geomColor = vertColor[0];"
" float s = 0.1;"
" float yo[2] = float[2](-1.0, 1.0);"
" float xo[2] = float[2](-1.0, 1.0);"
" for(int j=0;j!=2;++j)"
" for(int i=0;i!=2;++i)"
" {"
" float xoffs = xo[i]*s;"
" float yoffs = yo[j]*s;"
" gl_Position = ProjectionMatrix * vec4("
" gl_in[0].gl_Position.x-xoffs,"
" gl_in[0].gl_Position.y-yoffs,"
" gl_in[0].gl_Position.z,"
" 1.0"
" );"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
);
prog << FragmentShader(ObjectDesc("Draw"),
"#version 330\n"
"in vec3 geomColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float a = 1.0/16.0;"
" fragColor = vec4(geomColor, a);"
"}"
);
prog.Link();
return prog;
}
Program::Program(const std::string& vShaderPath,const std::string& fShaderPath)
:vertexShader(VertexShader(vShaderPath)),
fragmentShader(FragmentShader(fShaderPath)){
programID=glCreateProgram();
compile();
}
