std::string read_text_file(const std::string& path)
{
#if 1
const auto vec = read_binary_file(path);
return std::string(begin(vec), end(vec));
#else
ifstream file;
file.open(path.c_str());
std::string content = "";
std::string line;
if (!file.is_open()) {
ABORT_F("Failed to open '%s'", path.c_str());
}
while (!file.eof()) {
getline(file, line);
content += line + "\n";
}
file.close();
return content;
#endif
}
size_t VertComp::sizeBytes() const
{
if (type == GL_BYTE) { return num_comps * sizeof(int8_t); }
if (type == GL_UNSIGNED_BYTE) { return num_comps * sizeof(uint8_t); }
if (type == GL_SHORT) { return num_comps * sizeof(int16_t); }
if (type == GL_UNSIGNED_SHORT) { return num_comps * sizeof(uint16_t); }
if (type == GL_FLOAT) { return num_comps * sizeof(float); }
ABORT_F("Unknow type: %u", type);
}
int Program::get_attribute_loc(const std::string& attrib_name) const
{
for (const auto& attrib : _attributes) {
if (attrib.name == attrib_name) {
return attrib.location;
}
}
ABORT_F("Failed to find location for attribute '%s' in program '%s'",
attrib_name.c_str(), _debug_name.c_str());
}
int Program::get_uniform_loc(const std::string& uniform_name) const
{
for (const auto& uniform : _uniforms) {
if (uniform.name == uniform_name) {
return uniform.location;
}
}
ABORT_F("Failed to find location for uniform '%s' in program '%s'",
uniform_name.c_str(), _debug_name.c_str());
}
unsigned Texture::bits_per_pixel() const
{
if (_bpp != 0) {
return _bpp;
} else {
switch (_format) {
case ImageFormat::Alpha8: return 1 * 8;
case ImageFormat::Red8: return 1 * 8;
case ImageFormat::RGB24: return 3 * 8;
case ImageFormat::RGBA32: return 4 * 8;
case ImageFormat::BGRA32: return 4 * 8;
case ImageFormat::AlphaHF: return 2 * 8;
case ImageFormat::RGBAHF: return 8 * 8;
case ImageFormat::RGBAf: return 16 * 8;
default: ABORT_F("Unknown image format: %d", (int)_format);
}
}
}
bool link_program(unsigned prog, const char* debug_name)
{
CHECK_FOR_GL_ERROR;
glLinkProgram(prog);
#if defined(DEBUG)
print_link_log(prog, debug_name);
#endif
GLint status;
glGetProgramiv(prog, GL_LINK_STATUS, &status);
if (status == GL_FALSE) {
print_link_log(prog, debug_name);
ABORT_F("Failed to link GL program");
}
return true;
}
bool validate_program(GLuint prog, const char* debug_name)
{
CHECK_FOR_GL_ERROR;
GLint log_length, status;
glValidateProgram(prog);
glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
std::vector<GLchar> log((size_t)log_length);
glGetProgramInfoLog(prog, log_length, &log_length, log.data());
LOG_F(INFO, "Program '%s' validate log:\n%s", debug_name, log.data());
}
glGetProgramiv(prog, GL_VALIDATE_STATUS, &status);
if (status == 0) {
ABORT_F("Program status is zero: %s", debug_name);
}
return true;
}
void test_error_contex()
{
{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
ERROR_CONTEXT("Parent thread value", 42);
{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
char parent_thread_name[17];
loguru::get_thread_name(parent_thread_name, sizeof(parent_thread_name), false);
ERROR_CONTEXT("Parent thread name", &parent_thread_name[0]);
const auto parent_ec_handle = loguru::get_thread_ec_handle();
std::thread([=]{
loguru::set_thread_name("EC test thread");
ERROR_CONTEXT("parent error context", parent_ec_handle);
{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
ERROR_CONTEXT("const char*", "test string");
ERROR_CONTEXT("integer", 42);
ERROR_CONTEXT("float", 3.14f);
ERROR_CONTEXT("double", 3.14);
{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
ERROR_CONTEXT("char A", 'A');
ERROR_CONTEXT("char backslash", '\\');
ERROR_CONTEXT("char double-quote", '\"');
ERROR_CONTEXT("char single-quote", '\'');
ERROR_CONTEXT("char zero", '\0');
ERROR_CONTEXT("char bell", '\b');
ERROR_CONTEXT("char feed", '\f');
ERROR_CONTEXT("char newline", '\n');
ERROR_CONTEXT("char return", '\r');
ERROR_CONTEXT("char tab", '\t');
ERROR_CONTEXT("char x13", '\u0013');
{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
CustomType custom{"custom_contents"};
ERROR_CONTEXT("CustomType", &custom);
ABORT_F("Intentional abort");
}).join();
}
int main(int argc, char* argv[])
{
if (argc > 1 && argv[1] == std::string("test"))
{
return main_test(argc, argv);
}
loguru::init(argc, argv);
// auto verbose_type_name = loguru::demangle(typeid(std::ofstream).name());
// loguru::add_stack_cleanup(verbose_type_name.c_str(), "std::ofstream");
// std::ofstream os;
// die(os);
if (argc == 1)
{
loguru::add_file("latest_readable.log", loguru::Truncate, loguru::Verbosity_INFO);
loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX);
LOG_F(INFO, "Loguru test");
test_thread_names();
test_scopes();
test_levels();
test_stream();
}
else
{
std::string test = argv[1];
if (test == "ABORT_F") {
ABORT_F("ABORT_F format message");
} else if (test == "ABORT_S") {
ABORT_S() << "ABORT_S stream message";
} else if (test == "assert") {
const char* ptr = 0;
assert(ptr && "Error that was unexpected");
} else if (test == "LOG_F(FATAL)") {
LOG_F(FATAL, "Fatal format message");
} else if (test == "LOG_S(FATAL)") {
LOG_S(FATAL) << "Fatal stream message";
} else if (test == "CHECK_NOTNULL_F") {
const char* ptr = 0;
CHECK_NOTNULL_F(ptr);
} else if (test == "CHECK_F") {
CHECK_F(1 > 2);
} else if (test == "CHECK_EQ_F") {
CHECK_EQ_F(always_increasing(), 0);
CHECK_EQ_F(always_increasing(), 1);
CHECK_EQ_F(always_increasing(), 42);
} else if (test == "CHECK_EQ_F_int") {
int x = 42;
CHECK_EQ_F(x, x + 1);
} else if (test == "CHECK_EQ_F_unsigned") {
unsigned x = 42;
CHECK_EQ_F(x, x + 1);
} else if (test == "CHECK_EQ_F_size_t") {
size_t x = 42;
CHECK_EQ_F(x, x + 1);
} else if (test == "CHECK_EQ_F_message") {
CHECK_EQ_F(always_increasing(), 0, "Should pass");
CHECK_EQ_F(always_increasing(), 1, "Should pass");
CHECK_EQ_F(always_increasing(), 42, "Should fail");
} else if (test == "CHECK_EQ_S") {
std::string str = "right";
CHECK_EQ_S(str, "wrong") << "Expected to fail, since `str` isn't \"wrong\" but \"" << str << "\"";
} else if (test == "CHECK_LT_S") {
CHECK_EQ_S(always_increasing(), 0);
CHECK_EQ_S(always_increasing(), 1);
CHECK_EQ_S(always_increasing(), 42);
} else if (test == "CHECK_LT_S_message") {
CHECK_EQ_S(always_increasing(), 0) << "Should pass";
CHECK_EQ_S(always_increasing(), 1) << "Should pass";
CHECK_EQ_S(always_increasing(), 42) << "Should fail!";
} else if (test == "deep_abort") {
deep_abort_10({"deep_abort"});
} else if (test == "SIGSEGV") {
test_SIGSEGV_2();
} else if (test == "hang") {
test_hang_2();
} else {
LOG_F(ERROR, "Unknown test: '%s'", test.c_str());
}
}
}
void the_one_where_the_problem_is(const std::vector<std::string>& v) {
ABORT_F("Abort deep in stack trace, msg: %s", v[0].c_str());
}
void Texture::set_mip_data(const void* data_ptr, Size size, unsigned mip_level)
{
NAME_PAINT_FUNCTION();
bind();
//glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // FIXME
CHECK_FOR_GL_ERROR;
GLenum src_format;
GLint dst_format;
GLenum element_format;
switch (_format)
{
case ImageFormat::Alpha8:
src_format = GL_RED;
dst_format = GL_RED;
element_format = GL_UNSIGNED_BYTE;
break;
case ImageFormat::Red8:
src_format = GL_RED;
dst_format = src_format;
element_format = GL_UNSIGNED_BYTE;
break;
case ImageFormat::RGB24:
src_format = GL_RGB;
dst_format = GL_RGB;
element_format = GL_UNSIGNED_BYTE;
break;
case ImageFormat::RGBA32:
src_format = GL_RGBA;
dst_format = GL_RGBA;
element_format = GL_UNSIGNED_BYTE;
break;
case ImageFormat::BGRA32:
src_format = GL_BGRA;
dst_format = GL_RGBA;
element_format = GL_UNSIGNED_BYTE;
break;
case ImageFormat::AlphaHF:
//src_format = GL_R16F_EXT; // WRONG
//src_format = GL_RGBA16F_EXT; // WRONG
//src_format = GL_LUMINANCE; // Doesn't work with FBO
src_format = GL_ALPHA; // The number of components
dst_format = src_format;
#if TARGET_OS_IPHONE
element_format = GL_HALF_FLOAT_OES;
#else
element_format = GL_HALF_FLOAT;
#endif
// TODO: GL_EXT_texture_rg ?
break;
case ImageFormat::RGBAHF:
src_format = GL_RGBA; // The number of components
dst_format = src_format;
#if TARGET_OS_IPHONE
element_format = GL_HALF_FLOAT_OES;
#else
element_format = GL_HALF_FLOAT;
#endif
break;
default:
ABORT_F("Unknown image format");
}
CHECK_FOR_GL_ERROR;
glTexImage2D(GL_TEXTURE_2D, mip_level, dst_format,
(GLsizei)size.x, (GLsizei)size.y, 0,
src_format, element_format, data_ptr);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mip_level);
CHECK_FOR_GL_ERROR;
_has_data = true;
}
