void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { loading_done = true; prev_num_particles = 0; in_particlesystem = (vsx_module_param_particlesystem*)in_parameters.create(VSX_MODULE_PARAM_ID_PARTICLESYSTEM,"in_particlesystem"); color0 = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "color0"); color0->set(1.0f,0); color0->set(1.0f,1); color0->set(1.0f,2); color0->set(0.3f,3); color1 = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "color1"); color1->set(1.0f,0); color1->set(1.0f,1); color1->set(1.0f,2); color1->set(1.0f,3); // parameters for the effect friction = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "friction"); friction->set(1); step_length = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "step_length"); step_length->set(10); ribbon_width = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "ribbon_width"); ribbon_width->set(0.2f); length = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "length"); length->set(1.0f); render_result = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out"); render_result->set(0); }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { last_updated = -1.0f; loading_done = true; pos = (vsx_module_param_float3*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT3, "pos"); pos->set(0,0); pos->set(0,1); pos->set(0,2); color0 = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "color0"); color0->set(1.0f,0); color0->set(1.0f,1); color0->set(1.0f,2); color0->set(0.3f,3); color1 = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "color1"); color1->set(1.0f,0); color1->set(1.0f,1); color1->set(1.0f,2); color1->set(1.0f,3); // parameters for the effect friction = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "friction"); friction->set(1); step_length = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "step_length"); step_length->set(10); render_result = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out"); render_result->set(0); gr.init(); }
void output(vsx_module_param_abs* param) { VSX_UNUSED(param); particles = in_particlesystem->get_addr(); if (particles) { if (prev_num_particles != particles->particles->size()) { // remove all the old ones /*for (unsigned long i = 0; i < gr.size(); i++) { delete gr[i]; } gr.reset_used(0);*/ //printf("num particles: %d\n",particles->particles->size()); //printf("prev_num: %d\n",prev_num_particles); for (unsigned long i = prev_num_particles; i < particles->particles->size(); ++i) { //if (i == prev_num_particles) printf("allocating again\n"); gr[i] = new gravity_strip; //printf("i: %d\n",i); gr[i]->init(); gr[i]->init_strip(); } prev_num_particles = particles->particles->size(); } //printf("done alloc %d\n",particles->particles->size()); for (unsigned long i = 0; i < particles->particles->size(); ++i) { //gr[i].length = 0.0f; gr[i]->width = ribbon_width->get(); //gr[i].masses[1].mass = gr[i].masses[0].mass + ribbon_width->get(); gr[i]->length = length->get(); gr[i]->friction = friction->get(); float tt = ((*particles->particles)[i].time/(*particles->particles)[i].lifetime); if (tt < 0.0f) tt = 0.0f; if (tt > 1.0f) tt = 1.0f; gr[i]->color0[0] = color0->get(0)*tt; gr[i]->color0[1] = color0->get(1)*tt; gr[i]->color0[2] = color0->get(2)*tt; gr[i]->color0[3] = color0->get(3)*tt; gr[i]->color1[0] = color1->get(0); gr[i]->color1[1] = color1->get(1); gr[i]->color1[2] = color1->get(2); gr[i]->step_freq = 10.0f * step_length->get(); //if (last_update != engine->vtime) { gr[i]->update(engine->dtime, (*(particles->particles))[i].pos.x, (*(particles->particles))[i].pos.y, (*(particles->particles))[i].pos.z); //last_upd ate = engine->vtime; //} //printf("%f, %f, %f\n", (*particles->particles)[i].pos.x, (*particles->particles)[i].pos.y, (*particles->particles)[i].pos.z); gr[i]->render(); // printf("%d %d;;; %d\n",__LINE__,i, particles->particles->size()); // add the delta-time to the time of the particle /*(*particles->particles)[i].pos.x += px*engine->dtime; (*particles->particles)[i].pos.y += py*engine->dtime; (*particles->particles)[i].pos.z += pz*engine->dtime;*/ } //printf("done drawing\n"); } render_result->set(1); }
void run() { if (p_updates != param_updates) { p_updates = param_updates; if (directory_path->get() != "") { if (old_path != directory_path->get()) { old_path = directory_path->get(); std::list<vsx_string> files; //vsxfst tt; vsx_string engine_resources_base_path = engine->filesystem->get_base_path(); get_files_recursive(engine_resources_base_path + DIRECTORY_SEPARATOR + directory_path->get(), &files); files_list.reset_used(0); for (std::list<vsx_string>::iterator it = files.begin(); it != files.end(); ++it) { if ((*it).find(".svn/") == -1) { files_list.push_back( (*it).substr(engine_resources_base_path.size()+1)); } } } } if (files_list.size()) { filename_count->set((float)files_list.size()); unsigned long fid = (unsigned long)floor(file_id->get()); if (fid >= files_list.size()) fid = files_list.size()-1; filename_result->set(files_list[fid]); } } }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { mesh_in = (vsx_module_param_mesh*)in_parameters.create(VSX_MODULE_PARAM_ID_MESH,"mesh_in"); steps_per_second = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "steps_per_second"); step_size = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "step_size"); gas_amount = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "gas_amount"); gas_expansion_factor = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "gas_expansion_factor"); grid_stiffness_factor = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "grid_stiffness_factor"); damping_factor = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "damping_factor"); material_weight = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "material_weight"); lower_boundary = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "lower_boundary"); steps_per_second->set(100.0f); step_size->set(0.01f); gas_amount->set(1.0f); gas_expansion_factor->set(1.0f); grid_stiffness_factor->set(1.0f); damping_factor->set(0.98f); material_weight->set(0.00f); lower_boundary->set(-150.00f); loading_done = true; mesh_out = (vsx_module_param_mesh*)out_parameters.create(VSX_MODULE_PARAM_ID_MESH,"mesh_out"); mesh_out->set_p(mesh); volume_out = (vsx_module_param_float*)out_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"volume_out"); volume_out->set(0.0f); }
void setup_font() { if ( (cur_font != font_in->get()) || (cur_render_type !=render_type->get()) || (cur_glyph_size != glyph_size->get()) ) { vsx::file *fp; if ((fp = engine_state->filesystem->f_open(font_in->get().c_str())) == NULL) { printf("font not found: %s\n",cur_font.c_str()); return; } cur_font = font_in->get(); cur_render_type = render_type->get(); cur_glyph_size = glyph_size->get(); if (ftfont) { delete ftfont; ftfont = 0; } if (ftfont2) { delete ftfont2; ftfont2 = 0; } unsigned long size = engine_state->filesystem->f_get_size(fp); char* fdata = (char*)malloc(size); unsigned long bread = engine_state->filesystem->f_read((void*)fdata, size, fp); if (bread == size) { switch (cur_render_type) { case 0: ftfont = new FTGLTextureFont((unsigned char*)fdata, size); break; case 1: ftfont = new FTGLPolygonFont((unsigned char*)fdata, size); ftfont2 = new FTGLOutlineFont((unsigned char*)fdata, size); break; } ftfont->FaceSize((unsigned int)round(cur_glyph_size)); ftfont->CharMap(ft_encoding_unicode); if (ftfont2) { ftfont2->FaceSize((unsigned int)round(cur_glyph_size)); ftfont2->CharMap(ft_encoding_unicode); } loading_done = true; } engine_state->filesystem->f_close(fp); } }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { directory_path = (vsx_module_param_resource*)in_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE,"directory_path"); directory_path->set("resources"); filename_result = (vsx_module_param_resource*)out_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE,"filename_result"); filename_result->set(""); filename_count = (vsx_module_param_float*)out_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"filename_count"); filename_count->set(0.0f); file_id = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"file_id"); file_id->set(0.0f); p_updates = 0; loading_done = true; }
void map() { unsigned long new_pts = floor(abs(points->get())); if(pts != new_pts) { unsigned int res = 0; if(pts < new_pts || pts > 4 * new_pts) res = new_pts * 2; pts = new_pts; for(int i = 0; i < 7; i++) { map(i, res); } } else { for(int i = 0; i < 7; i++) { if(seqs[i]->updates) { seqs[i]->updates = 0; map(i); } } } }
void vsx_module_texture_rotate::run() { //printf("rotate_begin\n"); vsx_texture** texture_info_in = texture_info_param_in->get_addr(); //printf("validness: %d\n",texture_info_param_in->valid); // if (texture_info_in->valid) if (texture_info_in) { texture_out->valid = (*texture_info_in)->valid; // if (texture_info_in->texture_info) { texture_out->texture_info = (*texture_info_in)->texture_info; // } float x = rotation_axis->get(0); float y = rotation_axis->get(1); float z = rotation_axis->get(2); float a = rotation_angle->get()*360; vsx_transform_obj* prev_transform = (*texture_info_in)->get_transform(); transform.set_previous_transform(prev_transform); transform.update(a, x, y, z); // if (texture_out) texture_out->set_transform(&transform); ((vsx_module_param_texture*)texture_result)->set(texture_out); } else { //printf("fooble\n"); texture_result->valid = false; } }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { loading_done = true; float_in = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"shutdown"); float_in->set(0); render_out = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out"); //-------------------------------------------------------------------------------------------------- }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { grid_size = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"grid_size"); grid_size->set(20.0f); result = (vsx_module_param_mesh*)out_parameters.create(VSX_MODULE_PARAM_ID_MESH,"mesh"); loading_done = true; first_run = true; }
void output(vsx_module_param_abs* param) { vsx_texture** t_a; t_a = texture_a_in->get_addr(); vsx_texture** t_b; t_b = texture_b_in->get_addr(); if (t_a && t_b) { ((vsx_module_param_texture*)texture_a_out)->set(*t_a); ((vsx_module_param_texture*)texture_b_out)->set(*t_b); } if (fade_pos_from_engine->get() != 0.0f) { fade_pos_out->set(fade_pos_in->get()); } else { fade_pos_out->set((float)fmod(engine->real_vtime, 1.0f)); } }
void output(vsx_module_param_abs* param) { gr.friction = friction->get(); gr.color0[0] = color0->get(0); gr.color0[1] = color0->get(1); gr.color0[2] = color0->get(2); gr.color0[3] = color0->get(3); gr.color1[0] = color1->get(0); gr.color1[1] = color1->get(1); gr.color1[2] = color1->get(2); gr.step_freq = 10.0f * step_length->get(); if (last_updated != engine->vtime) { gr.update(engine->dtime, pos->get(0), pos->get(1), pos->get(2)); last_updated = engine->vtime; } gr.render(); render_result->set(1); }
// this is run for each connection to this in-param. void output(vsx_module_param_abs* param) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); // translation glTranslatef(position->get(0),position->get(1),position->get(2)); // rotation glRotatef( (float)angle->get()*360, rotation_axis->get(0), rotation_axis->get(1), rotation_axis->get(2) ); // scaling glScalef(size->get(0), size->get(1), size->get(2)); // color glColor4f( color_rgb->get(0), color_rgb->get(1), color_rgb->get(2), color_rgb->get(3) ); glBegin(GL_QUADS); glTexCoord2f(0.0f,0.0f); glVertex3f(-1.0f, -1.0f, 0.0f); glTexCoord2f(0.0f,1.0f); glVertex3f(-1.0f, 1.0f, 0.0f); glTexCoord2f(1.0f,1.0f); glVertex3f( 1.0f, 1.0f, 0.0f); glTexCoord2f(1.0f,0.0f); glVertex3f( 1.0f, -1.0f, 0.0f); glEnd(); if (border->get()) { glEnable(GL_LINE_SMOOTH); glLineWidth(1.5); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBegin(GL_LINE_STRIP); glColor3f(0, 0, 0); glVertex3f(-2, -0.4f, 0); glVertex3f(-2, -0.2f, 0); glVertex3f( 2, -0.2f, 0); glVertex3f( 2, -0.4f, 0); glVertex3f(-2, -0.4f, 0); glEnd(); } glPopMatrix(); render_result->set(1); loading_done = true; }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { seqs[0] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"x_sequence"); seqs[1] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"y_sequence"); seqs[2] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"z_sequence"); seqs[3] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"r_sequence"); seqs[4] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"g_sequence"); seqs[5] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"b_sequence"); seqs[6] = (vsx_module_param_sequence*)in_parameters.create(VSX_MODULE_PARAM_ID_SEQUENCE,"a_sequence"); for (int i = 0; i < 7; i++) seqs[i]->set(seq_int); points = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"points"); points->set(100.0f); line_width = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"line_width"); line_width->set(1.0f); render_out = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out"); }
// this method uses the engine's parameter holder to create data holders for // each of the parameters also binding them to their name (string) void declare_params( vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters ) { loading_done = true; position = (vsx_module_param_float3*)in_parameters.create( VSX_MODULE_PARAM_ID_FLOAT3, "position" ); position->set(0.0f, 0); position->set(0.0f, 1); position->set(0.0f, 2); size = (vsx_module_param_float3*)in_parameters.create( VSX_MODULE_PARAM_ID_FLOAT3, "size" ); size->set(1.0f,0); size->set(0.3f,1); angle = (vsx_module_param_float*)in_parameters.create( VSX_MODULE_PARAM_ID_FLOAT, "angle" ); angle->set(0.0f); border = (vsx_module_param_int*)in_parameters.create( VSX_MODULE_PARAM_ID_INT, "border" ); rotation_axis = (vsx_module_param_float3*)in_parameters.create( VSX_MODULE_PARAM_ID_FLOAT3, "rotation_axis" ); rotation_axis->set(1.0f, 0); rotation_axis->set(1.0f, 1); rotation_axis->set(0.0f, 2); color_rgb = (vsx_module_param_float4*)in_parameters.create( VSX_MODULE_PARAM_ID_FLOAT4, "color" ); color_rgb->set(1.0,0); color_rgb->set(1.0,1); color_rgb->set(1.0,2); color_rgb->set(1.0,3); render_result = (vsx_module_param_render*)out_parameters.create( VSX_MODULE_PARAM_ID_RENDER, "render_out" ); render_result->set(0); }
void output(vsx_module_param_abs* param) { map(); glLineWidth(line_width->get()); glBegin(GL_LINE_LOOP); for(unsigned long i = 0; i < pts; i++) { glColor4f(vals[3][i], vals[4][i], vals[5][i], vals[6][i]); glVertex3f(vals[0][i], vals[1][i], vals[2][i]); } glEnd(); render_out->set(1); loading_done = true; }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { loading_done = true; prev_num_vertices = 0; mesh_id_start = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "mesh_id_start"); mesh_id_start->set(0.0f); mesh_id_count = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "mesh_id_count"); mesh_id_count->set(0.0f); in_mesh = (vsx_module_param_mesh*)in_parameters.create(VSX_MODULE_PARAM_ID_MESH,"in_mesh"); upvector = (vsx_module_param_float3*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT3, "upvector"); upvector->set(0.0f); upvector->set(0.0f); upvector->set(1.0f); color0 = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "color0"); color0->set(1.0f,0); color0->set(1.0f,1); color0->set(1.0f,2); color0->set(0.3f,3); color1 = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "color1"); color1->set(1.0f,0); color1->set(1.0f,1); color1->set(1.0f,2); color1->set(1.0f,3); modelview_matrix = (vsx_module_param_matrix*)in_parameters.create(VSX_MODULE_PARAM_ID_MATRIX,"modelview_matrix"); // parameters for the effect friction = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "friction"); friction->set(1); step_length = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "step_length"); step_length->set(10); ribbon_width = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "ribbon_width"); ribbon_width->set(0.2f); length = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "length"); length->set(1.0f); reset_pos = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "reset_pos"); reset_pos->set(-1.0f); render_result = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out"); render_result->set(0); mesh_result = (vsx_module_param_mesh*)out_parameters.create(VSX_MODULE_PARAM_ID_MESH,"mesh_out"); }
void vsx_module_texture_rotate::declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { texture_info_param_in = (vsx_module_param_texture*)in_parameters.create(VSX_MODULE_PARAM_ID_TEXTURE, "texture_in"); // texture_info_param_in->set(new vsx_texture_info); loading_done = true; texture_out = new vsx_texture; rotation_axis = (vsx_module_param_float3*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT3, "rotation_axis"); rotation_axis->set(0, 0); rotation_axis->set(0, 1); rotation_axis->set(1, 2); rotation_angle = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "rotation_angle"); rotation_angle->set(0.0f); // out_parameter_type_id = VSX_PARAM_ID_TEXTURE; texture_result = (vsx_module_param_texture*)out_parameters.create(VSX_MODULE_PARAM_ID_TEXTURE,"texture_rotate_out"); // texture_result->set(new vsx_texture_info); }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { texture_a_in = (vsx_module_param_texture*)in_parameters.create(VSX_MODULE_PARAM_ID_TEXTURE, "texture_a_in"); texture_b_in = (vsx_module_param_texture*)in_parameters.create(VSX_MODULE_PARAM_ID_TEXTURE, "texture_b_in"); fade_pos_from_engine = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "fade_pos_from_engine"); fade_pos_in = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "fade_pos_in"); fade_pos_out = (vsx_module_param_float*)out_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "fade_pos_out"); fade_pos_out->set(0.0f); texture_a_out = (vsx_module_param_texture*)out_parameters.create(VSX_MODULE_PARAM_ID_TEXTURE, "texture_a_out"); texture_b_out = (vsx_module_param_texture*)out_parameters.create(VSX_MODULE_PARAM_ID_TEXTURE, "texture_b_out"); ab.bpp = 4; ab.bformat = GL_RGBA; ab.size_x = ab.size_y = 2; ab.data = new vsx_bitmap_32bt[4]; ((vsx_bitmap_32bt*)ab.data)[0] = 0xFFFF0000; ((vsx_bitmap_32bt*)ab.data)[1] = 0xFF000000; ((vsx_bitmap_32bt*)ab.data)[2] = 0xFF000000; ((vsx_bitmap_32bt*)ab.data)[3] = 0xFFFF0000; ab.valid = true; bb.bpp = 4; bb.bformat = GL_RGBA; bb.size_x = bb.size_y = 2; bb.data = new vsx_bitmap_32bt[4]; ((vsx_bitmap_32bt*)bb.data)[0] = 0xFF000000; ((vsx_bitmap_32bt*)bb.data)[1] = 0xFF0000FF; ((vsx_bitmap_32bt*)bb.data)[2] = 0xFF0000FF; ((vsx_bitmap_32bt*)bb.data)[3] = 0xFF000000; bb.valid = true; texture_a.locked = true; texture_a.init_opengl_texture(); texture_b.locked = true; texture_b.init_opengl_texture(); texture_a.upload_ram_bitmap(&ab,false); texture_b.upload_ram_bitmap(&bb,false); texture_a_out->set(&texture_a); texture_b_out->set(&texture_b); }
void run() { if (drive->get() == 0) current_frame = (int)(engine->vtime * get_frame_rate()); else current_frame = (int)(time->get() * get_frame_rate()); if (current_frame != previous_frame) { //printf("r-"); bitm.data=(long unsigned int*)get_frame_data(current_frame); bitm.timestamp++; previous_frame = current_frame; // printf("t-"); } if (bitm.valid && bitm_timestamp != bitm.timestamp) { bitm_timestamp = bitm.timestamp; result1->set(bitm); loading_done = true; } if (current_frame>num_frames) current_frame=0; }
void run() { int l_grid_size = (int)floor(grid_size->get()); if (i_grid_size != l_grid_size) { balls.SetGridSize(l_grid_size); i_grid_size = l_grid_size; } if (engine->dtime != 0.0f) { float dd = engine->dtime; if (dd < 0) dd = 0; vsx_timer timer; timer.start(); balls.Update(dd); //printf("update took: %f s\n", timer.dtime()); timer.start(); balls.Render(); //printf("render took: %f s\n", timer.dtime()); mesh->timestamp++; } result->set_p(mesh); }
void run() { if (prev_play == 0.0f && trig_play->get() > 0.0f) { engine->request_play = 1; } prev_play = trig_play->get(); if (prev_stop == 0.0f && trig_stop->get() > 0.0f) { engine->request_stop = 1; } prev_stop = trig_stop->get(); if (prev_rewind == 0.0f && trig_rewind->get() > 0.0f) { engine->request_rewind = 1; } prev_rewind = trig_rewind->get(); }
void run() { if (float_in->get() > 1.0) exit(0); render_out->set(1); }
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters) { declare_run = false; size = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "size"); size->set(1.0f); angle = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "angle"); angle->set(0.0f); text_in = (vsx_module_param_string*)in_parameters.create(VSX_MODULE_PARAM_ID_STRING, "text_in"); text_in->set("Vovoid VSX Ultra"); text_in->updates = 1; font_in = (vsx_module_param_resource*)in_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE, "font_in"); font_in->set("resources/fonts/pala.ttf"); cur_font = ""; limit_line = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "limit_line"); limit_line->set(-1.0f); leading = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "leading"); leading->set(1.0f); glyph_size = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "glyph_size"); glyph_size->set(24.0f); cur_glyph_size = 24.0f; render_type = (vsx_module_param_int*)in_parameters.create(VSX_MODULE_PARAM_ID_INT,"render_type"); render_type->set(0); align = (vsx_module_param_int*)in_parameters.create(VSX_MODULE_PARAM_ID_INT,"align"); align->set(0); cur_render_type = 0; ftfont = 0; ftfont2 = 0; rotation_axis = (vsx_module_param_float3*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT3, "rotation_axis"); rotation_axis->set(0.0f, 0); rotation_axis->set(1.0f, 1); rotation_axis->set(0.0f, 2); red = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "red"); red->set(1.0f); green = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "green"); green->set(1.0f); blue = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "blue"); blue->set(1.0f); text_alpha = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "text_alpha"); text_alpha->set(1.0); outline_alpha = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "outline_alpha"); outline_alpha->set(0.5); outline_thickness = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "outline_thickness"); outline_thickness->set(3.0); outline_color = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "outline_color"); outline_color->set(0.0f, 0); outline_color->set(0.0f, 1); outline_color->set(0.0f, 2); outline_color->set(0.0f, 3); render_result = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out"); render_result->set(0); declare_run = true; gl_state = vsx_gl_state::get(); }
void run() { vsx_mesh* p = mesh_in->get_addr(); if (!p) { mesh_empty.timestamp = (int)(engine->real_vtime*1000.0f); mesh_out->set_p(mesh_empty); prev_timestamp = 0xFFFFFFFF; return; } debug = false; bool newMeshLoaded = false; //after a mesh change clone the mesh if (p && (prev_timestamp != p->timestamp)) { prev_timestamp = p->timestamp; mesh.data->vertices.reset_used(0); mesh.data->vertex_normals.reset_used(0); mesh.data->vertex_tex_coords.reset_used(0); mesh.data->vertex_colors.reset_used(0); mesh.data->faces.reset_used(0); for (unsigned int i = 0; i < p->data->vertices.size(); i++) { mesh.data->vertices[i] = p->data->vertices[i] + v; verticesSpeed[i] = vsx_vector(0, 0, 0); } for (unsigned int i = 0; i < p->data->vertex_normals.size(); i++) mesh.data->vertex_normals[i] = p->data->vertex_normals[i]; for (unsigned int i = 0; i < p->data->vertex_tangents.size(); i++) mesh.data->vertex_tangents[i] = p->data->vertex_tangents[i]; for (unsigned int i = 0; i < p->data->vertex_tex_coords.size(); i++) mesh.data->vertex_tex_coords[i] = p->data->vertex_tex_coords[i]; for (unsigned int i = 0; i < p->data->vertex_colors.size(); i++) mesh.data->vertex_colors[i] = p->data->vertex_colors[i]; for (unsigned int i = 0; i < p->data->faces.size(); i++) mesh.data->faces[i] = p->data->faces[i]; //calc and store original face lengths faceLengths.reset_used(); vsx_vector normal; vsx_vector len; vsx_vector hypVec; for (unsigned int i = 0; i < p->data->faces.size(); i++) { vsx_face& f = mesh.data->faces[i]; vsx_vector& v0 = mesh.data->vertices[f.a]; vsx_vector& v1 = mesh.data->vertices[f.b]; vsx_vector& v2 = mesh.data->vertices[f.c]; //calc face area normal.assign_face_normal(&v0, &v1, &v2); float area = normal.length() / 2.0f; faceAreas[i] = area; //facelengths a, b, c stored in vector x, y, z len.x = (v1 - v0).length(); len.y = (v2 - v1).length(); len.z = (v0 - v2).length(); faceLengths.push_back(len); } mesh.timestamp++; param_updates = 0; newMeshLoaded = true; dtimeRest = 0.0f; } float stepSize = step_size->get(); //float stepsPerSecond = steps_per_second->get(); float gasExpansionFactor = gas_expansion_factor->get(); float gridStiffnessFactor = grid_stiffness_factor->get(); float dampingFactor = damping_factor->get(); float materialWeight = material_weight->get(); float lowerBoundary = lower_boundary->get(); //use engine->dtime; and dtimeRest //to repeat the calculation several times ((dtime + rest) * stepsPerSecond) //calculate volume float volume = 0.0f; vsx_face* face_p = mesh.data->faces.get_pointer(); vsx_vector* vertex_p = mesh.data->vertices.get_pointer(); vsx_vector* faces_length_p = faceLengths.get_pointer(); verticesSpeed.allocate(mesh.data->vertices.size()); vsx_vector* vertices_speed_p = verticesSpeed.get_pointer(); float onedivsix = (1.0f / 6.0f); for(unsigned int i = 0; i < mesh.data->faces.size(); i++) { vsx_face& f = face_p[i];//mesh.data->faces[i]; vsx_vector& v0 = vertex_p[f.a]; vsx_vector& v2 = vertex_p[f.b]; vsx_vector& v1 = vertex_p[f.c]; volume += (v0.x * (v1.y - v2.y) + v1.x * (v2.y - v0.y) + v2.x * (v0.y - v1.y)) * (v0.z + v1.z + v2.z) * onedivsix; } //default gas_amount to volume of a new mesh i.e. no pressure if(newMeshLoaded) { gas_amount->set(volume); } float pressure = (gas_amount->get() - volume) / volume; //mesh.data->face_normals.reset_used(0); //mesh.data->vertex_normals.reset_used(0); //calculate face areas, normals, forces and add to speed for(unsigned int i = 0; i < mesh.data->faces.size(); i++) { vsx_face& f = face_p[i];//mesh.data->faces[i]; vsx_vector& v0 = vertex_p[f.a];//mesh.data->vertices[f.a]; vsx_vector& v1 = vertex_p[f.b];//mesh.data->vertices[f.b]; vsx_vector& v2 = vertex_p[f.c];//mesh.data->vertices[f.c]; printVector("v0", i, v0); printVector("v1", i, v1); printVector("v2", i, v2); //vsx_vector normal = mesh.data->get_face_normal(i); vsx_vector a = vertex_p[face_p[i].b] - vertex_p[face_p[i].a]; vsx_vector b = vertex_p[face_p[i].c] - vertex_p[face_p[i].a]; vsx_vector normal; normal.cross(a,b); printVector("normal", i, normal); //float len = normal.length(); //float area = len / 2; printFloat("length", i, len); printFloat("area", i, len); vsx_vector edgeA = (v1 - v0); vsx_vector edgeB = (v2 - v1); vsx_vector edgeC = (v0 - v2); printVector("edgeA", i, edgeA); printVector("edgeB", i, edgeB); printVector("edgeC", i, edgeC); float lenA = edgeA.length(); float lenB = edgeB.length(); float lenC = edgeC.length(); printFloat("lenA", i, lenA); printFloat("lenB", i, lenB); printFloat("lenC", i, lenC); float edgeForceA = (faces_length_p[i].x - lenA) / faces_length_p[i].x; float edgeForceB = (faces_length_p[i].y - lenB) / faces_length_p[i].y; float edgeForceC = (faces_length_p[i].z - lenC) / faces_length_p[i].z; printFloat("edgeForceA", i, edgeForceA); printFloat("edgeForceB", i, edgeForceB); printFloat("edgeForceC", i, edgeForceC); float edgeAccA = edgeForceA / lenA; float edgeAccB = edgeForceB / lenB; float edgeAccC = edgeForceC / lenC; printFloat("edgeAccA", i, edgeAccA); printFloat("edgeAccB", i, edgeAccB); printFloat("edgeAccC", i, edgeAccC); vsx_vector accA = edgeA * edgeAccA; vsx_vector accB = edgeB * edgeAccB; vsx_vector accC = edgeC * edgeAccC; printVector("accA", i, accA); printVector("accB", i, accB); printVector("accC", i, accC); vertices_speed_p[f.a] -= (accA - accC) * gridStiffnessFactor; vertices_speed_p[f.b] -= (accB - accA) * gridStiffnessFactor; vertices_speed_p[f.c] -= (accC - accB) * gridStiffnessFactor; //applying pressure to areas of faces vsx_vector pressureAcc = normal * pressure * gasExpansionFactor; vertices_speed_p[f.a] -= pressureAcc; vertices_speed_p[f.b] -= pressureAcc; vertices_speed_p[f.c] -= pressureAcc; //apply material weight float gravityAcc = materialWeight; vertices_speed_p[f.a].y -= gravityAcc; vertices_speed_p[f.b].y -= gravityAcc; vertices_speed_p[f.c].y -= gravityAcc; } //apply speeds to vertices for(unsigned int i = 0; i < mesh.data->vertices.size(); i++) { vertex_p[i] += vertices_speed_p[i] * stepSize; if(vertex_p[i].y < lowerBoundary) { vertex_p[i].y = lowerBoundary; } vertices_speed_p[i] = vertices_speed_p[i] * dampingFactor; } mesh.data->vertex_normals.allocate(mesh.data->vertices.size()); mesh.data->vertex_normals.memory_clear(); vsx_vector* vertex_normals_p = mesh.data->vertex_normals.get_pointer(); /*for(unsigned int i = 0; i < mesh.data->vertices.size(); i++) { mesh.data->vertex_normals[i] = vsx_vector(0, 0, 0); }*/ //TODO: create vertex normals, for rendering... should be a separate module... for(unsigned int i = 0; i < mesh.data->faces.size(); i++) { vsx_vector a = vertex_p[face_p[i].b] - vertex_p[face_p[i].a]; vsx_vector b = vertex_p[face_p[i].c] - vertex_p[face_p[i].a]; vsx_vector normal; normal.cross(a,b); //vsx_vector normal = mesh.data->get_face_normal(i); normal = -normal; normal.normalize(); vertex_normals_p[face_p[i].a] += normal; vertex_normals_p[face_p[i].b] += normal; vertex_normals_p[face_p[i].c] += normal; } volume_out->set(volume); //printf("***************Pressure %f ", pressure); //printf(" Volume %f\n", volume); mesh_out->set_p(mesh); }
void output(vsx_module_param_abs* param) { VSX_UNUSED(param); if (text_in->updates) { if (process_lines()) text_in->updates = 0; } if (text_alpha->get() <= 0) return; if (!ftfont) { user_message = "module||error loading font "+cur_font; return; } if (text_in->get() == "_") return; float obj_size = size->get(); gl_state->matrix_mode (VSX_GL_MODELVIEW_MATRIX ); gl_state->matrix_push(); gl_state->matrix_rotate_f( (float)angle->get()*360, rotation_axis->get(0), rotation_axis->get(1), rotation_axis->get(2) ); if (obj_size < 0) obj_size = 0; gl_state->matrix_scale_f( obj_size*0.8*0.01, obj_size*0.01, obj_size*0.01 ); int l_align = align->get(); float l_leading = leading->get(); float ypos = 0; if (cur_render_type == 0) glEnable(GL_TEXTURE_2D); glColor4f(red->get(),green->get(),blue->get(),text_alpha->get()); for (unsigned long i = 0; i < lines.size(); ++i) { float ll = limit_line->get(); if (ll != -1.0f) { if (trunc(ll) != i) continue; } gl_state->matrix_push(); if (l_align == 0) { gl_state->matrix_translate_f( 0, ypos, 0 ); } else if (l_align == 1) { gl_state->matrix_translate_f( -lines[i].size_x*0.5f,ypos,0 ); } if (l_align == 2) { gl_state->matrix_translate_f( -lines[i].size_x,ypos,0 ); } if (cur_render_type == 1) { if (outline_alpha->get() > 0.0f && ftfont2) { float pre_linew; pre_linew = gl_state->line_width_get(); gl_state->line_width_set( outline_thickness->get() ); glColor4f(outline_color->get(0),outline_color->get(1),outline_color->get(2),outline_alpha->get()*outline_color->get(3)); ftfont2->Render(lines[i].string.c_str()); gl_state->line_width_set( pre_linew ); } glColor4f(red->get(),green->get(),blue->get(),text_alpha->get()); } ftfont->Render(lines[i].string.c_str()); gl_state->matrix_pop(); ypos += l_leading; } if (cur_render_type == 0) glDisable(GL_TEXTURE_2D); gl_state->matrix_pop(); render_result->set(1); loading_done = true; }
void output(vsx_module_param_abs* param) { mesh = in_mesh->get_addr(); if (mesh && (*mesh)->data->vertices.size()) { if (prev_num_vertices != (unsigned long)mesh_id_count->get()) { // remove all the old ones for (unsigned long i = prev_num_vertices; i < (unsigned long)mesh_id_count->get(); ++i) { //printf("allocating %d\n", i); //if (i == prev_num_vertices) //printf("allocating again\n"); gr[i] = new gravity_strip; gr[i]->init(); gr[i]->init_strip(); } prev_num_vertices = (int)mesh_id_count->get(); } //printf("mesh_id_start: %d\n", (int)mesh_id_start->get()); size_t mesh_index = (size_t)mesh_id_start->get() % (*mesh)->data->vertices.size(); vsx_matrix* matrix_result = modelview_matrix->get_addr(); if (!matrix_result) { matrix_result = &modelview_matrix_no_connection; glGetFloatv(GL_MODELVIEW_MATRIX, modelview_matrix_no_connection.m); } //printf("in-mesh vertex count: %d\n", mesh->data->vertices.size()); if (param == render_result) { for (unsigned long i = 0; i < prev_num_vertices; ++i) { //gr[i].length = 0.0f; gr[i]->width = ribbon_width->get(); //gr[i].masses[1].mass = gr[i].masses[0].mass + ribbon_width->get(); gr[i]->length = length->get(); gr[i]->friction = friction->get(); //float tt = ((*particles->particles)[i].time/(*particles->particles)[i].lifetime); //if (tt < 0.0f) tt = 0.0f; //if (tt > 1.0f) tt = 1.0f; gr[i]->color0[0] = color0->get(0); gr[i]->color0[1] = color0->get(1); gr[i]->color0[2] = color0->get(2); gr[i]->color0[3] = color0->get(3); gr[i]->color1[0] = color1->get(0); gr[i]->color1[1] = color1->get(1); gr[i]->color1[2] = color1->get(2); gr[i]->step_freq = 10.0f * step_length->get(); //if (last_update != engine->vtime) { if (reset_pos->get() > 0.0f) { gr[i]->reset_pos( (*mesh)->data->vertices[mesh_index].x, (*mesh)->data->vertices[mesh_index].y, (*mesh)->data->vertices[mesh_index].z ); } else { gr[i]->update( engine->dtime, (*mesh)->data->vertices[mesh_index].x, (*mesh)->data->vertices[mesh_index].y, (*mesh)->data->vertices[mesh_index].z ); } gr[i]->render(); //(*(particles->particles))[i].pos.x, (*(particles->particles))[i].pos.y, (*(particles->particles))[i].pos.z); //last_upd ate = engine->vtime; //} //printf("%f, %f, %f\n", (*particles->particles)[i].pos.x, (*particles->particles)[i].pos.y, (*particles->particles)[i].pos.z); // printf("%d %d;;; %d\n",__LINE__,i, particles->particles->size()); // add the delta-time to the time of the particle /*(*particles->particles)[i].pos.x += px*engine->dtime; (*particles->particles)[i].pos.y += py*engine->dtime; (*particles->particles)[i].pos.z += pz*engine->dtime;*/ mesh_index++; mesh_index = mesh_index % (*mesh)->data->vertices.size(); } } else { float ilength = length->get(); if (ilength > 1.0f) ilength = 1.0f; if (ilength < 0.01f) ilength = 0.01f; int num2 = BUFF_LEN * (int)(ilength * 8.0f * (float)prev_num_vertices); //printf("num2: %d\n", num2); // allocate mesh memory for all parts mesh_out->data->faces.allocate(num2); mesh_out->data->vertices.allocate(num2); mesh_out->data->vertex_normals.allocate(num2); mesh_out->data->vertex_tex_coords.allocate(num2); //printf("mesh: %d\n", __LINE__); mesh_out->data->faces.reset_used(num2); mesh_out->data->vertices.reset_used(num2); mesh_out->data->vertex_normals.reset_used(num2); mesh_out->data->vertex_tex_coords.reset_used(num2); //printf("mesh: %d\n", __LINE__); vsx_face* fs_d = mesh_out->data->faces.get_pointer(); vsx_vector* vs_d = mesh_out->data->vertices.get_pointer(); vsx_vector* ns_d = mesh_out->data->vertex_normals.get_pointer(); vsx_tex_coord* ts_d = mesh_out->data->vertex_tex_coords.get_pointer(); int generated_vertices = 0; int generated_faces = 0; //printf("mesh: %d\n", __LINE__); generated_faces = 0; generated_vertices = 0; generated_vertices = 0; generated_vertices = 0; vsx_vector upv; upv.x = upvector->get(0); upv.y = upvector->get(1); upv.z = upvector->get(2); for (unsigned long i = 0; i < prev_num_vertices; ++i) { gr[i]->width = ribbon_width->get(); gr[i]->length = length->get(); gr[i]->friction = friction->get(); gr[i]->color0[0] = color0->get(0); gr[i]->color0[1] = color0->get(1); gr[i]->color0[2] = color0->get(2); gr[i]->color0[3] = color0->get(3); gr[i]->color1[0] = color1->get(0); gr[i]->color1[1] = color1->get(1); gr[i]->color1[2] = color1->get(2); gr[i]->step_freq = 10.0f * step_length->get(); //printf("mesh: %d %d\n", __LINE__, mesh_index); if (reset_pos->get() > 0.0f) { gr[i]->reset_pos( (*mesh)->data->vertices[mesh_index].x, (*mesh)->data->vertices[mesh_index].y, (*mesh)->data->vertices[mesh_index].z ); } else { gr[i]->update( engine->dtime, (*mesh)->data->vertices[mesh_index].x, (*mesh)->data->vertices[mesh_index].y, (*mesh)->data->vertices[mesh_index].z ); } //printf("%d\n", (int)i); gr[i]->generate_mesh(*mesh_out,fs_d, vs_d, ns_d, ts_d, matrix_result, &upv, generated_vertices, generated_faces); mesh_index++; mesh_index = mesh_index % (*mesh)->data->vertices.size(); } // printf("generated faces: %d\n", generated_faces); //printf("generated vertices: %d\n", generated_vertices); mesh_out->data->faces.reset_used(generated_faces); mesh_out->data->vertices.reset_used(generated_vertices); mesh_out->data->vertex_normals.reset_used(generated_vertices); mesh_out->data->vertex_tex_coords.reset_used(generated_vertices); //printf("mesh: %d\n", __LINE__); mesh_result->set_p(mesh_out); } //printf("done drawing\n"); } render_result->set(1); }