Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-04 04:24:47 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Incorporating comments for code review (minecraft import)

Browse source
This commit is contained in:
atlante45 2013-07-09 17:55:55 +02:00
parent 3433cf5a98
commit dbdbd7a8c4
5 changed files with 402 additions and 381 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
interface/src/Application.cpp
View file

@ -1363,8 +1363,10 @@ void Application::exportVoxels() {
void Application::importVoxels() { void Application::importVoxels() {
QString desktopLocation = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation); QString desktopLocation = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
QString fileNameString = QFileDialog::getOpenFileName(_glWidget, tr("Import Voxels"), desktopLocation, QString fileNameString = QFileDialog::getOpenFileName(
tr("Sparse Voxel Octree Files, Square PNG, Schematic Files (*.svo *.png *.schematic)")); _glWidget, tr("Import Voxels"), desktopLocation,
tr("Sparse Voxel Octree Files, Square PNG, Schematic Files (*.svo *.png *.schematic)"));
QByteArray fileNameAscii = fileNameString.toAscii(); QByteArray fileNameAscii = fileNameString.toAscii();
const char* fileName = fileNameAscii.data(); const char* fileName = fileNameAscii.data();

211
libraries/voxels/src/Tags.cpp
View file

@ -1,3 +1,11 @@
//
// Tags.h
// hifi
//
// Created by Clement Brisset on 7/3/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "Tags.h" #include "Tags.h"
#include <Log.h> #include <Log.h>
@ -8,10 +16,9 @@
Tag::Tag(int tagId, std::stringstream &ss) : _tagId(tagId) { Tag::Tag(int tagId, std::stringstream &ss) : _tagId(tagId) {
int size = ss.get() << 8 | ss.get(); int size = ss.get() << 8 | ss.get();
_name.clear(); _name.clear();
for (int i = 0; i < size; ++i) { for (int i = 0; i < size; ++i) { _name += ss.get();
_name += ss.get();
} }
} }
@ -46,22 +53,22 @@ Tag* Tag::readTag(int tagId, std::stringstream &ss) {
} }
TagByte::TagByte(std::stringstream &ss) : Tag(TAG_Byte, ss) { TagByte::TagByte(std::stringstream &ss) : Tag(TAG_Byte, ss) {
_data = ss.get(); _data = ss.get();
} }
TagShort::TagShort(std::stringstream &ss) : Tag(TAG_Short, ss) { TagShort::TagShort(std::stringstream &ss) : Tag(TAG_Short, ss) {
_data = ss.get() << 8 | ss.get(); _data = ss.get() << 8 | ss.get();
} }
TagInt::TagInt(std::stringstream &ss) : Tag(TAG_Int, ss) { TagInt::TagInt(std::stringstream &ss) : Tag(TAG_Int, ss) {
_data = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get(); _data = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
} }
TagLong::TagLong(std::stringstream &ss) : Tag(TAG_Long, ss) { TagLong::TagLong(std::stringstream &ss) : Tag(TAG_Long, ss) {
_data = (((int64_t) ss.get()) << 56 | ((int64_t) ss.get()) << 48 _data = (((int64_t) ss.get()) << 56 | ((int64_t) ss.get()) << 48
|((int64_t) ss.get()) << 40 | ((int64_t) ss.get()) << 32 |((int64_t) ss.get()) << 40 | ((int64_t) ss.get()) << 32
| ss.get() << 24 | ss.get() << 16 | ss.get() << 24 | ss.get() << 16
| ss.get() << 8 | ss.get()); | ss.get() << 8 | ss.get());
} }
// We don't need Float and double, so we just ignore the bytes // We don't need Float and double, so we just ignore the bytes
@ -74,31 +81,32 @@ TagDouble::TagDouble(std::stringstream &ss) : Tag(TAG_Double, ss) {
} }
TagByteArray::TagByteArray(std::stringstream &ss) : Tag(TAG_Byte_Array, ss) { TagByteArray::TagByteArray(std::stringstream &ss) : Tag(TAG_Byte_Array, ss) {
_size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get(); _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
_data = new char[_size]; _data = new char[_size];
for (int i = 0; i < _size; ++i) { for (int i = 0; i < _size; ++i) {
_data[i] = ss.get(); _data[i] = ss.get();
} }
} }
TagString::TagString(std::stringstream &ss) : Tag(TAG_String, ss) { TagString::TagString(std::stringstream &ss) : Tag(TAG_String, ss) {
_size = ss.get() << 8 | ss.get(); _size = ss.get() << 8 | ss.get();
for (int i = 0; i < _size; ++i) { for (int i = 0; i < _size; ++i) {
_data += ss.get(); _data += ss.get();
} }
} }
TagList::TagList(std::stringstream &ss) : TagList::TagList(std::stringstream &ss) :
Tag(TAG_List, ss) { Tag(TAG_List, ss) {
_tagId = ss.get(); _tagId = ss.get();
_size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get(); _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
for (int i = 0; i < _size; ++i) { for (int i = 0; i < _size; ++i) {
ss.putback(0); ss.putback(0); ss.putback(0);
_data.push_back(readTag(_tagId, ss)); ss.putback(0);
} _data.push_back(readTag(_tagId, ss));
}
} }
TagCompound::TagCompound(std::stringstream &ss) : TagCompound::TagCompound(std::stringstream &ss) :
@ -139,96 +147,99 @@ TagCompound::TagCompound(std::stringstream &ss) :
} }
TagIntArray::TagIntArray(std::stringstream &ss) : Tag(TAG_Int_Array, ss) { TagIntArray::TagIntArray(std::stringstream &ss) : Tag(TAG_Int_Array, ss) {
_size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get(); _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
_data = new int[_size]; _data = new int[_size];
for (int i = 0; i < _size; ++i) { for (int i = 0; i < _size; ++i) {
_data[i] = ss.get(); _data[i] = ss.get();
} }
} }
int retrieveData(std::string filename, std::stringstream &ss) { int retrieveData(std::string filename, std::stringstream &ss) {
std::ifstream file(filename.c_str(), std::ios::binary); std::ifstream file(filename.c_str(), std::ios::binary);
int type = file.peek(); int type = file.peek();
if (0x0A == type) { if (type == 0x0A) {
ss.flush(); ss.flush();
ss << file; ss << file;
return 0; return 0;
} }
if (0x1F == type) { if (type == 0x1F) {
return ungzip(file, ss); return ungzip(file, ss);
} }
return 1; return 1;
} }
int ungzip(std::ifstream &file, std::stringstream &ss) { int ungzip(std::ifstream &file, std::stringstream &ss) {
std::string gzipedBytes; std::string gzipedBytes;
gzipedBytes.clear(); gzipedBytes.clear();
ss.flush(); ss.flush();
while (!file.eof()) { while (!file.eof()) {
gzipedBytes += (char) file.get(); gzipedBytes += (char) file.get();
} }
file.close(); file.close();
if ( gzipedBytes.size() == 0 ) { if (gzipedBytes.size() == 0) {
ss << gzipedBytes; ss << gzipedBytes;
return 0; return 0;
}
unsigned int full_length = gzipedBytes.size();
unsigned int half_length = gzipedBytes.size()/2;
unsigned int uncompLength = full_length;
char* uncomp = (char*) calloc(sizeof(char), uncompLength);
z_stream strm;
strm.next_in = (Bytef *) gzipedBytes.c_str();
strm.avail_in = full_length;
strm.total_out = 0;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
bool done = false;
if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK) {
free(uncomp);
return 1;
}
while (!done) {
// If our output buffer is too small
if (strm.total_out >= uncompLength) {
// Increase size of output buffer
char* uncomp2 = (char*) calloc(sizeof(char), uncompLength + half_length);
memcpy(uncomp2, uncomp, uncompLength);
uncompLength += half_length;
free(uncomp);
uncomp = uncomp2;
} }
strm.next_out = (Bytef *) (uncomp + strm.total_out); unsigned int full_length = gzipedBytes.size();
strm.avail_out = uncompLength - strm.total_out; unsigned int half_length = gzipedBytes.size()/2;
unsigned int uncompLength = full_length;
// Inflate another chunk. char* uncomp = (char*) calloc(sizeof(char), uncompLength);
int err = inflate (&strm, Z_SYNC_FLUSH);
if (err == Z_STREAM_END) done = true;
else if (err != Z_OK) break;
}
if (inflateEnd (&strm) != Z_OK) { z_stream strm;
strm.next_in = (Bytef *) gzipedBytes.c_str();
strm.avail_in = full_length;
strm.total_out = 0;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
bool done = false;
if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK) {
free(uncomp);
return 1;
}
while (!done) {
// If our output buffer is too small
if (strm.total_out >= uncompLength) {
// Increase size of output buffer
char* uncomp2 = (char*) calloc(sizeof(char), uncompLength + half_length);
memcpy(uncomp2, uncomp, uncompLength);
uncompLength += half_length;
free(uncomp);
uncomp = uncomp2;
}
strm.next_out = (Bytef *) (uncomp + strm.total_out);
strm.avail_out = uncompLength - strm.total_out;
// Inflate another chunk.
int err = inflate (&strm, Z_SYNC_FLUSH);
if (err == Z_STREAM_END) {
done = true;
} else if (err != Z_OK) {
break;
}
}
if (inflateEnd (&strm) != Z_OK) {
free(uncomp);
return 1;
}
for (size_t i = 0; i < strm.total_out; ++i) {
ss << uncomp[i];
}
free(uncomp); free(uncomp);
return 1;
}
for (size_t i = 0; i < strm.total_out; ++i) { return 0;
ss << uncomp[i];
}
free(uncomp);
return 0;
} }

