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;
	}
	static Program make_prog(FBTexExample& example)
	{
		Program prog(ObjectDesc("Thread"));

		prog.AttachShader(example.vertex_shader);

		FragmentShader fs(ObjectDesc("Thread fragment"));
		fs.Source(
			"#version 330\n"
			"in vec3 vertNormal;"
			"in vec3 vertLight;"
			"in vec2 vertTexCoord;"
			"out vec3 fragColor;"
			"void main(void)"
			"{"
			"	float d = max(dot("
			"		vertNormal, "
			"		normalize(vertLight)"
			"	), 0.0);"
			"	float i = int("
			"		vertTexCoord.x*18.0+"
			"		vertTexCoord.y*14.0 "
			"	) % 2;"
			"	vec3 Red =   vec3(1.0, 0.2, 0.2);"
			"	vec3 White = vec3(1.0, 1.0, 1.0);"
			"	fragColor = (0.4+0.8*d)*mix(Red, White, i);"
			"}"
		);
		fs.Compile();
		prog.AttachShader(fs);

		prog.Link().Use();

		return std::move(prog);
	}
	static Program make(void)
	{
		Program prog;

		prog << VertexShader(ObjectDesc("Dist"),
			"#version 330\n"
			"uniform mat4 ProjectionMatrix, CameraMatrix;"
			"in vec4 Position;"
			"out uint xfbIndex;"
			"out float xfbDistance;"
			"void main(void)"
			"{"
			"	vec4 p = ProjectionMatrix*CameraMatrix*Position;"
			"	xfbIndex = uint(gl_VertexID);"
			"	xfbDistance = p.z;"
			"}"
		);

		prog << TransformFeedbackMode::SeparateAttribs
			<< "xfbIndex"
			<< "xfbDistance";

		prog.Link();

		return prog;
	}
Exemple #4
0
	ShapeVertShader(void)
	 : VertexShader(
		ObjectDesc("Shape vertex shader"),
		StrCRef("#version 330\n"

		"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
		"uniform vec3 CameraPosition;"

		"in vec4 Position;"
		"in vec3 Normal;"
		"in vec3 Tangent;"
		"in vec2 TexCoord;"

		"out vec3 vertPosition;"
		"out vec3 vertViewDir;"
		"out vec3 vertNormal;"
		"out vec3 vertTangent;"
		"out vec3 vertBitangent;"
		"out vec2 vertTexCoord;"
		"void main(void)"
		"{"
		"	gl_Position = ModelMatrix * Position;"
		"	vertPosition = gl_Position.xyz;"
		"	vertViewDir = CameraPosition - gl_Position.xyz;"
		"	vertNormal =  (ModelMatrix * vec4(Normal,  0.0)).xyz;"
		"	vertTangent =  (ModelMatrix * vec4(Tangent,  0.0)).xyz;"
		"	vertBitangent = cross(vertNormal, vertTangent);"
		"	vertTexCoord = mat2(0.0, 2.0, 1.0, 0.0) * TexCoord;"
		"	gl_Position = "
		"		ProjectionMatrix * "
		"		CameraMatrix * "
		"		gl_Position;"
		"}")
	)
	{ }
 static Program make() {
     Program prog(ObjectDesc("Shape program"));
     prog.AttachShader(ShapeVertShader());
     prog.AttachShader(ShapeFragShader());
     prog.Link().Use();
     return prog;
 }
Exemple #6
0
	static Program make(void)
	{
		Program prog(ObjectDesc("Sketch"));
		prog.AttachShader(SketchFragShader());
		prog.MakeSeparable().Link().Use();
		return prog;
	}
    PointVertShader()
      : VertexShader(
          ObjectDesc("Vertex shader"),
          "#version 140\n"
          "uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
          "uniform vec3 Color1, Color2;"
          "uniform float Status;"

          "in vec4 Position1, Position2;"
          "in float Radiance1, Radiance2;"

          "out vec3 vertColor;"

          "void main()"
          "{"
          "	gl_Position = "
          "		ProjectionMatrix * "
          "		CameraMatrix * "
          "		ModelMatrix * "
          "		mix(Position1, Position2, Status);"
          "	gl_PointSize = (2.0 + 3.0 * mix("
          "		Radiance1, "
          "		Radiance2, "
          "		Status"
          "	));"
          "	vertColor = mix("
          "		(0.2 + Radiance1) * Color1,"
          "		(0.2 + Radiance2) * Color2,"
          "		Status"
          "	);"
          "}") {}
	CubeVertShader(void)
	 : VertexShader(
		ObjectDesc("Cube vertex"),
		"#version 400\n"
		"uniform vec3 LightPosition;"
		"uniform vec3 CameraPosition;"
		"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"

		"in vec4 Position;"
		"in vec3 Normal;"
		"in vec3 TexCoord;"

		"out vec3 vertNormal;"
		"out vec3 vertLightDir;"
		"out vec3 vertLightRefl;"
		"out vec3 vertViewDir;"
		"out vec2 vertTexCoord;"
		"void main(void)"
		"{"
		"	gl_Position = ModelMatrix* Position;"
		"	vertNormal = mat3(ModelMatrix)*Normal;"
		"	vertLightDir = normalize(LightPosition - gl_Position.xyz);"
		"	vertLightRefl = reflect(-vertLightDir, vertNormal);"
		"	vertViewDir = normalize(CameraPosition - gl_Position.xyz);"
		"	gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
		"	vertTexCoord = TexCoord.xy;"
		"}"
	)
	{ }
	static Program make(void)
	{
		Program prog(ObjectDesc("Metal"));
		prog.AttachShader(MetalFragmentShader());
		prog.MakeSeparable().Link().Use();
		return prog;
	}
 static Program make() {
     Program prog(ObjectDesc("Point program"));
     prog.AttachShader(PointVertShader());
     prog.AttachShader(PointFragShader());
     prog.Link().Use();
     return prog;
 }
