SphereFlake.cc

Go to the documentation of this file.

#include <gra/scene/SphereFlake.h>
#include <esg/PointLight.h>
#include <esg/geometry/Sphere.h>
#include <esg/geometry/Polygon.h>
#include <esg/geometry/Triangle.h>

using namespace gra;

void SphereFlake::_create_lights()
{
    (void) appendLight(new PointLight(Vector3( 4.00000, 3.00000, 2.00000),
                                      Vector3( 0.57735, 0.57735, 0.57735)));
    (void) appendLight(new PointLight(Vector3( 1.00000,-4.00000, 4.00000),
                                      Vector3( 0.57735, 0.57735, 0.57735)));
    (void) appendLight(new PointLight(Vector3(-3.00000, 1.00000, 5.00000),
                                      Vector3( 0.57735, 0.57735, 0.57735)));
}

AutoPtr<Material>** SphereFlake::_create_materials(unsigned& numMats)
{
    Color3f color(1.0, 0.9, 0.7);

    Color3f ambient(color);
    Color3f diffuse(color);
    Color3f specular(color);
    Color3f reflection(color);

    ambient.scale(0.0);
    diffuse.scale(0.5);
    specular.scale(0.5);
    reflection.scale(0.5);

    //float roughness  = log(0.5) / log(cos(PI * 37.0 / 180.0));
    float roughness = .04;

    numMats = 5;
    AutoPtr<Material>** materials = new AutoPtr<Material>* [numMats];

    materials[0] = new AutoPtr<Material>(new Ambient(ambient));
    materials[1] = new AutoPtr<Material>(new Diffuse(diffuse));
    materials[2] = new AutoPtr<Material>(new Specular(specular));
    materials[3] = new AutoPtr<Material>(new Roughness(roughness));
    materials[4] = new AutoPtr<Material>(new Reflection(reflection));

    return materials;
}

void SphereFlake::_create_object_set(Vector3 objset[9])
{
    /*
     * Create the set of 9 vectors needed to generate the sphere set.
     * Uses global 'objset'
     */

    Vector3 axis, trio_dir[3];
    double  dist;
    Matrix4 mx;
        
    dist = 1.0 / sqrt((double)2.0);
        
    trio_dir[0].set(dist, dist,   0.0);
    trio_dir[1].set(dist,  0.0, -dist);
    trio_dir[2].set( 0.0, dist, -dist);
        
    axis.set(dist, -dist, 0.0);
    
    mx.rotationGL(asin((double)(2.0/sqrt((double)6.0))), axis);
        
    for (int i = 0; i < 3; i++) mx.transform(trio_dir[i]);
        
    for (int i = 0; i < 3; i++) {
        mx.rotZ(i*2.0*PI/3.0);
        for (int j = 0; j < 3; j++) mx.transform(trio_dir[j], objset[i*3+j]);
    }
}

void SphereFlake::_create_spheres(unsigned            depth,
                                  const Vector4&      center,
                                  const Vector4&      direction,
                                  Vector3             objset[9],
                                  AutoPtr<Material>** materials,
                                  unsigned            numMats)
{
    /*
     * Output the parent sphere, then output the children of the sphere.
     */

    double   angle, scale;
    Matrix4  mx;
    Vector3  axis, z_axis;
    Vector4  child_pt, child_dir;

    Shape* pSphere = new Shape(_lastOID++, NULL);
    pSphere->setPrivateGeometry(new Sphere(center.x,
                                           center.y,
                                           center.z,
                                           center.w));
    for (unsigned i = 0; i < numMats; i++)
        pSphere->appendSharedMaterial(materials[i]);

    (void) appendObject(pSphere);

    /* check if children should be generated */
    if (depth > 0) {
        --depth;
                
        /* rotation matrix to new axis from +Z axis */
        if (direction.z >= 1.0) {
            mx.setIdentity();
        } else if (direction.z <= -1.0) {
            mx.rotY(PI);
        } else {
            Vector3 aux(direction.x, direction.y, direction.z);
            z_axis.set(0.0, 0.0, 1.0);
            axis.cross(z_axis, aux);
            axis.normalize();
            angle = acos((double) z_axis.dot(aux));
            mx.rotationGL(angle, axis);
        }

        /* scale down location of new spheres */
        scale = center.w * (1.0 + direction.w);

        for (int i = 0 ; i < 9 ; i++) {
            mx.transform(objset[i], child_pt);
            child_pt.scaleAdd(scale, center);
            /* scale down radius */
            child_pt.w = center.w * direction.w;
            child_dir.set(child_pt);
            child_dir.sub(center);
            child_dir.x /= scale;
            child_dir.y /= scale;
            child_dir.z /= scale;
            child_dir.w = direction.w;
            _create_spheres(depth,child_pt,child_dir,objset,materials,numMats);
        }
    }
}

