コード例 #1
0
ファイル: 010_cube.cpp プロジェクト: matus-chochlik/oglplu2
    example_program(void)
    {
        shader vs(GL.vertex_shader);
        vs.source(glsl_literal(
                      "#version 140\n"

                      "uniform mat4 Projection;\n"

                      "in vec4 Position;\n"
                      "in vec3 Normal;\n"
                      "in vec3 BoxCoord;\n"
                      "in vec3 TexCoord;\n"
                      "out vec2 vertCoord;\n"
                      "out vec3 vertColor1;\n"
                      "out vec3 vertColor2;\n"

                      "void main(void)\n"
                      "{\n"
                      "	gl_Position = Projection*Position;\n"
                      "	vertColor1 = mix(BoxCoord,abs(Normal),0.5);\n"
                      "	vertColor2 = vertColor1 * 0.3;\n"
                      "	vertCoord = TexCoord.xy*(2+TexCoord.z);\n"
                      "}\n"
                  ));
        vs.compile();

        shader fs(GL.fragment_shader);
        fs.source(glsl_literal(
                      "#version 140\n"

                      "in  vec2 vertCoord;\n"
                      "in  vec3 vertColor1;\n"
                      "in  vec3 vertColor2;\n"
                      "out vec3 fragColor;\n"

                      "float pattern(vec2 tc)\n"
                      "{\n"
                      "	return float((int(tc.x)%2+int(tc.y)%2)%2);\n"
                      "}\n"

                      "void main(void)\n"
                      "{\n"
                      "	float c = pattern(vertCoord);\n"
                      "	fragColor = mix(vertColor1, vertColor2, c);\n"
                      "}\n"
                  ));
        fs.compile();

        attach(vs);
        attach(fs);
        link();
        report_link_error();

        gl.use(*this);

        gl.query_location(projection, *this, "Projection");
    }
コード例 #2
0
	void set_projection(const example_state_view& state)
	{
		auto projection = 
			matrix_perspective::y(
				right_angle_(),
				state.aspect(),
				0.5f, 50.f
			)*matrix_orbiting_y_up(
				vec3(),
				smooth_lerp(1.5f, 5.0f, cam_orbit),
				turns_(cam_turns),
				smooth_oscillate(radians_(1.5f), cam_pitch)
			);

		gl.use(light_prog);
		gl.uniform(light_prog.projection, projection);
		gl.use(erase_prog);
		gl.uniform(erase_prog.projection, projection);
	}
コード例 #3
0
	voronoi_program(const example_params& params)
	{
		std::string path = params.get_resource_file_path(
			example_resource_type::program_source,
			cstr_ref("014_voronoi.oglpprog")
		);
		_init(program_source_file(cstr_ref(path)));

		gl.use(*this);

		gl.query_location(offset_loc, *this, "Offset");
		gl.query_location(scale_loc, *this, "Scale");
	}
コード例 #4
0
	lighting_program(const example_params& params)
	{
		std::string path = params.get_resource_file_path(
			example_resource_type::program_source,
			cstr_ref("028_lighting-lt.oglpprog")
		);
		build_program(*this, program_source_file(cstr_ref(path)));

		gl.use(*this);

		gl.query_location(projection, *this, "Projection");
		gl.query_location(modelview, *this, "Modelview");
	}
コード例 #5
0
	void render(const example_state_view& state)
	override
	{
		gl.use(erase_prog);
		gl.disable(GL.depth_test);
		background.use();
		background.draw();

		shp_turns += 0.1f*state.frame_duration().value();

		gl.use(light_prog);
		gl.uniform(
			light_prog.modelview,
			matrix_rotation_x(turns_(shp_turns)/1)*
			matrix_rotation_y(turns_(shp_turns)/2)*
			matrix_rotation_z(turns_(shp_turns)/3)
		);

		gl.clear(GL.depth_buffer_bit);
		gl.enable(GL.depth_test);
		shape.use();
		shape.draw();
	}
コード例 #6
0
	example_program(void)
	{
		shader vs(GL.vertex_shader);

		vs.source(glsl_literal(
		"#version 140\n"

		"uniform mat4 Projection;"
		"uniform mat4 Modelview;"
		"uniform vec3 LightPos;"

		"in vec4 Position;\n"
		"in vec3 Normal;\n"
		"in vec2 TexCoord;\n"

		"out vec3 vertNormal;\n"
		"out vec3 vertLightDir;\n"
		"out vec2 vertTexCoord;\n"

		"void main(void)\n"
		"{\n"
		"	gl_Position = Modelview*Position;\n"
		"	vertNormal = mat3(Modelview)*Normal;\n"
		"	vertLightDir = LightPos - gl_Position.xyz;\n"
		"	vertTexCoord = TexCoord;\n"
		"	gl_Position = Projection*gl_Position;\n"
		"}\n"
		));
		vs.compile();
		vs.report_compile_error();

		shader fs(GL.fragment_shader);

		fs.source(glsl_literal(
		"#version 140\n"

		"uniform sampler2D CubeTex;"
		"in vec3 vertNormal;\n"
		"in vec3 vertLightDir;\n"
		"in vec2 vertTexCoord;\n"
		"out vec4 fragColor;\n"

		"void main(void)\n"
		"{\n"
		"	float d=0.3*dot(vertNormal, normalize(vertLightDir));\n"
		"	float i=0.6 + max(d, 0.0);\n"
		"	fragColor = texture(CubeTex, vertTexCoord)*i;\n"
		"}\n"
		));
		fs.compile();
		fs.report_compile_error();

		attach(vs);
		attach(fs);
		link();
		report_link_error();

		gl.use(*this);

		gl.query_location(projection, *this, "Projection");
		gl.query_location(modelview, *this, "Modelview");
		gl.query_location(light_pos, *this, "LightPos");
		gl.query_location(cube_tex, *this, "CubeTex");
	}
