fix some bugs, Compressors: methods simplified

src/Camera.cpp

@@ -32,6 +32,7 @@ namespace crown
 {
 
 Camera::Camera(const Vec3& position, bool visible, float fov, float aspect, bool active) :
+	mPosition(position),
 	mLookAt(0, 0, -1),
 	mUp(0, 1, 0),
 	mFOV(fov),

src/core/compressors/Compressor.h

@@ -12,8 +12,8 @@ public:
 						Compressor(Allocator& allocator);
 	virtual 			~Compressor();	
 
-	virtual uint8_t* 	compress(void* data, size_t in_size, size_t& out_size) = 0;
-	virtual uint8_t* 	decompress(const void* data, size_t in_size, size_t& out_size) = 0;
+	virtual uint8_t* 	compress(const void* data, size_t in_size, size_t& out_size) = 0;
+	virtual uint8_t* 	uncompress(const void* data, size_t in_size, size_t& out_size) = 0;
 
 protected:
 	
@@ -31,5 +31,4 @@ inline Compressor::~Compressor()
 	
 }
 
-
 }

src/core/compressors/ZipCompressor.cpp

@@ -19,147 +19,30 @@ ZipCompressor::~ZipCompressor()
 
 }
 
-uint8_t* ZipCompressor::compress(void* data, size_t in_size, size_t& out_size)
+uint8_t* ZipCompressor::compress(const void* data, size_t in_size, size_t& out_size)
 {
-	assert(data != NULL);
-	assert(in_size > 0);
-
-	m_data_list.clear();
-
-	// memory's chunk max dimension
-	const size_t CHUNK_SIZE = 16384;
-	// incoming buffer
-	uint8_t in[CHUNK_SIZE];
-	// outgoing buffer
-	uint8_t out[CHUNK_SIZE];
-
-	int32_t ret;
-	int32_t flush;
-	unsigned have;
-	z_stream strm;
-
-	strm.zalloc = Z_NULL;
-	strm.zfree = Z_NULL;
-	strm.opaque = Z_NULL;
-	ret = deflateInit(&strm, 6);
-
+	out_size = in_size + in_size * 0.1f + 12;
+	
+ 	uint8_t* dest = (uint8_t*)m_allocator->allocate(out_size);
+	
+	int32_t ret = ::compress(dest, &out_size, (const Bytef*)data, in_size);
+	
 	assert(ret == Z_OK);
-
-	size_t bytes_read = 0;
-
-	do
-	{
-		size_t this_step_bytes = math::min(CHUNK_SIZE, in_size - bytes_read);
-		memcpy(in, (uint8_t*)data, sizeof(uint8_t) * this_step_bytes);
-
-		strm.avail_in = this_step_bytes;
-		strm.next_in = in;
-
-		flush = (in_size - bytes_read) <= CHUNK_SIZE ? Z_FINISH : Z_NO_FLUSH;
-
-		do
-		{
-			strm.avail_out = CHUNK_SIZE;
-			strm.next_out = out;
-
-			ret = deflate(&strm, flush);    /* no bad return value */
-			assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
-
-			have = CHUNK_SIZE - strm.avail_out;
-			if (have > 0)
-			{
-				m_data_list.push(out, have);			
-			}
-		} while (strm.avail_out == 0);
-		assert(strm.avail_in == 0);     /* all input will be used */
-
-		bytes_read += this_step_bytes;
-		/* done when last data in file processed */
-	} while (flush != Z_FINISH);
-	assert(ret == Z_STREAM_END);        /* stream will be complete */
-
-	/* clean up and return */
-	(void)deflateEnd(&strm);
-
-	out_size = strm.total_out;
-
-	return m_data_list.begin(); 
+	
+	return dest;
 }
 
