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()
)
{ }
ShapeWrapperWithAdjacency(
const StdRange& names,
const ShapeBuilder& builder,
const ProgramOps& prog
): ShapeWrapperBase(
names.begin(),
names.end(),
builder,
builder.IndicesWithAdjacency(),
builder.InstructionsWithAdjacency()
)
{
UseInProgram(prog);
}
// 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())
, shape_indices(make_shape.Indices())
, nva(4)
, vbos(nva+1)
{
vao.Bind();
typename ShapeBuilder::VertexAttribs vert_attr_info;
const GLchar* vert_attr_name[] = {
"Position",
"Normal",
"Tangent",
"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)
try
{
vbos[va].Bind(Buffer::Target::Array);
GLuint npv = getter(make_shape, data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, name);
attr.Setup<GLfloat>(npv);
attr.Enable();
}
catch(Error& error)
{ }
}
vbos[nva].Bind(Buffer::Target::ElementArray);
Buffer::Data(Buffer::Target::ElementArray, shape_indices);
shape_indices.clear();
}
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);
}
