draw item stack entities

core.mod/src/entities/ItemStackEntity.cc

@@ -20,15 +20,9 @@ ItemStackEntity::ItemStackEntity(const Swan::Context &ctx, const PackObject &obj
 }
 
 void ItemStackEntity::draw(const Swan::Context &ctx, Cygnet::Renderer &rnd) {
-	/*
-	SDL_Rect rect = item_->image_.frameRect();
-
-	SDL_Texture *tex = item_->image_.texture_.get();
-	Swan::TexColorMod darken(tex, 220, 220, 220);
-
-	win.showTexture(body_.pos, tex, &rect,
-		{ .hscale = 0.5, .vscale = 0.5 });
-	TODO */
+	// TODO: decrease brightness?
+	rnd.drawTile(item_->id, Cygnet::Mat3gf{}.scale({0.5, 0.5}).translate(body_.pos));
+	rnd.drawRect(body_.pos, body_.size);
 }
 
 void ItemStackEntity::update(const Swan::Context &ctx, float dt) {

libcygnet/include/cygnet/Renderer.h

@@ -37,6 +37,7 @@ public:
 	~Renderer();
 
 	void drawChunk(RenderChunk chunk, SwanCommon::Vec2 pos);
+	void drawTile(TileID id, Mat3gf mat);
 	void drawSprite(RenderSprite sprite, Mat3gf mat, int y = 0);
 	void drawRect(SwanCommon::Vec2 pos, SwanCommon::Vec2 size);
 
@@ -62,6 +63,11 @@ private:
 		RenderChunk chunk;
 	};
 
+	struct DrawTile {
+		Mat3gf transform;
+		TileID id;
+	};
+
 	struct DrawSprite {
 		Mat3gf transform;
 		int frame;
@@ -78,6 +84,7 @@ private:
 	std::unique_ptr<RendererState> state_;
 
 	std::vector<DrawChunk> drawChunks_;
+	std::vector<DrawTile> drawTiles_;
 	std::vector<DrawSprite> drawSprites_;
 	std::vector<DrawRect> drawRects_;
 };
@@ -86,6 +93,10 @@ inline void Renderer::drawChunk(RenderChunk chunk, SwanCommon::Vec2 pos) {
 	drawChunks_.push_back({pos, chunk});
 }
 
+inline void Renderer::drawTile(TileID id, Mat3gf mat) {
+	drawTiles_.push_back({mat, id});
+}
+
 inline void Renderer::drawSprite(RenderSprite sprite, Mat3gf mat, int frame) {
 	drawSprites_.push_back({mat, frame, sprite});
 }

libcygnet/include/cygnet/shaders.h

@@ -5,6 +5,9 @@ namespace Cygnet::Shaders {
 extern const char *chunkVx;
 extern const char *chunkFr;
 
+extern const char *tileVx;
+extern const char *tileFr;
+
 extern const char *spriteVx;
 extern const char *spriteFr;
 

libcygnet/src/Renderer.cc

@@ -73,15 +73,17 @@ struct ChunkProg: public GlProgram {
 	}
 };
 