-uint8_t* ZipCompressor::decompress(const void* data, size_t in_size, size_t& out_size)
+uint8_t* ZipCompressor::uncompress(const void* data, size_t in_size, size_t& out_size)
 {
-	m_data_list.clear();
+	out_size = in_size + in_size * 0.1f + 12;
 	
-	const size_t CHUNK_SIZE = 16384;
-	int32_t ret;
-	unsigned have;
-	z_stream strm;
-	uint8_t in[CHUNK_SIZE];
-	uint8_t out[CHUNK_SIZE];
-
-	/* allocate inflate state */
-	strm.zalloc = Z_NULL;
-	strm.zfree = Z_NULL;
-	strm.opaque = Z_NULL;
-	strm.avail_in = 0;
-	strm.next_in = Z_NULL;
-	ret = inflateInit(&strm);
+ 	uint8_t* dest = (uint8_t*)m_allocator->allocate(out_size);
+	
+	int32_t ret = ::uncompress(dest, &out_size, (const Bytef*)data, in_size);
 	
 	assert(ret == Z_OK);
-
-	size_t bytes_read = 0;
-
-	/* decompress until deflate stream ends or end of file */
-	do
-	{
-		size_t this_step_bytes = math::min(CHUNK_SIZE, in_size - bytes_read);
-		memcpy(in, (uint8_t*)data, sizeof(uint8_t) * this_step_bytes);
-
-		strm.avail_in = this_step_bytes;
-		strm.next_in = in;
-		if (strm.avail_in == 0)
-		{
-				break;
-		}
-
-		/* run inflate() on input until output buffer not full */
-		do {
-				strm.avail_out = CHUNK_SIZE;
-				strm.next_out = out;
-				ret = inflate(&strm, Z_NO_FLUSH);
-				
-				assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
-				
-				switch (ret) 
-				{
-					case Z_NEED_DICT:
-					{
-							ret = Z_DATA_ERROR;     /* and fall through */
-					}
-					case Z_DATA_ERROR:
-					case Z_MEM_ERROR:
-					{
-							(void)inflateEnd(&strm);
-							return false;
-					}
-				}
-				have = CHUNK_SIZE - strm.avail_out;
-				if (have > 0)
-				{
-					m_data_list.push(out, have);			
-				}
-		} while (strm.avail_out == 0);
-
-		bytes_read += this_step_bytes;
-		/* done when inflate() says it's done */
-	} while (ret != Z_STREAM_END);
-
-	/* clean up and return */
-	(void)inflateEnd(&strm);
 	
-	out_size = strm.total_out;
-
-	return m_data_list.begin();
+	return dest;
 }
 
 }

src/core/compressors/ZipCompressor.h

@@ -8,13 +8,21 @@ namespace crown
 
 class ZipCompressor : Compressor
 {
+public:
+				enum Mode
+				{
+					DEFAULT,
+					LOW,
+					HIGH
+				};
+	
 public:
 
 				ZipCompressor(Allocator& allocator);
 				~ZipCompressor();
-
-	uint8_t*	compress(void* data, size_t in_size, size_t& out_size);
-	uint8_t* 	decompress(const void* data, size_t in_size, size_t& out_size);
+	
+	uint8_t* 	compress(const void* data, size_t in_size, size_t& out_size);
+	uint8_t* 	uncompress(const void* data, size_t in_size, size_t& out_size);
 
 private:
 	

src/core/containers/Queue.h

@@ -212,6 +212,7 @@ inline void Queue<T>::pop_front()
 template <typename T>
 inline void Queue<T>::clear()
 {
+	m_read = 0;
 	m_size = 0;
 }
 

tests/compressors.cpp

@@ -11,13 +11,13 @@ int main(int argc, char** argv)
 	MallocAllocator allocator;
 	ZipCompressor compressor(allocator);
 
-	const char* uncompressed_string = "letstrythismotherfuckercompressionmethodoncrowngameengine.enjoy!";
+	const char* uncompressed_string = "letstry";
 	uint8_t* compressed_string;
 	uint8_t* result;
 	size_t compr_size = 0;
 	size_t result_size = 0;
-
-	compressed_string = compressor.compress((void*)uncompressed_string, strlen(uncompressed_string), compr_size);
+	
+ 	compressed_string = compressor.compress((void*)uncompressed_string, strlen(uncompressed_string), compr_size);
 	
 	printf("Uncompressed: ");
 	printf("Size: %d - ", strlen(uncompressed_string));
@@ -31,8 +31,8 @@ int main(int argc, char** argv)
 		printf("%c", compressed_string[i]);
 	}
 	printf("\n\n");
-	
-	result = compressor.decompress((void*)compressed_string, compr_size, result_size);
+
+	result = compressor.uncompress((void*)compressed_string, compr_size, result_size);
 	
 	printf("Uncompressed again: ");
 	printf("Size: %d - ", result_size);
@@ -42,7 +42,7 @@ int main(int argc, char** argv)
 	}
 	printf("\n\n");
 	
-//  	allocator.deallocate(result); //FIX: invalid pointer -> check header in MallocAllocator
+  	allocator.deallocate(result); //FIX: invalid pointer -> check header in MallocAllocator*/
 	
 	return 0;
 }