renderstack::shapes::sphere Class Reference

#include <polymesh.hpp>

Inherits renderstack::shapes::polymesh.

Public Member Functions
	sphere (float radius, int stack_division, int slice_count)
mesh3d::point *	make_point (double rel_slice, double rel_stack, double radius)

---

Detailed Description

Definition at line 81 of file polymesh.hpp.

---

Constructor & Destructor Documentation

renderstack::shapes::sphere::sphere	(	float	radius,
		int	stack_division,
		int	slice_count
	)

Definition at line 873 of file polymesh.cpp.

{
    int stack_count = (2 * stack_division) + 1;

    int slice;
    int stack;

    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_centroids;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals;

    mesh3d::geometry &g = m_geometry;
    point_locations   = g.point_attributes  ().find_or_create<mesh3d::vec3>("point_locations");
    point_normals     = g.point_attributes  ().find_or_create<mesh3d::vec3>("point_normals");
    polygon_centroids = g.polygon_attributes().find_or_create<mesh3d::vec3>("polygon_centroids");
    polygon_normals   = g.polygon_attributes().find_or_create<mesh3d::vec3>("polygon_normals");

    /*  Bottom and top vertices  */ 
    mesh3d::point *bottom = make_point(0.5f, -1.0f, radius);
    mesh3d::point *top    = make_point(0.5f, 1.0f, radius);

    /*  Other vertices  */ 
    std::vector<mesh3d::point*> points;
    for(slice = 0; slice <= slice_count; ++slice)
    {
        double rel_slice = (double)(slice) / (double)(slice_count);
        for(stack = -stack_division; stack <= stack_division; ++stack)
        {
            double rel_stack = (double)(stack) / (double)(stack_division + 1);

            mesh3d::point *pnt = make_point(rel_slice, rel_stack, radius);

            points.push_back(pnt);
        }
    }

    /*  Bottom fan  */ 
    std::vector<mesh3d::point*> centroids;
    {
        for(slice = 0; slice < slice_count; ++slice)
        {
            int next_slice  = (slice + 1);
            int stack_base0 = 0;

            double rel_slice = ((double)(slice) + 0.5) / (double)(slice_count);
            double rel_stack = 0.5 / (double)(stack_division + 1);

            mesh3d::point *centroid = make_point(rel_slice, rel_stack, radius);

            mesh3d::polygon *pol = g.make_polygon(
                points[(slice      * stack_count) + stack_base0],
                bottom,
                points[(next_slice * stack_count) + stack_base0]
            );

            polygon_centroids->set_value(pol, point_locations->value(centroid));
            polygon_normals  ->set_value(pol, point_normals  ->value(centroid));
        }
    }

    /*  Middle quads, bottom up  */ 
    for(
        stack = -stack_division; 
        stack < stack_division; 
        ++stack
    )
    {
        int stack_base0      = stack + stack_division;
        int next_stack_base0 = stack_base0 + 1;

        double rel_stack = ((double)(stack) + 0.5) / (double)(stack_division + 1);

        for(slice = 0; slice < slice_count; ++slice)
        {
            int next_slice = (slice + 1);

            double rel_slice = ((double)(slice) + 0.5) / (double)(slice_count);

            mesh3d::point *centroid = make_point(rel_slice, rel_stack, radius);

            mesh3d::polygon *pol = g.make_polygon(
                points[(next_slice * stack_count) + next_stack_base0],
                points[(slice      * stack_count) + next_stack_base0],
                points[(slice      * stack_count) + stack_base0],
                points[(next_slice * stack_count) + stack_base0]
            );

            polygon_centroids->set_value(pol, point_locations->value(centroid));
            polygon_normals  ->set_value(pol, point_normals  ->value(centroid));
        }
    }

    /*  Top fan   */ 
    for(slice = 0; slice < slice_count; ++slice)
    {
        int next_slice  = (slice + 1);
        int stack       =  stack_division;
        int stack_base0 =  stack + stack_division;

        double rel_slice = ((double)(slice) + 0.5) / (double)(slice_count);
        double rel_stack = 1.0 - (0.5 / (double)(stack_division + 1));

        mesh3d::point *centroid = make_point(rel_slice, rel_stack, radius);

        mesh3d::polygon *pol = g.make_polygon(
            top,
            points[(slice      * stack_count) + stack_base0],
            points[(next_slice * stack_count) + stack_base0]
        );

        polygon_centroids->set_value(pol, point_locations->value(centroid));
        polygon_normals  ->set_value(pol, point_normals  ->value(centroid));
    }

    build_mesh_from_geometry(false);
}

---

Member Function Documentation

mesh3d::point * renderstack::shapes::sphere::make_point	(	double	rel_slice,
		double	rel_stack,
		double	radius
	)

Definition at line 819 of file polymesh.cpp.

{
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, mesh3d::vec3> > point_locations;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, mesh3d::vec3> > point_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, mesh3d::vec2> > point_texcoords;

    mesh3d::geometry &g = m_geometry;
    point_locations = g.point_attributes().find_or_create<mesh3d::vec3>("point_locations");
    point_normals   = g.point_attributes().find_or_create<mesh3d::vec3>("point_normals");
    point_texcoords = g.point_attributes().find_or_create<mesh3d::vec2>("point_texcoords");

    double  phi             = (RS_TWO_PI * rel_slice);
    double  sin_phi         = std::sin(phi);
    double  cos_phi         = std::cos(phi);

    double  theta           = (RS_HALF_PI * rel_stack);
    double  sin_theta       = std::sin(theta);
    double  cos_theta       = std::cos(theta);

    double  stack_radius    = cos_theta;

    float   xVN             = (float)(stack_radius * cos_phi);
    float   yVN             = (float)(sin_theta);
    float   zVN             = (float)(stack_radius * sin_phi);

    float   xP              = (float)(radius * xVN);
    float   yP              = (float)(radius * yVN);
    float   zP              = (float)(radius * zVN);

    float   s               = (float)(rel_slice);
    float   t               = (float)(0.5f * (1.0f + rel_stack));

    mesh3d::point* pnt = g.make_point();

    point_locations->set_value(pnt, mesh3d::vec3(xP, yP, zP));
    point_normals  ->set_value(pnt, mesh3d::vec3(xVN, yVN, zVN));
    point_texcoords->set_value(pnt, mesh3d::vec2(s, t));

    return pnt;
}

---

The documentation for this class was generated from the following files:

• polymesh.hpp
• polymesh.cpp