bool validate() const { std::string expected_wkt("Polygon((181 286.666667,233 454,315 340,421 446,463 324,559 466,631 321.320755,631 234.386861,528 178,394 229,329 138,212 134,183 228,200 264,181 238.244444,181 286.666667),(313 190,440 256,470 248,510 305,533 237,613 263,553 397,455 262,405 378,343 287,249 334,229 191,313 190))"); boost::ptr_vector<mapnik::geometry_type> paths; if (!mapnik::from_wkt(wkt_in_, paths)) { throw std::runtime_error("Failed to parse WKT"); } if (paths.size() != 1) { std::clog << "paths.size() != 1\n"; return false; } mapnik::geometry_type const& geom = paths[0]; mapnik::vertex_adapter va(geom); poly_clipper clipped(extent_, va); unsigned cmd; double x,y; mapnik::geometry_type geom2(mapnik::geometry_type::types::Polygon); while ((cmd = clipped.vertex(&x, &y)) != mapnik::SEG_END) { geom2.push_vertex(x,y,(mapnik::CommandType)cmd); } std::string expect = expected_+".png"; std::string actual = expected_+"_actual.png"; auto env = mapnik::envelope(geom); if (!mapnik::util::exists(expect) || (std::getenv("UPDATE") != nullptr)) { std::clog << "generating expected image: " << expect << "\n"; render(geom2,env,expect); } render(geom2,env,actual); return benchmark::compare_images(actual,expect); }
bool validate() const { mapnik::geometry::geometry<double> geom; if (!mapnik::from_wkt(wkt_in_, geom)) { throw std::runtime_error("Failed to parse WKT"); } if (mapnik::geometry::is_empty(geom)) { std::clog << "empty geom!\n"; return false; } if (!geom.is<mapnik::geometry::polygon<double> >()) { std::clog << "not a polygon!\n"; return false; } mapnik::geometry::polygon<double> & poly = mapnik::util::get<mapnik::geometry::polygon<double> >(geom); mapnik::geometry::correct(poly); mapnik::geometry::linear_ring<double> bbox; bbox.emplace_back(extent_.minx(), extent_.miny()); bbox.emplace_back(extent_.minx(), extent_.maxy()); bbox.emplace_back(extent_.maxx(), extent_.maxy()); bbox.emplace_back(extent_.maxx(), extent_.miny()); bbox.emplace_back(extent_.minx(), extent_.miny()); std::deque<mapnik::geometry::polygon<double> > result; boost::geometry::intersection(bbox, poly, result); std::string expect = expected_+".png"; std::string actual = expected_+"_actual.png"; mapnik::geometry::multi_polygon<double> mp; for (auto const& _geom: result) { //std::clog << boost::geometry::dsv(geom) << "\n"; mp.emplace_back(_geom); } mapnik::geometry::geometry<double> geom2(mp); auto env = mapnik::geometry::envelope(geom2); if (!mapnik::util::exists(expect) || (std::getenv("UPDATE") != nullptr)) { std::clog << "generating expected image: " << expect << "\n"; render(mp,env,expect); } render(mp,env,actual); return benchmark::compare_images(actual,expect); }
bool validate() const { std::string expected_wkt("Polygon((212 134,329 138,394 229,528 178,631 234.4,631 321.3,559 466,463 324,421 446,315 340,233 454,181 286.7,181 238.2,200 264,183 228),(313 190,229 191,249 334,343 287,405 378,455 262,553 397,613 263,533 237,510 305,470 248,440 256))"); boost::ptr_vector<mapnik::geometry_type> paths; if (!mapnik::from_wkt(wkt_in_, paths)) { throw std::runtime_error("Failed to parse WKT"); } agg::path_storage ps; ps.move_to(extent_.minx(), extent_.miny()); ps.line_to(extent_.minx(), extent_.maxy()); ps.line_to(extent_.maxx(), extent_.maxy()); ps.line_to(extent_.maxx(), extent_.miny()); ps.close_polygon(); if (paths.size() != 1) { std::clog << "paths.size() != 1\n"; return false; } mapnik::geometry_type const& geom = paths[0]; mapnik::vertex_adapter va(geom); poly_clipper clipped(va,ps, agg::clipper_and, agg::clipper_non_zero, agg::clipper_non_zero, 1); clipped.rewind(0); unsigned cmd; double x,y; mapnik::geometry_type geom2(mapnik::geometry_type::types::Polygon); while ((cmd = clipped.vertex(&x, &y)) != mapnik::SEG_END) { geom2.push_vertex(x,y,(mapnik::CommandType)cmd); } std::string expect = expected_+".png"; std::string actual = expected_+"_actual.png"; auto env = mapnik::envelope(geom); if (!mapnik::util::exists(expect) || (std::getenv("UPDATE") != nullptr)) { std::clog << "generating expected image: " << expect << "\n"; render(geom2,env,expect); } render(geom2,env,actual); return benchmark::compare_images(actual,expect); }
Water::Water(osg::Group *parent, osg::Group* sceneRoot, Resource::ResourceSystem *resourceSystem, osgUtil::IncrementalCompileOperation *ico, const Fallback::Map* fallback, const std::string& resourcePath) : mParent(parent) , mSceneRoot(sceneRoot) , mResourceSystem(resourceSystem) , mFallback(fallback) , mResourcePath(resourcePath) , mEnabled(true) , mToggled(true) , mTop(0) { mSimulation.reset(new RippleSimulation(parent, resourceSystem, fallback)); mWaterGeom = SceneUtil::createWaterGeometry(CELL_SIZE*150, 40, 900); mWaterGeom->setDrawCallback(new DepthClampCallback); mWaterGeom->setNodeMask(Mask_Water); if (ico) ico->add(mWaterGeom); mWaterNode = new osg::PositionAttitudeTransform; mWaterNode->setName("Water Root"); mWaterNode->addChild(mWaterGeom); mWaterNode->addCullCallback(new FudgeCallback); // simple water fallback for the local map osg::ref_ptr<osg::Geometry> geom2 (osg::clone(mWaterGeom.get(), osg::CopyOp::DEEP_COPY_NODES)); createSimpleWaterStateSet(geom2, mFallback->getFallbackFloat("Water_Map_Alpha")); geom2->setNodeMask(Mask_SimpleWater); mWaterNode->addChild(geom2); mSceneRoot->addChild(mWaterNode); setHeight(mTop); mRainIntensityUniform = new osg::Uniform("rainIntensity",(float) 0.0); updateWaterMaterial(); }
Raytracer::Raytracer(): texture(0) { prepareTargetBuffer(128,128); std::shared_ptr<Clump3d> clump(new Clump3d); // // Cube // std::shared_ptr<MeshGeometry3d> geom1(new MeshGeometry3d()); cube(geom1->getMesh()); geom1->meshChanged(); geom1->setColor(GAL::P4d(1.0, 0.0, 0.0, 1.0)); std::shared_ptr<MeshGeometry3d> geom5(new MeshGeometry3d()); cube(geom5->getMesh()); geom5->meshChanged(); geom5->setColor(GAL::P4d(0.0, 0.7, 1.0, 1.0)); // // Manifold // std::shared_ptr<MeshGeometry<Vertex3d> > geom3(new MeshGeometry<Vertex3d>()); manifold(geom3->getMesh()); geom3->meshChanged(); geom3->setColor(GAL::P4d(1.0, 1.0, 0.0, 1.0)); // // Sphere // std::shared_ptr<SphereGeometry3d> geom2(new SphereGeometry3d(0.5)); geom2->setColor(GAL::P4d(0.0, 1.0, 1.0, 1.0)); std::shared_ptr<SphereGeometry3d> geom4(new SphereGeometry3d(0.25)); geom4->setColor(GAL::P4d(1.0, 0.8, 0.0, 1.0)); clump->addGeometry(geom1); clump->addGeometry(geom2); clump->addGeometry(geom3); clump->addGeometry(geom4); clump->addGeometry(geom5); geom1->setTranslation(GAL::P3d(-1,-1,0)); geom2->setTranslation(GAL::P3d(0,1,0)); geom3->setTranslation(GAL::P3d(1,0.5,0)); geom3->setLocalTransform(GAL::EulerRotationX(90.0), 0); geom4->setTranslation(GAL::P3d(1.2,1,0.8)); geom5->setTranslation(GAL::P3d(0,1,-3)); geom5->setLocalTransform(GAL::EulerRotationY(10.0), 0); scene.addClump(clump); std::shared_ptr<Light3d> light1(new Light3d()); light1->setPosition(GAL::P3d(1,4,-1)); light1->setDiffuseColor(GAL::P3d(0.7, 0.7, 0.7)); light1->setSpecularColor(GAL::P3d(1.0, 1.0, 1.0)); light1->setShadow(true); light1->setSoftShadowWidth(0.05); scene.addLight(light1); std::shared_ptr<Light3d> light2(new Light3d()); light2->setPosition(GAL::P3d(-1,4,3)); light2->setDiffuseColor(GAL::P3d(0.7, 0.7, 0.7)); light2->setSpecularColor(GAL::P3d(1.0, 1.0, 1.0)); light2->setShadow(true); light2->setSoftShadowWidth(0.05); scene.addLight(light2); camera.setFrustum(-1, 1, -1, 1, -1, -100); camera.setTranslation(GAL::P3d(1,2,3)); camera.setLocalTransform(GAL::EulerRotationX(30.0) * GAL::EulerRotationY(15.0), 0); camera.setFSAA(true); camera.setRecursionDepth(3); }
void Gizmo::renderTranslateGizmo(PipelineInstance& pipeline) { if (!m_shader->isReady()) return; Matrix scale_mtx = Matrix::IDENTITY; scale_mtx.m11 = scale_mtx.m22 = scale_mtx.m33 = m_scale; Matrix gizmo_mtx; getMatrix(gizmo_mtx); Matrix mtx = gizmo_mtx * scale_mtx; Vertex vertices[9]; uint16 indices[9]; vertices[0].position = Vec3(0, 0, 0); vertices[0].color = m_transform_axis == Axis::X ? SELECTED_COLOR : X_COLOR; indices[0] = 0; vertices[1].position = Vec3(1, 0, 0); vertices[1].color = m_transform_axis == Axis::X ? SELECTED_COLOR : X_COLOR; indices[1] = 1; vertices[2].position = Vec3(0, 0, 0); vertices[2].color = m_transform_axis == Axis::Y ? SELECTED_COLOR : Y_COLOR; indices[2] = 2; vertices[3].position = Vec3(0, 1, 0); vertices[3].color = m_transform_axis == Axis::Y ? SELECTED_COLOR : Y_COLOR; indices[3] = 3; vertices[4].position = Vec3(0, 0, 0); vertices[4].color = m_transform_axis == Axis::Z ? SELECTED_COLOR : Z_COLOR; indices[4] = 4; vertices[5].position = Vec3(0, 0, 1); vertices[5].color = m_transform_axis == Axis::Z ? SELECTED_COLOR : Z_COLOR; indices[5] = 5; Lumix::TransientGeometry geom(vertices, 6, m_vertex_decl, indices, 6); pipeline.render(geom, mtx, 0, 6, BGFX_STATE_PT_LINES | BGFX_STATE_DEPTH_TEST_LEQUAL, m_shader->getInstance(0).m_program_handles[pipeline.getPassIdx()]); if (dotProduct(gizmo_mtx.getXVector(), m_camera_dir) < 0) mtx.setXVector(-mtx.getXVector()); if (dotProduct(gizmo_mtx.getYVector(), m_camera_dir) < 0) mtx.setYVector(-mtx.getYVector()); if (dotProduct(gizmo_mtx.getZVector(), m_camera_dir) < 0) mtx.setZVector(-mtx.getZVector()); vertices[0].position = Vec3(0, 0, 0); vertices[0].color = m_transform_axis == Axis::XY ? SELECTED_COLOR : Z_COLOR; indices[0] = 0; vertices[1].position = Vec3(0.5f, 0, 0); vertices[1].color = m_transform_axis == Axis::XY ? SELECTED_COLOR : Z_COLOR; indices[1] = 1; vertices[2].position = Vec3(0, 0.5f, 0); vertices[2].color = m_transform_axis == Axis::XY ? SELECTED_COLOR : Z_COLOR; indices[2] = 2; vertices[3].position = Vec3(0, 0, 0); vertices[3].color = m_transform_axis == Axis::YZ ? SELECTED_COLOR : X_COLOR; indices[3] = 3; vertices[4].position = Vec3(0, 0.5f, 0); vertices[4].color = m_transform_axis == Axis::YZ ? SELECTED_COLOR : X_COLOR; indices[4] = 4; vertices[5].position = Vec3(0, 0, 0.5f); vertices[5].color = m_transform_axis == Axis::YZ ? SELECTED_COLOR : X_COLOR; indices[5] = 5; vertices[6].position = Vec3(0, 0, 0); vertices[6].color = m_transform_axis == Axis::XZ ? SELECTED_COLOR : Y_COLOR; indices[6] = 6; vertices[7].position = Vec3(0.5f, 0, 0); vertices[7].color = m_transform_axis == Axis::XZ ? SELECTED_COLOR : Y_COLOR; indices[7] = 7; vertices[8].position = Vec3(0, 0, 0.5f); vertices[8].color = m_transform_axis == Axis::XZ ? SELECTED_COLOR : Y_COLOR; indices[8] = 8; Lumix::TransientGeometry geom2(vertices, 9, m_vertex_decl, indices, 9); auto program_handle = m_shader->getInstance(0).m_program_handles[pipeline.getPassIdx()]; pipeline.render(geom2, mtx, 0, 9, BGFX_STATE_DEPTH_TEST_LEQUAL, program_handle); }
bool validate() const { mapnik::geometry::geometry<double> geom; if (!mapnik::from_wkt(wkt_in_, geom)) { throw std::runtime_error("Failed to parse WKT"); } if (mapnik::geometry::is_empty(geom)) { std::clog << "empty geom!\n"; return false; } if (!geom.is<mapnik::geometry::polygon<double> >()) { std::clog << "not a polygon!\n"; return false; } mapnik::geometry::polygon<double> & poly = mapnik::util::get<mapnik::geometry::polygon<double> >(geom); mapnik::geometry::correct(poly); ClipperLib::Clipper clipper; mapnik::geometry::line_string<std::int64_t> path; for (auto const& pt : poly.exterior_ring) { double x = pt.x; double y = pt.y; path.emplace_back(static_cast<ClipperLib::cInt>(x),static_cast<ClipperLib::cInt>(y)); } if (!clipper.AddPath(path, ClipperLib::ptSubject, true)) { std::clog << "ptSubject ext failed!\n"; } for (auto const& ring : poly.interior_rings) { path.clear(); for (auto const& pt : ring) { double x = pt.x; double y = pt.y; path.emplace_back(static_cast<ClipperLib::cInt>(x),static_cast<ClipperLib::cInt>(y)); } if (!clipper.AddPath(path, ClipperLib::ptSubject, true)) { std::clog << "ptSubject ext failed!\n"; } } std::cerr << "path size=" << path.size() << std::endl; mapnik::geometry::line_string<std::int64_t> clip_box; clip_box.emplace_back(static_cast<ClipperLib::cInt>(extent_.minx()),static_cast<ClipperLib::cInt>(extent_.miny())); clip_box.emplace_back(static_cast<ClipperLib::cInt>(extent_.maxx()),static_cast<ClipperLib::cInt>(extent_.miny())); clip_box.emplace_back(static_cast<ClipperLib::cInt>(extent_.maxx()),static_cast<ClipperLib::cInt>(extent_.maxy())); clip_box.emplace_back(static_cast<ClipperLib::cInt>(extent_.minx()),static_cast<ClipperLib::cInt>(extent_.maxy())); clip_box.emplace_back(static_cast<ClipperLib::cInt>(extent_.minx()),static_cast<ClipperLib::cInt>(extent_.miny())); if (!clipper.AddPath( clip_box, ClipperLib::ptClip, true )) { std::clog << "ptClip failed!\n"; } ClipperLib::PolyTree polygons; clipper.Execute(ClipperLib::ctIntersection, polygons, ClipperLib::pftNonZero, ClipperLib::pftNonZero); clipper.Clear(); ClipperLib::PolyNode* polynode = polygons.GetFirst(); mapnik::geometry::multi_polygon<double> mp; mp.emplace_back(); bool first = true; while (polynode) { if (!polynode->IsHole()) { if (first) first = false; else mp.emplace_back(); // start new polygon for (auto const& pt : polynode->Contour) { mp.back().exterior_ring.add_coord(pt.x, pt.y); } // childrens are interior rings for (auto const* ring : polynode->Childs) { mapnik::geometry::linear_ring<double> hole; for (auto const& pt : ring->Contour) { hole.add_coord(pt.x, pt.y); } mp.back().add_hole(std::move(hole)); } } polynode = polynode->GetNext(); } std::string expect = expected_+".png"; std::string actual = expected_+"_actual.png"; mapnik::geometry::geometry<double> geom2(mp); auto env = mapnik::geometry::envelope(geom2); if (!mapnik::util::exists(expect) || (std::getenv("UPDATE") != nullptr)) { std::clog << "generating expected image: " << expect << "\n"; render(mp,env,expect); } render(mp,env,actual); return benchmark::compare_images(actual,expect); }
static Geo_t clone( Geo_t const& geom ) { Geo_t geom2( geom ); fusion::at_key<key_type>( geom2 ) = fusion::at_key<key_type>( geom )->clone(); return geom2; }