C++ Shader::Enable方法代码示例

void Renderer::RenderScene(Scene& scene)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	Camera &cam = scene.GetCamera();

	// view matrix
	Mat4 view_matrix = glm::lookAt(cam.position, cam.point, cam.up);

	// gather info
	std::vector<DirectionalLightComponent*> directional_lights;
	std::vector<PointLightComponent*> point_lights;
	std::map<Shader*, std::vector<VisibleComponent*>> visible_by_shader;

	for (auto x : scene.GetVisibleComponents()) {
		Shader *shader = x->GetShader();

		if (shader != nullptr) {
			auto it = visible_by_shader.find(x->GetShader());

			if (it == visible_by_shader.end())
				it = visible_by_shader.emplace(std::piecewise_construct, std::forward_as_tuple(shader), std::forward_as_tuple()).first;

			it->second.push_back(x);
		}
	}

	for (auto x : scene.GetLightComponents()) {
		switch (x->GetType()) {
			case LightComponentType::Directional:
				directional_lights.push_back(static_cast<DirectionalLightComponent*>(x));
				break;

			case LightComponentType::Point:
				point_lights.push_back(static_cast<PointLightComponent*>(x));
				break;

			default:
				break;
		}
	}

	// render
	for (auto it = visible_by_shader.begin(); it != visible_by_shader.end(); ++it) {
		Shader *shader = it->first;

		shader->Enable();
		shader->SetupUniforms(view_matrix, projection_, ambient_, directional_lights, point_lights);

		for (auto x : it->second) {
			Mesh *mesh = x->GetMesh();

			if (mesh == nullptr)
				continue;

			glBindVertexArray(mesh->GetVAO());

			const MeshEntries &entries = mesh->GetEntries();
			int i = 0;

			const Mat4 *generic_model_matrix = x->GetModelMatrix(-1);
			Mat4 generic_normal_matrix = glm::inverse(view_matrix * *generic_model_matrix);
			Vec4 &blend = x->GetColor();

			for (auto it2 = entries.begin(); it2 != entries.end(); ++it2, ++i) {
				const Mat4 *model_matrix = x->GetModelMatrix(i);

				if (model_matrix != nullptr) {
					shader->SetupUniformsForMesh(blend, *model_matrix, glm::inverse(view_matrix * *model_matrix), *mesh, *it2, placeholder_tex_);
				} else {
					shader->SetupUniformsForMesh(blend, *generic_model_matrix, generic_normal_matrix, *mesh, *it2, placeholder_tex_);
				}

				glDrawElementsBaseVertex(GL_TRIANGLES, it2->vertex_count, GL_UNSIGNED_INT,
					reinterpret_cast<void*>(sizeof(uint) * it2->index_base), it2->vertex_base);
			}
		}
	}

	glBindVertexArray(0);
}

//.........这里部分代码省略.........
		0.822f,  0.569f,  0.201f,
		0.435f,  0.602f,  0.223f,
		0.310f,  0.747f,  0.185f,
		0.597f,  0.770f,  0.761f,
		0.559f,  0.436f,  0.730f,
		0.359f,  0.583f,  0.152f,
		0.483f,  0.596f,  0.789f,
		0.559f,  0.861f,  0.639f,
		0.195f,  0.548f,  0.859f,
		0.014f,  0.184f,  0.576f,
		0.771f,  0.328f,  0.970f,
		0.406f,  0.615f,  0.116f,
		0.676f,  0.977f,  0.133f,
		0.971f,  0.572f,  0.833f,
		0.140f,  0.616f,  0.489f,
		0.997f,  0.513f,  0.064f,
		0.945f,  0.719f,  0.592f,
		0.543f,  0.021f,  0.978f,
		0.279f,  0.317f,  0.505f,
		0.167f,  0.620f,  0.077f,
		0.347f,  0.857f,  0.137f,
		0.055f,  0.953f,  0.042f,
		0.714f,  0.505f,  0.345f,
		0.783f,  0.290f,  0.734f,
		0.722f,  0.645f,  0.174f,
		0.302f,  0.455f,  0.848f,
		0.225f,  0.587f,  0.040f,
		0.517f,  0.713f,  0.338f,
		0.053f,  0.959f,  0.120f,
		0.393f,  0.621f,  0.362f,
		0.673f,  0.211f,  0.457f,
		0.820f,  0.883f,  0.371f,
		0.982f,  0.099f,  0.879f
	};

	GLushort indicesData[] =
	{
		0,  1,  2,      0,  2,  3,    // front
		4,  5,  6,      4,  6,  7,    // back
		8,  9,  10,     8,  10, 11,   // top
		12, 13, 14,     12, 14, 15,   // bottom
		16, 17, 18,     16, 18, 19,   // right
		20, 21, 22,     20, 22, 23    // left
	};


	VertexArray cube, cube2;
	IndexBuffer ibo(indicesData, std::end(indicesData) - std::begin(indicesData));

	cube.AddBuffer(sfnew Buffer(vertexBufferData, sizeof(vertexBufferData), 3), 0);
	cube.AddBuffer(sfnew Buffer(colorBufferData, sizeof(colorBufferData), 3), 1);

	cube2.AddBuffer(sfnew Buffer(vertexBufferData, sizeof(vertexBufferData), 3), 0);
	cube2.AddBuffer(sfnew Buffer(colorBufferData, sizeof(colorBufferData), 3), 1);

	Matrix4 projection = Matrix4::Perspective(100.0f, window.GetSize().X / window.GetSize().Y, 0.1f, 100.f);
	Matrix4 view = Matrix4::LookAt(Vector3(4, 3, 3), Vector3(0, 0, 0), Vector3(0, 0.8f, 0));
	Matrix4 model = Matrix4(1.0f);
	Matrix4 mvp = projection * view * model;

	Shader shader = Shader("tri_vertex.glsl", "tri_fragment.glsl");
	shader.Enable();

	while (!window.ShouldClose())
	{
		window.Clear(clearColor);

		// Render here
		cube.Bind();
		ibo.Bind();
		model = Matrix4::Translation(Vector3(0, 0, 0));
		mvp = projection * view * model;
		shader.SetUniformMat4("MVP", mvp);
		glDrawElements(GL_TRIANGLES, ibo.GetCount(), GL_UNSIGNED_SHORT, 0);
		ibo.Bind();
		cube.Unbind();

		cube2.Bind();
		ibo.Bind();
		model = Matrix4::Translation(Vector3(4, 0, 0));
		mvp = projection * view * model;
		shader.SetUniformMat4("MVP", mvp);
		glDrawElements(GL_TRIANGLES, ibo.GetCount(), GL_UNSIGNED_SHORT, 0);
		ibo.Bind();
		cube2.Unbind();


		window.Display();
		window.Update();
	}

	window.Close();

#if _DEBUG
	LOG_DEBUG("PAUSING NOW!");
	system("PAUSE");
#endif

	return EXIT_SUCCESS;
}