Add Bicubic Filtering and optional SDF Rendering for some shapes

Author: usagirei

GL/include/shader.inl

@@ -44,4 +44,23 @@ namespace gl {
 		use();
 		glUniform1iv(getUniformLocation(name), count, value);
 	}
+
+	template<>
+	inline void shader::_setUniform<bool>(const char* name, int count, const bool* value)
+	{
+		use();
+		if (count <= 16) {
+			GLint tmp[16];
+			for (int i = 0; i < count; i++)
+				tmp[i] = value[i] ? 1 : 0;
+			glUniform1iv(getUniformLocation(name), count, tmp);
+		}
+		else {
+			GLint* tmp = new GLint[count];
+			for (int i = 0; i < count; i++)
+				tmp[i] = value[i] ? 1 : 0;
+			glUniform1iv(getUniformLocation(name), count, tmp);
+			delete[] tmp;
+		}
+	}
 }

Shared/include/openglrenderer.h

@@ -24,26 +24,34 @@ struct OpenGLContext {
 
 class OpenGLRenderer final : public SarRenderer {
 public:
+	static constexpr int FLAG_HD = 1;
+
 	OpenGLRenderer();
 	~OpenGLRenderer();
 
+	void Render(SarFile& sar, gl::framebuffer& fbo);
+
+	void SetFlag(int flag, bool value) override;
 	void Render(SarFile& sar, int texW, int texH, void* bgraData) override;
 
 private:
-	void initShapeMap();
+	void initShapeAttrs();
 
-	struct shape_map {
+	struct shape_attr {
 		uint16_t m_Value;
+		bool m_EnableSdf;
+
 		inline uint8_t x_pos() { return _BITFIELD(m_Value, 0, 4); }
 		inline uint8_t y_pos() { return _BITFIELD(m_Value, 4, 4); }
 		inline uint8_t sheet() { return _BITFIELD(m_Value, 8, 2); }
+		inline bool    sdf() { return m_EnableSdf; }
 	};
 
 	OpenGLContext m_ctx;
 
 	gl::shader shader;
 	gl::texture atlas;
-	std::unordered_map<uint16_t, shape_map> m_ShapeMaps;
+	std::unordered_map<uint16_t, shape_attr> m_ShapeAttrs;
 };
 
 class glrenderer_exception final : public std::exception {

Shared/include/renderer.h

@@ -5,5 +5,6 @@
 class SarRenderer {
 public:
 	virtual ~SarRenderer() = 0;
+	virtual void SetFlag(int flag, bool value) = 0;
 	virtual void Render(SarFile& sar, int texW, int texH, void* rgbaData) = 0;
 };

Shared/rsrc/default.fs

@@ -3,19 +3,79 @@
 in vec3 Position;
 in vec4 Color;  
 in vec2 TexCoords;
-flat in int DrawMode;
+flat in ivec2 DrawMode;
 
 out vec4 FragColor;
 
 uniform sampler2D m_Tex;
 uniform mat4 m_TexSelector[4];
 uniform vec4 m_TexMixer[4];
+uniform float m_SdfOffset;
+uniform bool m_SdfEnable;
+
+
+vec4 cubic(float v){
+    vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
+    vec4 s = n * n * n;
+    float x = s.x;
+    float y = s.y - 4.0 * s.x;
+    float z = s.z - 4.0 * s.y + 6.0 * s.x;
+    float w = 6.0 - x - y - z;
+    return vec4(x, y, z, w) * (1.0/6.0);
+}
+
+vec4 textureBicubic(sampler2D sampler, vec2 texCoords){
+
+    vec2 texSize = textureSize(sampler, 0);
+    vec2 invTexSize = 1.0 / texSize;
+
+    texCoords = texCoords * texSize - 0.5;
+
+    vec2 fxy = fract(texCoords);
+    texCoords -= fxy;
+
+    vec4 xcubic = cubic(fxy.x);
+    vec4 ycubic = cubic(fxy.y);
+
+    vec4 c = texCoords.xxyy + vec2 (-0.5, +1.5).xyxy;
+
+    vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
+    vec4 offset = c + vec4(xcubic.yw, ycubic.yw) / s;
+
+    offset *= invTexSize.xxyy;
+
+    vec4 sample0 = texture(sampler, offset.xz);
+    vec4 sample1 = texture(sampler, offset.yz);
+    vec4 sample2 = texture(sampler, offset.xw);
+    vec4 sample3 = texture(sampler, offset.yw);
+
+    float sx = s.x / (s.x + s.y);
+    float sy = s.z / (s.z + s.w);
+
+    return mix(
+       mix(sample3, sample2, sx), mix(sample1, sample0, sx)
+    , sy);
+}
 
 void main()
 { 
-    mat4 texSel = m_TexSelector[DrawMode];
-    vec4 texMix = m_TexMixer[DrawMode];
-    vec4 texCol = texture(m_Tex, TexCoords) * texSel;
+    int selector = DrawMode.x;
+    int sdfFactor = DrawMode.y;
+
+    mat4 texSel = m_TexSelector[selector];
+    vec4 texMix = m_TexMixer[selector];
+    vec4 texCol = textureBicubic(m_Tex, TexCoords) * texSel;
+    
     vec4 shape = mix(texCol, vec4(1), texMix);
+
+    if(m_SdfEnable) {
+        float dist = texCol.w - m_SdfOffset;
+        float delta = fwidth(dist) * 0.5;
+        float edge = smoothstep(-delta, delta, dist);
+    
+        vec4 shapeSdf = vec4(1,1,1, edge);
+        shape = mix(shape, shapeSdf, sdfFactor);
+    }
+
     FragColor = shape * Color;
 }

Shared/rsrc/default.vs

@@ -3,12 +3,12 @@
 layout (location = 0) in vec3 aPos;
 layout (location = 1) in vec4 aColor;
 layout (location = 2) in vec2 aTexCoords;
-layout (location = 3) in int aDrawMode;
+layout (location = 3) in ivec2 aDrawMode;
 
 out vec4 Color;
 out vec2 TexCoords;
 out vec3 Position;
-flat out int DrawMode;
+flat out ivec2 DrawMode;
 
 uniform mat4 m_View;
 uniform mat4 m_Proj;

Shared/src/openglrenderer.cpp

@@ -2,6 +2,7 @@
 #include "stb_image.h"
 #include "resource.h"
 #include "debug.h"
+#include "..\include\openglrenderer.h"
 
 #ifdef _USRDLL
 extern HINSTANCE g_hInstDll;
@@ -51,7 +52,7 @@ OpenGLRenderer::OpenGLRenderer()
 	char* fss = getRcdata(m_ctx.hInstance, IDR_SHADER_DEFAULT_FS, fsl);
 	char* atl = getRcdata(m_ctx.hInstance, IDR_TEXTURE_ATLAS, texl);
 
-	initShapeMap();
+	initShapeAttrs();
 
 	int atl_w, atl_h;
 	int	atl_cmp;
@@ -85,6 +86,8 @@ OpenGLRenderer::OpenGLRenderer()
 
 		shader.setUniform("m_TexSelector", texSelector);
 		shader.setUniform("m_TexMixer", texMixer);
+		shader.setUniform("m_SdfOffset", 0.3f);
+		shader.setUniform("m_SdfEnable", false);
 
 		atlas.image2d(atl_w, atl_h, GL_RGBA, GL_UNSIGNED_BYTE, atl_data);
 	}
@@ -97,14 +100,12 @@ OpenGLRenderer::~OpenGLRenderer()
 
 }
 
-void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
-{
-	// Prepare Data
+void OpenGLRenderer::Render(SarFile& sar, gl::framebuffer& fbo) {
 
 	std::vector<glm::vec3>	vertices;
 	std::vector<glm::vec4>	colors;
 	std::vector<glm::vec2>	uvs;
-	std::vector<GLint>		drawMode;
+	std::vector<glm::ivec2>	drawMode;
 	std::vector<GLuint>		indices;
 
 	glm::vec2 uv[] = { {0,0},{0,1},{1,0}, {1,1} };
@@ -117,13 +118,13 @@ void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
 		if (l.hidden())
 			continue;
 
-		auto map_it = m_ShapeMaps.find(l.shape());
-		if (map_it == m_ShapeMaps.end()) {
+		auto map_it = m_ShapeAttrs.find(l.shape());
+		if (map_it == m_ShapeAttrs.end()) {
 			DEBUG_PRINT("Invalid Shape ID: " << l.shape());
 			continue;
 		}
 
-		shape_map map = map_it->second;
+		shape_attr map = map_it->second;
 		glm::vec2 uv_offset = glm::vec2(map.x_pos(), map.y_pos());
 		// 0 2
 		// 1 3
@@ -147,7 +148,7 @@ void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
 			uvs.push_back(baseUv);
 
 			// Shape Mod
-			drawMode.push_back(map.sheet());
+			drawMode.push_back(glm::ivec2(map.sheet(), map.sdf() ? 1 : 0));
 
 			DEBUG_PRINT("UVs: " << baseUv.x << ", " << baseUv.y);
 		}
@@ -165,12 +166,9 @@ void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
 	float halfH = sar.height() / 2.f;
 	glm::mat4 proj = glm::ortho(-halfW - 0.5f, halfW - 0.5f, -halfH - 0.5f, halfH - 0.5f);
 
-
-	// OpenGL Drawing
 	{
 		std::lock_guard<std::mutex> lock{ m_ctx.mutex };
 
-		gl::framebuffer fbo(texW, texH);
 		shader.setUniform("m_View", view);
 		shader.setUniform("m_Proj", proj);
 
@@ -211,15 +209,15 @@ void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
 		glEnableVertexAttribArray(2);
 
 		attr_mod.bind();
-		glVertexAttribIPointer(3, 1, GL_INT, 1 * sizeof(GLint), (void*)0);
+		glVertexAttribIPointer(3, 2, GL_INT, 2 * sizeof(GLint), (void*)0);
 		glEnableVertexAttribArray(3);
 
 		vao.unbind();
 
 		// Draw
 		fbo.bind();
 
-		glViewport(0, 0, texW, texH);
+		glViewport(0, 0, fbo.width, fbo.height);
 
 		glClearColor(1, 1, 1, 0);
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
@@ -229,42 +227,75 @@ void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
 
 		glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
 
-		glReadPixels(0, 0, texW, texH, GL_BGRA, GL_UNSIGNED_BYTE, bgraData);
-
 		fbo.unbind();
 	}
 }
 
-void OpenGLRenderer::initShapeMap()
+void OpenGLRenderer::SetFlag(int flag, bool value)
+{
+	switch (flag) {
+	case FLAG_HD:
+	{
+		std::lock_guard<std::mutex> lock{ m_ctx.mutex };
+		shader.use();
+		shader.setUniform("m_SdfEnable", value);
+	}
+	break;
+	}
+}
+
+void OpenGLRenderer::Render(SarFile& sar, int texW, int texH, void* bgraData)
 {
-	struct map_offset {
+	gl::framebuffer fbo(texW, texH);
+
+	Render(sar, fbo);
+
+	fbo.bind();
+	glReadPixels(0, 0, texW, texH, GL_BGRA, GL_UNSIGNED_BYTE, bgraData);
+	fbo.unbind();
+}
+
+void OpenGLRenderer::initShapeAttrs()
+{
+	struct shape_attr_info {
 		uint16_t start;
 		uint16_t end;
 		int16_t offset;
+		bool sdfEnabled;
+	};
+
+	shape_attr_info attrs[] = {
+		/*	Start	End		Offset	SDF		Shape Set	*/
+		{	0,		79,		0,		true},	//	Characters
+		{	240,	291,	16,		true},	//	Basic Diagram
+		{	320,	358,	0,		true},	//	Lines
+		{	400,	438,	-16,	true},	//	Ink
+		{	480,	516,	32,		false},	//	Gradients
+		{	560,	584,	16,		true},	//	Fractals
+		{	608,	612,	16,		true},	//	Marks
+		{	640,	703,	0,		true},
+		{	720,	753,	240,	false}	//	Pictures 
 	};
 
-	map_offset fixups[] = {
-		/*	Start	End		Offset		Shape Set	*/
-		{	0,		79,		0},		//	Characters
-		{	240,	291,	16},	//	Basic Diagram
-		{	320,	358,	0},		//	Lines
-		{	400,	438,	-16},	//	Ink
-		{	480,	516,	32},	//	Gradients
-		{	560,	584,	16},	//	Fractals
-		{	608,	612,	16},	//	Marks
-		{	640,	703,	0},
-		{	720,	753,	240}	//	Pictures 
+	uint16_t blacklist[] = {
+		560 + 8, 560 + 20, 560 + 21, 560 + 22, 560 + 23, 560 + 24  // Some Fractals
 	};
 
-	constexpr int num_fixups = sizeof(fixups) / sizeof(map_offset);
-	for (int i = 0; i < num_fixups; i++) {
-		map_offset& fixup = fixups[i];
-		for (uint16_t shape_id = fixup.start; shape_id <= fixup.end; shape_id++) {
-			uint16_t new_id = uint16_t(shape_id + fixup.offset);
-			m_ShapeMaps[shape_id] = { new_id };
+	constexpr int num_attrs = sizeof(attrs) / sizeof(shape_attr_info);
+	for (int i = 0; i < num_attrs; i++) {
+		shape_attr_info& attr = attrs[i];
+		for (uint16_t shape_id = attr.start; shape_id <= attr.end; shape_id++) {
+			uint16_t new_id = uint16_t(shape_id + attr.offset);
+			m_ShapeAttrs[shape_id] = { new_id, attr.sdfEnabled };
 			DEBUG_PRINT("Shape Mapping: " << shape_id << " => " << new_id);
 		}
 	}
+
+	constexpr int num_blacklisted = sizeof(blacklist) / sizeof(uint16_t);
+	for (int i = 0; i < num_blacklisted; i++) {
+		uint16_t shape = blacklist[i];
+		m_ShapeAttrs[shape].m_EnableSdf = false;
+	}
 }
 
 OpenGLContext::OpenGLContext()