213
libraries/voxels/src/Tags.h
View file

@ -1,3 +1,14 @@
//
// Tags.h
// hifi
//
// Created by Clement Brisset on 7/3/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __hifi__Tags__
#define __hifi__Tags__
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
@ -22,141 +33,143 @@ int retrieveData(std::string filename, std::stringstream &ss);
int ungzip(std::ifstream &file, std::stringstream &ss); int ungzip(std::ifstream &file, std::stringstream &ss);
class Tag { class Tag {
protected: public:
int _tagId; Tag(int tagId, std::stringstream &ss);
std::string _name;
int getTagId() const {return _tagId;}
public: std::string getName () const {return _name; }
Tag(int tagId, std::stringstream &ss);
static Tag* readTag(int tagId, std::stringstream &ss);
int getTagId() const {return _tagId;}
std::string getName () const {return _name; } protected:
int _tagId;
static Tag* readTag(int tagId, std::stringstream &ss); std::string _name;
}; };
class TagByte : public Tag { class TagByte : public Tag {
private: public:
int8_t _data; TagByte(std::stringstream &ss);
public: int8_t getData() const {return _data;}
TagByte(std::stringstream &ss);
private:
int8_t getData() const {return _data;} int8_t _data;
}; };
class TagShort : public Tag { class TagShort : public Tag {
private: public:
int16_t _data; TagShort(std::stringstream &ss);
public: int16_t getData() const {return _data;}
TagShort(std::stringstream &ss);
private:
int16_t getData() const {return _data;} int16_t _data;
}; };
class TagInt : public Tag { class TagInt : public Tag {
private: public:
int32_t _data; TagInt(std::stringstream &ss);
public: int32_t getData() const {return _data;}
TagInt(std::stringstream &ss);
private:
int32_t getData() const {return _data;} int32_t _data;
}; };
class TagLong : public Tag { class TagLong : public Tag {
private: public:
int64_t _data; TagLong(std::stringstream &ss);
public: int64_t getData() const {return _data;}
TagLong(std::stringstream &ss);
private:
int64_t getData() const {return _data;} int64_t _data;
}; };
class TagFloat : public Tag { class TagFloat : public Tag {
public: public:
TagFloat(std::stringstream &ss); TagFloat(std::stringstream &ss);
}; };
class TagDouble : public Tag { class TagDouble : public Tag {
public: public:
TagDouble(std::stringstream &ss); TagDouble(std::stringstream &ss);
}; };
class TagByteArray : public Tag { class TagByteArray : public Tag {
private: public:
int _size; TagByteArray(std::stringstream &ss);
char* _data;
int getSize() const {return _size;}
public: char* getData() const {return _data;}
TagByteArray(std::stringstream &ss);
private:
int getSize() const {return _size;} int _size;
char* getData() const {return _data;} char* _data;
}; };
class TagString : public Tag { class TagString : public Tag {
private: public:
int _size; TagString(std::stringstream &ss);
std::string _data;
public: int getSize() const {return _size;}
TagString(std::stringstream &ss); std::string getData() const {return _data;}
int getSize() const {return _size;} private:
std::string getData() const {return _data;} int _size;
std::string _data;
}; };
class TagList : public Tag { class TagList : public Tag {
private: public:
int _tagId; TagList(std::stringstream &ss);
int _size;
std::list<Tag*> _data; int getTagId() const {return _tagId;}
int getSize () const {return _size; }
public: std::list<Tag*> getData () const {return _data; }
TagList(std::stringstream &ss);
private:
int getTagId() const {return _tagId;} int _tagId;
int getSize () const {return _size; } int _size;
std::list<Tag*> getData () const {return _data; } std::list<Tag*> _data;
}; };
class TagCompound : public Tag { class TagCompound : public Tag {
private: public:
int _size; TagCompound(std::stringstream &ss);
std::list<Tag*> _data;
// Specific to schematics file
int _width;
int _length;
int _height;
char* _blocksData;
char* _blocksId;
public: int getSize () const {return _size; }
TagCompound(std::stringstream &ss); std::list<Tag*> getData () const {return _data; }
int getSize () const {return _size; }
std::list<Tag*> getData () const {return _data; }
int getWidth () const {return _width; } int getWidth () const {return _width; }
int getLength () const {return _length; } int getLength () const {return _length; }
int getHeight () const {return _height; } int getHeight () const {return _height; }
char* getBlocksId () const {return _blocksId; } char* getBlocksId () const {return _blocksId; }
char* getBlocksData() const {return _blocksData;} char* getBlocksData() const {return _blocksData;}
private:
int _size;
std::list<Tag*> _data;
// Specific to schematics file
int _width;
int _length;
int _height;
char* _blocksData;
char* _blocksId;
}; };
class TagIntArray : public Tag { class TagIntArray : public Tag {
private: public:
int _size; TagIntArray(std::stringstream &ss);
int* _data; ~TagIntArray() {delete _data;}
public: int getSize() const {return _size;}
TagIntArray(std::stringstream &ss); int* getData() const {return _data;}
~TagIntArray() {delete _data;}
private:
int getSize() const {return _size;} int _size;
int* getData() const {return _data;} int* _data;
}; };
#endif /* defined(__hifi__Tags__) */

