// Process projected vertices and extract primitives. thrust::host_vector<triangle> process_primitives(const mesh & m, thrender::render_context & rstate) { thrust::host_vector<triangle> primitives(m.total_triangles()); thrust::transform( m.triangles.begin(), m.triangles.end(), // Input primitives.begin(), // Output primitives_proc_kernel(m.render_buffer.projected_vertices, m, rstate)); return primitives; }
int main (void) { primitives(); CPU_PRESCALE(0); usb_init(); while (!usb_configured()) /* wait */ ; define_constant("portb", (int)&PORTB); define_constant("portd", (int)&PORTD); define_constant("portf", (int)&PORTF); define_constant("ddrb", (int)&DDRB); define_constant("ddrd", (int)&DDRD); define_constant("ddrf", (int)&DDRF); define_constant("pinb", (int)&PINB); define_constant("pind", (int)&PIND); define_constant("pinf", (int)&PINF); define("pressedkeys", VARIABLE, keyboard_keys); define("pressedmodifiers", VARIABLE, &keyboard_modifier_keys); define("reset", PRIMITIVE, &reset); define("blink", PRIMITIVE, &blink); define("blinks", PRIMITIVE, &blinks); define("blinq", PRIMITIVE, &blinq); define("delaysec", PRIMITIVE, &delaysec); define("delay", PRIMITIVE, &delay); define("delayten", PRIMITIVE, &delayten); define("usbsend", PRIMITIVE, &usbsend); define_constant("onboard", 1); delaysec(); input = malloc(81); #include "inlined.c" delaysec(); (DDRD |= (1<<6)); blinq(); blinq(); blinq(); reset(); };
int main(int argc, char **argv) { primsigs = primitives(); Parser ps; Lexer lexer; FILE *ic, *oc; int err = 0; getopts(argc, argv); ic = fopen(input, "r"); if(ic == NULL){ printf("Can not open the file.\n"); return 1; } parser_init(&ps); lexer_init(&lexer); lexer_setin(&lexer, ic); err |= yyparse(&ps, &lexer, "input"); fclose(ic); if(proc_compile && err == 0){ oc = fopen(compiled_file, "w"); err |= compile(oc, &ps.prog); fclose(oc); } if(proc_assemble && err == 0){ char cmd[100]; sprintf(cmd, "gcc -o %s %s -L%s %s", output, compiled_file, libdir, LIBS); system(cmd); } return 0; }
bool KdIntersection::leafIntersectBox(KdTreeNode *node, const BoundingBox & box) { const unsigned num = node->getNumPrims(); if(num < 1) return false; if(!box.intersect(m_testBox)) return false; unsigned start = node->getPrimStart(); IndexArray &indir = indirection(); PrimitiveArray &prims = primitives(); indir.setIndex(start); for(unsigned i = 0; i < num; i++) { unsigned *iprim = indir.asIndex(); Primitive * prim = prims.asPrimitive(*iprim); Geometry * geo = prim->getGeometry(); unsigned icomponent = prim->getComponentIndex(); if(geo->intersectBox(icomponent, m_testBox)) return true; indir.next(); } return false; }
TEST_F(BPTFullpathTest2, Consistency) { StubConfig config; ASSERT_TRUE(config.LoadFromString(TestScenes::Simple03(), "")); std::unique_ptr<Assets> assets(ComponentFactory::Create<Assets>()); ASSERT_TRUE(assets->RegisterInterface<Texture>()); ASSERT_TRUE(assets->RegisterInterface<BSDF>()); ASSERT_TRUE(assets->RegisterInterface<TriangleMesh>()); ASSERT_TRUE(assets->RegisterInterface<Film>()); ASSERT_TRUE(assets->RegisterInterface<Camera>()); ASSERT_TRUE(assets->RegisterInterface<Light>()); ASSERT_TRUE(assets->Load(config.Root().Child("assets"))); std::unique_ptr<Primitives> primitives(ComponentFactory::Create<Primitives>()); ASSERT_TRUE(primitives->Load(config.Root().Child("scene"), *assets)); std::unique_ptr<Scene> scene(ComponentFactory::Create<Scene>(config.Root().Child("scene").AttributeValue("type"))); ASSERT_NE(scene, nullptr); scene->Load(primitives.release()); ASSERT_TRUE(scene->Configure(config.Root().Child("scene"))); ASSERT_TRUE(scene->Build()); BPTPathVertexPool pool; BPTSubpath subpathL(TransportDirection::LE); BPTSubpath subpathE(TransportDirection::EL); std::unique_ptr<ConfigurableSampler> sampler(ComponentFactory::Create<ConfigurableSampler>("random")); ASSERT_TRUE(sampler->Configure(ConfigNode(), *assets)); sampler->SetSeed(1); const int Samples = 1<<10; for (int sample = 0; sample < Samples; sample++) { pool.Release(); subpathL.Clear(); subpathE.Clear(); subpathL.Sample(*scene, *sampler, pool, 3, -1); subpathE.Sample(*scene, *sampler, pool, 3, -1); const int nL = subpathL.NumVertices(); const int nE = subpathE.NumVertices(); for (int s = 0; s <= nL; s++) { for (int t = 0; t <= nE; t++) { // # of vertices must be no less than 2 const int n = s + t; if (n < 2) { continue; } // Between termination vertices geometry term must be positive // Otherwise, EvaluateFullpathPDFRatio is invalid due to offsetting of geometry terms. Math::Float connGeom(-1); if (s > 0 && t > 0) { connGeom = RenderUtils::GeneralizedGeometryTermWithVisibility(*scene, subpathL.Vertex(s-1)->geom, subpathE.Vertex(t-1)->geom); if (Math::Abs(connGeom) < Math::Constants::Eps()) { continue; } } BPTFullPath fullpath(s, t, subpathL, subpathE); auto ps = fullpath.EvaluateFullpathPDF(s); if (Math::Abs(ps) < Math::Constants::Eps()) { // EvaluateFullpathPDFRatio is invalid if p_s is zero continue; } for (int i = 0; i < n; i++) { auto pi = fullpath.EvaluateFullpathPDF(i); auto piNext = fullpath.EvaluateFullpathPDF(i+1); auto ratio = fullpath.EvaluateFullpathPDFRatio(i); bool piIsZero = Math::Abs(pi) < Math::Constants::Eps(); bool piNextIsZero = Math::Abs(piNext) < Math::Constants::Eps(); // We note that we have only to check the case with p_i and p_{i+1} are both non-zero // because in actual weight calculation (cf. bpt.mis.power.cpp) // calculation of the ratio is aborted immediately after p_i or p_{i+1} is found to be non-zero. bool cond = false; if (piIsZero && piNextIsZero) { continue; } else if (piIsZero) { auto result = ExpectNear(Math::Float(0), ratio); EXPECT_TRUE(result); cond = result; } else if (piNextIsZero) { auto result = ExpectNear(Math::Float(0), ratio); EXPECT_TRUE(result); cond = result; } else { auto result = ExpectNearRelative(ratio, piNext / pi, Math::Constants::EpsLarge()); EXPECT_TRUE(result); cond = result; } if (!cond) { LM_LOG_DEBUG("Evaluating i = " + std::to_string(i)); LM_LOG_DEBUG("connGeom = " + std::to_string(connGeom)); LM_LOG_DEBUG("ps = " + std::to_string(ps)); LM_LOG_DEBUG("pi = " + std::to_string(pi)); LM_LOG_DEBUG("piNext = " + std::to_string(piNext)); LM_LOG_DEBUG("ratio = " + std::to_string(ratio)); fullpath.DebugPrint(); } } } } } }
const k3d::selection::set operator()(k3d::inode* const Node, const k3d::mesh& Mesh, const k3d::selection::set& CurrentSelection, const k3d::selection::records& InteractiveSelection) const { k3d::selection::set results = CurrentSelection; // Extract the set of edges to be selected ... mesh::indices_t edges; mesh::indices_t edge_primitives; for(k3d::selection::records::const_iterator record = InteractiveSelection.begin(); record != InteractiveSelection.end(); ++record) { if(k3d::selection::get_node(*record) != Node) continue; for(k3d::selection::record::tokens_t::const_iterator primitive_token = record->tokens.begin(); primitive_token != record->tokens.end(); ++primitive_token) { if(primitive_token->type != k3d::selection::PRIMITIVE) continue; for(k3d::selection::record::tokens_t::const_iterator edge_token = primitive_token + 1; edge_token != record->tokens.end(); ++edge_token) { if(edge_token->type != k3d::selection::EDGE) continue; edges.push_back(edge_token->id); edge_primitives.push_back(primitive_token->id); break; } break; } } // Get the set of unique primitives ... std::set<uint_t> primitives(edge_primitives.begin(), edge_primitives.end()); // Optionally select adjacent edges ... if(select_adjacent) { const uint_t edge_begin = 0; const uint_t edge_end = edge_begin + edges.size(); for(std::set<uint_t>::const_iterator primitive = primitives.begin(); primitive != primitives.end(); ++primitive) { if(Mesh.primitives.size() <= *primitive) continue; boost::scoped_ptr<polyhedron::const_primitive> polyhedron(polyhedron::validate(Mesh, *Mesh.primitives[*primitive])); if(!polyhedron) continue; mesh::bools_t boundary_edges; mesh::indices_t adjacent_edges; polyhedron::create_edge_adjacency_lookup(polyhedron->vertex_points, polyhedron->clockwise_edges, boundary_edges, adjacent_edges); std::set<uint_t> primitive_edges; for(uint_t edge = edge_begin; edge != edge_end; ++edge) { if(edge_primitives[edge] != *primitive) continue; primitive_edges.insert(edges[edge]); } for(std::set<uint_t>::const_iterator edge = primitive_edges.begin(); edge != primitive_edges.end(); ++edge) { if(boundary_edges[*edge]) continue; if(primitive_edges.count(adjacent_edges[*edge])) continue; edges.push_back(adjacent_edges[*edge]); edge_primitives.push_back(*primitive); } } } // Add all our edges to the output selection ... if(edges.size()) { const uint_t edge_begin = 0; const uint_t edge_end = edge_begin + edges.size(); boost::scoped_ptr<geometry::primitive_selection::storage> primitive_selection(geometry::primitive_selection::create(results)); for(std::set<uint_t>::const_iterator primitive = primitives.begin(); primitive != primitives.end(); ++primitive) { primitive_selection->primitive_begin.push_back(*primitive); primitive_selection->primitive_end.push_back(*primitive + 1); primitive_selection->primitive_selection_type.push_back(k3d::selection::EDGE); primitive_selection->primitive_first_range.push_back(primitive_selection->index_begin.size()); primitive_selection->primitive_range_count.push_back(0); for(uint_t edge = edge_begin; edge != edge_end; ++edge) { if(edge_primitives[edge] != *primitive) continue; primitive_selection->primitive_range_count.back() += 1; primitive_selection->index_begin.push_back(edges[edge]); primitive_selection->index_end.push_back(edges[edge] + 1); primitive_selection->weight.push_back(weight); } } } return results; }