FractalMount.cc

Go to the documentation of this file.

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

using namespace gra;

void FractalMount::_create_lights()
{
    (void) appendLight(new PointLight(Vector3(-100.0, -100.0, 100.0),
                                      Vector3(1.0, 1.0, 1.0)));
}

AutoPtr<Material>** FractalMount::_create_crystal_materials(unsigned& numMats)
{
    Color3f color(0.9, 0.9, 0.9);

    Color3f ambient(color);
    Color3f diffuse(color);
    Color3f specular(color);
    Color3f transparency(color);
    Color3f reflection(.1,.1,.1);

    ambient.scale(0.0);
    diffuse.scale(0.1);
    specular.scale(0.4);
    transparency.scale(1.0);

    //float roughness  = log(0.5) / log(cos(PI * 37.0 / 180.0));
    float roughness  = .5;
    float refrIndex  = 1.5;

    numMats = 7;
    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 IndexOfRefraction(refrIndex));
    materials[4] = new AutoPtr<Material>(new Roughness(roughness));
    materials[5] = new AutoPtr<Material>(new Transparency(transparency));
    materials[6] = new AutoPtr<Material>(new Reflection(reflection));

    return materials;
}

AutoPtr<Material>** FractalMount::_create_mount_materials(unsigned& numMats)
{
    Color3f color(0.5, 0.45, 0.35);
    Color3f ambient(color);  ambient.scale(0.0);
    Color3f diffuse(color);  diffuse.scale(1.0);
    Color3f specular(color); specular.scale(0.0);

    numMats = 4;
    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((float)_roughness));

    return materials;
}

void FractalMount::_create_spheres(const Vector4&      center,
                                 AutoPtr<Material>** materials,
                                 unsigned            numMats)
                                 
{
    double  angle;
    double  radius = center.w;
    Vector3 axis, pt, new_pt;
    Vector3 sphere;
    Matrix4 mx;

    axis.set(1.0, 1.0, 0.0);
    axis.normalize();
    angle = acos((double)(-1.0/3.0));
        
    /* set center of pyramid */
    pt.set(0., 0., radius * sqrt((double)(3.0/2.0)));

    sphere.set(center.x, center.y, center.z);
    sphere.add(pt);

    Shape* pSphere = new Shape(_lastOID++, NULL);
    pSphere->setPrivateGeometry(new Sphere(sphere.x,
                                           sphere.y,
                                           sphere.z,
                                           radius));
    for (unsigned j = 0; j < numMats; j++)
        pSphere->appendSharedMaterial(materials[j]);
    (void) appendObject(pSphere);

    mx.rotationGL(angle, axis);
    mx.transform(pt, new_pt);
        
    for (unsigned i = 0; i < 3; i++) {
        mx.rotZ((double)i * 2.0 * PI / 3.0);
        mx.transform(new_pt, sphere);
        sphere.x += center.x;
        sphere.y += center.y;
        sphere.z += center.z;
        pSphere = new Shape(_lastOID++, NULL);
        pSphere->setPrivateGeometry(new Sphere(sphere.x,
                                               sphere.y,
                                               sphere.z,
                                               radius));
        for (unsigned j = 0; j < numMats; j++)
            pSphere->appendSharedMaterial(materials[j]);
        (void) appendObject(pSphere);
    }
}

/*
 * Build mountain section.  If at width > 1, split quadrilateral into four
 * parts.  Else if at width == 1, output quadrilateral as two triangles.
 */
