C++ GeometryNode类代码示例

void Branch::spawnSubBranches(const int level, const double length, const double thickness)
{
  if (level == recursiveDepth) return;

  // Spawn subbranches (make more as we get smaller)
  int numBranches = rand(0.2, 0.8, (level == 0 ? 2 : level) * initialBranches);
  for (int i = 0; i < numBranches; i++) {
    add_child(new Branch("SubBranch", level + 1,
                         nextThickness(thickness, level),
                         nextLength(length, level)));
    totalBranches++;
  }

  // Tree branches seem to split in two at the ends so simulate that.

  add_child(new Branch("SplitBranch", level + 1, nextThickness(thickness, level), 
                       nextLength(length, level), length, -30.0, 0.0));
  add_child(new Branch("SplitBranch", level + 1, nextThickness(thickness, level), 
                       nextLength(length, level), length, 30.0, 0.0));
  // Two branches coming out of the top looks a little weird so add a sphere.
  Sphere* p_sphere = new Sphere();
  GeometryNode* sphere = new GeometryNode("BranchTop", p_sphere);
  sphere->set_material(&wood);

  sphere->translate(Vector3D(0.0, 0.0, length));
  sphere->scale(Vector3D(thickness, thickness, thickness));

  add_child(sphere);

  totalBranches += 3;
}

void SceneGraph::recomputeBoundingBox() 
{
	Node	*node;
	float	center[3];
	float	size[3];

	BoundingBox bbox;

	for (node=getNodes(); node; node=node->nextTraversal()) {
		if (node->isGroupingNode()) {
			GroupingNode *gnode = (GroupingNode *)node;
			gnode->getBoundingBoxCenter(center);
			gnode->getBoundingBoxSize(size);
			bbox.addBoundingBox(center, size);
		}
		else if (node->isGeometryNode()) { 
			GeometryNode *gnode = (GeometryNode *)node; 
			gnode->getBoundingBoxCenter(center); 
			gnode->getBoundingBoxSize(size); 
			bbox.addBoundingBox(center, size); 
		} 
	}

	setBoundingBox(&bbox);
}

void GBufferPass::update_ubershader_from_scene(SerializedScene const& scene,
                                               SceneGraph const& graph) {
  bool ubershader_available = true;
  for (auto const& geometry_pair : scene.geometrynodes_) {
    ubershader_available =
        ubershader_available && ubershaders_.count(geometry_pair.first);
  }

  if (!ubershader_available) {
    auto get_ubershader = [&](Node * n) {
      GeometryNode* geode = dynamic_cast<GeometryNode*>(n);
      if (geode) {
        std::type_index type(typeid(*geode));
        if (!ubershaders_.count(type)) {
          auto const& ressource =
              GeometryDatabase::instance()->lookup(geode->get_filename());
          if (ressource) {
            auto ubershader = ressource->get_ubershader();
            ubershader->create(materials_);
            ubershaders_[type] = ubershader;
          }
        }
      }
    }
    ;
    gua::dfs_traverse(graph.get_root().get(), get_ubershader);
  }
}