コード例 #7
0
ファイル: 011_mandelbrot.cpp プロジェクト: deranen/oglplu2
	example_mandelbrot(void)
	 : offset_x(-0.5f)
	 , offset_y(0.0f)
	 , scale(1.0f)
	 , aspect(1.0f)
	{
		shader vs(GL.vertex_shader);
		vs.source(glsl_literal(
			"#version 130\n"
			"uniform vec2 Offset;\n"
			"uniform vec2 Scale;\n"
			"in vec2 Position;\n"
			"in vec2 Coord;\n"
			"out vec2 vertCoord;\n"
			"void main(void)\n"
			"{\n"
			"	vertCoord = Coord*Scale+Offset;\n"
			"	gl_Position = vec4(Position, 0.0, 1.0);\n"
			"}\n"
		));
		vs.compile();

		shader fs(GL.fragment_shader);
		fs.source(glsl_literal(
		"#version 130\n"
		"uniform sampler1D gradient;\n"
		"in vec2 vertCoord;\n"
		"out vec4 fragColor;\n"
		"void main(void)\n"
		"{\n"
		"	vec2 z = vec2(0.0, 0.0);\n"
		"	vec2 c = vertCoord;\n"
		"	int i = 0, max = 256;\n"
		"	while((i != max) && (distance(z, c) < 2.0))\n"
		"	{\n"
		"		vec2 zn = vec2(\n"
		"			z.x * z.x - z.y * z.y + c.x,\n"
		"			2.0 * z.x * z.y + c.y\n"
		"		);\n"
		"		z = zn;\n"
		"		++i;\n"
		"	}\n"
		"	float a = float(i)/float(max);\n"
		"	fragColor = texture(gradient, a+sqrt(length(c))*0.1);\n"
		"} \n"
		));
		fs.compile();

		prog.attach(vs);
		prog.attach(fs);
		prog.link();

		gl.use(prog);

		gl.query_location(offset_loc, prog, "Offset");
		gl.query_location(scale_loc, prog, "Scale");
		gl.uniform(offset_loc, offset_x, offset_y);


		gl.bind(vao);

		GLfloat position_data[4*2] = {
			-1.0f, -1.0f,
			-1.0f,  1.0f,
			 1.0f, -1.0f,
			 1.0f,  1.0f
		};

		gl.bind(GL.array_buffer, positions);
		gl.buffer_data(GL.array_buffer, position_data, GL.static_draw);

		vertex_attrib_location va_p;
		gl.query_location(va_p, prog, "Position");
		gl.vertex_array_attrib_pointer(
			va_p,
			2, GL.float_,
			false, 0, nullptr
		);
		gl.enable_vertex_array_attrib(va_p);


		GLfloat coord_data[4*2] = {
			-1.0f, -1.0f,
			-1.0f,  1.0f,
			 1.0f, -1.0f,
			 1.0f,  1.0f
		};

		gl.bind(GL.array_buffer, coords);
		gl.buffer_data(GL.array_buffer, coord_data, GL.static_draw);

		vertex_attrib_location va_c;
		gl.query_location(va_c, prog, "Coord");
		gl.vertex_array_attrib_pointer(
			va_c,
			2, GL.float_,
			false, 0, nullptr
		);
		gl.enable_vertex_array_attrib(va_c);

		GLfloat gradient_data[8*3];

		for(int i=0; i<8*3; ++i)
		{
			gradient_data[i] = (std::rand() % 10000) / 10000.f;
		}

		gl.bind(GL.texture_1d, gradient);
		gl.texture_min_filter(GL.texture_1d, GL.linear);
		gl.texture_mag_filter(GL.texture_1d, GL.linear);
		gl.texture_wrap(
			GL.texture_1d,
			GL.texture_wrap_s,
			GL.repeat
		);
		gl.texture_image_1d(
			GL.texture_1d,
			0, GL.rgb,
			8,
			0, GL.rgb,
			GL.float_,
			const_memory_block{gradient_data}
		);

		gl.disable(GL.depth_test);
	}
コード例 #8
0
	erase_program(const example_params& params)
	 : program(build_program(_get_source(params)))
	{
		gl.use(*this);
		gl.query_location(projection, *this, "Projection");
	}