-struct RectProg: public GlProgram {
+struct TileProg: public GlProgram {
 	template<typename... T>
-	RectProg(const T &... shaders): GlProgram(shaders...) { init(); }
-	~RectProg() { deinit(); }
+	TileProg(const T &... shaders): GlProgram(shaders...) { init(); }
+	~TileProg() { deinit(); }
 
 	GLint camera = uniformLoc("camera");
-	GLint pos = uniformLoc("pos");
-	GLint size = uniformLoc("size");
+	GLint transform = uniformLoc("transform");
 	GLint vertex = attribLoc("vertex");
+	GLint tileAtlas = uniformLoc("tileAtlas");
+	GLint tileAtlasSize = uniformLoc("tileAtlasSize");
+	GLint tileID = uniformLoc("tileID");
 
 	GLuint vbo;
 
@@ -100,6 +102,8 @@ struct RectProg: public GlProgram {
 		glVertexAttribPointer(vertex, 2, GL_FLOAT, GL_FALSE, 0, (void *)0);
 		glEnableVertexAttribArray(vertex);
 		glCheck();
+
+		glUniform1i(tileAtlas, 0);
 	}
 
 	void disable() {
@@ -116,7 +120,7 @@ struct RectProg: public GlProgram {
 		glCheck();
 	}
 
-	void deinit()  {
+	void deinit() {
 		glDeleteBuffers(1, &vbo);
 		glCheck();
 	}
@@ -175,16 +179,68 @@ struct SpriteProg: public GlProgram {
 	}
 };
 
+struct RectProg: public GlProgram {
+	template<typename... T>
+	RectProg(const T &... shaders): GlProgram(shaders...) { init(); }
+	~RectProg() { deinit(); }
+
+	GLint camera = uniformLoc("camera");
+	GLint pos = uniformLoc("pos");
+	GLint size = uniformLoc("size");
+	GLint vertex = attribLoc("vertex");
+
+	GLuint vbo;
+
+	static constexpr GLfloat vertexes[] = {
+		0.0f,  0.0f, // pos 0: top left
+		0.0f,  1.0f, // pos 1: bottom left
+		1.0f,  1.0f, // pos 2: bottom right
+		1.0f,  1.0f, // pos 2: bottom right
+		1.0f,  0.0f, // pos 3: top right
+		0.0f,  0.0f, // pos 0: top left
+	};
+
+	void enable() {
+		glUseProgram(id());
+		glBindBuffer(GL_ARRAY_BUFFER, vbo);
+		glVertexAttribPointer(vertex, 2, GL_FLOAT, GL_FALSE, 0, (void *)0);
+		glEnableVertexAttribArray(vertex);
+		glCheck();
+	}
+
+	void disable() {
+		glDisableVertexAttribArray(vertex);
+		glCheck();
+	}
+
+	void init() {
+		glGenBuffers(1, &vbo);
+		glCheck();
+
+		glBindBuffer(GL_ARRAY_BUFFER, vbo);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(vertexes), vertexes, GL_STATIC_DRAW);
+		glCheck();
+	}
+
+	void deinit()  {
+		glDeleteBuffers(1, &vbo);
+		glCheck();
+	}
+};
+
 struct RendererState {
-	GlVxShader spriteVx{Shaders::spriteVx};
-	GlFrShader spriteFr{Shaders::spriteFr};
 	GlVxShader chunkVx{Shaders::chunkVx};
 	GlFrShader chunkFr{Shaders::chunkFr};
+	GlVxShader tileVx{Shaders::tileVx};
+	GlFrShader tileFr{Shaders::tileFr};
+	GlVxShader spriteVx{Shaders::spriteVx};
+	GlFrShader spriteFr{Shaders::spriteFr};
 	GlVxShader rectVx{Shaders::rectVx};
 	GlFrShader rectFr{Shaders::rectFr};
 
-	SpriteProg spriteProg{spriteVx, spriteFr};
 	ChunkProg chunkProg{chunkVx, chunkFr};
+	TileProg tileProg{tileVx, tileFr};
+	SpriteProg spriteProg{spriteVx, spriteFr};
 	RectProg rectProg{rectVx, rectFr};
 
 	GLuint atlasTex;
@@ -214,6 +270,7 @@ void Renderer::draw(const RenderCamera &cam) {
 	}
 
 	auto &chunkProg = state_->chunkProg;
+	auto &tileProg = state_->tileProg;
 	auto &spriteProg = state_->spriteProg;
 	auto &rectProg = state_->rectProg;
 
@@ -241,6 +298,30 @@ void Renderer::draw(const RenderCamera &cam) {
 		chunkProg.disable();
 	}
 
+	{
+		tileProg.enable();
+		glUniformMatrix3fv(tileProg.camera, 1, GL_TRUE, camMat.data());
+		glCheck();
+
+		glUniform2f(tileProg.tileAtlasSize, state_->atlasTexSize.x, state_->atlasTexSize.y);
+		glCheck();
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, state_->atlasTex);
+		glCheck();
+
+		glActiveTexture(GL_TEXTURE1);
+		for (auto [mat, id]: drawTiles_) {
+			glUniformMatrix3fv(tileProg.transform, 1, GL_TRUE, mat.data());
+			glUniform1f(tileProg.tileID, id);
+			glDrawArrays(GL_TRIANGLES, 0, 6);
+			glCheck();
+		}
+
+		drawTiles_.clear();
+		tileProg.disable();
+	}
+
 	{
 		spriteProg.enable();
 		glUniformMatrix3fv(spriteProg.camera, 1, GL_TRUE, camMat.data());

libcygnet/src/shaders.cc

@@ -43,6 +43,42 @@ const char *chunkFr = R"glsl(
 	}
 )glsl";
 
+const char *tileVx = R"glsl(
+	precision mediump float;
+	uniform mat3 camera;
+	uniform mat3 transform;
+	attribute vec2 vertex;
+	varying vec2 v_tileCoord;
+
+	void main() {
+		vec3 pos = camera * transform * vec3(vertex, 1);
+		gl_Position = vec4(pos.xy, 0, 1);
+		v_tileCoord = vertex;
+	}
+)glsl";
+
+const char *tileFr = R"glsl(
+	precision mediump float;
+	#define TILE_SIZE 32.0
+
+	varying vec2 v_tileCoord;
+	uniform sampler2D tileAtlas;
+	uniform vec2 tileAtlasSize;
+	uniform float tileID;
+
+	void main() {
+
+		// 1/(TILE_SIZE*16) plays the same role here as in the sprite vertex shader.
+		vec2 offset = v_tileCoord;
+		vec2 pixoffset = (1.0 - offset * 2.0) / (TILE_SIZE * 16.0);
+		vec2 atlasPos = vec2(
+			pixoffset.x + tileID + offset.x,
+			pixoffset.y + floor(tileID / tileAtlasSize.x) + offset.y);
+
+		gl_FragColor = texture2D(tileAtlas, atlasPos / tileAtlasSize);
+	}
+)glsl";
+
 const char *spriteVx = R"glsl(
 	precision mediump float;
 	#define TILE_SIZE 32.0