void BallAndStick::process(const Molecule &molecule,
                           Rendering::GroupNode &node)
{
  // Add a sphere node to contain all of the spheres.
  GeometryNode *geometry = new GeometryNode;
  node.addChild(geometry);
  SphereGeometry *spheres = new SphereGeometry;
  spheres->identifier().molecule = &molecule;
  spheres->identifier().type = Rendering::AtomType;
  geometry->addDrawable(spheres);

  for (Index i = 0; i < molecule.atomCount(); ++i) {
    Core::Atom atom = molecule.atom(i);
    unsigned char atomicNumber = atom.atomicNumber();
    const unsigned char *c = Elements::color(atomicNumber);
    Vector3ub color(c[0], c[1], c[2]);
    spheres->addSphere(atom.position3d().cast<float>(), color,
                       static_cast<float>(Elements::radiusVDW(atomicNumber))
                       * 0.3f);
  }

  float bondRadius = 0.1f;
  CylinderGeometry *cylinders = new CylinderGeometry;
  cylinders->identifier().molecule = &molecule;
  cylinders->identifier().type = Rendering::BondType;
  geometry->addDrawable(cylinders);
  for (Index i = 0; i < molecule.bondCount(); ++i) {
    Core::Bond bond = molecule.bond(i);
    Vector3f pos1 = bond.atom1().position3d().cast<float>();
    Vector3f pos2 = bond.atom2().position3d().cast<float>();
    Vector3ub color1(Elements::color(bond.atom1().atomicNumber()));
    Vector3ub color2(Elements::color(bond.atom2().atomicNumber()));
    Vector3f bondVector = pos2 - pos1;
    float bondLength = bondVector.norm();
    bondVector /= bondLength;
    switch (bond.order()) {
    case 3: {
      Vector3f delta = bondVector.unitOrthogonal() * (2.0f * bondRadius);
      cylinders->addCylinder(pos1 + delta, bondVector, bondLength, bondRadius,
                             color1, color2, i);
      cylinders->addCylinder(pos1 - delta, bondVector, bondLength, bondRadius,
                             color1, color2, i);
    }
    default:
    case 1:
      cylinders->addCylinder(pos1, bondVector, bondLength, bondRadius,
                             color1, color2, i);
      break;
    case 2: {
      Vector3f delta = bondVector.unitOrthogonal() * bondRadius;
      cylinders->addCylinder(pos1 + delta, bondVector, bondLength, bondRadius,
                             color1, color2, i);
      cylinders->addCylinder(pos1 - delta, bondVector, bondLength, bondRadius,
                             color1, color2, i);
    }
    }
  }
}

		// ---|> NodeVisitor
		NodeVisitor::status enter(Node * node) override {
			GeometryNode * geometry = dynamic_cast<GeometryNode*>(node);
			if (geometry != nullptr) {
				currentTriangleCount += geometry->getTriangleCount();
				++currentNodeCount;
			}

			if (currentTriangleCount > maxTriangleCount || currentNodeCount > maxNodeCount) {
				return BREAK_TRAVERSAL;
			}
			return CONTINUE_TRAVERSAL;
		}

void Branch::createGeometryNode(const double length, const double thickness, const double upDist,
                                const double upAngle, const double zAngle)
{  
  Cylinder* c_branch= new Cylinder;
  GeometryNode* branch = new GeometryNode("TreeTrunk", c_branch);
  branch->set_material(&wood);

  this->rotate('z', zAngle);
  this->translate(Vector3D(0.0, 0.0, upDist));
  this->rotate('y', upAngle);
  branch->scale(Vector3D(thickness, thickness, length));

  add_child(branch);
}

int gr_node_set_bump_cmd(lua_State* L)
{
  GRLUA_DEBUG_CALL;
  
  gr_node_ud* selfdata = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
  luaL_argcheck(L, selfdata != 0, 1, "Node expected");

  GeometryNode* self = dynamic_cast<GeometryNode*>(selfdata->node);

  luaL_argcheck(L, self != 0, 1, "Geometry node expected");
  const char* filename = luaL_checkstring(L, 2);
  self->set_bump(filename);
  return 0;
}

//Render meshes as they are traversed in the scene graph
void NMS_SceneRenderer::sg_before(Matrix transform, SceneGraphNode * node)
{
	GeometryNode * geomNode = (GeometryNode *) node;
	NMS_Mesh* model = geomNode->getModel();
	btRigidBody *b = geomNode->getCollisionBody();

	glLoadIdentity();
	Matrix t_transposed = ~transform;
	glMultMatrixf(t_transposed.getElements());
	if(b != NULL)
		applyPhysics(b);
	setWireframeModeGL(wireframe);
	(*model).setMaterialGL();
	(*model).render(currentTime);
}

int gr_node_set_texture_scale_cmd(lua_State* L)
{
  GRLUA_DEBUG_CALL;
  
  gr_node_ud* selfdata = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
  luaL_argcheck(L, selfdata != 0, 1, "Node expected");

  GeometryNode* self = dynamic_cast<GeometryNode*>(selfdata->node);

  luaL_argcheck(L, self != 0, 1, "Geometry node expected");
  int scale_x = luaL_checknumber(L, 2);
  int scale_y = luaL_checknumber(L, 3);

  self->set_texture_scale(scale_x, scale_y);
  return 0;
}

