C++ Grammar::resolve方法代码示例

void CylinderRule::execute(Grammar &grammar, Context &context, Shape &shape) {
    if (shape.getShapeType() != ST_Prism) {
        // La règle ne s'applique que sur un prisme
        throw std::runtime_error("build_cylinder can only be used on Prism primitives");
    }

    Prism const& prism = static_cast<Prism const&>(shape);
    std::vector<glm::vec2> const &points = prism.poly.getPoints();
    const int n = points.size();

    // Find the centroid
    glm::vec2 centroid;
    for (int i = 0; i < n; i++) {
        centroid += points[i];
    }
    centroid /= n;
    glm::vec3 centroid3d(centroid.x, 0, centroid.y);
    centroid3d = centroid3d + glm::vec3(0, context.terrain->getHeight(centroid), 0);

    // Build a cylinder of center 'centroid' of radius 'radius' and height 'height'
    float radius = GRandom.RandomNumber(radius_min, radius_max);
	float height = GRandom.RandomNumber(height_min, height_max);

    Circle2D circle(radius, centroid3d);
    Cylinder cyl(circle, height);

    // Successeurs
    if (successors.size() != 1) {
        throw std::runtime_error("build_cylinder operation must have only one successor");
    }

    CSymbol *succ = *successors.begin();
    grammar.resolve(succ, context, cyl);
}

void SelectFacesRule::execute(Grammar &grammar, Context &context, Shape &shape) {
    if (shape.getShapeType() != ST_Cuboid) {
        throw std::runtime_error("select_faces can only be used on cuboids");
    }

    Cuboid const &cube = static_cast<Cuboid const &>(shape);
    std::vector<Rectangle2D *> faces(6);
	CoordSystem const &cs = cube.getCoordSystem();

    // compute faces of the cuboid
    glm::vec3 dimensions = cube.dimensions;

	float dx = cube.dimensions.x;
	float dy = cube.dimensions.y;
	float dz = cube.dimensions.z;

	glm::vec3 position = cs.position;
	glm::vec3 vdx = glm::vec3(dimensions.x, 0, 0);
	glm::vec3 vdy = glm::vec3(0, dimensions.y, 0);
	glm::vec3 vdz = glm::vec3(0, 0, dimensions.z);

	glm::vec3 vx = glm::vec3(1, 0, 0);
	glm::vec3 vy = glm::vec3(0, 1, 0);
	glm::vec3 vz = glm::vec3(0, 0, 1);

    // front
	faces[0] = new Rectangle2D(CoordSystem::fromVectors(cs, vdy + vdx, -vx, -vy), dx, dy);
	// back
	faces[1] = new Rectangle2D(CoordSystem::fromVectors(cs, vdz, vy, vx), dy, dx);
    // up
	faces[2] = new Rectangle2D(CoordSystem::fromVectors(cs, vdy, vx, vz), dx, dz);
	// down
	faces[3] = new Rectangle2D(CoordSystem::fromVectors(cs, glm::vec3(0.f), vx, vz), dx, dz);
    // left
	faces[4] = new Rectangle2D(CoordSystem::fromVectors(cs, vdx, vz, vy), dz, dy);
    // right
	faces[5] = new Rectangle2D(CoordSystem::fromVectors(cs, glm::vec3(0.f), vy, vz), dy, dz);

    // Successeurs = faces
    int i = 0;
    for (std::list<CSymbol *>::iterator it = successors.begin(); it != successors.end(); it++, i++) {
        grammar.resolve(*it, context, *(faces[i]));
    }
}

void SplitCylinderRule::execute(Grammar &grammar, Context &context, Shape &shape) {
    if (shape.getShapeType() != ST_Cylinder) {
        // La règle ne s'applique que sur un cylindre
        throw std::runtime_error("split_cylinder can only be used on Cylinder primitives");
    }

    Cylinder const& cylinder = static_cast<Cylinder const&>(shape);

    std::vector<Cylinder> cylinders;
    cylinder.split(numDivisions, cylinders);

    // Successeurs
    if (successors.size() != 1) {
        throw std::runtime_error("split_cylinder operation must have only one successor");
    }

    CSymbol *succ = *successors.begin();
    for (std::vector<Cylinder>::iterator it = cylinders.begin();
         it != cylinders.end();
         it++) {
        grammar.resolve(succ, context, *it);
    }
}

void TranslationRule::execute(Grammar &grammar, Context &context, Shape &shape) {
	if (shape.getShapeType() != ST_Polygon) {
		// La règle ne s'applique que sur un polygon
		throw std::runtime_error("translation can only be used on Polygon2D primitives");
	}
	Polygon2D const& poly = static_cast<Polygon2D const&>(shape);
	std::vector<glm::vec2> points = poly.getPoints();
	const int n = points.size();

	for (int i = 0; i < n; i++) {
		points[i].x += x;
		points[i].y += y;
	}

	CoordSystem cs = poly.getCoordSystem();

	cs.position.x += x;
	cs.position.y += y;

	Polygon2D res;

	for (int i = 0; i < n; i++) {
		res.addPoint(points[i]);
	}

	res.getCoordSystem().position = cs.position;
	res.getCoordSystem().rotation = cs.rotation;

	// Successeurs
	if (successors.size() != 1) {
		throw std::runtime_error("translation operation must have only one successor");
	}

	CSymbol *succ = *successors.begin();
	grammar.resolve(succ, context, res);
}