graphics/shader-shark: comparison Shark.cpp

equal deleted inserted replaced

-:2a156cb51479
+:4cbd9c0beb4c
 */
 #include <iostream>
 #include <iomanip>
 #include <string>
+#include <charconv>
 #include <memory>
 #include <functional>
 #include <sstream>
 #include <vector>
 		GLint uModel = -2;
 		GLint uView = -2;
 		GLint uProjection = -2;
 		GLint uTexture = -2;
+		GLint uTextureScale = -2;
 	} ProgAttr;
 	struct {
 		float yaw = -90.f;
 		float pitch = 0.f;
 	int setNonBlocking(int fd);
 	void loadVertices();
 	void parametrizeTexture(std::shared_ptr<Texture> tex);
 	bool reloadTexture(const std::string& fileName);
 	void loadTextures();
-	std::shared_ptr<Program> loadShaders();
+	void loadShaders();
+	void updateVariableLocations();
 	bool reloadShader(const std::string& fileName);
 	void setTitle(const std::string& suffix = "");
 	static const std::string getDefaultFile(const std::string& relativePath);
 };
 	clear();
 	glXSwapBuffers(dpy, win);
 	// Load GLSL shaders:
-	shaderProgram = loadShaders();
+	loadShaders();
 	loadTextures();
 	loadVertices();
 	auto toggleFullscreen = [&]() {
 		full = setFullscreen(dpy, win, !full);
 	// glBindVertexArray(vao);
 	glm::mat4 model = glm::mat4(1.0f); // identity matrix
 	glUniformMatrix4fv(ProgAttr.uModel, 1, GL_FALSE, &model[0][0]);
+	// TODO: draw a rectangle for each texture
+	glUniform1f(ProgAttr.uTextureScale, textures[0]->getScale());
 	glDrawArrays(GL_TRIANGLES, 0, 2 * 3); // see loadVertices()
 	std::cerr << "GLSL: glDrawArrays()" << std::endl;
 }
 void Shark::Impl::log(LogLevel level, std::string message) {
 void Shark::Impl::parametrizeTexture(std::shared_ptr<Texture> tex) {
 	XAttrs xa(tex->getFileName());
 	std::string magf = xa["shader-shark.texture.mag-filter"];
 	std::string minf = xa["shader-shark.texture.min-filter"];
-	// TODO: std::string scale = xa["shader-shark.texture.scale"];
+	std::string scale = xa["shader-shark.texture.scale"];
-	// TODO: keep MappedFile locked until we read the attributes
 	auto GLT2D = GL_TEXTURE_2D;
 	auto MAG = GL_TEXTURE_MAG_FILTER;
 	auto MIN = GL_TEXTURE_MIN_FILTER;
 	if (magf == "linear") glTexParameteri(GLT2D, MAG, GL_LINEAR);
 	else if (magf == "nearest") glTexParameteri(GLT2D, MAG, GL_NEAREST);
 	if (minf == "linear") glTexParameteri(GLT2D, MIN, GL_LINEAR);
 	else if (minf == "nearest") glTexParameteri(GLT2D, MIN, GL_NEAREST);
+	if (scale.size()) {
+		float sc;
+		if (std::from_chars(scale.data(), scale.data() + scale.size(), sc).ec
+				== std::errc{}) tex->setScale(sc);
+		else std::cerr << "Invalid texture scale value - expecting float\n";
+		// tex->setScale(std::stof(scale)); // locale-dependent (. vs ,)
+	}
 }
 void Shark::Impl::loadTextures() {
 	// Load default texture if there is no configured:
 	if (cfg.textures.empty())
 		}
 	}
 	return false;
 }