Leaf::Leaf(const std::string& name, const double branchThickness, const double branchLength)
  : SceneNode(name)
{
  ImagePrimitive* i_leaf = new ImagePrimitive();
  GeometryNode* leaf = new GeometryNode("Leaf", i_leaf);
  leaf->set_material(&leafTexture);

  double upDist = rand(1.0/3.0, 1.0, branchLength);
  double zAngle = rand(0.0, 1.0, 360.0);

  double diagonalDist = branchThickness + sqrt(2.0) - 0.25;
  double xyDist = -diagonalDist * sqrt(2.0) / 2.0;

  leaf->rotate('z', zAngle); 
  leaf->translate(Vector3D(xyDist, xyDist, upDist));

  add_child(leaf);
}

int gr_node_set_refractionIndex_cmd(lua_State* L)
{
  GRLUA_DEBUG_CALL;
  
  gr_node_ud* selfdata = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
  luaL_argcheck(L, selfdata != 0, 1, "Node expected");

  GeometryNode* self = dynamic_cast<GeometryNode*>(selfdata->node);
  luaL_argcheck(L, self != 0, 1, "Geometry node expected");

  double index = luaL_checknumber(L, 2);

  PhongMaterial * pM = (PhongMaterial*)self->get_material();
  if (pM == NULL) { std::cerr << "LUA:You are using a non-phong Material!" << std::endl; return 0; }
  pM->setRefractiveIndex(index);

  return 0;
}

void VanDerWaals::process(const Core::Molecule &molecule,
                          Rendering::GroupNode &node)
{
  // Add a sphere node to contain all of the VdW spheres.
  GeometryNode *geometry = new GeometryNode;
  node.addChild(geometry);
  SphereGeometry *spheres = new SphereGeometry;
  spheres->identifier().molecule = &molecule;
  spheres->identifier().type = Rendering::AtomType;
  geometry->addDrawable(spheres);

  for (size_t i = 0; i < molecule.atomCount(); ++i) {
    Core::Atom atom = molecule.atom(i);
    unsigned char atomicNumber = atom.atomicNumber();
    const unsigned char *c = Elements::color(atomicNumber);
    Vector3ub color(c[0], c[1], c[2]);
    spheres->addSphere(atom.position3d().cast<float>(), color,
                       static_cast<float>(Elements::radiusVDW(atomicNumber)));
  }
}

int gr_node_set_material_cmd(lua_State* L)
{
  GRLUA_DEBUG_CALL;
  
  gr_node_ud* selfdata = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
  luaL_argcheck(L, selfdata != 0, 1, "Node expected");

  GeometryNode* self = dynamic_cast<GeometryNode*>(selfdata->node);

  luaL_argcheck(L, self != 0, 1, "Geometry node expected");
  
  gr_material_ud* matdata = (gr_material_ud*)luaL_checkudata(L, 2, "gr.material");
  luaL_argcheck(L, matdata != 0, 2, "Material expected");

  Material* material = matdata->material;

  self->set_material(material);

  return 0;
}

int gr_node_set_km_cmd(lua_State* L)
{
  GRLUA_DEBUG_CALL;
  
  gr_node_ud* selfdata = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
  luaL_argcheck(L, selfdata != 0, 1, "Node expected");

  GeometryNode* self = dynamic_cast<GeometryNode*>(selfdata->node);
  luaL_argcheck(L, self != 0, 1, "Geometry node expected");

  double km[3];
  for (int i = 0; i < 3; i++) {
    km[i] = luaL_checknumber(L, i + 2);
  }

  PhongMaterial * pM = (PhongMaterial*)self->get_material();
  if (pM == NULL) { std::cerr << "LUA:You are using a non-phong Material!" << std::endl; return 0; }
  pM->setKM(Colour(km[0], km[1], km[2]));

  return 0;
}

int gr_node_set_bump_cmd(lua_State* L)
{
  GRLUA_DEBUG_CALL;
  
  gr_node_ud* selfdata = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
  luaL_argcheck(L, selfdata != 0, 1, "Node expected");

  GeometryNode* self = dynamic_cast<GeometryNode*>(selfdata->node);

  luaL_argcheck(L, self != 0, 1, "Geometry node expected");
  
  const char* name = luaL_checkstring(L, 2);
  
  Image * bump = new Image();
  if (!bump->loadPng(name)) { std::cerr << "LUA:Loading PNG Failed!!" << std::endl; return -1; }
  
  self->apply_bump(bump);
  
  
  return 0;
}