Finalization for linux branch.

Author: StarbotArc

CMakeLists.txt

@@ -7,6 +7,8 @@ if (LINUX)
 	set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++)
 
 	set(CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32)
+
+	option(VCPKG "Use vcpkg for dependencies" ON)
 endif()
 
 if(WIN32)

src/Core/ByteStream.cpp

@@ -55,94 +55,26 @@ void WriteStream::write(const void* in, int bytes)
 	}
 }
 
-void WriteStream::write8(const void* val)
-{
-	if(current_size_ < capacity_)
-	{
-		buffer_[current_size_] = *(const uint8_t*)val;
-		++current_size_;
-	}
-	else if(!is_external_buffer_)
-	{
-		capacity_ <<= 1;
-		buffer_ = (uchar*)realloc(buffer_, capacity_);
-		buffer_[current_size_] = *(const uint8_t*)val;
-		++current_size_;
-	}
-	else
-	{
-		is_write_successful_ = false;
-	}
-}
-
-void WriteStream::write16(const void* val)
-{
-	int newSize = current_size_ + sizeof(uint16_t);
-	if(newSize <= capacity_)
-	{
-		*(uint16_t*)(buffer_ + current_size_) = *(const uint16_t*)val;
-		current_size_ = newSize;
-	}
-	else if(!is_external_buffer_)
-	{
-		capacity_ <<= 1;
-		buffer_ = (uchar*)realloc(buffer_, capacity_);
-		*(uint16_t*)(buffer_ + current_size_) = *(const uint16_t*)val;
-		current_size_ = newSize;
-	}
-	else
-	{
-		is_write_successful_ = false;
-	}
-}
-
-void WriteStream::write32(const void* val)
-{
-	int newSize = current_size_ + sizeof(uint32_t);
-	if(newSize <= capacity_)
-	{
-		*(uint32_t*)(buffer_ + current_size_) = *(const uint32_t*)val;
-		current_size_ = newSize;
-	}
-	else if(!is_external_buffer_)
-	{
-		capacity_ <<= 1;
-		buffer_ = (uchar*)realloc(buffer_, capacity_);
-		*(uint32_t*)(buffer_ + current_size_) = *(const uint32_t*)val;
-		current_size_ = newSize;
-	}
-	else
-	{
-		is_write_successful_ = false;
-	}
-}
-
-void WriteStream::write64(const void* val)
-{
-	int newSize = current_size_ + sizeof(uint64_t);
-	if(newSize <= capacity_)
-	{
-		*(uint64_t*)(buffer_ + current_size_) = *(const uint64_t*)val;
-		current_size_ = newSize;
-	}
-	else if(!is_external_buffer_)
-	{
-		capacity_ <<= 1;
-		buffer_ = (uchar*)realloc(buffer_, capacity_);
-		*(uint64_t*)(buffer_ + current_size_) = *(const uint64_t*)val;
-		current_size_ = newSize;
-	}
-	else
-	{
-		is_write_successful_ = false;
-	}
-}
-
 void WriteStream::writeNum(uint num)
 {
 	if(num < 0x80)
 	{
-		write8(&num);
+		if(current_size_ < capacity_)
+		{
+			buffer_[current_size_] = static_cast<uint8_t>(num);
+			++current_size_;
+		}
+		else if(!is_external_buffer_)
+		{
+			capacity_ <<= 1;
+			buffer_ = (uchar*)realloc(buffer_, capacity_);
+			buffer_[current_size_] = static_cast<uint8_t>(num);
+			++current_size_;
+		}
+		else
+		{
+			is_write_successful_ = false;
+		}
 	}
 	else
 	{
@@ -206,70 +138,6 @@ void ReadStream::read(void* out, int bytes)
 	}
 }
 