-std::shared_ptr<Program> Shark::Impl::loadShaders() {
+void Shark::Impl::loadShaders() {
-	try {
+	// Vertex Array Object (VAO)
-		// Vertex Array Object (VAO)
+	GLuint vao;
-		GLuint vao;
+	glGenVertexArrays(1, &vao);
-		glGenVertexArrays(1, &vao);
+	glBindVertexArray(vao);
-		glBindVertexArray(vao);
+	// VAO - something like context for bound data/variables
-		// VAO - something like context for bound data/variables
+	// We can switch multiple VAOs. VAO can contain multiple VBOs.
-		// We can switch multiple VAOs. VAO can contain multiple VBOs.
+	// what-are-vertex-array-objects
-		// what-are-vertex-array-objects
+	// Vertex Buffer Object (VBO):
-		// Vertex Buffer Object (VBO):
+	GLuint vbo;
-		GLuint vbo;
+	glGenBuffers(1, &vbo);
-		glGenBuffers(1, &vbo);
+	glBindBuffer(GL_ARRAY_BUFFER, vbo);
-		glBindBuffer(GL_ARRAY_BUFFER, vbo);
+	{
-		{
+		// Load default shaders if there are no configured:
-			// Load default shaders if there are no configured:
+		int vc = 0;
-			int vc = 0;
+		int fc = 0;
-			int fc = 0;
+		auto& ss = cfg.shaders;
-			auto& ss = cfg.shaders;
+		for (const auto& s : ss) if (s.type == "vertex") vc++;
-			for (const auto& s : ss) if (s.type == "vertex") vc++;
+		for (const auto& s : ss) if (s.type == "fragment") fc++;
-			for (const auto& s : ss) if (s.type == "fragment") fc++;
+		auto& d = getDefaultFile;
-			auto& d = getDefaultFile;
+		if (vc == 0) ss.push_back({d("shaders/default.vert"), "vertex"});
-			if (vc == 0) ss.push_back({d("shaders/default.vert"), "vertex"});
+		if (fc == 0) ss.push_back({d("shaders/default.frag"), "fragment"});
-			if (fc == 0) ss.push_back({d("shaders/default.frag"), "fragment"});
+	}
-		}
+	shaderProgram = std::make_shared<Program>();
-		std::shared_ptr<Program> program = std::make_shared<Program>();
+	// glBindFragDataLocation(program, 0, "outColor");
-		// glBindFragDataLocation(program, 0, "outColor");
+	// glBindAttribLocation(program, LOC.input, "vertices");
-		// glBindAttribLocation(program, LOC.input, "vertices");
+	for (const Configuration::Shader definition : cfg.shaders) {
-		for (const Configuration::Shader definition : cfg.shaders) {
+		Shader::Type type;
-			Shader::Type type;
+		std::string fileName = definition.fileName;
-			std::string fileName = definition.fileName;
+		if (definition.type == "fragment") type = Shader::Type::FRAGMENT;
-			if (definition.type == "fragment") type = Shader::Type::FRAGMENT;
+		else if (definition.type == "vertex") type = Shader::Type::VERTEX;
-			else if (definition.type == "vertex") type = Shader::Type::VERTEX;
+		else throw std::invalid_argument("unsupported shader type");
-			else throw std::invalid_argument("unsupported shader type");
+		MappedFile file(fileName);
-			MappedFile file(fileName);
+		std::shared_ptr<Shader> shader = std::make_shared<Shader>(
-			std::shared_ptr<Shader> shader = std::make_shared<Shader>(
+				type, file, fileName);
-					type, file, fileName);
+		shaderProgram->attachShader(*shader.get());
-			program->attachShader(*shader.get());
+		shaders.push_back(shader);
-			shaders.push_back(shader);
+		watchedFiles.push_back(fileMonitor.watch(fileName));
-			watchedFiles.push_back(fileMonitor.watch(fileName));
+		std::cerr << "GLSL loaded: " << fileName.c_str() << std::endl;
-			std::cerr << "GLSL loaded: " << fileName.c_str() << std::endl;
+		// We may detach and delete shaders,
-			// We may detach and delete shaders,
+		// but our shaders are small, so we keep them for later reloading.
-			// but our shaders are small, so we keep them for later reloading.
+	}
-		}
+	shaderProgram->link();
-		// GLSL compiler does very efficient / aggressive optimization.
+	updateVariableLocations();
-		// Attributes and uniforms that are not used in the shader are deleted.
+	// listVariables(program);
-		// And even if we e.g. read color from a texture and overwrite it,
+	std::cerr << "GLSL shader count: " << shaders.size() << std::endl;
-		// the variable is still deleted and considered „inactive“.
+}
-		// Functions glGetAttribLocation() and glGetUniformLocation() return -1.
+void Shark::Impl::updateVariableLocations() {
-		program->link();
+	// GLSL compiler does very efficient / aggressive optimization.
+	// Attributes and uniforms that are not used in the shader are deleted.
-		ProgAttr.aVertexXYZ = program->getAttribLocation("aVertexXYZ");
+	// And even if we e.g. read color from a texture and overwrite it,
-		ProgAttr.aTextureXY = program->getAttribLocation("aTextureXY");
+	// the variable is still deleted and considered „inactive“.
-		ProgAttr.uModel = program->getUniformLocation("uModel");
+	// Functions glGetAttribLocation() and glGetUniformLocation() return -1.
-		ProgAttr.uView = program->getUniformLocation("uView");
+	ProgAttr.aVertexXYZ = shaderProgram->getAttribLocation("aVertexXYZ");
-		ProgAttr.uProjection = program->getUniformLocation("uProjection");
+	ProgAttr.aTextureXY = shaderProgram->getAttribLocation("aTextureXY");
-		ProgAttr.uTexture = program->getUniformLocation("uTexture");
+	ProgAttr.uModel = shaderProgram->getUniformLocation("uModel");
-		ProgAttr.fColor = program->getFragDataLocation("fColor");
+	ProgAttr.uView = shaderProgram->getUniformLocation("uView");
-		program->bindFragDataLocation("fColor", ProgAttr.fColor);
+	ProgAttr.uProjection = shaderProgram->getUniformLocation("uProjection");
-		// listVariables(program);
+	ProgAttr.uTexture = shaderProgram->getUniformLocation("uTexture");
-		std::cerr << "GLSL shader count: " << shaders.size() << std::endl;
+	ProgAttr.uTextureScale = shaderProgram->getUniformLocation("uTextureScale");
-		return program;
+	ProgAttr.fColor = shaderProgram->getFragDataLocation("fColor");
-	} catch (const std::exception& e) {
+	shaderProgram->bindFragDataLocation("fColor", ProgAttr.fColor);
-		std::cerr << "Error while loading shaders: " << e.what() << std::endl;
-	} catch (...) {
-		std::cerr << "Error while loading shaders: unknown" << std::endl;
-	}
-	throw std::logic_error("GLSL: loadShaders() failed");
 }
 bool Shark::Impl::reloadShader(const std::string& fileName) {
 	for (auto shader : shaders) {
 		if (shader->getFileName() == fileName) {
 			shader->update(MappedFile(fileName));
 			shaderProgram->link();
+			updateVariableLocations();
 			return true;
 		}
 	}
 	return false;
 }

branch	v_0
changeset 28	4cbd9c0beb4c
parent 27	2a156cb51479
child 30	e15d04d98fca