static void on_font_load_clicked(int id, void* user) {
KankerApp* app = static_cast<KankerApp*>(user);
if (NULL == app) {
RX_ERROR("error: cannot cast to KankerApp* in on_file_selected().");
return;
}
std::vector<std::string> files;
if (0 != app->getFontFiles(files)) {
RX_ERROR("error: cannot load font, file not found.");
return;
}
if (app->selected_font_dx >= files.size()) {
RX_ERROR("error: selected font dx is too big: %d, files.size() = %lu.", app->selected_font_dx, files.size());
return;
}
std::string filepath = rx_to_data_path("fonts/" +files[app->selected_font_dx]);
if (!rx_file_exists(filepath)) {
RX_ERROR("error: cannot load file; file seems to be removed?");
return;
}
if (0 != app->kanker_font.load(filepath)) {
RX_ERROR("error: font failed to load: %s\n", filepath.c_str());
return;
}
app->font_filename = files[app->selected_font_dx];
app->switchState(KSTATE_CHAR_OVERVIEW);
}
GLuint Water::createTexture(std::string filename) {
int w, h, n;
unsigned char* pix;
if(!rx_load_png(rx_to_data_path(filename), &pix, w, h, n)) {
printf("Error: cannot find: %s\n", filename.c_str());
return 0;
}
GLuint tex;
GLenum format = GL_RGB;
if(n == 4) {
format = GL_RGBA;
}
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, format, GL_UNSIGNED_BYTE, pix);
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_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
delete[] pix;
pix = NULL;
return tex;
}
bool HTTPFile::setFile(std::string fname, bool datapath) {
filepath = fname;
filename = fname;
if(datapath) {
filepath = rx_to_data_path(fname);
}
return exists();
}
int main() {
// get necessary config
// -----------------------------------------------
Jansson j;
if(!j.load("youtube.cfg", true)) {
RX_ERROR("Make sure that you created the youtube.cfg; we're using that config to authorize ourself");
return EXIT_FAILURE;
}
std::string client_id;
std::string client_secret;
std::string auth_code;
j.getString("/client_id", client_id);
j.getString("/client_secret", client_secret);
j.getString("/auth_code", auth_code);
if(!client_id.size() || !client_secret.size() || !auth_code.size()) {
RX_ERROR("One of the configuration options is empty! Did you set the auth code? See html/index.html and readme.");
return EXIT_FAILURE;
}
// test an upload with some garbage json
// -----------------------------------------------
YouTube yt;
if(!yt.setup(client_id, client_secret)) {
RX_ERROR("Cannot setup the youtube API handler");
return EXIT_FAILURE;
}
if(!yt.hasAccessToken()) {
RX_VERBOSE("Fetching access token");
if(!yt.exchangeAuthCode(auth_code)) {
RX_ERROR("Cannot update the access token");
return EXIT_FAILURE;
}
}
YouTubeVideo video;
video.title = "some title";
video.filename = rx_to_data_path("test.mov");
video.datapath = false;
video.video_resource_json = "_invalid_json_";
video.bytes_total = rx_get_file_size(video.filename);
YouTubeUploadStart uploader;
if(uploader.start(video, yt.getAccessToken())) {
RX_ERROR("TEST FAILED, uploader should return false on error");
}
else {
RX_ERROR("TEST SUCCEEDED!");
}
return EXIT_SUCCESS;
}
static void on_abb_load_settings_clicked(int id, void* user) {
KankerApp* app = static_cast<KankerApp*>(user);
if (NULL == app) {
RX_ERROR("Failed to cast to KankerApp");
return;
}
if (0 != app->kanker_abb.loadSettings(rx_to_data_path("abb_settings.xml"))) {
RX_ERROR("Failed to load the settings.");
}
}
// create the request string
bool HTTPRequest::toString(std::string& result) {
// create the content string
std::string http_body;
if(!createBody(http_body)) {
RX_ERROR("Cannot create request body");
return false;
}
// create the headers.
addDefaultHTTPHeaders();
addHeader(HTTPHeader("Content-Length", http_body.size()));
// construct the request
result = getHTTPString() +"\r\n";
result += headers.join();
result += "\r\n";
#if 1
printf("%s", result.c_str());
for(size_t i = 0; i < http_body.size(); ++i) {
if(i > 40) {
break;
}
printf("%c", http_body[i]);
}
printf("\n");
for(size_t i = 0; i < http_body.size(); ++i) {
if(i > 40) {
break;
}
printf("%02X ", (unsigned char)http_body[i]);
}
printf("\n");
#endif
result += http_body;
#if 0
std::ofstream ofs(rx_to_data_path("out.raw").c_str(), std::ios::binary | std::ios::out);
if(!ofs.is_open()) {
RX_ERROR("Cannot open output file");
}
else {
ofs.write(result.c_str(), result.size());
ofs.close();
}
#endif
return true;
}
bool JPG::load(std::string filename, bool datapath) {
if(datapath) {
filename = rx_to_data_path(filename);
}
struct jpeg_error_mgr jerr;
struct jpeg_decompress_struct cinfo;
FILE* fp;
JSAMPARRAY buffer;
if( (fp = fopen(filename.c_str(), "rb")) == NULL ) {
RX_ERROR(ERR_JPG_FILE_NOT_OPENED, filename.c_str());
return false;
}
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
jpeg_stdio_src(&cinfo, fp);
jpeg_read_header(&cinfo, TRUE);
jpeg_start_decompress(&cinfo);
stride = cinfo.output_width * cinfo.output_components;
num_channels = cinfo.output_components;
width = cinfo.output_width;
height = cinfo.output_height;
bit_depth = 8;
num_bytes = width * height * num_channels;
pixels = new unsigned char[num_bytes];
if(!pixels) {
RX_ERROR(ERR_JPG_CANNOT_ALLOC);
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
fclose(fp);
return false;
}
size_t dest_row = 0;
buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo, JPOOL_IMAGE, stride, 1);
while(cinfo.output_scanline < cinfo.output_height) {
jpeg_read_scanlines(&cinfo, buffer, 1);
memcpy(pixels + (dest_row * stride), buffer[0], stride);
dest_row++;
}
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
fclose(fp);
return true;
}
/* Returns 0 when we found some font files, otherwise < 0. */
int KankerApp::getFontFiles(std::vector<std::string>& files) {
std::vector<std::string> full_paths;
full_paths = rx_get_files(rx_to_data_path("fonts"), "xml");
if (0 == full_paths.size()) {
return -1;
}
for (size_t i = 0; i < full_paths.size(); ++i) {
files.push_back(rx_strip_dir(full_paths[i]));
}
return 0;
}
static void on_font_save_clicked(int id, void* user) {
KankerApp* app = static_cast<KankerApp*>(user);
if (NULL == app) {
RX_ERROR("error: cannot cast to KankerApp* in on_save_clicked().");
return;
}
if (0 == app->font_filename.size()) {
RX_ERROR("No filename entered. Cannot save.");
return;
}
RX_VERBOSE("Saving file: %s, origin_x: %f", app->font_filename.c_str(), app->kanker_font.origin_x);
app->kanker_font.save(rx_to_data_path("fonts/" +app->font_filename));
}
bool Mist::setup() {
vert = rx_create_shader(GL_VERTEX_SHADER, MIST_VS);
frag = rx_create_shader(GL_FRAGMENT_SHADER, MIST_FS);
prog = rx_create_program(vert, frag);
glBindAttribLocation(prog, 0, "a_pos");
glBindAttribLocation(prog, 1, "a_tex");
glLinkProgram(prog);
rx_print_shader_link_info(prog);
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "u_tex"), 0);
u_time = glGetUniformLocation(prog, "u_time");
u_perc = glGetUniformLocation(prog, "u_perc");
assert(u_time >= 0);
assert(u_perc >= 0);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexPT3), (GLvoid*)0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(VertexPT3), (GLvoid*)12);
createRing(effects.win_w * 0.5, effects.win_h * 0.5, 20.0f, 450.0);
MistShape shape;
shape.reset();
shape.offset = offsets.back();
shape.count = counts.back();
shape.x = 1024 * 0.5;
shape.y = 768 * 0.5;
shapes.push_back(shape);
mist_tex = rx_create_texture(rx_to_data_path("images/mist.png")); // , GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
if(!mist_tex) {
printf("Error: cannot create the mist texture.\n");
return false;
}
printf("mist.mist_tex: %d\n", mist_tex);
return true;
}
MP3FileWriter::MP3FileWriter(std::string filename, bool datapath)
:cb_open(NULL)
,cb_data(NULL)
,cb_close(NULL)
{
if(datapath) {
filename = rx_to_data_path(filename);
}
ofs.open(filename.c_str(), std::ios::binary);
if(!ofs.is_open()) {
RX_ERROR(MP3_WRERR_FILE_OPEN, filename.c_str());
}
else {
cb_open = mp3_writer_default_open;
cb_close = mp3_writer_default_close;
cb_data = mp3_writer_default_data;
}
}
int main() {
glfwSetErrorCallback(error_callback);
if(!glfwInit()) {
printf("Error: cannot setup glfw.\n");
exit(EXIT_FAILURE);
}
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWwindow* win = NULL;
int w = 1280;
int h = 720;
win = glfwCreateWindow(w, h, "~`` Image Loader - Copy Images Into data/test/ ``~", NULL, NULL);
if(!win) {
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetFramebufferSizeCallback(win, resize_callback);
glfwSetKeyCallback(win, key_callback);
glfwSetCharCallback(win, char_callback);
glfwSetCursorPosCallback(win, cursor_callback);
glfwSetMouseButtonCallback(win, button_callback);
glfwMakeContextCurrent(win);
glfwSwapInterval(1);
if (!gladLoadGL()) {
printf("Cannot load GL.\n");
exit(1);
}
// ----------------------------------------------------------------
// THIS IS WHERE YOU START CALLING OPENGL FUNCTIONS, NOT EARLIER!!
// ----------------------------------------------------------------
rx_log_init();
mos::ImageLoader loader;
if (0 != loader.init()) {
exit(EXIT_FAILURE);
}
loader.on_loaded = on_loaded;
mos::DirWatcher watcher;
if (0 != watcher.init(rx_to_data_path("test"), on_dir_change, &loader)) {
exit(EXIT_FAILURE);
}
Painter painter;
while(!glfwWindowShouldClose(win)) {
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
watcher.update();
GLenum fmt = GL_NONE;
if (must_recreate || must_update) {
if (1 == tex_channels) {
fmt = GL_RED;
}
else if (2 == tex_channels) {
fmt = GL_RG;
}
else if (3 == tex_channels) {
fmt = GL_RGB;
}
else if (4 == tex_channels) {
fmt = GL_RGBA;
}
else {
RX_ERROR("Unsupported number of channels: %d", tex_channels);
}
}
if (must_recreate) {
RX_VERBOSE("Create texture, width: %d, height: %d, channels: %d", tex_width, tex_height, tex_channels);
if (0 != tex_id) {
glDeleteTextures(1, &tex_id);
}
if (GL_NONE != fmt) {
glGenTextures(1, &tex_id);
glBindTexture(GL_TEXTURE_2D, tex_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_width, tex_height, 0, fmt, GL_UNSIGNED_BYTE, pixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
must_recreate = false;
must_update = false;
}
if (must_update && GL_NONE != fmt) {
RX_VERBOSE("Updating pixels");
glBindTexture(GL_TEXTURE_2D, tex_id);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, tex_width, tex_height, 0, fmt, GL_UNSIGNED_BYTE, pixels);
must_update = false;
}
if (0 != tex_id) {
int x = MAX(0, (w/2) - (tex_width/2));
int y = 0;
painter.clear();
painter.texture(tex_id, x, y, tex_width, tex_height);
painter.draw();
}
glfwSwapBuffers(win);
glfwPollEvents();
}
loader.shutdown();
glfwTerminate();
return EXIT_SUCCESS;
}
bool JPG::save(std::string filename, bool datapath) {
if(!width || !height) {
RX_ERROR("Invalid width or height: %d x %d", width, height);
return false;
}
if(!stride) {
RX_ERROR("Invalid stride: %d", stride);
return false;
}
if(!pixels) {
RX_ERROR("No pixels set to save");
return false;
}
if(!bit_depth) {
RX_ERROR("Invalid bit_depth: %d", bit_depth);
return false;
}
if(datapath) {
filename = rx_to_data_path(filename);
}
FILE* fp = fopen(filename.c_str(), "wb");
if(!fp) {
RX_ERROR("Cannot open the file: `%s`", filename.c_str());
fp = NULL;
return false;
}
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, fp);
// compression parameters
cinfo.image_width = width;
cinfo.image_height = height;
cinfo.input_components = num_channels;
cinfo.in_color_space = color_space;
jpeg_set_defaults(&cinfo); // after setting the default we can set our custom settings
// @todo > set compression level, dither, dct
jpeg_set_quality(&cinfo, quality, TRUE /* limit to jpeg baseline values */);
jpeg_start_compress(&cinfo, TRUE /* write complete data stream */);
while(cinfo.next_scanline < cinfo.image_height) {
row_pointer[0] = &pixels[cinfo.next_scanline * stride];
jpeg_write_scanlines(&cinfo, row_pointer, 1);
}
jpeg_finish_compress(&cinfo);
fclose(fp);
fp = NULL;
jpeg_destroy_compress(&cinfo);
return true;
}
int KankerApp::init() {
/* title font */
std::string font = "appfont.otf";
if (0 != title_font.open(rx_to_data_path(font), 60)) {
RX_ERROR("error: cannot load the font.");
exit(EXIT_FAILURE);
}
title_font.color(1.0f, 1.0f, 1.0f, 1.0f);
title_font.alignCenter();
/* info font */
if (0 != info_font.open(rx_to_data_path(font), 16)) {
RX_ERROR("error: cannot load the font.");
exit(EXIT_FAILURE);
}
info_font.color(1.0f, 1.0f, 1.0f, 1.0f);
/* verbose font */
if (0 != verbose_font.open(rx_to_data_path(font), 16)) {
RX_ERROR("error: cannot load the font.");
exit(EXIT_FAILURE);
}
verbose_font.color(0.0f, 0.7f, 0.1f, 1.0f);
switchState(KSTATE_HOME);
/* create the GUI. */
if (0 != createGui()) {
RX_ERROR("error: failed to create the gui.");
exit(EXIT_FAILURE);
}
/* init the drawer. */
painter.init();
if (0 != tiny_drawer.init(1024, 768, painter.width(), painter.height())) {
RX_ERROR("error: failed to initialize the drawer.");
return -1;
}
int pw = 1024;
int ph = 768;
if (0 != preview_drawer.init(pw, ph, painter.width(), painter.height())) {
RX_ERROR("error: failed to initialize the preview drawer.");
return -1;
}
/* TEST LOAD FONT */
kanker_font.setOrigin(origin_x, origin_y);
std::string test_font = rx_to_data_path("fonts/roxlu.xml");
if (0 != kanker_font.load(test_font)) {
RX_ERROR("Cannot load: %s", test_font.c_str());
}
/* Init the ABB interface. */
// kanker_abb.range_width = 500;
// kanker_abb.range_height = 500;
/* Setup the controller that we use to test the ABB communication */
KankerAbbControllerSettings cfg;
cfg.font_file = rx_to_data_path("fonts/roxlu.xml");
cfg.settings_file = rx_to_data_path("abb_settings.xml");
if (0 != controller.init(cfg, this)) {
RX_ERROR("Cannot initialize the controller.");
}
test_message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque ac fermentum ";
//test_message = "roger abb";
//test_message = "ik sta op tegen kanker ik sta op tegen kanker.";
//test_message = "He Martin, gefeliciteerd met je verjaardag!";
//test_message = "Dearest Tina, we both have a lot of emotions for you";
//test_message = "Keez Duyves";
//test_message = "i love ";
//test_message = "diederick";
//test_message = "Martin gefeliciteerd!";
//test_message = "ipsum";
//test_message = "d d d a a";
//test_message = "aaaaaa";
//test_message = "bbbbbb";
//test_message = "x";
//test_message = "a";
//test_message = "Lieve papa, we denken aan je.";
//test_message = "Ik sta op tegen kanker voor mijn lieve schoonvader";
test_message = "Mijn, mijn, Lieve papa, we denken aan je.";
/* Force a load for the settings. */
on_abb_load_settings_clicked(0, this);
return 0;
}
bool Water::setup(int w, int h) {
assert(w && h);
win_w = w;
win_h = h;
// create shader
vert = rx_create_shader(GL_VERTEX_SHADER, WATER_VS);
frag = rx_create_shader(GL_FRAGMENT_SHADER, WATER_FS);
prog = rx_create_program(vert, frag);
glBindAttribLocation(prog, 0, "a_tex");
glLinkProgram(prog);
rx_print_shader_link_info(prog);
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "u_tex_pos"), 0); // VS
glUniform1i(glGetUniformLocation(prog, "u_tex_norm"), 1); // VS
glUniform1i(glGetUniformLocation(prog, "u_tex_texcoord"), 2); // VS
// glUniform1i(glGetUniformLocation(prog, "u_tex_tang"), 3); // VS
glUniform1i(glGetUniformLocation(prog, "u_tex_gradient"), 3); // VS
glUniform1i(glGetUniformLocation(prog, "u_noise_tex"), 4); // FS
glUniform1i(glGetUniformLocation(prog, "u_norm_tex"), 5); // FS
glUniform1i(glGetUniformLocation(prog, "u_flow_tex"), 6); // FS
glUniform1i(glGetUniformLocation(prog, "u_diffuse_tex"), 7); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_tex"), 8); // FS
glUniform1i(glGetUniformLocation(prog, "u_color_tex"), 9); // FS
glUniform1i(glGetUniformLocation(prog, "u_extra_flow_tex"), 10); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_delta_tex"), 11); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_colors"), 12); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_ramp"), 13); // FS
glUniform1i(glGetUniformLocation(prog, "u_vortex_tex"), 14); // FS
glUniform1i(glGetUniformLocation(prog, "u_sand_tex"), 15); // FS
glUniform1i(glGetUniformLocation(prog, "u_depth_ramp_tex"), 16); // FS
//GLint texture_units = 0;
//glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &texture_units);
//printf("Max units: %d\n", texture_units);
glUniformMatrix4fv(glGetUniformLocation(prog, "u_pm"), 1, GL_FALSE, height_field.pm.ptr());
glUniformMatrix4fv(glGetUniformLocation(prog, "u_vm"), 1, GL_FALSE, height_field.vm.ptr());
// load textures
normals_tex = createTexture("images/water_normals.png");
flow_tex = createTexture("images/water_flow.png");
noise_tex = createTexture("images/water_noise.png");
diffuse_tex = createTexture("images/water_diffuse.png");
foam_tex = createTexture("images/water_foam.png");
force_tex0 = createTexture("images/force.png");
foam_colors_tex = createTexture("images/foam_densities.png");
foam_ramp_tex = createTexture("images/foam_ramps.png");
vortex_tex = createTexture("images/vortex.png");
sand_tex = createTexture("images/sand.png");
depth_ramp_tex = createTexture("images/depth_ramp.png");
glBindTexture(GL_TEXTURE_2D, foam_colors_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, foam_ramp_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, depth_ramp_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
unsigned char* img_pix = NULL;
int img_w, img_h,img_channels = 0;
// load diffuse color ramp
if(!rx_load_png(rx_to_data_path("images/water_color.png"), &img_pix, img_w, img_h, img_channels)) {
printf("Error: cannot load the water_color.png image.\n");
return false;
}
glGenTextures(1, &color_tex);
glBindTexture(GL_TEXTURE_1D, color_tex);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB, img_w, 0, GL_RGB, GL_UNSIGNED_BYTE, img_pix);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
delete[] img_pix;
printf("water.color_tex: %d\n", color_tex);
glBindTexture(GL_TEXTURE_2D, flow_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// FBO we used for rendering extra diffuse colors to the water
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenTextures(1, &extra_flow_tex);
glBindTexture(GL_TEXTURE_2D, extra_flow_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, win_w, win_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, extra_flow_tex, 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("Cannot create the framebuffer for the water diffuse capture.\n");
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return true;
}
// @todo - we need to construct the correct video resource json
bool YouTubeModel::addVideoToUploadQueue(YouTubeVideo video) {
if(!video.filename.size()) {
RX_ERROR("Cannot add a video which has no filename set");
return false;
}
std::string filepath = video.filename;
if(video.datapath) {
filepath = rx_to_data_path(video.filename);
}
size_t fsize = rx_get_file_size(filepath);
if(!fsize) {
RX_ERROR("Filesize of %s returned %ld", filepath.c_str(), fsize);
return false;
}
#if USE_JSON_PACK
// @todo - libjansson is used as DLL, and json_dumps
// is supposed to free() the memory; this is icky and
// libjansson should free() any allocated mem as it's used
// as a dll
std::string video_json;
char* video_resource = NULL;
json_t* body = NULL;
if(!video.video_resource_json.size()) {
body = json_pack("{ s: {s:s}, s: { s:s, s:i, s:s, s:s } }",
"status", "privacyStatus", "private",
"snippet", "tags", video.tags.c_str(),
"categoryId", video.category,
"description", video.description.c_str(),
"title", video.title.c_str());
video_resource = json_dumps(body, JSON_INDENT(0));
json_decref(body);
video_json.assign(video_resource, strlen(video_resource));
if(!video_resource) {
RX_ERROR("Cannot create JSON video resource string");
return false;
}
}
else {
video_json = video.video_resource_json;
}
#else
std::string video_json;
if(!video.video_resource_json.size()) {
std::stringstream ss;
ss << "{ \"status\": { \"privacyStatus\" : \"private\" }, "
<< "\"snippet\": {"
<< "\"title\":\"" << video.title << "\", "
<< "\"tags\":\"" << video.tags << "\", "
<< "\"categoryId\":" << video.category << ", "
<< "\"description\":\"" << video.description << "\""
<< "}"
<< "}";
video_json = ss.str();
}
else {
video_json = video.video_resource_json;
}
#endif
bool r = db.insert("videos")
.use("filename", video.filename)
.use("state", YT_VIDEO_STATE_NONE)
.use("bytes_total", fsize)
.use("video_resource_json", video_json)
.use("datapath", (video.datapath) ? 1 : 0)
.use("title", video.title)
.use("description", video.description)
.use("tags", video.tags)
.use("privacy_status", video.privacy_status)
.use("category", video.category)
.execute();
#if USE_JSON_PACK
if(video_resource) {
free(video_resource);
video_resource = NULL;
}
#endif
if(r) {
RX_VERBOSE("Added video to the queue: %s", video.filename.c_str());
}
else {
RX_ERROR("Error while trying to add: %s to the video upload queue", video.filename.c_str());
}
return r;
}
bool WaterBallDrawer::setup(int w, int h) {
assert(w && h);
win_w = w;
win_h = h;
pm.ortho(0, w, h, 0, 0.0f, 100.0f);
// create basic shader
const char* atts[] = { "a_pos", "a_size" } ;
const char* frags[] = { "out_normals", "out_alpha" };
basic_prog.create(GL_VERTEX_SHADER, rx_to_data_path("shaders/waterdrop_basic.vert"));
basic_prog.create(GL_FRAGMENT_SHADER, rx_to_data_path("shaders/waterdrop_basic.frag"));
basic_prog.link(2, atts, 2, frags);
glUseProgram(basic_prog.id);
glUniformMatrix4fv(glGetUniformLocation(basic_prog.id, "u_pm"), 1, GL_FALSE, pm.ptr());
glUniform1i(glGetUniformLocation(basic_prog.id, "u_normals_tex"), 0);
glUniform1i(glGetUniformLocation(basic_prog.id, "u_alpha_tex"), 1);
// create water render shader
water_prog.create(GL_VERTEX_SHADER, rx_to_data_path("shaders/waterdrop_water.vert"));
water_prog.create(GL_FRAGMENT_SHADER, rx_to_data_path("shaders/waterdrop_water.frag"));
water_prog.link();
glUseProgram(water_prog.id);
glUniform1i(glGetUniformLocation(water_prog.id, "u_normals_tex"), 0);
glUniform1i(glGetUniformLocation(water_prog.id, "u_alpha_tex"), 1);
glUniform1i(glGetUniformLocation(water_prog.id, "u_background_tex"), 2);
glGenVertexArrays(1, &water_vao);
glGenVertexArrays(1, &basic_vao);
glBindVertexArray(basic_vao);
glGenBuffers(1, &basic_vbo);
glBindBuffer(GL_ARRAY_BUFFER, basic_vbo);
glEnableVertexAttribArray(0); // pos
glEnableVertexAttribArray(1); // size
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(WaterDrop), (GLvoid*) 0);
glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, sizeof(WaterDrop), (GLvoid*) 32);
glVertexAttribDivisor(0, 1);
glVertexAttribDivisor(1, 1);
normals_tex = rx_create_texture(rx_to_data_path("images/waterdrop_normals.png"));
alpha_tex = rx_create_texture(rx_to_data_path("images/waterdrop_alpha.png"));
background_tex = rx_create_texture(rx_to_data_path("images/waterdrop_background.png"));
glBindTexture(GL_TEXTURE_2D, background_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// fbo
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenTextures(1, &scene_normals_tex);
glBindTexture(GL_TEXTURE_2D, scene_normals_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, win_w, win_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, scene_normals_tex, 0);
glGenTextures(1, &scene_alpha_tex);
glBindTexture(GL_TEXTURE_2D, scene_alpha_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, win_w, win_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, scene_alpha_tex, 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("Framebuffer not complete.\n");
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return true;
}