Exemple #11
0
 static Program make() {
     Program prog(ObjectDesc("Metal program"));
     prog.AttachShader(MetalVertShader());
     prog.AttachShader(MetalFragShader());
     prog.Link().Use();
     return prog;
 }
	Program make_prog(void)
	{
		Program result(ObjectDesc("Main"));

		vertex_shader.Source(
			"#version 330\n"
			"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
			"in vec4 Position;"
			"in vec3 Normal;"
			"in vec2 TexCoord;"
			"out vec3 vertNormal;"
			"out vec3 vertLight;"
			"out vec2 vertTexCoord;"
			"uniform vec3 LightPos;"
			"void main(void)"
			"{"
			"	vertNormal = mat3(ModelMatrix)*Normal;"
			"	gl_Position = ModelMatrix * Position;"
			"	vertLight = LightPos-gl_Position.xyz;"
			"	vertTexCoord = TexCoord;"
			"	gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
			"}"
		).Compile();
		result.AttachShader(vertex_shader);

		FragmentShader fs(ObjectDesc("Main fragment"));
		fs.Source(
			"#version 330\n"
			"uniform sampler2D TexUnit;"
			"in vec3 vertNormal;"
			"in vec3 vertLight;"
			"in vec2 vertTexCoord;"
			"out vec4 fragColor;"
			"void main(void)"
			"{"
			"	float d = dot(vertNormal, normalize(vertLight));"
			"	float i = 0.6 + max(d, 0.0);"
			"	fragColor = texture(TexUnit, vertTexCoord)*i;"
			"}"
		);
		fs.Compile();
		result.AttachShader(fs);

		result.Link().Use();

		return std::move(result);
	}
	static Program make(const VertexShader& vs)
	{
		Program prog;

		FragmentShader fs(ObjectDesc("Draw"));
		fs.Source(
			"#version 140\n"
			"const vec3 LightColor = vec3(0.6, 0.6, 1.0);"
			"const vec3 Up = normalize(vec3(0.1, 1.0, 0.1));"

			"uniform vec3 LightScreenPos;"
			"uniform vec2 ScreenSize;"
			"uniform sampler2DRect LightMap;"
			"uniform sampler2DShadow ShadowMap;"

			"in vec3 vertNormal;"
			"in vec3 vertLightDir;"
			"in vec4 vertShadowCoord;"

			"out vec3 fragColor;"

			"void main(void)"
			"{"
			"	vec3 ShadowCoord = (vertShadowCoord.xyz/vertShadowCoord.w)*0.5 + 0.5;"
			"	float s = 0.0f;"
			"	if("
			"		ShadowCoord.x >= 0.0 && "
			"		ShadowCoord.x <= 1.0 && "
			"		ShadowCoord.y >= 0.0 && "
			"		ShadowCoord.y <= 1.0 && "
			"		ShadowCoord.z <= 1.0"
			"	) s = texture(ShadowMap, ShadowCoord);"
			"	float a = 0.1*(max(dot(vertNormal, Up)+0.1, 0.0)+0.1);"
			"	float d = max(dot(vertNormal, vertLightDir)+0.1, 0.0)+a;"


			"	vec2 LMCoord = gl_FragCoord.xy;"
			"	vec2 LPos = (LightScreenPos.xy*0.5+0.5)*ScreenSize;"
			"	vec2 Ray = LMCoord - LPos;"
			"	float Len = length(Ray);"
			"	int NSampl = int(max(abs(Ray.x), abs(Ray.y)))+1;"
			"	vec2 RayStep = Ray / NSampl;"
			"	float r = texture(LightMap, LMCoord).r;"
			"	NSampl = min(NSampl, int(min(ScreenSize.x, ScreenSize.y)*0.25));"
			"	for(int s=0; s!=NSampl;++s)"
			"	{"
			"		r += texture(LightMap, LPos+RayStep*s).r;"
			"	}"
			"	r /= NSampl;"
			"	r = min(r, 1.0);"
			"	fragColor = LightColor * (mix(a, d, s) + r);"
			"}"
		).Compile();

		prog.AttachShader(vs).AttachShader(fs);
		prog.Link().Use();

		return prog;
	}
