aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/body.cpp18
-rw-r--r--src/camera2d.cpp18
-rw-r--r--src/glslprogram.cpp79
-rw-r--r--src/imageloader.cpp53
-rw-r--r--src/inputmanager.cpp13
-rw-r--r--src/iomanager.cpp15
-rw-r--r--src/particlebody.cpp23
-rw-r--r--src/picopng.cpp905
-rw-r--r--src/rectanglecollider.cpp25
-rw-r--r--src/resourcemanager.cpp8
-rw-r--r--src/rigidbody.cpp13
-rw-r--r--src/sprite.cpp34
-rw-r--r--src/spritebatch.cpp94
-rw-r--r--src/texturecache.cpp22
-rw-r--r--src/window.cpp43
15 files changed, 795 insertions, 568 deletions
diff --git a/src/body.cpp b/src/body.cpp
index a17f6ee3..96d01c22 100644
--- a/src/body.cpp
+++ b/src/body.cpp
@@ -6,9 +6,12 @@
* ----------------------------------------------------------------------------
*/
+#include <utility>
+
#include "Physics/body.hpp"
-namespace yage {
+namespace yage
+{
const double Body::GRAVITY = -9.81;
@@ -16,11 +19,10 @@ double Body::xPosition() const { return position_[0]; }
double Body::yPosition() const { return position_[1]; }
-Body::Body(const Vector2d& position, double mass, const Vector2d& velocity,
- bool gravity)
- : position_(position),
- mass_(mass),
- velocity_(velocity),
- gravity_(gravity) {}
+Body::Body(Vector2d position, double mass, Vector2d velocity, bool gravity)
+ : position_(std::move(position)), mass_(mass),
+ velocity_(std::move(velocity)), gravity_(gravity)
+{
+}
-} // yage
+} // yage
diff --git a/src/camera2d.cpp b/src/camera2d.cpp
index 690ac98d..9f210ddc 100644
--- a/src/camera2d.cpp
+++ b/src/camera2d.cpp
@@ -10,15 +10,18 @@
#include <GL/glew.h>
-namespace yage {
+namespace yage
+{
Camera2D::Camera2D(int screen_width, int screen_height)
- : position_(0.f, 0.f),
- camera_matrix_(1.f),
+ : position_(0.f, 0.f), camera_matrix_(1.f),
ortho_matrix_(
- glm::ortho(0.f, (float)screen_width, 0.f, (float)screen_height)) {}
+ glm::ortho(0.f, (float)screen_width, 0.f, (float)screen_height))
+{
+}
-void Camera2D::update(GlslProgram& program) {
+void Camera2D::update(GlslProgram &program)
+{
if (matrix_needs_update_) {
glm::vec3 translate(-position_.x, -position_.y, 0.f);
glm::vec3 scale(scale_, scale_, 0.f);
@@ -33,9 +36,10 @@ void Camera2D::update(GlslProgram& program) {
glUniformMatrix4fv(matrix_location, 1, GL_FALSE, &(camera_matrix_[0][0]));
}
-void Camera2D::move(const glm::vec2& direction) {
+void Camera2D::move(const glm::vec2 &direction)
+{
position_ += direction;
matrix_needs_update_ = true;
}
-} // yage
+} // yage
diff --git a/src/glslprogram.cpp b/src/glslprogram.cpp
index a5f95ad5..d77f373d 100644
--- a/src/glslprogram.cpp
+++ b/src/glslprogram.cpp
@@ -12,39 +12,51 @@
#include <stdexcept>
#include <vector>
-namespace yage {
+namespace yage
+{
-GlslProgram::~GlslProgram() {
+GlslProgram::~GlslProgram()
+{
// cleanup all the shaders and the program
- if (fragment_shader_id_ != 0) glDeleteShader(fragment_shader_id_);
+ if (fragment_shader_id_ != 0) {
+ glDeleteShader(fragment_shader_id_);
+ }
- if (vertex_shader_id_ != 0) glDeleteShader(vertex_shader_id_);
+ if (vertex_shader_id_ != 0) {
+ glDeleteShader(vertex_shader_id_);
+ }
- if (program_id_ != 0) glDeleteProgram(program_id_);
+ if (program_id_ != 0) {
+ glDeleteProgram(program_id_);
+ }
}
-void GlslProgram::compileShader(const GLuint& shader,
- const std::string& file_path) {
+void GlslProgram::compileShader(const GLuint &shader,
+ const std::string &file_path)
+{
// get a string with the input from the shader file
std::ifstream file(file_path);
- if (!file.is_open())
+ if (!file.is_open()) {
throw std::runtime_error("Failed to open '" + file_path + "'");
+ }
std::string content = "";
std::string line;
- while (std::getline(file, line)) content += line + "\n";
+ while (std::getline(file, line)) {
+ content += line + "\n";
+ }
file.close();
// cast source to a c string to get the address of it and input it for
// compilation
- const GLchar* vertex_source = (const GLchar*)content.c_str();
+ const auto *vertex_source = (const GLchar *)content.c_str();
glShaderSource(shader, 1, &vertex_source, nullptr);
glCompileShader(shader);
// check if compilation was successful
GLint is_compiled = 0;
- glGetShaderiv(shader, GL_COMPILE_STATUS, (int*)&is_compiled);
+ glGetShaderiv(shader, GL_COMPILE_STATUS, (int *)&is_compiled);
// if it isn't compiled throw exception to clean up
if (is_compiled == GL_FALSE) {
@@ -53,34 +65,38 @@ void GlslProgram::compileShader(const GLuint& shader,
std::vector<GLchar> error_log(max_length);
glGetShaderInfoLog(shader, max_length, &max_length, &error_log[0]);
- std::string error_log_str((const char*)&error_log[0]);
+ std::string error_log_str((const char *)&error_log[0]);
throw std::runtime_error("Couldn't compile " + file_path + " : " +
error_log_str);
}
}
-void GlslProgram::compileShaders(const std::string& vertex_shader_path,
- const std::string& fragment_shader_path) {
+void GlslProgram::compileShaders(const std::string &vertex_shader_path,
+ const std::string &fragment_shader_path)
+{
// create the program that will be run on GPU
program_id_ = glCreateProgram();
// create vertex shader
vertex_shader_id_ = glCreateShader(GL_VERTEX_SHADER);
- if (vertex_shader_id_ == 0)
+ if (vertex_shader_id_ == 0) {
throw std::runtime_error("Vertex shader failed to be created");
+ }
// create fragment shader
fragment_shader_id_ = glCreateShader(GL_FRAGMENT_SHADER);
- if (fragment_shader_id_ == 0)
+ if (fragment_shader_id_ == 0) {
throw std::runtime_error("Fragment shader failed to be created");
+ }
// compile the two shaders
compileShader(vertex_shader_id_, vertex_shader_path);
compileShader(fragment_shader_id_, fragment_shader_path);
}
-void GlslProgram::linkShaders() {
+void GlslProgram::linkShaders()
+{
// attach the shaders that we want
glAttachShader(program_id_, vertex_shader_id_);
glAttachShader(program_id_, fragment_shader_id_);
@@ -89,7 +105,7 @@ void GlslProgram::linkShaders() {
glLinkProgram(program_id_);
GLint is_linked = 0;
- glGetProgramiv(program_id_, GL_LINK_STATUS, (int*)&is_linked);
+ glGetProgramiv(program_id_, GL_LINK_STATUS, (int *)&is_linked);
if (is_linked == GL_FALSE) {
GLint max_length = 0;
glGetProgramiv(program_id_, GL_INFO_LOG_LENGTH, &max_length);
@@ -98,7 +114,7 @@ void GlslProgram::linkShaders() {
glGetProgramInfoLog(program_id_, max_length, &max_length,
&error_log[0]);
- std::string error_log_str((const char*)&error_log[0]);
+ std::string error_log_str((const char *)&error_log[0]);
throw std::runtime_error("Could not link program : " + error_log_str);
}
@@ -112,26 +128,35 @@ void GlslProgram::linkShaders() {
glDeleteShader(vertex_shader_id_);
}
-void GlslProgram::addAttribute(const std::string& attribute_name) {
+void GlslProgram::addAttribute(const std::string &attribute_name)
+{
glBindAttribLocation(program_id_, attribute_index_++,
attribute_name.c_str());
}
-GLint GlslProgram::getUniformLocation(const std::string& uniform_name) {
+GLint GlslProgram::getUniformLocation(const std::string &uniform_name)
+{
GLint location = glGetUniformLocation(program_id_, uniform_name.c_str());
- if ((GLuint)location == GL_INVALID_INDEX)
+ if ((GLuint)location == GL_INVALID_INDEX) {
throw std::runtime_error("'" + uniform_name + "' not found");
+ }
return location;
}
-void GlslProgram::use() {
+void GlslProgram::use()
+{
glUseProgram(program_id_);
- for (int i = 0; i < attribute_index_; ++i) glEnableVertexAttribArray(i);
+ for (int i = 0; i < attribute_index_; ++i) {
+ glEnableVertexAttribArray(i);
+ }
}
-void GlslProgram::unuse() {
- for (int i = 0; i < attribute_index_; ++i) glDisableVertexAttribArray(i);
+void GlslProgram::unuse()
+{
+ for (int i = 0; i < attribute_index_; ++i) {
+ glDisableVertexAttribArray(i);
+ }
glUseProgram(0);
}
-} // yage
+} // yage
diff --git a/src/imageloader.cpp b/src/imageloader.cpp
index 241cf588..95c73021 100644
--- a/src/imageloader.cpp
+++ b/src/imageloader.cpp
@@ -17,37 +17,44 @@ namespace yage
Texture ImageLoader::loadPng(const std::string &file_path)
{
- Texture texture = {};
+ Texture texture = {};
- std::vector<unsigned char> in;
- std::vector<unsigned char> out;
- unsigned long width, height;
+ std::vector<unsigned char> in;
+ std::vector<unsigned char> out;
+ unsigned long width, height;
- if(!IoManager::readFileToBuffer(file_path, in))
- throw std::runtime_error("Failed to load '"+file_path+"' to buffer");
+ if (!IoManager::readFileToBuffer(file_path, in)) {
+ throw std::runtime_error("Failed to load '" + file_path +
+ "' to buffer");
+ }
- int error_code = decodePNG(out, width, height, &in[0], in.size());
- if(error_code != 0)
- throw std::runtime_error("Failed to load '"+file_path+"' to png with error code"+std::to_string(error_code));
+ int error_code = decodePNG(out, width, height, &in[0], in.size());
+ if (error_code != 0) {
+ throw std::runtime_error("Failed to load '" + file_path +
+ "' to png with error code" +
+ std::to_string(error_code));
+ }
- glGenTextures(1, &texture.id);
-
- glBindTexture(GL_TEXTURE_2D, texture.id);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &out[0]);
+ glGenTextures(1, &texture.id);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+ glBindTexture(GL_TEXTURE_2D, texture.id);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
+ GL_UNSIGNED_BYTE, &out[0]);
- glGenerateMipmap(GL_TEXTURE_2D);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR_MIPMAP_LINEAR);
- glBindTexture(GL_TEXTURE_2D, 0);
+ glGenerateMipmap(GL_TEXTURE_2D);
- texture.width = (int)width;
- texture.height = (int)height;
+ glBindTexture(GL_TEXTURE_2D, 0);
- return texture;
+ texture.width = (int)width;
+ texture.height = (int)height;
+
+ return texture;
}
-
+
} // yage
diff --git a/src/inputmanager.cpp b/src/inputmanager.cpp
index 2583201a..cbb9d2df 100644
--- a/src/inputmanager.cpp
+++ b/src/inputmanager.cpp
@@ -8,15 +8,20 @@
#include "inputmanager.hpp"
-namespace yage {
+namespace yage
+{
void InputManager::keyPressed(unsigned key) { key_map_[key] = true; }
void InputManager::keyReleased(unsigned key) { key_map_[key] = false; }
-bool InputManager::isKeyPressed(unsigned key) const {
+bool InputManager::isKeyPressed(unsigned key) const
+{
auto key_index = key_map_.find(key);
- if (key_index != key_map_.end()) return key_index->second;
+ if (key_index != key_map_.end()) {
+ return key_index->second;
+ }
return false;
}
-}
+
+} // yage
diff --git a/src/iomanager.cpp b/src/iomanager.cpp
index 6059bfbc..60cd7201 100644
--- a/src/iomanager.cpp
+++ b/src/iomanager.cpp
@@ -11,13 +11,16 @@
#include <fstream>
#include <stdexcept>
-namespace yage {
+namespace yage
+{
-bool IoManager::readFileToBuffer(const std::string& file_path,
- std::vector<unsigned char>& buffer) {
+bool IoManager::readFileToBuffer(const std::string &file_path,
+ std::vector<unsigned char> &buffer)
+{
std::ifstream file(file_path, std::ios::binary);
- if (!file.is_open())
+ if (!file.is_open()) {
throw std::runtime_error("Could not open '" + file_path + "'");
+ }
// seek to the end
file.seekg(0, std::ios::end);
@@ -30,10 +33,10 @@ bool IoManager::readFileToBuffer(const std::string& file_path,
file_size -= file.tellg();
buffer.resize(file_size);
- file.read((char*)&buffer[0], file_size);
+ file.read((char *)&buffer[0], file_size);
file.close();
return true;
}
-} // yage
+} // yage
diff --git a/src/particlebody.cpp b/src/particlebody.cpp
index e120d3c5..20682368 100644
--- a/src/particlebody.cpp
+++ b/src/particlebody.cpp
@@ -11,15 +11,19 @@
#include <cmath>
#include <iostream>
-namespace yage {
+namespace yage
+{
-ParticleBody::ParticleBody(const Vector2d& position, double mass,
- const Vector2d& velocity, bool gravity)
- : Body(position, mass, velocity, gravity) {}
+ParticleBody::ParticleBody(const Vector2d &position, double mass,
+ const Vector2d &velocity, bool gravity)
+ : Body(position, mass, velocity, gravity)
+{
+}
-void ParticleBody::applyForce(const Vector2d& force) { force_ += force; }
+void ParticleBody::applyForce(const Vector2d &force) { force_ += force; }
-void ParticleBody::update() {
+void ParticleBody::update()
+{
// set the time_step for 60fps
double time_step = 1.0 / 60.0;
@@ -31,11 +35,12 @@ void ParticleBody::update() {
(0.5 * last_acceleration * std::pow(time_step, 2));
// update the acceleration
- if (gravity_)
+ if (gravity_) {
acceleration_ =
Vector2d(force_.x() / mass_, (GRAVITY + force_.y()) / mass_);
- else
+ } else {
acceleration_ = Vector2d(force_.x() / mass_, force_.y() / mass_);
+ }
Vector2d avg_acceleration = (acceleration_ + last_acceleration) / 2.0;
@@ -43,4 +48,4 @@ void ParticleBody::update() {
velocity_ += avg_acceleration * time_step;
}
-} // yage
+} // yage
diff --git a/src/picopng.cpp b/src/picopng.cpp
index 6fe9c1f7..337038ba 100644
--- a/src/picopng.cpp
+++ b/src/picopng.cpp
@@ -1,7 +1,8 @@
#include <cstdlib>
#include <vector>
-namespace yage {
+namespace yage
+{
/*
decodePNG: The picoPNG function, decodes a PNG file buffer in memory, into a
@@ -30,9 +31,10 @@ namespace yage {
information.
return: 0 if success, not 0 if some error occured.
*/
-int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
- unsigned long& image_height, const unsigned char* in_png,
- size_t in_size, bool convert_to_rgba32) {
+int decodePNG(std::vector<unsigned char> &out_image, unsigned long &image_width,
+ unsigned long &image_height, const unsigned char *in_png,
+ size_t in_size, bool convert_to_rgba32)
+{
// picoPNG version 20101224
// Copyright (c) 2005-2010 Lode Vandevenne
//
@@ -82,409 +84,465 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
static const unsigned long CLCL[19] = {
16, 17, 18, 0, 8, 7, 9, 6, 10, 5,
- 11, 4, 12, 3, 13, 2, 14, 1, 15}; // code length code lengths
- struct Zlib // nested functions for zlib decompression
+ 11, 4, 12, 3, 13, 2, 14, 1, 15}; // code length code lengths
+ struct Zlib // nested functions for zlib decompression
{
- static unsigned long readBitFromStream(size_t& bitp,
- const unsigned char* bits) {
+ static unsigned long readBitFromStream(size_t &bitp,
+ const unsigned char *bits)
+ {
unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1;
bitp++;
return result;
}
- static unsigned long readBitsFromStream(size_t& bitp,
- const unsigned char* bits,
- size_t nbits) {
+ static unsigned long readBitsFromStream(size_t &bitp,
+ const unsigned char *bits,
+ size_t nbits)
+ {
unsigned long result = 0;
- for (size_t i = 0; i < nbits; i++)
+ for (size_t i = 0; i < nbits; i++) {
result += (readBitFromStream(bitp, bits)) << i;
+ }
return result;
}
struct HuffmanTree {
- int makeFromLengths(
- const std::vector<unsigned long>& bitlen,
- unsigned long maxbitlen) { // make tree given the lengths
+ int makeFromLengths(const std::vector<unsigned long> &bitlen,
+ unsigned long maxbitlen)
+ { // make tree given the lengths
unsigned long numcodes = (unsigned long)(bitlen.size()),
treepos = 0, nodefilled = 0;
std::vector<unsigned long> tree1d(numcodes),
blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0);
- for (unsigned long bits = 0; bits < numcodes; bits++)
- blcount[bitlen[bits]]++; // count number of instances of
- // each code length
- for (unsigned long bits = 1; bits <= maxbitlen; bits++)
+ for (unsigned long bits = 0; bits < numcodes; bits++) {
+ blcount[bitlen[bits]]++; // count number of instances of
+ }
+ // each code length
+ for (unsigned long bits = 1; bits <= maxbitlen; bits++) {
nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1])
<< 1;
- for (unsigned long n = 0; n < numcodes; n++)
- if (bitlen[n] != 0)
+ }
+ for (unsigned long n = 0; n < numcodes; n++) {
+ if (bitlen[n] != 0) {
tree1d[n] =
- nextcode[bitlen[n]]++; // generate all the codes
+ nextcode[bitlen[n]]++; // generate all the codes
+ }
+ }
tree2d.clear();
- tree2d.resize(numcodes * 2, 32767); // 32767 here means the
- // tree2d isn't filled
- // there yet
- for (unsigned long n = 0; n < numcodes; n++) // the codes
+ tree2d.resize(numcodes * 2, 32767); // 32767 here means the
+ // tree2d isn't filled
+ // there yet
+ for (unsigned long n = 0; n < numcodes; n++) { // the codes
for (unsigned long i = 0; i < bitlen[n];
- i++) // the bits for this code
+ i++) // the bits for this code
{
unsigned long bit =
(tree1d[n] >> (bitlen[n] - i - 1)) & 1;
- if (treepos > numcodes - 2) return 55;
+ if (treepos > numcodes - 2) {
+ return 55;
+ }
if (tree2d[2 * treepos + bit] ==
- 32767) // not yet filled in
+ 32767) // not yet filled in
{
if (i + 1 == bitlen[n]) {
tree2d[2 * treepos + bit] = n;
treepos = 0;
- } // last bit
+ } // last bit
else {
tree2d[2 * treepos + bit] =
++nodefilled + numcodes;
treepos = nodefilled;
- } // addresses are encoded as values > numcodes
- } else
+ } // addresses are encoded as values > numcodes
+ } else {
treepos = tree2d[2 * treepos + bit] -
- numcodes; // subtract numcodes from
- // address to get address value
+ numcodes; // subtract numcodes from
+ }
+ // address to get address value
}
+ }
return 0;
}
- int decode(
- bool& decoded, unsigned long& result, size_t& treepos,
- unsigned long bit) const { // Decodes a symbol from the tree
+ int decode(bool &decoded, unsigned long &result, size_t &treepos,
+ unsigned long bit) const
+ { // Decodes a symbol from the tree
unsigned long numcodes = (unsigned long)tree2d.size() / 2;
- if (treepos >= numcodes)
- return 11; // error: you appeared outside the codetree
+ if (treepos >= numcodes) {
+ return 11; // error: you appeared outside the codetree
+ }
result = tree2d[2 * treepos + bit];
decoded = (result < numcodes);
treepos = decoded ? 0 : result - numcodes;
return 0;
}
- std::vector<unsigned long> tree2d; // 2D representation of a
- // huffman tree: The one
- // dimension is "0" or "1", the
- // other contains all nodes and
- // leaves of the tree.
+ std::vector<unsigned long> tree2d; // 2D representation of a
+ // huffman tree: The one
+ // dimension is "0" or "1", the
+ // other contains all nodes and
+ // leaves of the tree.
};
struct Inflator {
int error;
- void inflate(std::vector<unsigned char>& out,
- const std::vector<unsigned char>& in,
- size_t inpos = 0) {
- size_t bp = 0, pos = 0; // bit pointer and byte pointer
+ void inflate(std::vector<unsigned char> &out,
+ const std::vector<unsigned char> &in, size_t inpos = 0)
+ {
+ size_t bp = 0, pos = 0; // bit pointer and byte pointer
error = 0;
unsigned long BFINAL = 0;
while (!BFINAL && !error) {
if (bp >> 3 >= in.size()) {
error = 52;
return;
- } // error, bit pointer will jump past memory
+ } // error, bit pointer will jump past memory
BFINAL = readBitFromStream(bp, &in[inpos]);
unsigned long BTYPE = readBitFromStream(bp, &in[inpos]);
BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
if (BTYPE == 3) {
error = 20;
return;
- } // error: invalid BTYPE
- else if (BTYPE == 0)
+ } // error: invalid BTYPE
+ else if (BTYPE == 0) {
inflateNoCompression(out, &in[inpos], bp, pos,
in.size());
- else
+ } else {
inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(),
BTYPE);
+ }
}
- if (!error)
- out.resize(pos); // Only now we know the true size of out,
- // resize it to that
+ if (!error) {
+ out.resize(pos); // Only now we know the true size of out,
+ }
+ // resize it to that
}
- void generateFixedTrees(HuffmanTree& tree,
- HuffmanTree& treeD) // get the tree of a
- // deflated block with
- // fixed tree
+ void generateFixedTrees(HuffmanTree &tree,
+ HuffmanTree &treeD) // get the tree of a
+ // deflated block with
+ // fixed tree
{
std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);
;
- for (size_t i = 144; i <= 255; i++) bitlen[i] = 9;
- for (size_t i = 256; i <= 279; i++) bitlen[i] = 7;
+ for (size_t i = 144; i <= 255; i++) {
+ bitlen[i] = 9;
+ }
+ for (size_t i = 256; i <= 279; i++) {
+ bitlen[i] = 7;
+ }
tree.makeFromLengths(bitlen, 15);
treeD.makeFromLengths(bitlenD, 15);
}
HuffmanTree codetree, codetreeD,
- codelengthcodetree; // the code tree for Huffman codes, dist
- // codes, and code length codes
- unsigned long huffmanDecodeSymbol(
- const unsigned char* in, size_t& bp,
- const HuffmanTree& codetree,
- size_t inlength) { // decode a single symbol from given list of
- // bits with given code tree. return value
- // is the symbol
+ codelengthcodetree; // the code tree for Huffman codes, dist
+ // codes, and code length codes
+ unsigned long huffmanDecodeSymbol(const unsigned char *in,
+ size_t &bp,
+ const HuffmanTree &codetree,
+ size_t inlength)
+ { // decode a single symbol from given list of
+ // bits with given code tree. return value
+ // is the symbol
bool decoded;
unsigned long ct;
for (size_t treepos = 0;;) {
if ((bp & 0x07) == 0 && (bp >> 3) > inlength) {
error = 10;
return 0;
- } // error: end reached without endcode
+ } // error: end reached without endcode
error = codetree.decode(decoded, ct, treepos,
readBitFromStream(bp, in));
- if (error) return 0; // stop, an error happened
- if (decoded) return ct;
+ if (error) {
+ return 0; // stop, an error happened
+ }
+ if (decoded) {
+ return ct;
+ }
}
}
- void getTreeInflateDynamic(
- HuffmanTree& tree, HuffmanTree& treeD, const unsigned char* in,
- size_t& bp,
- size_t inlength) { // get the tree of a deflated block with
- // dynamic tree, the tree itself is also
- // Huffman compressed with a known tree
+ void getTreeInflateDynamic(HuffmanTree &tree, HuffmanTree &treeD,
+ const unsigned char *in, size_t &bp,
+ size_t inlength)
+ { // get the tree of a deflated block with
+ // dynamic tree, the tree itself is also
+ // Huffman compressed with a known tree
std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0);
if (bp >> 3 >= inlength - 2) {
error = 49;
return;
- } // the bit pointer is or will go past the memory
+ } // the bit pointer is or will go past the memory
size_t HLIT = readBitsFromStream(bp, in, 5) +
- 257; // number of literal/length codes + 257
+ 257; // number of literal/length codes + 257
size_t HDIST = readBitsFromStream(bp, in, 5) +
- 1; // number of dist codes + 1
+ 1; // number of dist codes + 1
size_t HCLEN = readBitsFromStream(bp, in, 4) +
- 4; // number of code length codes + 4
+ 4; // number of code length codes + 4
std::vector<unsigned long> codelengthcode(
- 19); // lengths of tree to decode the lengths of the
- // dynamic tree
- for (size_t i = 0; i < 19; i++)
+ 19); // lengths of tree to decode the lengths of the
+ // dynamic tree
+ for (size_t i = 0; i < 19; i++) {
codelengthcode[CLCL[i]] =
(i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
+ }
error = codelengthcodetree.makeFromLengths(codelengthcode, 7);
- if (error) return;
+ if (error) {
+ return;
+ }
size_t i = 0, replength;
while (i < HLIT + HDIST) {
unsigned long code = huffmanDecodeSymbol(
in, bp, codelengthcodetree, inlength);
- if (error) return;
+ if (error) {
+ return;
+ }
if (code <= 15) {
- if (i < HLIT)
+ if (i < HLIT) {
bitlen[i++] = code;
- else
+ } else {
bitlenD[i++ - HLIT] = code;
- } // a length code
- else if (code == 16) // repeat previous
+ }
+ } // a length code
+ else if (code == 16) // repeat previous
{
if (bp >> 3 >= inlength) {
error = 50;
return;
- } // error, bit pointer jumps past memory
+ } // error, bit pointer jumps past memory
replength = 3 + readBitsFromStream(bp, in, 2);
- unsigned long value; // set value to the previous code
- if ((i - 1) < HLIT)
+ unsigned long value; // set value to the previous code
+ if ((i - 1) < HLIT) {
value = bitlen[i - 1];
- else
+ } else {
value = bitlenD[i - HLIT - 1];
+ }
for (size_t n = 0; n < replength;
- n++) // repeat this value in the next lengths
+ n++) // repeat this value in the next lengths
{
if (i >= HLIT + HDIST) {
error = 13;
return;
- } // error: i is larger than the amount of codes
- if (i < HLIT)
+ } // error: i is larger than the amount of codes
+ if (i < HLIT) {
bitlen[i++] = value;
- else
+ } else {
bitlenD[i++ - HLIT] = value;
+ }
}
- } else if (code == 17) // repeat "0" 3-10 times
+ } else if (code == 17) // repeat "0" 3-10 times
{
if (bp >> 3 >= inlength) {
error = 50;
return;
- } // error, bit pointer jumps past memory
+ } // error, bit pointer jumps past memory
replength = 3 + readBitsFromStream(bp, in, 3);
for (size_t n = 0; n < replength;
- n++) // repeat this value in the next lengths
+ n++) // repeat this value in the next lengths
{
if (i >= HLIT + HDIST) {
error = 14;
return;
- } // error: i is larger than the amount of codes
- if (i < HLIT)
+ } // error: i is larger than the amount of codes
+ if (i < HLIT) {
bitlen[i++] = 0;
- else
+ } else {
bitlenD[i++ - HLIT] = 0;
+ }
}
- } else if (code == 18) // repeat "0" 11-138 times
+ } else if (code == 18) // repeat "0" 11-138 times
{
if (bp >> 3 >= inlength) {
error = 50;
return;
- } // error, bit pointer jumps past memory
+ } // error, bit pointer jumps past memory
replength = 11 + readBitsFromStream(bp, in, 7);
for (size_t n = 0; n < replength;
- n++) // repeat this value in the next lengths
+ n++) // repeat this value in the next lengths
{
if (i >= HLIT + HDIST) {
error = 15;
return;
- } // error: i is larger than the amount of codes
- if (i < HLIT)
+ } // error: i is larger than the amount of codes
+ if (i < HLIT) {
bitlen[i++] = 0;
- else
+ } else {
bitlenD[i++ - HLIT] = 0;
+ }
}
} else {
error = 16;
return;
- } // error: somehow an unexisting code appeared. This can
- // never happen.
+ } // error: somehow an unexisting code appeared. This can
+ // never happen.
}
if (bitlen[256] == 0) {
error = 64;
return;
- } // the length of the end code 256 must be larger than 0
+ } // the length of the end code 256 must be larger than 0
error = tree.makeFromLengths(bitlen, 15);
- if (error)
- return; // now we've finally got HLIT and HDIST, so
- // generate the code trees, and the function is
- // done
+ if (error) {
+ return; // now we've finally got HLIT and HDIST, so
+ }
+ // generate the code trees, and the function is
+ // done
error = treeD.makeFromLengths(bitlenD, 15);
- if (error) return;
+ if (error) {
+ return;
+ }
}
- void inflateHuffmanBlock(std::vector<unsigned char>& out,
- const unsigned char* in, size_t& bp,
- size_t& pos, size_t inlength,
- unsigned long btype) {
+ void inflateHuffmanBlock(std::vector<unsigned char> &out,
+ const unsigned char *in, size_t &bp,
+ size_t &pos, size_t inlength,
+ unsigned long btype)
+ {
if (btype == 1) {
generateFixedTrees(codetree, codetreeD);
} else if (btype == 2) {
getTreeInflateDynamic(codetree, codetreeD, in, bp,
inlength);
- if (error) return;
+ if (error) {
+ return;
+ }
}
for (;;) {
unsigned long code =
huffmanDecodeSymbol(in, bp, codetree, inlength);
- if (error) return;
- if (code == 256)
- return; // end code
- else if (code <= 255) // literal symbol
+ if (error) {
+ return;
+ }
+ if (code == 256) {
+ return; // end code
+ } else if (code <= 255) // literal symbol
{
- if (pos >= out.size())
- out.resize((pos + 1) * 2); // reserve more room
+ if (pos >= out.size()) {
+ out.resize((pos + 1) * 2); // reserve more room
+ }
out[pos++] = (unsigned char)(code);
- } else if (code >= 257 && code <= 285) // length code
+ } else if (code >= 257 && code <= 285) // length code
{
size_t length = LENBASE[code - 257],
numextrabits = LENEXTRA[code - 257];
if ((bp >> 3) >= inlength) {
error = 51;
return;
- } // error, bit pointer will jump past memory
+ } // error, bit pointer will jump past memory
length += readBitsFromStream(bp, in, numextrabits);
unsigned long codeD =
huffmanDecodeSymbol(in, bp, codetreeD, inlength);
- if (error) return;
+ if (error) {
+ return;
+ }
if (codeD > 29) {
error = 18;
return;
- } // error: invalid dist code (30-31 are never used)
+ } // error: invalid dist code (30-31 are never used)
unsigned long dist = DISTBASE[codeD],
numextrabitsD = DISTEXTRA[codeD];
if ((bp >> 3) >= inlength) {
error = 51;
return;
- } // error, bit pointer will jump past memory
+ } // error, bit pointer will jump past memory
dist += readBitsFromStream(bp, in, numextrabitsD);
- size_t start = pos, back = start - dist; // backwards
- if (pos + length >= out.size())
- out.resize((pos + length) * 2); // reserve more
- // room
+ size_t start = pos, back = start - dist; // backwards
+ if (pos + length >= out.size()) {
+ out.resize((pos + length) * 2); // reserve more
+ }
+ // room
for (size_t i = 0; i < length; i++) {
out[pos++] = out[back++];
- if (back >= start) back = start - dist;
+ if (back >= start) {
+ back = start - dist;
+ }
}
}
}
}
- void inflateNoCompression(std::vector<unsigned char>& out,
- const unsigned char* in, size_t& bp,
- size_t& pos, size_t inlength) {
- while ((bp & 0x7) != 0) bp++; // go to first boundary of byte
+ void inflateNoCompression(std::vector<unsigned char> &out,
+ const unsigned char *in, size_t &bp,
+ size_t &pos, size_t inlength)
+ {
+ while ((bp & 0x7) != 0) {
+ bp++; // go to first boundary of byte
+ }
size_t p = bp / 8;
if (p >= inlength - 4) {
error = 52;
return;
- } // error, bit pointer will jump past memory
+ } // error, bit pointer will jump past memory
unsigned long LEN = in[p] + 256 * in[p + 1],
NLEN = in[p + 2] + 256 * in[p + 3];
p += 4;
if (LEN + NLEN != 65535) {
error = 21;
return;
- } // error: NLEN is not one's complement of LEN
- if (pos + LEN >= out.size()) out.resize(pos + LEN);
+ } // error: NLEN is not one's complement of LEN
+ if (pos + LEN >= out.size()) {
+ out.resize(pos + LEN);
+ }
if (p + LEN > inlength) {
error = 23;
return;
- } // error: reading outside of in buffer
- for (unsigned long n = 0; n < LEN; n++)
- out[pos++] = in[p++]; // read LEN bytes of literal data
+ } // error: reading outside of in buffer
+ for (unsigned long n = 0; n < LEN; n++) {
+ out[pos++] = in[p++]; // read LEN bytes of literal data
+ }
bp = p * 8;
}
};
- int decompress(
- std::vector<unsigned char>& out,
- const std::vector<unsigned char>& in) // returns error value
+ int
+ decompress(std::vector<unsigned char> &out,
+ const std::vector<unsigned char> &in) // returns error value
{
Inflator inflator;
if (in.size() < 2) {
return 53;
- } // error, size of zlib data too small
+ } // error, size of zlib data too small
if ((in[0] * 256 + in[1]) % 31 != 0) {
return 24;
- } // error: 256 * in[0] + in[1] must be a multiple of 31, the
- // FCHECK value is supposed to be made that way
+ } // error: 256 * in[0] + in[1] must be a multiple of 31, the
+ // FCHECK value is supposed to be made that way
unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15,
FDICT = (in[1] >> 5) & 1;
if (CM != 8 || CINFO > 7) {
return 25;
- } // error: only compression method 8: inflate with sliding window
- // of 32k is supported by the PNG spec
+ } // error: only compression method 8: inflate with sliding window
+ // of 32k is supported by the PNG spec
if (FDICT != 0) {
return 26;
- } // error: the specification of PNG says about the zlib stream:
- // "The additional flags shall not specify a preset dictionary."
+ } // error: the specification of PNG says about the zlib stream:
+ // "The additional flags shall not specify a preset dictionary."
inflator.inflate(out, in, 2);
return inflator
- .error; // note: adler32 checksum was skipped and ignored
+ .error; // note: adler32 checksum was skipped and ignored
}
};
- struct PNG // nested functions for PNG decoding
+ struct PNG // nested functions for PNG decoding
{
struct Info {
unsigned long width, height, colorType, bitDepth, compressionMethod,
filterMethod, interlaceMethod, key_r, key_g, key_b;
- bool key_defined; // is a transparent color key given?
+ bool key_defined; // is a transparent color key given?
std::vector<unsigned char> palette;
} info;
int error;
- void decode(std::vector<unsigned char>& out, const unsigned char* in,
- size_t size, bool convert_to_rgba32) {
+ void decode(std::vector<unsigned char> &out, const unsigned char *in,
+ size_t size, bool convert_to_rgba32)
+ {
error = 0;
- if (size == 0 || in == 0) {
+ if (size == 0 || in == nullptr) {
error = 48;
return;
- } // the given data is empty
+ } // the given data is empty
readPngHeader(&in[0], size);
- if (error) return;
- size_t pos = 33; // first byte of the first chunk after the header
- std::vector<unsigned char> idat; // the data from idat chunks
+ if (error) {
+ return;
+ }
+ size_t pos = 33; // first byte of the first chunk after the header
+ std::vector<unsigned char> idat; // the data from idat chunks
bool IEND = false, known_type = true;
info.key_defined = false;
- while (!IEND) // loop through the chunks, ignoring unknown chunks
- // and stopping at IEND chunk. IDAT data is put at
- // the start of the in buffer
+ while (!IEND) // loop through the chunks, ignoring unknown chunks
+ // and stopping at IEND chunk. IDAT data is put at
+ // the start of the in buffer
{
if (pos + 8 >= size) {
error = 30;
return;
- } // error: size of the in buffer too small to contain next
- // chunk
+ } // error: size of the in buffer too small to contain next
+ // chunk
size_t chunkLength = read32bitInt(&in[pos]);
pos += 4;
if (chunkLength > 2147483647) {
@@ -494,12 +552,12 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
if (pos + chunkLength >= size) {
error = 35;
return;
- } // error: size of the in buffer too small to contain next
- // chunk
+ } // error: size of the in buffer too small to contain next
+ // chunk
if (in[pos + 0] == 'I' && in[pos + 1] == 'D' &&
in[pos + 2] == 'A' &&
in[pos + 3] ==
- 'T') // IDAT chunk, containing compressed image data
+ 'T') // IDAT chunk, containing compressed image data
{
idat.insert(idat.end(), &in[pos + 4],
&in[pos + 4 + chunkLength]);
@@ -510,40 +568,42 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
IEND = true;
} else if (in[pos + 0] == 'P' && in[pos + 1] == 'L' &&
in[pos + 2] == 'T' &&
- in[pos + 3] == 'E') // palette chunk (PLTE)
+ in[pos + 3] == 'E') // palette chunk (PLTE)
{
- pos += 4; // go after the 4 letters
+ pos += 4; // go after the 4 letters
info.palette.resize(4 * (chunkLength / 3));
if (info.palette.size() > (4 * 256)) {
error = 38;
return;
- } // error: palette too big
+ } // error: palette too big
for (size_t i = 0; i < info.palette.size(); i += 4) {
- for (size_t j = 0; j < 3; j++)
- info.palette[i + j] = in[pos++]; // RGB
- info.palette[i + 3] = 255; // alpha
+ for (size_t j = 0; j < 3; j++) {
+ info.palette[i + j] = in[pos++]; // RGB
+ }
+ info.palette[i + 3] = 255; // alpha
}
} else if (in[pos + 0] == 't' && in[pos + 1] == 'R' &&
in[pos + 2] == 'N' &&
in[pos + 3] ==
- 'S') // palette transparency chunk (tRNS)
+ 'S') // palette transparency chunk (tRNS)
{
- pos += 4; // go after the 4 letters
+ pos += 4; // go after the 4 letters
if (info.colorType == 3) {
if (4 * chunkLength > info.palette.size()) {
error = 39;
return;
- } // error: more alpha values given than there are
- // palette entries
- for (size_t i = 0; i < chunkLength; i++)
+ } // error: more alpha values given than there are
+ // palette entries
+ for (size_t i = 0; i < chunkLength; i++) {
info.palette[4 * i + 3] = in[pos++];
+ }
} else if (info.colorType == 0) {
if (chunkLength != 2) {
error = 40;
return;
- } // error: this chunk must be 2 bytes for greyscale
- // image
- info.key_defined = 1;
+ } // error: this chunk must be 2 bytes for greyscale
+ // image
+ info.key_defined = true;
info.key_r = info.key_g = info.key_b =
256 * in[pos] + in[pos + 1];
pos += 2;
@@ -551,8 +611,8 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
if (chunkLength != 6) {
error = 41;
return;
- } // error: this chunk must be 6 bytes for RGB image
- info.key_defined = 1;
+ } // error: this chunk must be 6 bytes for RGB image
+ info.key_defined = true;
info.key_r = 256 * in[pos] + in[pos + 1];
pos += 2;
info.key_g = 256 * in[pos] + in[pos + 1];
@@ -562,78 +622,84 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
} else {
error = 42;
return;
- } // error: tRNS chunk not allowed for other color models
- } else // it's not an implemented chunk type, so ignore it:
- // skip over the data
+ } // error: tRNS chunk not allowed for other color models
+ } else // it's not an implemented chunk type, so ignore it:
+ // skip over the data
{
if (!(in[pos + 0] & 32)) {
error = 69;
return;
- } // error: unknown critical chunk (5th bit of first byte
- // of chunk type is 0)
- pos += (chunkLength + 4); // skip 4 letters and
- // uninterpreted data of
- // unimplemented chunk
+ } // error: unknown critical chunk (5th bit of first byte
+ // of chunk type is 0)
+ pos += (chunkLength + 4); // skip 4 letters and
+ // uninterpreted data of
+ // unimplemented chunk
known_type = false;
}
- pos += 4; // step over CRC (which is ignored)
+ pos += 4; // step over CRC (which is ignored)
}
unsigned long bpp = getBpp(info);
std::vector<unsigned char> scanlines(
((info.width * (info.height * bpp + 7)) / 8) +
- info.height); // now the out buffer will be filled
- Zlib zlib; // decompress with the Zlib decompressor
+ info.height); // now the out buffer will be filled
+ Zlib zlib; // decompress with the Zlib decompressor
error = zlib.decompress(scanlines, idat);
- if (error)
- return; // stop if the zlib decompressor returned an error
+ if (error) {
+ return; // stop if the zlib decompressor returned an error
+ }
size_t bytewidth = (bpp + 7) / 8,
outlength = (info.height * info.width * bpp + 7) / 8;
- out.resize(outlength); // time to fill the out buffer
- unsigned char* out_ =
- outlength ? &out[0] : 0; // use a regular pointer to the
- // std::vector for faster code if
- // compiled without optimization
- if (info.interlaceMethod == 0) // no interlace, just filter
+ out.resize(outlength); // time to fill the out buffer
+ unsigned char *out_ =
+ outlength ? &out[0] : nullptr; // use a regular pointer to the
+ // std::vector for faster code if
+ // compiled without optimization
+ if (info.interlaceMethod == 0) // no interlace, just filter
{
size_t linestart = 0,
linelength = (info.width * bpp + 7) /
- 8; // length in bytes of a scanline,
- // excluding the filtertype byte
- if (bpp >= 8) // byte per byte
+ 8; // length in bytes of a scanline,
+ // excluding the filtertype byte
+ if (bpp >= 8) { // byte per byte
for (unsigned long y = 0; y < info.height; y++) {
unsigned long filterType = scanlines[linestart];
- const unsigned char* prevline =
- (y == 0) ? 0
+ const unsigned char *prevline =
+ (y == 0) ? nullptr
: &out_[(y - 1) * info.width * bytewidth];
unFilterScanline(&out_[linestart - y],
&scanlines[linestart + 1], prevline,
bytewidth, filterType, linelength);
- if (error) return;
+ if (error) {
+ return;
+ }
linestart +=
- (1 + linelength); // go to start of next scanline
+ (1 + linelength); // go to start of next scanline
}
- else // less than 8 bits per pixel, so fill it up bit per bit
+ } else // less than 8 bits per pixel, so fill it up bit per bit
{
std::vector<unsigned char> templine(
- (info.width * bpp + 7) >> 3); // only used if bpp < 8
+ (info.width * bpp + 7) >> 3); // only used if bpp < 8
for (size_t y = 0, obp = 0; y < info.height; y++) {
unsigned long filterType = scanlines[linestart];
- const unsigned char* prevline =
- (y == 0) ? 0
+ const unsigned char *prevline =
+ (y == 0) ? nullptr
: &out_[(y - 1) * info.width * bytewidth];
unFilterScanline(&templine[0],
&scanlines[linestart + 1], prevline,
bytewidth, filterType, linelength);
- if (error) return;
- for (size_t bp = 0; bp < info.width * bpp;)
+ if (error) {
+ return;
+ }
+ for (size_t bp = 0; bp < info.width * bpp;) {
setBitOfReversedStream(
obp, out_,
readBitFromReversedStream(bp, &templine[0]));
+ }
linestart +=
- (1 + linelength); // go to start of next scanline
+ (1 + linelength); // go to start of next scanline
}
}
- } else // interlaceMethod is 1 (Adam7)
+ } else // interlaceMethod is 1 (Adam7)
{
size_t passw[7] = {(info.width + 7) / 8, (info.width + 3) / 8,
(info.width + 3) / 4, (info.width + 1) / 4,
@@ -644,50 +710,52 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
(info.height + 1) / 4, (info.height + 1) / 2,
(info.height + 0) / 2};
size_t passstart[7] = {0};
- size_t pattern[28] = {
- 0, 4, 0, 2, 0, 1, 0, 0, 0, 4, 0, 2, 0, 1, 8,
- 8, 4, 4, 2, 2, 1, 8, 8, 8, 4, 4, 2, 2}; // values for the
- // adam7 passes
- for (int i = 0; i < 6; i++)
+ size_t pattern[28] = {0, 4, 0, 2, 0, 1, 0, 0, 0, 4,
+ 0, 2, 0, 1, 8, 8, 4, 4, 2, 2,
+ 1, 8, 8, 8, 4, 4, 2, 2}; // values for the
+ // adam7 passes
+ for (int i = 0; i < 6; i++) {
passstart[i + 1] = passstart[i] +
passh[i] * ((passw[i] ? 1 : 0) +
(passw[i] * bpp + 7) / 8);
+ }
std::vector<unsigned char> scanlineo((info.width * bpp + 7) /
8),
scanlinen((info.width * bpp + 7) /
- 8); //"old" and "new" scanline
- for (int i = 0; i < 7; i++)
+ 8); //"old" and "new" scanline
+ for (int i = 0; i < 7; i++) {
adam7Pass(&out_[0], &scanlinen[0], &scanlineo[0],
&scanlines[passstart[i]], info.width, pattern[i],
pattern[i + 7], pattern[i + 14], pattern[i + 21],
passw[i], passh[i], bpp);
+ }
}
if (convert_to_rgba32 && (info.colorType != 6 ||
- info.bitDepth != 8)) // conversion needed
+ info.bitDepth != 8)) // conversion needed
{
std::vector<unsigned char> data = out;
error = convert(out, &data[0], info, info.width, info.height);
}
}
- void readPngHeader(const unsigned char* in,
- size_t inlength) // read the information from the
- // header and store it in the Info
+ void readPngHeader(const unsigned char *in,
+ size_t inlength) // read the information from the
+ // header and store it in the Info
{
if (inlength < 29) {
error = 27;
return;
- } // error: the data length is smaller than the length of the
- // header
+ } // error: the data length is smaller than the length of the
+ // header
if (in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 ||
in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) {
error = 28;
return;
- } // no PNG signature
+ } // no PNG signature
if (in[12] != 'I' || in[13] != 'H' || in[14] != 'D' ||
in[15] != 'R') {
error = 29;
return;
- } // error: it doesn't start with a IHDR chunk!
+ } // error: it doesn't start with a IHDR chunk!
info.width = read32bitInt(&in[16]);
info.height = read32bitInt(&in[20]);
info.bitDepth = in[24];
@@ -696,199 +764,236 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
if (in[26] != 0) {
error = 32;
return;
- } // error: only compression method 0 is allowed in the
- // specification
+ } // error: only compression method 0 is allowed in the
+ // specification
info.filterMethod = in[27];
if (in[27] != 0) {
error = 33;
return;
- } // error: only filter method 0 is allowed in the specification
+ } // error: only filter method 0 is allowed in the specification
info.interlaceMethod = in[28];
if (in[28] > 1) {
error = 34;
return;
- } // error: only interlace methods 0 and 1 exist in the
- // specification
+ } // error: only interlace methods 0 and 1 exist in the
+ // specification
error = checkColorValidity(info.colorType, info.bitDepth);
}
- void unFilterScanline(unsigned char* recon,
- const unsigned char* scanline,
- const unsigned char* precon, size_t bytewidth,
- unsigned long filterType, size_t length) {
+ void unFilterScanline(unsigned char *recon,
+ const unsigned char *scanline,
+ const unsigned char *precon, size_t bytewidth,
+ unsigned long filterType, size_t length)
+ {
switch (filterType) {
- case 0:
- for (size_t i = 0; i < length; i++) recon[i] = scanline[i];
- break;
- case 1:
- for (size_t i = 0; i < bytewidth; i++)
+ case 0:
+ for (size_t i = 0; i < length; i++) {
+ recon[i] = scanline[i];
+ }
+ break;
+ case 1:
+ for (size_t i = 0; i < bytewidth; i++) {
+ recon[i] = scanline[i];
+ }
+ for (size_t i = bytewidth; i < length; i++) {
+ recon[i] = scanline[i] + recon[i - bytewidth];
+ }
+ break;
+ case 2:
+ if (precon) {
+ for (size_t i = 0; i < length; i++) {
+ recon[i] = scanline[i] + precon[i];
+ }
+ } else {
+ for (size_t i = 0; i < length; i++) {
recon[i] = scanline[i];
- for (size_t i = bytewidth; i < length; i++)
- recon[i] = scanline[i] + recon[i - bytewidth];
- break;
- case 2:
- if (precon)
- for (size_t i = 0; i < length; i++)
- recon[i] = scanline[i] + precon[i];
- else
- for (size_t i = 0; i < length; i++)
- recon[i] = scanline[i];
- break;
- case 3:
- if (precon) {
- for (size_t i = 0; i < bytewidth; i++)
- recon[i] = scanline[i] + precon[i] / 2;
- for (size_t i = bytewidth; i < length; i++)
- recon[i] = scanline[i] +
- ((recon[i - bytewidth] + precon[i]) / 2);
- } else {
- for (size_t i = 0; i < bytewidth; i++)
- recon[i] = scanline[i];
- for (size_t i = bytewidth; i < length; i++)
- recon[i] = scanline[i] + recon[i - bytewidth] / 2;
- }
- break;
- case 4:
- if (precon) {
- for (size_t i = 0; i < bytewidth; i++)
- recon[i] =
- scanline[i] + paethPredictor(0, precon[i], 0);
- for (size_t i = bytewidth; i < length; i++)
- recon[i] =
- scanline[i] +
- paethPredictor(recon[i - bytewidth], precon[i],
- precon[i - bytewidth]);
- } else {
- for (size_t i = 0; i < bytewidth; i++)
- recon[i] = scanline[i];
- for (size_t i = bytewidth; i < length; i++)
- recon[i] =
- scanline[i] +
- paethPredictor(recon[i - bytewidth], 0, 0);
- }
- break;
- default:
- error = 36;
- return; // error: unexisting filter type given
+ }
+ }
+ break;
+ case 3:
+ if (precon) {
+ for (size_t i = 0; i < bytewidth; i++) {
+ recon[i] = scanline[i] + precon[i] / 2;
+ }
+ for (size_t i = bytewidth; i < length; i++) {
+ recon[i] = scanline[i] +
+ ((recon[i - bytewidth] + precon[i]) / 2);
+ }
+ } else {
+ for (size_t i = 0; i < bytewidth; i++) {
+ recon[i] = scanline[i];
+ }
+ for (size_t i = bytewidth; i < length; i++) {
+ recon[i] = scanline[i] + recon[i - bytewidth] / 2;
+ }
+ }
+ break;
+ case 4:
+ if (precon) {
+ for (size_t i = 0; i < bytewidth; i++) {
+ recon[i] =
+ scanline[i] + paethPredictor(0, precon[i], 0);
+ }
+ for (size_t i = bytewidth; i < length; i++) {
+ recon[i] =
+ scanline[i] + paethPredictor(recon[i - bytewidth],
+ precon[i],
+ precon[i - bytewidth]);
+ }
+ } else {
+ for (size_t i = 0; i < bytewidth; i++) {
+ recon[i] = scanline[i];
+ }
+ for (size_t i = bytewidth; i < length; i++) {
+ recon[i] = scanline[i] +
+ paethPredictor(recon[i - bytewidth], 0, 0);
+ }
+ }
+ break;
+ default:
+ error = 36;
+ return; // error: unexisting filter type given
}
}
- void adam7Pass(unsigned char* out, unsigned char* linen,
- unsigned char* lineo, const unsigned char* in,
+ void adam7Pass(unsigned char *out, unsigned char *linen,
+ unsigned char *lineo, const unsigned char *in,
unsigned long w, size_t passleft, size_t passtop,
size_t spacex, size_t spacey, size_t passw, size_t passh,
- unsigned long bpp) { // filter and reposition the pixels
- // into the output when the image
- // is Adam7 interlaced. This
- // function can only do it after
- // the full image is already
- // decoded. The out buffer must
- // have the correct allocated
- // memory size already.
- if (passw == 0) return;
+ unsigned long bpp)
+ { // filter and reposition the pixels
+ // into the output when the image
+ // is Adam7 interlaced. This
+ // function can only do it after
+ // the full image is already
+ // decoded. The out buffer must
+ // have the correct allocated
+ // memory size already.
+ if (passw == 0) {
+ return;
+ }
size_t bytewidth = (bpp + 7) / 8,
linelength = 1 + ((bpp * passw + 7) / 8);
for (unsigned long y = 0; y < passh; y++) {
unsigned char filterType = in[y * linelength],
- *prevline = (y == 0) ? 0 : lineo;
+ *prevline = (y == 0) ? nullptr : lineo;
unFilterScanline(linen, &in[y * linelength + 1], prevline,
bytewidth, filterType, (w * bpp + 7) / 8);
- if (error) return;
- if (bpp >= 8)
- for (size_t i = 0; i < passw; i++)
+ if (error) {
+ return;
+ }
+ if (bpp >= 8) {
+ for (size_t i = 0; i < passw; i++) {
for (size_t b = 0; b < bytewidth;
- b++) // b = current byte of this pixel
+ b++) { // b = current byte of this pixel
out[bytewidth * w * (passtop + spacey * y) +
bytewidth * (passleft + spacex * i) + b] =
linen[bytewidth * i + b];
- else
+ }
+ }
+ } else {
for (size_t i = 0; i < passw; i++) {
size_t obp = bpp * w * (passtop + spacey * y) +
bpp * (passleft + spacex * i),
bp = i * bpp;
- for (size_t b = 0; b < bpp; b++)
+ for (size_t b = 0; b < bpp; b++) {
setBitOfReversedStream(
obp, out,
readBitFromReversedStream(bp, &linen[0]));
+ }
}
- unsigned char* temp = linen;
+ }
+ unsigned char *temp = linen;
linen = lineo;
- lineo = temp; // swap the two buffer pointers "line old" and
- // "line new"
+ lineo = temp; // swap the two buffer pointers "line old" and
+ // "line new"
}
}
- static unsigned long readBitFromReversedStream(
- size_t& bitp, const unsigned char* bits) {
+ static unsigned long
+ readBitFromReversedStream(size_t &bitp, const unsigned char *bits)
+ {
unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1;
bitp++;
return result;
}
- static unsigned long readBitsFromReversedStream(
- size_t& bitp, const unsigned char* bits, unsigned long nbits) {
+ static unsigned long
+ readBitsFromReversedStream(size_t &bitp, const unsigned char *bits,
+ unsigned long nbits)
+ {
unsigned long result = 0;
- for (size_t i = nbits - 1; i < nbits; i--)
+ for (size_t i = nbits - 1; i < nbits; i--) {
result += ((readBitFromReversedStream(bitp, bits)) << i);
+ }
return result;
}
- void setBitOfReversedStream(size_t& bitp, unsigned char* bits,
- unsigned long bit) {
+ void setBitOfReversedStream(size_t &bitp, unsigned char *bits,
+ unsigned long bit)
+ {
bits[bitp >> 3] |= (bit << (7 - (bitp & 0x7)));
bitp++;
}
- unsigned long read32bitInt(const unsigned char* buffer) {
+ unsigned long read32bitInt(const unsigned char *buffer)
+ {
return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) |
buffer[3];
}
int checkColorValidity(
unsigned long colorType,
- unsigned long bd) // return type is a LodePNG error code
+ unsigned long bd) // return type is a LodePNG error code
{
if ((colorType == 2 || colorType == 4 || colorType == 6)) {
- if (!(bd == 8 || bd == 16))
+ if (!(bd == 8 || bd == 16)) {
return 37;
- else
+ } else {
return 0;
+ }
} else if (colorType == 0) {
- if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16))
+ if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) {
return 37;
- else
+ } else {
return 0;
+ }
} else if (colorType == 3) {
- if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8))
+ if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8)) {
return 37;
- else
+ } else {
return 0;
- } else
- return 31; // unexisting color type
+ }
+ } else {
+ return 31; // unexisting color type
+ }
}
- unsigned long getBpp(const Info& info) {
- if (info.colorType == 2)
+ unsigned long getBpp(const Info &info)
+ {
+ if (info.colorType == 2) {
return (3 * info.bitDepth);
- else if (info.colorType >= 4)
+ } else if (info.colorType >= 4) {
return (info.colorType - 2) * info.bitDepth;
- else
+ } else {
return info.bitDepth;
+ }
}
- int convert(std::vector<unsigned char>& out, const unsigned char* in,
- Info& infoIn, unsigned long w,
- unsigned long h) { // converts from any color type to
- // 32-bit. return value = LodePNG error
- // code
+ int convert(std::vector<unsigned char> &out, const unsigned char *in,
+ Info &infoIn, unsigned long w, unsigned long h)
+ { // converts from any color type to
+ // 32-bit. return value = LodePNG error
+ // code
size_t numpixels = w * h, bp = 0;
out.resize(numpixels * 4);
- unsigned char* out_ =
+ unsigned char *out_ =
out.empty()
- ? 0
- : &out[0]; // faster if compiled without optimization
- if (infoIn.bitDepth == 8 && infoIn.colorType == 0) // greyscale
+ ? nullptr
+ : &out[0]; // faster if compiled without optimization
+ if (infoIn.bitDepth == 8 && infoIn.colorType == 0) { // greyscale
for (size_t i = 0; i < numpixels; i++) {
out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[i];
out_[4 * i + 3] =
(infoIn.key_defined && in[i] == infoIn.key_r) ? 0 : 255;
}
- else if (infoIn.bitDepth == 8 && infoIn.colorType == 2) // RGB
- // color
+ } else if (infoIn.bitDepth == 8 && infoIn.colorType == 2) { // RGB
+ // color
for (size_t i = 0; i < numpixels; i++) {
- for (size_t c = 0; c < 3; c++)
+ for (size_t c = 0; c < 3; c++) {
out_[4 * i + c] = in[3 * i + c];
+ }
out_[4 * i + 3] = (infoIn.key_defined == 1 &&
in[3 * i + 0] == infoIn.key_r &&
in[3 * i + 1] == infoIn.key_g &&
@@ -896,28 +1001,33 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
? 0
: 255;
}
- else if (infoIn.bitDepth == 8 &&
- infoIn.colorType == 3) // indexed color (palette)
+ } else if (infoIn.bitDepth == 8 &&
+ infoIn.colorType == 3) { // indexed color (palette)
for (size_t i = 0; i < numpixels; i++) {
- if (4U * in[i] >= infoIn.palette.size()) return 46;
- for (size_t c = 0; c < 4; c++)
+ if (4U * in[i] >= infoIn.palette.size()) {
+ return 46;
+ }
+ for (size_t c = 0; c < 4; c++) {
out_[4 * i + c] =
- infoIn.palette[4 * in[i] + c]; // get rgb colors
- // from the palette
+ infoIn.palette[4 * in[i] + c]; // get rgb colors
+ }
+ // from the palette
}
- else if (infoIn.bitDepth == 8 &&
- infoIn.colorType == 4) // greyscale with alpha
+ } else if (infoIn.bitDepth == 8 &&
+ infoIn.colorType == 4) { // greyscale with alpha
for (size_t i = 0; i < numpixels; i++) {
out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
in[2 * i + 0];
out_[4 * i + 3] = in[2 * i + 1];
}
- else if (infoIn.bitDepth == 8 && infoIn.colorType == 6)
- for (size_t i = 0; i < numpixels; i++)
- for (size_t c = 0; c < 4; c++)
- out_[4 * i + c] = in[4 * i + c]; // RGB with alpha
- else if (infoIn.bitDepth == 16 &&
- infoIn.colorType == 0) // greyscale
+ } else if (infoIn.bitDepth == 8 && infoIn.colorType == 6) {
+ for (size_t i = 0; i < numpixels; i++) {
+ for (size_t c = 0; c < 4; c++) {
+ out_[4 * i + c] = in[4 * i + c]; // RGB with alpha
+ }
+ }
+ } else if (infoIn.bitDepth == 16 &&
+ infoIn.colorType == 0) { // greyscale
for (size_t i = 0; i < numpixels; i++) {
out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
in[2 * i];
@@ -926,11 +1036,12 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
? 0
: 255;
}
- else if (infoIn.bitDepth == 16 &&
- infoIn.colorType == 2) // RGB color
+ } else if (infoIn.bitDepth == 16 &&
+ infoIn.colorType == 2) { // RGB color
for (size_t i = 0; i < numpixels; i++) {
- for (size_t c = 0; c < 3; c++)
+ for (size_t c = 0; c < 3; c++) {
out_[4 * i + c] = in[6 * i + 2 * c];
+ }
out_[4 * i + 3] =
(infoIn.key_defined &&
256U * in[6 * i + 0] + in[6 * i + 1] == infoIn.key_r &&
@@ -939,24 +1050,27 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
? 0
: 255;
}
- else if (infoIn.bitDepth == 16 &&
- infoIn.colorType == 4) // greyscale with alpha
+ } else if (infoIn.bitDepth == 16 &&
+ infoIn.colorType == 4) { // greyscale with alpha
for (size_t i = 0; i < numpixels; i++) {
out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
- in[4 * i]; // most significant byte
+ in[4 * i]; // most significant byte
out_[4 * i + 3] = in[4 * i + 2];
}
- else if (infoIn.bitDepth == 16 && infoIn.colorType == 6)
- for (size_t i = 0; i < numpixels; i++)
- for (size_t c = 0; c < 4; c++)
- out_[4 * i + c] = in[8 * i + 2 * c]; // RGB with alpha
- else if (infoIn.bitDepth < 8 && infoIn.colorType == 0) // greyscale
+ } else if (infoIn.bitDepth == 16 && infoIn.colorType == 6) {
+ for (size_t i = 0; i < numpixels; i++) {
+ for (size_t c = 0; c < 4; c++) {
+ out_[4 * i + c] = in[8 * i + 2 * c]; // RGB with alpha
+ }
+ }
+ } else if (infoIn.bitDepth < 8 &&
+ infoIn.colorType == 0) { // greyscale
for (size_t i = 0; i < numpixels; i++) {
unsigned long value =
(readBitsFromReversedStream(bp, in, infoIn.bitDepth) *
255) /
((1 << infoIn.bitDepth) -
- 1); // scale value from 0 to 255
+ 1); // scale value from 0 to 255
out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
(unsigned char)(value);
out_[4 * i + 3] =
@@ -966,21 +1080,26 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
? 0
: 255;
}
- else if (infoIn.bitDepth < 8 && infoIn.colorType == 3) // palette
+ } else if (infoIn.bitDepth < 8 &&
+ infoIn.colorType == 3) { // palette
for (size_t i = 0; i < numpixels; i++) {
unsigned long value =
readBitsFromReversedStream(bp, in, infoIn.bitDepth);
- if (4 * value >= infoIn.palette.size()) return 47;
- for (size_t c = 0; c < 4; c++)
+ if (4 * value >= infoIn.palette.size()) {
+ return 47;
+ }
+ for (size_t c = 0; c < 4; c++) {
out_[4 * i + c] =
- infoIn.palette[4 * value + c]; // get rgb colors
- // from the palette
+ infoIn.palette[4 * value + c]; // get rgb colors
+ }
+ // from the palette
}
+ }
return 0;
}
- unsigned char paethPredictor(
- short a, short b,
- short c) // Paeth predicter, used by PNG filter type 4
+ unsigned char
+ paethPredictor(short a, short b,
+ short c) // Paeth predicter, used by PNG filter type 4
{
short p = a + b - c, pa = p > a ? (p - a) : (a - p),
pb = p > b ? (p - b) : (b - p),
@@ -996,4 +1115,4 @@ int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
return decoder.error;
}
-} // yage
+} // yage
diff --git a/src/rectanglecollider.cpp b/src/rectanglecollider.cpp
index e9f695d7..936ac06a 100644
--- a/src/rectanglecollider.cpp
+++ b/src/rectanglecollider.cpp
@@ -8,22 +8,29 @@
#include "Physics/rectanglecollider.hpp"
-namespace yage {
+namespace yage
+{
-RectangleCollider::RectangleCollider(const glm::vec2& position,
- const glm::vec2& size)
- : Collider(position, size) {}
+RectangleCollider::RectangleCollider(const glm::vec2 &position,
+ const glm::vec2 &size)
+ : Collider(position, size)
+{
+}
-bool RectangleCollider::collides(const Collider& collider) const {
- for (int i = position_.x; i < position_.x + size_.x; ++i)
- for (int j = position_.y; j < position_.y + size_.y; ++j)
+bool RectangleCollider::collides(const Collider &collider) const
+{
+ for (int i = position_.x; i < position_.x + size_.x; ++i) {
+ for (int j = position_.y; j < position_.y + size_.y; ++j) {
return collider.inside(glm::vec2(i, j));
+ }
+ }
return false;
}
-inline bool RectangleCollider::inside(const glm::vec2& point) const {
+inline bool RectangleCollider::inside(const glm::vec2 &point) const
+{
return position_.x < point.x && position_.x + size_.x > point.x &&
position_.y < point.y && position_.y + size_.y > point.y;
}
-} // yage
+} // yage
diff --git a/src/resourcemanager.cpp b/src/resourcemanager.cpp
index 15fb606f..8444161f 100644
--- a/src/resourcemanager.cpp
+++ b/src/resourcemanager.cpp
@@ -8,12 +8,14 @@
#include "resourcemanager.hpp"
-namespace yage {
+namespace yage
+{
TextureCache ResourceManager::texture_cache_;
-Texture ResourceManager::getTexture(const std::string& texture_path) {
+Texture ResourceManager::getTexture(const std::string &texture_path)
+{
return texture_cache_.getTexture(texture_path);
}
-} // yage
+} // yage
diff --git a/src/rigidbody.cpp b/src/rigidbody.cpp
index f19d63ac..deb8aee9 100644
--- a/src/rigidbody.cpp
+++ b/src/rigidbody.cpp
@@ -8,10 +8,13 @@
#include "Physics/rigidbody.hpp"
-namespace yage {
+namespace yage
+{
-RigidBody::RigidBody(const Vector2d& position, double mass,
- const Vector2d& velocity, bool gravity)
- : ParticleBody(position, mass, velocity, gravity) {}
+RigidBody::RigidBody(const Vector2d &position, double mass,
+ const Vector2d &velocity, bool gravity)
+ : ParticleBody(position, mass, velocity, gravity)
+{
+}
-} // yage
+} // yage
diff --git a/src/sprite.cpp b/src/sprite.cpp
index e3d74982..92dd584c 100644
--- a/src/sprite.cpp
+++ b/src/sprite.cpp
@@ -12,23 +12,30 @@
#include <cstddef>
-namespace yage {
+namespace yage
+{
-Sprite::Sprite() {}
+Sprite::Sprite() = default;
-Sprite::~Sprite() {
- if (vbo_id_ != 0) glDeleteBuffers(1, &vbo_id_);
+Sprite::~Sprite()
+{
+ if (vbo_id_ != 0) {
+ glDeleteBuffers(1, &vbo_id_);
+ }
}
void Sprite::init(float x, float y, float width, float height,
- const std::string& texture_path) {
+ const std::string &texture_path)
+{
x_ = x;
y_ = y;
width_ = width;
height_ = height;
texture_ = ResourceManager::getTexture(texture_path);
- if (vbo_id_ == 0) glGenBuffers(1, &vbo_id_);
+ if (vbo_id_ == 0) {
+ glGenBuffers(1, &vbo_id_);
+ }
Vertex vertex_data[6];
@@ -50,7 +57,9 @@ void Sprite::init(float x, float y, float width, float height,
vertex_data[5].setPosition(x + width, y);
vertex_data[5].setUv(1.f, 0.f);
- for (int i = 0; i < 6; ++i) vertex_data[i].setColor(255, 0, 255, 255);
+ for (auto &i : vertex_data) {
+ i.setColor(255, 0, 255, 255);
+ }
vertex_data[1].setColor(0, 255, 255, 255);
vertex_data[4].setColor(255, 0, 0, 255);
@@ -61,7 +70,8 @@ void Sprite::init(float x, float y, float width, float height,
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
-void Sprite::draw() {
+void Sprite::draw()
+{
glBindTexture(GL_TEXTURE_2D, texture_.id);
glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
@@ -70,11 +80,11 @@ void Sprite::draw() {
glEnableVertexAttribArray(2);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
- (void*)offsetof(Vertex, position));
+ (void *)offsetof(Vertex, position));
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
- (void*)offsetof(Vertex, color));
+ (void *)offsetof(Vertex, color));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
- (void*)offsetof(Vertex, uv));
+ (void *)offsetof(Vertex, uv));
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(2);
@@ -84,4 +94,4 @@ void Sprite::draw() {
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
-} // yage
+} // yage
diff --git a/src/spritebatch.cpp b/src/spritebatch.cpp
index 8e64aa5e..efca0b8d 100644
--- a/src/spritebatch.cpp
+++ b/src/spritebatch.cpp
@@ -11,47 +11,57 @@
#include <algorithm>
#include <stdexcept>
-namespace yage {
+namespace yage
+{
const int SpriteBatch::NUM_VERTICES;
-Glyph::Glyph(GLuint texture, float depth, const Vertex& top_left,
- const Vertex& top_right, const Vertex& bottom_right,
- const Vertex& bottom_left)
- : texture_(texture),
- depth_(depth),
- top_left_(top_left),
- top_right_(top_right),
- bottom_right_(bottom_right),
- bottom_left_(bottom_left) {}
+Glyph::Glyph(GLuint texture, float depth, const Vertex &top_left,
+ const Vertex &top_right, const Vertex &bottom_right,
+ const Vertex &bottom_left)
+ : texture_(texture), depth_(depth), top_left_(top_left),
+ top_right_(top_right), bottom_right_(bottom_right),
+ bottom_left_(bottom_left)
+{
+}
RenderBatch::RenderBatch(GLint offset, GLsizei num_vertices, GLuint texture)
- : num_vertices_(num_vertices), offset_(offset), texture_(texture) {}
+ : num_vertices_(num_vertices), offset_(offset), texture_(texture)
+{
+}
-SpriteBatch::SpriteBatch() {}
+SpriteBatch::SpriteBatch() = default;
-SpriteBatch::~SpriteBatch() {
- if (vao_ != 0) glDeleteVertexArrays(1, &vao_);
+SpriteBatch::~SpriteBatch()
+{
+ if (vao_ != 0) {
+ glDeleteVertexArrays(1, &vao_);
+ }
- if (vbo_ != 0) glDeleteVertexArrays(1, &vbo_);
+ if (vbo_ != 0) {
+ glDeleteVertexArrays(1, &vbo_);
+ }
}
void SpriteBatch::init() { createVertexArray(); }
-void SpriteBatch::begin() {
+void SpriteBatch::begin()
+{
glyphs_.clear();
glyph_ptrs_.clear();
render_batches_.clear();
}
-void SpriteBatch::end() {
+void SpriteBatch::end()
+{
sortGlyphs();
createRenderBatches();
}
-void SpriteBatch::draw(const glm::vec4& destination_rect,
- const glm::vec4& uv_rect, GLuint texture,
- const Color& color, float depth) {
+void SpriteBatch::draw(const glm::vec4 &destination_rect,
+ const glm::vec4 &uv_rect, GLuint texture,
+ const Color &color, float depth)
+{
Vertex top_left, top_right, bottom_right, bottom_left;
top_left.color = color;
@@ -79,26 +89,32 @@ void SpriteBatch::draw(const glm::vec4& destination_rect,
glyph_ptrs_.push_back(&glyphs_.back());
}
-void SpriteBatch::render() {
+void SpriteBatch::render()
+{
glBindVertexArray(vao_);
- for (auto&& batch : render_batches_) {
+ for (auto &&batch : render_batches_) {
glBindTexture(GL_TEXTURE_2D, batch.texture());
glDrawArrays(GL_TRIANGLES, batch.offset(), batch.num_vertices());
}
glBindVertexArray(0);
}
-void SpriteBatch::createVertexArray() {
+void SpriteBatch::createVertexArray()
+{
if (vao_ == 0) {
glGenVertexArrays(1, &vao_);
- if (vao_ == 0) throw std::runtime_error("glGenVertexArrays failed");
+ if (vao_ == 0) {
+ throw std::runtime_error("glGenVertexArrays failed");
+ }
}
// bind vertex array object
glBindVertexArray(vao_);
if (vbo_ == 0) {
glGenBuffers(1, &vbo_);
- if (vbo_ == 0) throw std::runtime_error("glGenBuffers failed");
+ if (vbo_ == 0) {
+ throw std::runtime_error("glGenBuffers failed");
+ }
}
// bind vertex buffer object
glBindBuffer(GL_ARRAY_BUFFER, vbo_);
@@ -110,30 +126,34 @@ void SpriteBatch::createVertexArray() {
// set the vertex attribute pointers
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
- (void*)offsetof(Vertex, position));
+ (void *)offsetof(Vertex, position));
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
- (void*)offsetof(Vertex, color));
+ (void *)offsetof(Vertex, color));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
- (void*)offsetof(Vertex, uv));
+ (void *)offsetof(Vertex, uv));
glDrawArrays(GL_TRIANGLES, 0, 6);
// unbind vertex array object
glBindVertexArray(0);
}
-void SpriteBatch::createRenderBatches() {
+void SpriteBatch::createRenderBatches()
+{
std::vector<Vertex> vertices;
- if (glyph_ptrs_.empty()) return;
+ if (glyph_ptrs_.empty()) {
+ return;
+ }
render_batches_.reserve(glyph_ptrs_.size() * NUM_VERTICES);
for (int i = 0; i < (int)glyph_ptrs_.size(); ++i) {
if (i == 0 || (i > 0 && (glyph_ptrs_[i]->texture() !=
- glyph_ptrs_[i - 1]->texture())))
+ glyph_ptrs_[i - 1]->texture()))) {
render_batches_.emplace_back(i * NUM_VERTICES, NUM_VERTICES,
glyph_ptrs_[i]->texture());
- else
+ } else {
render_batches_.back().num_vertices_ += NUM_VERTICES;
+ }
vertices.push_back(glyph_ptrs_[i]->bottom_left());
vertices.push_back(glyph_ptrs_[i]->top_left());
@@ -155,14 +175,16 @@ void SpriteBatch::createRenderBatches() {
}
}
-void SpriteBatch::sortGlyphs() {
+void SpriteBatch::sortGlyphs()
+{
// sort using introsort or quicksort
std::sort(glyph_ptrs_.begin(), glyph_ptrs_.end(),
- [](Glyph* a, Glyph* b) -> bool {
- if (a->depth() == b->depth())
+ [](Glyph *a, Glyph *b) -> bool {
+ if (a->depth() == b->depth()) {
return a->texture() < b->texture();
+ }
return a->depth() < b->depth();
});
}
-} // yage
+} // yage
diff --git a/src/texturecache.cpp b/src/texturecache.cpp
index 6d10b209..5ce89dc1 100644
--- a/src/texturecache.cpp
+++ b/src/texturecache.cpp
@@ -6,27 +6,25 @@
* ----------------------------------------------------------------------------
*/
-#include "imageloader.hpp"
#include "texturecache.hpp"
+#include "imageloader.hpp"
namespace yage
{
-TextureCache::TextureCache()
-{}
+TextureCache::TextureCache() = default;
Texture TextureCache::getTexture(const std::string &texture_path)
{
- auto itr = texture_map_.find(texture_path);
+ auto itr = texture_map_.find(texture_path);
- if(itr == texture_map_.end())
- {
- Texture new_texture = ImageLoader::loadPng(texture_path);
- texture_map_.insert(make_pair(texture_path, new_texture));
- return new_texture;
- }
+ if (itr == texture_map_.end()) {
+ Texture new_texture = ImageLoader::loadPng(texture_path);
+ texture_map_.insert(make_pair(texture_path, new_texture));
+ return new_texture;
+ }
- return itr->second;
+ return itr->second;
}
-
+
} // yage
diff --git a/src/window.cpp b/src/window.cpp
index 7a00b0c9..14671bf9 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -13,23 +13,31 @@
#include <iostream>
#include <stdexcept>
-namespace yage {
+namespace yage
+{
-Window::Window() {}
+Window::Window() = default;
Window::~Window() { SDL_DestroyWindow(window_); }
-void Window::create(const std::string& window_name, int width, int height,
- unsigned flags) {
+void Window::create(const std::string &window_name, int width, int height,
+ unsigned flags)
+{
Uint32 gl_window_states = 0;
// set the correct input flags
- if (flags & WindowFlags::SHOWN) gl_window_states |= SDL_WINDOW_OPENGL;
- if (flags & WindowFlags::HIDDEN) gl_window_states |= SDL_WINDOW_HIDDEN;
- if (flags & WindowFlags::FULLSCREEN)
+ if (flags & WindowFlags::SHOWN) {
+ gl_window_states |= SDL_WINDOW_OPENGL;
+ }
+ if (flags & WindowFlags::HIDDEN) {
+ gl_window_states |= SDL_WINDOW_HIDDEN;
+ }
+ if (flags & WindowFlags::FULLSCREEN) {
gl_window_states |= SDL_WINDOW_FULLSCREEN;
- if (flags & WindowFlags::BORDERLESS)
+ }
+ if (flags & WindowFlags::BORDERLESS) {
gl_window_states |= SDL_WINDOW_BORDERLESS;
+ }
// SDL_GL options
@@ -41,16 +49,21 @@ void Window::create(const std::string& window_name, int width, int height,
window_ = SDL_CreateWindow(window_name.c_str(), SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, width, height,
gl_window_states);
- if (window_ == nullptr) throw std::runtime_error("SDL_CreateWindow failed");
+ if (window_ == nullptr) {
+ throw std::runtime_error("SDL_CreateWindow failed");
+ }
// initialize the GL context in the window
SDL_GLContext gl_context = SDL_GL_CreateContext(window_);
- if (gl_context == nullptr)
+ if (gl_context == nullptr) {
throw std::runtime_error("SDL_GL_CreateContext failed");
+ }
// initialize glew
GLenum error = glewInit();
- if (error != GLEW_OK) throw std::runtime_error("glewInit failed");
+ if (error != GLEW_OK) {
+ throw std::runtime_error("glewInit failed");
+ }
// print out the current OpenGL version to debug
std::cout << "*** OpenGL version: " << glGetString(GL_VERSION)
@@ -65,16 +78,18 @@ void Window::create(const std::string& window_name, int width, int height,
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
-void Window::swapBuffer() {
+void Window::swapBuffer()
+{
// swap the window buffer
SDL_GL_SwapWindow(window_);
}
-void Window::clearBuffer() {
+void Window::clearBuffer()
+{
// set the clear depth
glClearDepth(1.f);
// clears buffer with clear color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
-} // yage
+} // yage
generated by cgit (git 2.34.1) at 2024-06-26 02:24:42 +0000