SphereFlake::SphereFlake(const SDS & proto, unsigned factor, float radius)
    : Scene(proto)
{
    Vector3 objset[9];
    Vector4 center(0.0, 0.0, 0.0, radius/2.0);
    Vector4 direction(0.0, 0.0, 1.0, 1.0/3.0);
    
    AutoPtr<Material>** materials;
    unsigned            numMats;

    materials = _create_materials(numMats);
    _create_object_set(objset);
    _create_spheres(factor, center, direction, objset, materials, numMats);
    _create_lights();

    delete [] materials;

    /*
     * floor polygon
     */
    Vector3 bvec(12.0 * radius, 12.0 * radius, -radius / 2.0);
    Vector3 vert[4];
    Color3f color(1.0, 0.75, 0.33);

    Color3f ambient(color);  ambient.scale(0.2);
    Color3f diffuse(color);  diffuse.scale(0.8);
    Color3f specular(color); specular.scale(0.0);
    float   roughness  = 100000.0;

#if 0
    vert[0].set( bvec.x, bvec.y, bvec.z);
    vert[1].set(-bvec.x,-bvec.y, bvec.z);
    vert[2].set( bvec.x,-bvec.y, bvec.z);
    
    Shape * pFloor = new Shape(_lastOID++, NULL);
    pFloor->setPrivateGeometry(new Triangle(vert, NULL, NULL,
                                            Vector3(0,0,1), true));
    
    pFloor->appendPrivateMaterial(new Ambient(ambient));
    pFloor->appendPrivateMaterial(new Diffuse(diffuse));
    pFloor->appendPrivateMaterial(new Specular(specular));
    pFloor->appendPrivateMaterial(new Roughness(roughness));

    vert[0].set( bvec.x, bvec.y, bvec.z);
    vert[1].set(-bvec.x, bvec.y, bvec.z);
    vert[2].set(-bvec.x,-bvec.y, bvec.z);

    (void) appendObject(pFloor);

    pFloor = new Shape(_lastOID++, NULL);
    pFloor->setPrivateGeometry(new Triangle(vert, NULL, NULL,
                                            Vector3(0,0,1), true));
    
    pFloor->appendPrivateMaterial(new Ambient(ambient));
    pFloor->appendPrivateMaterial(new Diffuse(diffuse));
    pFloor->appendPrivateMaterial(new Specular(specular));
    pFloor->appendPrivateMaterial(new Roughness(roughness));

    (void) appendObject(pFloor);
#endif

#if 1
    vert[0].set( bvec.x, bvec.y, bvec.z);
    vert[1].set(-bvec.x, bvec.y, bvec.z);
    vert[2].set(-bvec.x,-bvec.y, bvec.z);
    vert[3].set( bvec.x,-bvec.y, bvec.z);
    
    Shape * pFloor = new Shape(_lastOID++, NULL);
    pFloor->setPrivateGeometry(new Polygon(vert,NULL,NULL,4,Vector3(0,0,1),true));
    
    pFloor->appendPrivateMaterial(new Ambient(ambient));
    pFloor->appendPrivateMaterial(new Diffuse(diffuse));
    pFloor->appendPrivateMaterial(new Specular(specular));
    pFloor->appendPrivateMaterial(new Roughness(roughness));

    (void) appendObject(pFloor);
#endif

    build();
}

---