Exemple #14
0
 static Program make() {
     Program prog(ObjectDesc("Flare"));
     prog.AttachShader(FlareVertShader());
     prog.AttachShader(FlareGeomShader());
     prog.AttachShader(FlareFragShader());
     prog.Link().Use();
     return prog;
 }
Exemple #15
0
 static Program make(const Shader& vs, const Shader& gs, const Shader& fs) {
     Program prog(ObjectDesc("Blob"));
     prog.AttachShader(vs);
     prog.AttachShader(gs);
     prog.AttachShader(fs);
     prog.Link().Use();
     return prog;
 }
Exemple #16
0
	static Program make(void)
	{
		Program prog(ObjectDesc("Light program"));
		prog.AttachShader(LightVertShader());
		prog.AttachShader(LightFragShader());
		prog.Link().Use();
		return prog;
	}
Exemple #17
0
	static Program make(void)
	{
		Program prog(ObjectDesc("Cube program"));
		prog.AttachShader(CubeVertShader());
		prog.AttachShader(CubeFragShader());
		prog.Link().Use();
		return prog;
	}
	// makes a fragment shader from the prologe, custom part and epilogue
	static Shader make_fs(const char* color_fs, const char* desc)
	{
		Shader shader(ShaderType::Fragment, ObjectDesc(desc));
		const GLchar* src[3] = {fs_prologue(), color_fs, fs_epilogue()};
		shader.Source(src);
		shader.Compile();
		return shader;
	}
Exemple #19
0
	static Program make(void)
	{
		Program prog(ObjectDesc("Line"));
		prog.AttachShader(LineGeomShader());
		prog.AttachShader(LineFragShader());
		prog.MakeSeparable().Link().Use();
		return prog;
	}
Exemple #20
0
	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);
	}
Exemple #21
0
    LightFragShader()
      : FragmentShader(
          ObjectDesc("Light fragment shader"),
          StrCRef("#version 150\n"

                  "out vec3 fragColor;"

                  "void main()"
                  "{"
                  "	fragColor = vec3(1.0, 1.0, 1.0);"
                  "}")) {}
Exemple #22
0
	LineGeomShader(void)
	 : GeometryShader(
		ObjectDesc("Line geometry shader"),
		"#version 150\n"
		"layout(lines) in;"
		"layout(line_strip, max_vertices=4) out;"

		"in gl_PerVertex {"
		"	vec4 gl_Position;"
		"} gl_in[];"
		"in float vertNoise[];"
		"in vec3 vertNormal[];"
		"in vec3 vertLightDir[], vertViewDir[];"
		"in vec2 vertTexCoord[];"
		"in vec4 vertLightTexCoord[];"

		"out gl_PerVertex {"
		"	vec4 gl_Position;"
		"};"
		"out float geomOpacity;"

		"void main(void)"
		"{"
		"	vec4 p0 = gl_in[0].gl_Position;"
		"	vec4 p1 = gl_in[1].gl_Position;"
		"	vec4 n0 = vec4(vertNormal[0], 0.0);"
		"	vec4 n1 = vec4(vertNormal[1], 0.0);"
		"	float dp = pow(length(p1 - p0), 0.25);"
		"	float l0 = cos(vertNoise[0]*1.618)*dp;"
		"	float l1 = sin(vertNoise[1]*1.618)*dp;"
		"	vec4 v0 = p0 + n0*l0*0.01;"
		"	vec4 v1 = p1 + n1*l1*0.01;"
		"	vec4 v = v1 - v0;"

		"	gl_Position = v0 - v*abs(l1*0.41);"
		"	geomOpacity = 0.0;"
		"	EmitVertex();"

		"	gl_Position = p0;"
		"	geomOpacity = 1.0;"
		"	EmitVertex();"

		"	gl_Position = p1;"
		"	geomOpacity = 1.0;"
		"	EmitVertex();"

		"	gl_Position = v1 + v*abs(l0*0.44);"
		"	geomOpacity = 0.0;"
		"	EmitVertex();"

		"	EndPrimitive();"
		"}"
	)
	{ }
    PointFragShader()
      : FragmentShader(
          ObjectDesc("Fragment shader"),
          "#version 140\n"

          "in vec3 vertColor;"
          "out vec3 fragColor;"

          "void main()"
          "{"
          "	fragColor = vertColor;"
          "}") {}
