C++ ShapeBuilder类代码示例

void CreateWireframeDialog::create_shape() {

    ShapeBuilder *builder = ShapeBuilder::instance();
    const std::string name = m_nameEntry->get_text().raw();

    if (!name.empty()) {
        std::vector<Coord<double>*> coords;
        if (m_coordBox->fill_coords(coords)) {

            // Check for minimum number of points.
            if (coords.size() >= 3) {
                m_minVertices = true;
                builder->add_name(name);
                builder->set_filled(m_filled);
                for (unsigned i = 0; i < coords.size(); i++) {
                    builder->add_point(coords[i]->x(), coords[i]->y(), coords[i]->z());
                }
                std::cout << "Added wireframe to ShapeBuilder." << std::endl;
            } else {
                std::cout << "Rolling back." << std::endl;
                builder->rollback();
            }
        }
        // Clean coords
        for_each (coords.begin(),
                  coords.end(),
                  DeleteList<Coord<double>*>());
    }
}

    Shape(const Program& prog, const ShapeBuilder& builder)
      : make_shape(builder)
      , shape_instr(make_shape.Instructions())
      , shape_indices(make_shape.Indices())
      , vbos(4) {
        // bind the VAO for the shape
        vao.Bind();

        typename ShapeBuilder::VertexAttribs vert_attr_info;
        const GLchar* vert_attr_name[] = {
          "Position", "Normal", "Tangent", "TexCoord"};
        for(int va = 0; va != 4; ++va) {
            const GLchar* name = vert_attr_name[va];
            std::vector<GLfloat> data;
            auto getter = vert_attr_info.VertexAttribGetter(data, name);
            if(getter != nullptr)
                try {
                    // bind the VBO for the vertex attribute
                    vbos[va].Bind(Buffer::Target::Array);
                    GLuint npv = getter(make_shape, data);
                    // upload the data
                    Buffer::Data(Buffer::Target::Array, data);
                    // setup the vertex attribs array
                    VertexArrayAttrib attr(prog, name);
                    attr.Setup<GLfloat>(npv);
                    attr.Enable();
                } catch(Error&) {
                }
        }
    }

	ShapeAnalyzerGraphData(const ShapeBuilder& builder)
	 : _instr(builder.Instructions())
	 , _index(_adapt(builder.Indices()))
	 , _main_va()
	 , _main_vpv(builder.Positions(_main_va))
	 , _smooth_va()
	 , _smooth_vpv(builder.Normals(_smooth_va))
	 , _eps(1.0e-9)
	{
		_initialize();
	}

	ShapeWrapperWithAdjacency(
		const StdRange& names,
		const ShapeBuilder& builder
	): ShapeWrapperBase(
		names.begin(),
		names.end(),
		builder,
		builder.IndicesWithAdjacency(),
		builder.InstructionsWithAdjacency()
	)
	{ }

// Patterns
static void builderExample() {
	ShapeBuilder *myRectangleBuilder = new RectangleBuilder();
	myRectangleBuilder->createShape();
	myRectangleBuilder->setHeight();
	myRectangleBuilder->setWidth();
	Shape *myRectangle = myRectangleBuilder->getShape();
	cout << "Area of the Rectangle is: " << myRectangle->getArea() << endl;
	delete myRectangleBuilder;

	ShapeBuilder *myTriangleBuilder = new TriangleBuilder();
	myTriangleBuilder->createShape();
	myTriangleBuilder->setHeight();
	myTriangleBuilder->setWidth();
	Shape *myTriangle = myTriangleBuilder->getShape();
	cout << "Area of the Triangle is: " << myTriangle->getArea() << endl;
	delete myTriangleBuilder;
}

	ShapeWrapperBase(
		Iterator names_begin,
		Iterator names_end,
		const ShapeBuilder& builder
	): _face_winding(builder.FaceWinding())
	 , _shape_instr(builder.Instructions())
	 , _index_info(builder)
	 , _vbos(std::distance(names_begin, names_end)+1)
	 , _npvs(std::distance(names_begin, names_end)+1, 0)
	 , _names(std::distance(names_begin, names_end))
	{
		this->_init(
			builder,
			builder.Indices(),
			names_begin,
			names_end
		);
	}

	Shape(const Program& prog, const ShapeBuilder& builder)
	 : make_shape(builder)
	 , shape_instr(make_shape.Instructions(shapes::DrawMode::Default()))
	 , edge_instr(make_shape.Instructions(shapes::DrawMode::Edges()))
	 , shape_indices(make_shape.Indices(shapes::DrawMode::Default()))
	 , edge_indices(make_shape.Indices(shapes::DrawMode::Edges()))
	 , vbos(3)
	{
		// bind the VAO for the shape
		vao.Bind();

		typename ShapeBuilder::VertexAttribs vert_attr_info;
		const GLuint nva = 3;
		const GLchar* vert_attr_name[nva] = {
			"Position",
			"Normal",
			"TexCoord"
		};
		for(GLuint va=0; va!=nva; ++va)
		{
			const GLchar* name = vert_attr_name[va];
			std::vector<GLfloat> data;
			auto getter = vert_attr_info.VertexAttribGetter(data, name);
			if(getter != nullptr)
			{
				// bind the VBO for the vertex attribute
				vbos[va].Bind(Buffer::Target::Array);
				GLuint n_per_vertex = getter(make_shape, data);
				// upload the data
				Buffer::Data(Buffer::Target::Array, data);
				// setup the vertex attribs array
				VertexArrayAttrib attr(prog, name);
				attr.Setup<GLfloat>(n_per_vertex);
				attr.Enable();
			}
		}
	}

	void _init(
		const ShapeBuilder& builder,
		const ShapeIndices& shape_indices,
		Iterator name,
		Iterator end
	)
	{
		VertexArray::Unbind();
		typename ShapeBuilder::VertexAttribs vert_attr_info;
		unsigned i = 0;
		std::vector<GLfloat> data;
		while(name != end)
		{
			auto getter = vert_attr_info.VertexAttribGetter(
				data,
				*name
			);
			if(getter != nullptr)
			{
				_vbos[i].Bind(Buffer::Target::Array);
				_npvs[i] = getter(builder, data);
				_names[i] = *name;

				Buffer::Data(Buffer::Target::Array, data);
			}
			++name;
			++i;
		}

		if(!shape_indices.empty())
		{
			assert((i+1) == _npvs.size());
			assert((i+1) == _vbos.size());

			_npvs[i] = 1;
			_vbos[i].Bind(Buffer::Target::ElementArray);
			Buffer::Data(
				Buffer::Target::ElementArray,
				shape_indices
			);
		}

		builder.BoundingSphere(_bounding_sphere);
	}

	void Draw(void)
	{
		vao.Bind();
		gl.FrontFace(make_shape.FaceWinding());
		shape_instr.Draw(shape_indices, 1);
	}

	void Draw(const std::function<bool (GLuint)>& drawing_driver)
	{
		vao.Bind();
		gl.FrontFace(make_shape.FaceWinding());
		shape_instr.Draw(shape_indices, 1, 0, drawing_driver);
	}