void FractalMount::_grow_mountain(double fnum_pts,
                                int    width,
                                int    ll_x,
                                int    ll_y,
                                double ll_fz,
                                double lr_fz,
                                double ur_fz,
                                double ul_fz,
                                AutoPtr<Material>** materials,
                                unsigned            numMats)
{
    long    iz;
    int     half_width, num_tri, num_tri_vert, num_vert, h1, h2;
    double  l_fx, r_fx, l_fy, u_fy;
    double  lower_fz, right_fz, upper_fz, left_fz, middle_fz;
    double  rise_height, hside_length;
    double  gauss_rand;
    Vector3 tri_vert[3];
    Vector3 normal,e1,e2;

    if (width == 1) {
        /* calculate x and y coordinates of corners */
        l_fx = _xCorner + (double)ll_x     * _width / fnum_pts;
        r_fx = _xCorner + (double)(ll_x+1) * _width / fnum_pts;
        l_fy = _yCorner + (double)ll_y     * _width / fnum_pts;
        u_fy = _yCorner + (double)(ll_y+1) * _width / fnum_pts;

        /* output two triangles for section */
        for (num_tri = 0; num_tri < 2; num_tri++) {
            for (num_vert = 0; num_vert < 3; num_vert++) {
                num_tri_vert = (num_vert + num_tri * 2) % 4;
                switch (num_tri_vert) {
                case 0:
                    tri_vert[num_vert].set(l_fx, l_fy, ll_fz); break;
                case 1:
                    tri_vert[num_vert].set(r_fx, l_fy, lr_fz); break;
                case 2:
                    tri_vert[num_vert].set(r_fx, u_fy, ur_fz); break;
                case 3:
                    tri_vert[num_vert].set(l_fx, u_fy, ul_fz); break;
                }
            }
            e1.set(tri_vert[2]); e1.sub(tri_vert[1]); e1.normalize();
            e2.set(tri_vert[0]); e2.sub(tri_vert[1]); e2.normalize();
            normal.cross(e1, e2);
            Shape * pPolygon = new Shape(_lastOID++, NULL);
            pPolygon->setPrivateGeometry(new esg::Polygon(tri_vert, NULL, NULL,
                                                     3, normal, true));
            for (unsigned i = 0; i < numMats; i++)
                pPolygon->appendSharedMaterial(materials[i]);
            (void) appendObject(pPolygon);
        }
    } else {
        /* subdivide edges and move them in z direction */
        half_width = width>>1;
        hside_length = (double)half_width * _width / fnum_pts;
        rise_height = hside_length * _roughness;

        /* for each midpoint, find z */
        h1 = ll_x + half_width;
        h2 = ll_y;
        ESG_HASH_RAND(h1, h2, _factor, iz);
        iz += _mountainNo;
        ESG_GAUSS_RAND(iz, gauss_rand);
        lower_fz = (ll_fz + lr_fz) / 2.0 + rise_height * gauss_rand;

        h1 = ll_x + width;
        h2 = ll_y + half_width;
        ESG_HASH_RAND(h1, h2, _factor, iz);
        iz += _mountainNo;
        ESG_GAUSS_RAND(iz, gauss_rand);
        right_fz = (lr_fz + ur_fz) / 2.0 + rise_height * gauss_rand;

        h1 = ll_x + half_width;
        h2 = ll_y + width;
        ESG_HASH_RAND(h1, h2, _factor, iz);
        iz += _mountainNo;
        ESG_GAUSS_RAND(iz, gauss_rand);
        upper_fz = (ur_fz + ul_fz) / 2.0 + rise_height * gauss_rand;

        h1 = ll_x;
        h2 = ll_y + half_width;
        ESG_HASH_RAND(h1, h2, _factor, iz);
        iz += _mountainNo;
        ESG_GAUSS_RAND(iz, gauss_rand);
        left_fz = (ul_fz + ll_fz) / 2.0 + rise_height * gauss_rand;

        h1 = ll_x + half_width;
        h2 = ll_y + half_width;
        ESG_HASH_RAND(h1, h2, _factor, iz);
        iz += _mountainNo;
        ESG_GAUSS_RAND(iz, gauss_rand);
        middle_fz = ((ll_fz + lr_fz + ur_fz + ul_fz) /
                     4.0 + 1.4142136 * rise_height * gauss_rand);
        
        /* check subsections for subdivision or output */
        _grow_mountain(fnum_pts, half_width, ll_x, ll_y,
                       ll_fz, lower_fz, middle_fz, left_fz,
                       materials, numMats);
        _grow_mountain(fnum_pts, half_width, ll_x+half_width, ll_y,
                       lower_fz, lr_fz, right_fz, middle_fz,
                       materials, numMats);
        _grow_mountain(fnum_pts, half_width, ll_x+half_width, ll_y+half_width,
                       middle_fz, right_fz, ur_fz, upper_fz,
                       materials, numMats);
        _grow_mountain(fnum_pts, half_width, ll_x, ll_y+half_width,
                       left_fz, middle_fz, upper_fz, ul_fz,
                       materials, numMats);
    }
}

FractalMount::FractalMount(const SDS & proto,
                       unsigned        factor,
                       unsigned        mn,
                       double          xc,
                       double          yc,
                       double          w)
    : Scene(proto)
{
    _factor = factor;

    AutoPtr<Material>** materials;
    unsigned            numMats;
    materials = _create_crystal_materials(numMats);
    _create_spheres(Vector4(-0.3, 0.3, 0.5, 0.15), materials, numMats);

    materials    = _create_mount_materials(numMats);
    int num_pts  = 1<<_factor;
    double ratio = 2.0 / exp((double)(log((double)2.0) / 1.2));
    _mountainNo  = mn;
    _xCorner     = xc;
    _yCorner     = yc;
    _width       = w;
    _roughness   = sqrt((double)(ratio * ratio - 1.0));
    
    _grow_mountain((double)num_pts, num_pts, 0, 0, 0.0, 0.0, 0.0, 0.0,
                   materials, numMats);

    _create_lights();

    build();
}
                       

---