351
libraries/voxels/src/VoxelTree.cpp
View file

@ -802,7 +802,7 @@ void VoxelTree::createSphere(float radius, float xc, float yc, float zc, float v
if (debug) { if (debug) {
printLog("perlin=%f gradient=%f color=(%d,%d,%d)\n",perlin, gradient, red, green, blue); printLog("perlin=%f gradient=%f color=(%d,%d,%d)\n",perlin, gradient, red, green, blue);
} }
} break; } break;
} }
if (wantNaturalSurface) { if (wantNaturalSurface) {
// for natural surfaces, we will render up to 16 voxel's above the surface of the sphere // for natural surfaces, we will render up to 16 voxel's above the surface of the sphere
@ -1460,7 +1460,7 @@ bool VoxelTree::readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension
bool VoxelTree::readFromSchematicsFile(const char *fileName) { bool VoxelTree::readFromSchematicsFile(const char *fileName) {
std::stringstream ss; std::stringstream ss;
int err = retrieveData(fileName, ss); int err = retrieveData(fileName, ss);
if (err && TAG_Compound != ss.get()) { if (err && ss.get() != TAG_Compound) {
printLog("[ERROR] Invalid schematic file.\n"); printLog("[ERROR] Invalid schematic file.\n");
return false; return false;
} }
@ -1476,7 +1476,7 @@ bool VoxelTree::readFromSchematicsFile(const char *fileName) {
max = (max > schematics.getHeight()) ? max : schematics.getHeight(); max = (max > schematics.getHeight()) ? max : schematics.getHeight();
int scale = 1; int scale = 1;
while (max > scale) scale *= 2; while (max > scale) {scale *= 2;}
float size = 1.0f / scale; float size = 1.0f / scale;
int create = 1; int create = 1;
@ -1491,41 +1491,41 @@ bool VoxelTree::readFromSchematicsFile(const char *fileName) {
int data = schematics.getBlocksData()[pos]; int data = schematics.getBlocksData()[pos];
create = 1; create = 1;
computeBlockColor(id, data, &red, &green, &blue, &create); computeBlockColor(id, data, red, green, blue, create);
switch (create) { switch (create) {
case 1:
createVoxel(size * x, size * y, size * z, size, red, green, blue, true);
++count;
break;
case 2:
switch (data) {
case 0:
createVoxel(size * x + size / 2, size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 1: case 1:
createVoxel(size * x , size * y + size / 2, size * z , size / 2, red, green, blue, true); createVoxel(size * x, size * y, size * z, size, red, green, blue, true);
createVoxel(size * x , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true); ++count;
break; break;
case 2: case 2:
createVoxel(size * x , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true); switch (data) {
createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true); case 0:
break; createVoxel(size * x + size / 2, size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 1:
createVoxel(size * x , size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 2:
createVoxel(size * x , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 3:
createVoxel(size * x , size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z , size / 2, red, green, blue, true);
break;
}
count += 2;
// There's no break on purpose.
case 3: case 3:
createVoxel(size * x , size * y + size / 2, size * z , size / 2, red, green, blue, true); createVoxel(size * x , size * y, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z , size / 2, red, green, blue, true); createVoxel(size * x + size / 2, size * y, size * z , size / 2, red, green, blue, true);
createVoxel(size * x , size * y, size * z + size / 2, size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y, size * z + size / 2, size / 2, red, green, blue, true);
count += 4;
break; break;
}
count += 2;
// There's no break on purpose.
case 3:
createVoxel(size * x , size * y, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y, size * z , size / 2, red, green, blue, true);
createVoxel(size * x , size * y, size * z + size / 2, size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y, size * z + size / 2, size / 2, red, green, blue, true);
count += 4;
break;
} }
} }
} }
@ -1620,160 +1620,155 @@ void VoxelTree::copyFromTreeIntoSubTree(VoxelTree* sourceTree, VoxelNode* destin
} }
} }
void VoxelTree::computeBlockColor(int id, int data, int* r, int* g, int* b, int* create) { void VoxelTree::computeBlockColor(int id, int data, int& red, int& green, int& blue, int& create) {
int red = *r, green = *g, blue = *b;
switch (id) { switch (id) {
case 1: case 1:
case 14: case 14:
case 15: case 15:
case 16: case 16:
case 21: case 21:
case 56: case 56:
case 73: case 73:
case 74: case 74:
case 97: case 97:
case 129: red = 128; green = 128; blue = 128; break; case 129: red = 128; green = 128; blue = 128; break;
case 2: red = 77; green = 117; blue = 66; break; case 2: red = 77; green = 117; blue = 66; break;
case 3: case 3:
case 60: red = 116; green = 83; blue = 56; break; case 60: red = 116; green = 83; blue = 56; break;
case 4: red = 71; green = 71; blue = 71; break; case 4: red = 71; green = 71; blue = 71; break;
case 5: case 5:
case 125: red = 133; green = 94; blue = 62; break; case 125: red = 133; green = 94; blue = 62; break;
case 7: red = 35; green = 35; blue = 35; break; case 7: red = 35; green = 35; blue = 35; break;
case 8: case 8:
case 9: red = 100; green = 109; blue = 185; break; case 9: red = 100; green = 109; blue = 185; break;
case 10: case 10:
case 11: red = 192; green = 64; blue = 8; break; case 11: red = 192; green = 64; blue = 8; break;
case 12: red = 209; green = 199; blue = 155; break; case 12: red = 209; green = 199; blue = 155; break;
case 13: red = 96; green = 94; blue = 93; break; case 13: red = 96; green = 94; blue = 93; break;
case 17: red = 71; green = 56; blue = 35; break; case 17: red = 71; green = 56; blue = 35; break;
case 18: red = 76; green = 104; blue = 64; break; case 18: red = 76; green = 104; blue = 64; break;
case 19: red = 119; green = 119; blue = 37; break; case 19: red = 119; green = 119; blue = 37; break;
case 22: red = 22; green = 44; blue = 86; break; case 22: red = 22; green = 44; blue = 86; break;
case 23: case 23:
case 29: case 29:
case 33: case 33:
case 61: case 61:
case 62: case 62:
case 158: red = 61; green = 61; blue = 61; break; case 158: red = 61; green = 61; blue = 61; break;
case 24: red = 209; green = 202; blue = 156; break; case 24: red = 209; green = 202; blue = 156; break;
case 25: case 25:
case 58: case 58:
case 84: case 84:
case 137: red = 57; green = 38; blue = 25; break; case 137: red = 57; green = 38; blue = 25; break;
case 35: case 35:
switch (data) { switch (data) {
case 0: red = 234; green = 234; blue = 234; break; case 0: red = 234; green = 234; blue = 234; break;
case 1: red = 224; green = 140; blue = 84; break; case 1: red = 224; green = 140; blue = 84; break;
case 2: red = 185; green = 90; blue = 194; break; case 2: red = 185; green = 90; blue = 194; break;
case 3: red = 124; green = 152; blue = 208; break; case 3: red = 124; green = 152; blue = 208; break;
case 4: red = 165; green = 154; blue = 35; break; case 4: red = 165; green = 154; blue = 35; break;
case 5: red = 70; green = 187; blue = 61; break; case 5: red = 70; green = 187; blue = 61; break;
case 6: red = 206; green = 124; blue = 145; break; case 6: red = 206; green = 124; blue = 145; break;
case 7: red = 66; green = 66; blue = 66; break; case 7: red = 66; green = 66; blue = 66; break;
case 8: red = 170; green = 176; blue = 176; break; case 8: red = 170; green = 176; blue = 176; break;
case 9: red = 45; green = 108; blue = 35; break; case 9: red = 45; green = 108; blue = 35; break;
case 10: red = 130; green = 62; blue = 8; break; case 10: red = 130; green = 62; blue = 8; break;
case 11: red = 43; green = 51; blue = 29; break; case 11: red = 43; green = 51; blue = 29; break;
case 12: red = 73; green = 47; blue = 29; break; case 12: red = 73; green = 47; blue = 29; break;
case 13: red = 57; green = 76; blue = 36; break; case 13: red = 57; green = 76; blue = 36; break;
case 14: red = 165; green = 58; blue = 53; break; case 14: red = 165; green = 58; blue = 53; break;
case 15: red = 24; green = 24; blue = 24; break; case 15: red = 24; green = 24; blue = 24; break;
default: default:
*create = 0; create = 0;
break;
}
break; break;
} case 41: red = 239; green = 238; blue = 105; break;
break; case 42: red = 146; green = 146; blue = 146; break;
case 41: red = 239; green = 238; blue = 105; break; case 43:
case 42: red = 146; green = 146; blue = 146; break; case 98: red = 161; green = 161; blue = 161; break;
case 43: case 44:
case 98: red = 161; green = 161; blue = 161; break; create = 3;
case 44:
*create = 3;
switch (data) { switch (data) {
case 0: red = 161; green = 161; blue = 161; break; case 0: red = 161; green = 161; blue = 161; break;
case 1: red = 209; green = 202; blue = 156; break; case 1: red = 209; green = 202; blue = 156; break;
case 2: red = 133; green = 94; blue = 62; break; case 2: red = 133; green = 94; blue = 62; break;
case 3: red = 71; green = 71; blue = 71; break; case 3: red = 71; green = 71; blue = 71; break;
case 4: red = 121; green = 67; blue = 53; break; case 4: red = 121; green = 67; blue = 53; break;
case 5: red = 161; green = 161; blue = 161; break; case 5: red = 161; green = 161; blue = 161; break;
case 6: red = 45; green = 22; blue = 26; break; case 6: red = 45; green = 22; blue = 26; break;
case 7: red = 195; green = 192; blue = 185; break; case 7: red = 195; green = 192; blue = 185; break;
default: default:
*create = 0; create = 0;
break;
}
break; break;
} case 45: red = 121; green = 67; blue = 53; break;
break; case 46: red = 118; green = 36; blue = 13; break;
case 45: red = 121; green = 67; blue = 53; break; case 47: red = 155; green = 127; blue = 76; break;
case 46: red = 118; green = 36; blue = 13; break; case 48: red = 61; green = 79; blue = 61; break;
case 47: red = 155; green = 127; blue = 76; break; case 49: red = 52; green = 41; blue = 74; break;
case 48: red = 61; green = 79; blue = 61; break; case 52: red = 12; green = 66; blue = 71; break;
case 49: red = 52; green = 41; blue = 74; break;
case 52: red = 12; green = 66; blue = 71; break;
case 53:
case 67:
case 108:
case 109:
case 114:
case 128:
case 134:
case 135:
case 136:
case 156:
*create = 2;
switch (id) {
case 53: case 53:
case 67:
case 108:
case 109:
case 114:
case 128:
case 134: case 134:
case 135: case 135:
case 136: red = 133; green = 94; blue = 62; break; case 136:
case 67: red = 71; green = 71; blue = 71; break; case 156:
case 108: red = 121; green = 67; blue = 53; break; create = 2;
case 109: red = 161; green = 161; blue = 161; break;
case 114: red = 45; green = 22; blue = 26; break;
case 128: red = 209; green = 202; blue = 156; break;
case 156: red = 195; green = 192; blue = 185; break;
default:
*create = 0;
break;
}
break;
case 54:
case 95:
case 146: red = 155; green = 105; blue = 32; break;
case 57: red = 145; green = 219; blue = 215; break;
case 79: red = 142; green = 162; blue = 195; break;
case 80: red = 255; green = 255; blue = 255; break;
case 81: red = 8; green = 64; blue = 15; break;
case 82: red = 150; green = 155; blue = 166; break;
case 86:
case 91: red = 179; green = 108; blue = 17; break;
case 87:
case 153: red = 91; green = 31; blue = 30; break;
case 88: red = 68; green = 49; blue = 38; break;
case 89: red = 180; green = 134; blue = 65; break;
case 103: red = 141; green = 143; blue = 36; break;
case 110: red = 103; green = 92; blue = 95; break;
case 112: red = 45; green = 22; blue = 26; break;
case 121: red = 183; green = 178; blue = 129; break;
case 123: red = 101; green = 59; blue = 31; break;
case 124: red = 213; green = 178; blue = 123; break;
case 130: red = 38; green = 54; blue = 56; break;
case 133: red = 53; green = 84; blue = 85; break;
case 152: red = 131; green = 22; blue = 7; break;
case 155: red = 195; green = 192; blue = 185; break;
case 159: red = 195; green = 165; blue = 150; break;
case 170: red = 168; green = 139; blue = 15; break;
case 172: red = 140; green = 86; blue = 61; break;
case 173: red = 9; green = 9; blue = 9; break;
default:
*create = 0;
break;
}
*r = red; switch (id) {
*g = green; case 53:
*b = blue; case 134:
case 135:
case 136: red = 133; green = 94; blue = 62; break;
case 67: red = 71; green = 71; blue = 71; break;
case 108: red = 121; green = 67; blue = 53; break;
case 109: red = 161; green = 161; blue = 161; break;
case 114: red = 45; green = 22; blue = 26; break;
case 128: red = 209; green = 202; blue = 156; break;
case 156: red = 195; green = 192; blue = 185; break;
default:
create = 0;
break;
}
break;
case 54:
case 95:
case 146: red = 155; green = 105; blue = 32; break;
case 57: red = 145; green = 219; blue = 215; break;
case 79: red = 142; green = 162; blue = 195; break;
case 80: red = 255; green = 255; blue = 255; break;
case 81: red = 8; green = 64; blue = 15; break;
case 82: red = 150; green = 155; blue = 166; break;
case 86:
case 91: red = 179; green = 108; blue = 17; break;
case 87:
case 153: red = 91; green = 31; blue = 30; break;
case 88: red = 68; green = 49; blue = 38; break;
case 89: red = 180; green = 134; blue = 65; break;
case 103: red = 141; green = 143; blue = 36; break;
case 110: red = 103; green = 92; blue = 95; break;
case 112: red = 45; green = 22; blue = 26; break;
case 121: red = 183; green = 178; blue = 129; break;
case 123: red = 101; green = 59; blue = 31; break;
case 124: red = 213; green = 178; blue = 123; break;
case 130: red = 38; green = 54; blue = 56; break;
case 133: red = 53; green = 84; blue = 85; break;
case 152: red = 131; green = 22; blue = 7; break;
case 155: red = 195; green = 192; blue = 185; break;
case 159: red = 195; green = 165; blue = 150; break;
case 170: red = 168; green = 139; blue = 15; break;
case 172: red = 140; green = 86; blue = 61; break;
case 173: red = 9; green = 9; blue = 9; break;
default:
create = 0;
break;
}
} }

2
libraries/voxels/src/VoxelTree.h
View file

@ -136,7 +136,7 @@ public:
// reads voxels from square image with alpha as a Y-axis // reads voxels from square image with alpha as a Y-axis
bool readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension); bool readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension);
bool readFromSchematicsFile(const char* filename); bool readFromSchematicsFile(const char* filename);
void computeBlockColor(int id, int data, int* r, int* g, int* b, int* create); void computeBlockColor(int id, int data, int& r, int& g, int& b, int& create);
unsigned long getVoxelCount(); unsigned long getVoxelCount();