GeometryTransitPtr createPathGeometry(const std::vector<Pnt3f>& Path) { //*******************Create the Geometry for the box GeoUInt8PropertyRecPtr type = GeoUInt8Property::create(); //Volume bound box type->push_back(GL_LINE_STRIP); GeoUInt32PropertyRefPtr lens = GeoUInt32Property::create(); //Volume bound box lens->push_back(Path.size()); Color3f CoolColor(0.0f,0.0f,1.0f), HotColor(1.0f,0.0f,0.0f); GeoUInt32PropertyRefPtr index = GeoUInt32Property::create(); GeoPnt3fPropertyRefPtr points = GeoPnt3fProperty::create(); GeoVec3fPropertyRefPtr colors = GeoVec3fProperty::create(); //Volume bound box Color3f Color; Real32 t; for(UInt32 i(0) ; i<Path.size() ; ++i) { t = static_cast<Real32>(i)/static_cast<Real32>(Path.size()); Color = (t*CoolColor) + ((1.0f-t)*HotColor); index->push_back(i); points->push_back(Path[i]); colors->push_back(Color); } GeometryRecPtr PathGeo = Geometry::create(); PathGeo->setTypes (type); PathGeo->setLengths (lens); PathGeo->setIndices (index); PathGeo->setPositions (points); PathGeo->setColors (colors); //Create the material for the line LineChunkRecPtr DefaultLineChunk = LineChunk::create(); DefaultLineChunk->setWidth(2.0f); MaterialChunkRecPtr DefaultMaterialChunk = MaterialChunk::create(); DefaultMaterialChunk->setLit(false); ChunkMaterialRecPtr DefaultChunkMaterial = ChunkMaterial::create(); DefaultChunkMaterial->addChunk(DefaultMaterialChunk); DefaultChunkMaterial->addChunk(DefaultLineChunk); PathGeo->setMaterial(DefaultChunkMaterial); return GeometryTransitPtr(PathGeo); }
int main(int argc, char* argv[]) { // Check arguments if (argc < 3) { std::cerr << "Usage: shallow_water NODES_FILE TRIS_FILE\n"; exit(1); } MeshType mesh; // HW4B: Need node_type before this can be used! #if 1 std::vector<typename MeshType::node_type> mesh_node; #endif // Read all Points and add them to the Mesh std::ifstream nodes_file(argv[1]); Point p; while (CS207::getline_parsed(nodes_file, p)) { // HW4B: Need to implement add_node before this can be used! #if 1 mesh_node.push_back(mesh.add_node(p)); #endif } // Read all mesh triangles and add them to the Mesh std::ifstream tris_file(argv[2]); std::array<int,3> t; while (CS207::getline_parsed(tris_file, t)) { // HW4B: Need to implement add_triangle before this can be used! #if 1 mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]); #endif } // Print out the stats std::cout << mesh.num_nodes() << " " << mesh.num_edges() << " " << mesh.num_triangles() << std::endl; // HW4B Initialization // Set the initial conditions based off third argument // Perform any needed precomputation std::pair<double, double> value_pair; if ((*argv[3]) == '0') { std::cout << "Pebble Ripple" << std::endl; value_pair = PebbleRipple()(mesh); } else if ((*argv[3]) == '1') { std::cout << "Sharp Wave" << std::endl; value_pair = SharpWave()(mesh); } else { std::cout << "Dam Break" << std::endl; value_pair = DamBreak()(mesh); } double max_height = value_pair.first; double min_edge_length = value_pair.second; // Launch the SDLViewer CS207::SDLViewer viewer; viewer.launch(); // HW4B: Need to define Mesh::node_type and node/edge iterator // before these can be used! #if 1 auto node_map = viewer.empty_node_map(mesh); viewer.add_nodes(mesh.node_begin(), mesh.node_end(), CS207::DefaultColor(), NodePosition(), node_map); viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map); #endif viewer.center_view(); // CFL stability condition requires dt <= dx / max|velocity| // For the shallow water equations with u = v = 0 initial conditions // we can compute the minimum edge length and maximum original water height // to set the time-step // Compute the minimum edge length and maximum water height for computing dt #if 1 double dt = 0.25 * min_edge_length / (sqrt(grav * max_height)); #else // Placeholder!! Delete me when min_edge_length and max_height can be computed! double dt = 0.1; #endif double t_start = 0; double t_end = 5; // Preconstruct a Flux functor EdgeFluxCalculator f; // Begin the time stepping for (double t = t_start; t < t_end; t += dt) { // Step forward in time with forward Euler hyperbolic_step(mesh, f, t, dt); // Update node values with triangle-averaged values post_process(mesh); // Update the viewer with new node positions #if 1 // Update viewer with nodes' new positions viewer.add_nodes(mesh.node_begin(), mesh.node_end(), CoolColor(), NodePosition(), node_map); #endif viewer.set_label(t); // These lines slow down the animation for small meshes. // Feel free to remove them or tweak the constants. if (mesh.num_nodes() < 100) CS207::sleep(0.05); } return 0; }