-void ReadStream::read8(void* out)
-{
-	if(read_position_ != end_position_)
-	{
-		*(uint8_t*)out = *read_position_;
-		++read_position_;
-	}
-	else
-	{
-		*(uint8_t*)out = 0;
-		read_position_ = end_position_;
-		is_read_successful_ = false;
-	}
-}
-
-void ReadStream::read16(void* out)
-{
-	auto newPos = read_position_ + sizeof(uint16_t);
-	if(newPos <= end_position_)
-	{
-		*(uint16_t*)out = *(const uint16_t*)read_position_;
-		read_position_ = newPos;
-	}
-	else
-	{
-		*(uint16_t*)out = 0;
-		read_position_ = end_position_;
-		is_read_successful_ = false;
-	}
-}
-
-
-void ReadStream::read32(void* out)
-{
-	auto newPos = read_position_ + sizeof(uint32_t);
-	if(newPos <= end_position_)
-	{
-		*(uint32_t*)out = *(const uint32_t*)read_position_;
-		read_position_ = newPos;
-	}
-	else
-	{
-		*(uint32_t*)out = 0;
-		read_position_ = end_position_;
-		is_read_successful_ = false;
-	}
-}
-
-void ReadStream::read64(void* out)
-{
-	auto newPos = read_position_ + sizeof(uint64_t);
-	if(newPos <= end_position_)
-	{
-		*(uint64_t*)out = *(const uint64_t*)read_position_;
-		read_position_ = newPos;
-	}
-	else
-	{
-		*(uint64_t*)out = 0;
-		read_position_ = end_position_;
-		is_read_successful_ = false;
-	}
-}
-
 uint ReadStream::readNum()
 {
 	uint32_t out;

src/Core/ByteStream.h

@@ -14,48 +14,13 @@ struct WriteStream
 
 	void write(const void* in, int bytes);
 
-	void write8(const void* val);
-	void write16(const void* val);
-	void write32(const void* val);
-	void write64(const void* val);
-
 	void writeNum(uint num);
 	void writeStr(StringRef str);
 
-	template <unsigned int S>
-	inline void writeSz(const void* val)
-	{
-		write(val, S);
-	}
-
-	template <>
-	inline void writeSz<1>(const void* val)
-	{
-		write8(val);
-	}
-
-	template <>
-	inline void writeSz<2>(const void* val)
-	{
-		write16(val);
-	}
-
-	template <>
-	inline void writeSz<4>(const void* val)
-	{
-		write32(val);
-	}
-
-	template <>
-	inline void writeSz<8>(const void* val)
-	{
-		write64(val);
-	}
-
 	template <typename T>
 	inline void write(const T& val)
 	{
-		writeSz<sizeof(T)>(&val);
+		write(&val, sizeof(T));
 	}
 
 	// Returns true if all write operations have succeeded.
@@ -83,58 +48,23 @@ struct ReadStream
 
 	void read(void* out, int bytes);
 
-	void read8(void* out);
-	void read16(void* out);
-	void read32(void* out);
-	void read64(void* out);
-
 	uint readNum();
 	String readStr();
 
 	void readNum(uint& num);
 	void readStr(String& str);
 
-	template <size_t S>
-	inline void readSz(void* out)
-	{
-		read(out, S);
-	}
-
-	template <>
-	inline void readSz<1>(void* out)
-	{
-		read8(out);
-	}
-
-	template <>
-	inline void readSz<2>(void* out)
-	{
-		read16(out);
-	}
-
-	template <>
-	inline void readSz<4>(void* out)
-	{
-		read32(out);
-	}
-
-	template <>
-	inline void readSz<8>(void* out)
-	{
-		read64(out);
-	}
-
 	template <typename T>
 	inline void read(T& out)
 	{
-		readSz<sizeof(T)>(&out);
+		read(&out, sizeof(T));
 	}
 
 	template <typename T>
 	inline T read()
 	{
 		T out = T();
-		readSz<sizeof(T)>(&out);
+		read(&out, sizeof(T));
 		return out;
 	}
 

src/Core/Canvas.cpp

@@ -156,7 +156,7 @@ struct GetPolyDist : public DistanceFunc
 
 struct Canvas::Data
 {
-	Canvas::Data();
+	Data();
 	void draw(float* buf, int w, int h, const areaf& area, DistanceFunc* func);
 
 	areai mask;

src/Core/FontData.cpp

@@ -9,6 +9,9 @@
 
 #include <System/OpenGL.h>
 
+#include <algorithm>
+#include <vector>
+
 namespace Vortex {
 
 static const int PADDING = 1;
@@ -59,7 +62,7 @@ static GlyphCache* CreateCache(FT_Face face, int size)
 {
 	int texW = 128, texH = 128;
 	while(texW < 1024 && texW < size * 8 + 64) texW *= 2;
-	std::vector<uchar> pixels(texW * texH, 0);
+	std::vector<uchar> pixels(texW * texH);
 
 	auto* cache = new GlyphCache;
 	cache->tex = TextureManager::load(texW, texH, FORMAT, false, pixels.data());
@@ -217,7 +220,7 @@ static Glyph* PutGlyphInCache(GlyphCache* cache, FT_GlyphSlot slot)
 		// Copy the glyph pixels to the cache texture.
 		uchar* pixels = CopyGlyphBitmap(bitmapW, bitmapH, bitmap);
 		cache->tex->modify(glyph->box.x, glyph->box.y, bitmapW, bitmapH, pixels);
-		cache->shelfH = max(cache->shelfH, bitmapH);
+		cache->shelfH = std::max(cache->shelfH, bitmapH);
 		free(pixels);
 
 		// Set the glyph uvs.

src/Core/Polyfit.h

@@ -5,6 +5,8 @@
 
 #include <math.h>
 
+#include <algorithm>
+
 namespace mathalgo {
 
 template <typename T>
@@ -307,4 +309,4 @@ void polyfit(int degree, T* outCoefs, const T* inValues, int numNonZeroValues, i
 	}
 }
 
-}; // namespace mathalgo
+}; // namespace mathalgo

src/Core/Renderer.cpp

@@ -9,6 +9,8 @@
 #include <System/Debug.h>
 #include <System/OpenGL.h>
 
+#include <algorithm>
+
 namespace Vortex {
 
 static const int BATCH_QUAD_LIMIT = 256;
@@ -206,7 +208,7 @@ void Renderer::pushScissorRect(const recti& r)
 void Renderer::pushScissorRect(int x, int y, int w, int h)
 {
 	auto& stack = RI->scissorStack;
-	w = max(w, 0), h = max(h, 0);
+	w = std::max(w, 0), h = std::max(h, 0);
 	if(stack.empty())
 	{
 		// The new scissor region is the first scissor region, use it as-is.
@@ -217,10 +219,10 @@ void Renderer::pushScissorRect(int x, int y, int w, int h)
 	{
 		// Calculate the intersection of the current and new scissor region.
 		recti last = stack.back();
-		int r = min(last.x + last.w, x + w);
-		int b = min(last.y + last.h, y + h);
-		x = max(last.x, x), w = max(0, r - x);
-		y = max(last.y, y), h = max(0, b - y);
+		int r = std::min(last.x + last.w, x + w);
+		int b = std::min(last.y + last.h, y + h);
+		x = std::max(last.x, x), w = std::max(0, r - x);
+		y = std::max(last.y, y), h = std::max(0, b - y);
 		stack.push_back({x, y, w, h});
 	}
 

src/Core/TextureImpl.cpp

@@ -13,8 +13,8 @@
 #include <map>
 
 #define WIN32_LEAN_AND_MEAN
-#include "windows.h"
-#include "gl/gl.h"
+#include <windows.h>
+#include <GL/gl.h>
 
 namespace Vortex {
 namespace {