Exemple #24
0
    MetalFragShader()
      : FragmentShader(
          ObjectDesc("Metal fragment shader"),
          "#version 150\n"
          "const vec3 Color1 = vec3(0.7, 0.6, 0.5);"
          "const vec3 Color2 = vec3(0.9, 0.8, 0.7);"

          "uniform sampler2D MetalTex;"

          "in vec3 vertNormal, vertTangent, vertBitangent;"
          "in vec3 vertLightDir, vertViewDir;"
          "in vec2 vertTexCoord;"

          "out vec3 fragColor;"

          "void main()"
          "{"
          "	vec3 Sample = texture(MetalTex, vertTexCoord).rgb;"
          "	vec3 LightColor = vec3(1.0, 1.0, 0.9);"

          "	vec3 Normal = normalize("
          "		2.0*vertNormal + "
          "		(Sample.r - 0.5)*vertTangent + "
          "		(Sample.g - 0.5)*vertBitangent"
          "	);"

          "	vec3 LightRefl = reflect("
          "		-normalize(vertLightDir),"
          "		Normal"
          "	);"

          "	float Specular = pow(max(dot("
          "		normalize(LightRefl),"
          "		normalize(vertViewDir)"
          "	)+0.04, 0.0), 16+Sample.b*48)*pow(0.4+Sample.b*1.6, 4.0);"

          "	Normal = normalize(vertNormal*3.0 + Normal);"

          "	float Diffuse = pow(max(dot("
          "		normalize(Normal), "
          "		normalize(vertLightDir)"
          "	), 0.0), 2.0);"

          "	float Ambient = 0.5;"

          "	vec3 Color = mix(Color1, Color2, Sample.b);"

          "	fragColor = "
          "		Color * Ambient +"
          "		LightColor * Color * Diffuse + "
          "		LightColor * Specular;"
          "}") {}
Exemple #25
0
    LightVertShader()
      : VertexShader(
          ObjectDesc("Light vertex shader"),
          StrCRef("#version 150\n"

                  "uniform mat4 ProjectionMatrix, CameraMatrix;"
                  "in vec4 Position;"

                  "void main()"
                  "{"
                  "	gl_Position = ProjectionMatrix * CameraMatrix * Position;"
                  "	gl_PointSize = 9.0;"
                  "}")) {}
Exemple #26
0
    FlareVertShader()
      : VertexShader(
          ObjectDesc("Flare vertex shader"),
          StrCRef("#version 150\n"

                  "uniform mat4 CameraMatrix;"
                  "in vec4 Position;"

                  "void main()"
                  "{"
                  "	gl_Position = CameraMatrix * Position;"
                  "	gl_PointSize = 9.0;"
                  "}")) {}
Exemple #27
0
	ShadowFragShader(void)
	 : FragmentShader(
		ObjectDesc("Shadow fragment shader"),
		"#version 150\n"
		"in float vertNoise;"
		"in vec3 vertNormal;"
		"in vec3 vertLightDir, vertViewDir;"
		"in vec2 vertTexCoord;"
		"in vec4 vertLightTexCoord;"

		"void main(void){ }"
	)
	{ }
Exemple #28
0
    FlareFragShader()
      : FragmentShader(
          ObjectDesc("Flare fragment shader"),
          StrCRef("#version 150\n"
                  "uniform sampler2D FlareTex;"

                  "in vec2 geomTexCoord;"
                  "out vec4 fragColor;"

                  "void main()"
                  "{"
                  "	vec4 Sample = texture(FlareTex, geomTexCoord);"
                  "	fragColor = vec4(Sample.rgb, Sample.a*0.4);"
                  "}")) {}
Exemple #29
0
	LineFragShader(void)
	 : FragmentShader(
		ObjectDesc("Line fragment shader"),
		"#version 150\n"
		"in float geomOpacity;"

		"out vec4 fragColor;"

		"void main(void)"
		"{"
		"	fragColor = vec4(0.0, 0.0, 0.0, 0.1+0.4*geomOpacity);"
		"}"
	)
	{ }
Exemple #30
0
	PointFragShader(void)
	 : FragmentShader(
		ObjectDesc("Fragment shader"),
		StrLit("#version 330\n"

		"in vec3 vertColor;"
		"out vec3 fragColor;"

		"void main(void)"
		"{"
		"	fragColor = vertColor;"
		"}")
	)
	{ }