---

Clipper.cc

Go to the documentation of this file.

/*
    File:       Clipper.cc

    Function:   Clips homogeneous coordinates to the unit cube
                between [0 0 0] and [1 1 1].

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/Clipper.h"
#include "cl/String.h"

#define DBG_COUT if (0) cerr

Clipper::Clipper()
{
    lastOutcode = 0;
    lastP = vl_0;
}

Void Clipper::ClipPoint(const HPoint &p, Bool draw)
{
    Int         outcode;
    BdryCoords  bc;

    // calc BC for [-1, 1] x [-1, 1] x [0, 1]
                                // bc is -ve if:
    bc[0] = p[3] + p[0];        // x < -1
    bc[1] = p[3] - p[0];        // x > 1
    bc[2] = p[3] + p[1];        // y < -1
    bc[3] = p[3] - p[1];        // y > 1
    bc[4] = p[2];               // z < 0
    bc[5] = p[3] - p[2];        // z > 1

    // should replace this with non-branching code where possible
    outcode = 0;
    if (bc[0] < 0) outcode |= 0x01;
    if (bc[1] < 0) outcode |= 0x02;
    if (bc[2] < 0) outcode |= 0x04;
    if (bc[3] < 0) outcode |= 0x08;
    if (bc[4] < 0) outcode |= 0x10;
    if (bc[5] < 0) outcode |= 0x20;
    
    DBG_COUT << String().Printf("outcode = %02x", outcode) << endl;

    // do the clipping

    if (!draw)
    {
        // move if we're inside the clip volume
        if (outcode == 0)
            ViewPoint(p, draw);
    }
    else
    {
        if ((outcode & lastOutcode) == 0)
            // we have at least one endpoint inside all planes
            if ((outcode | lastOutcode) == 0)
                // both are inside: trivial accept
                ViewPoint(p, draw);
            else
            {
                Int         i, clip = outcode | lastOutcode, mask = 1;
                GCLReal     alpha, alpha0 = 0.0, alpha1 = 1.0;

                DBG_COUT << String().Printf("clipping: clip = %02x", clip) << endl;

                // must clip line segment to the volume.

                // step through each plane              
                for (i = 0; i < 6; i++, mask <<= 1)
                {
                    if (mask & clip)
                    // we straddled this boundary
                    {
                        // find the alpha of the intersection with this plane
                        alpha = lastBC[i] / (lastBC[i] - bc[i]);
                        if (lastOutcode & mask)
                            // heading in: clip alpha0
                            alpha0 = Max(alpha0, alpha);
                        else
                            // heading out: clip alpha1
                            alpha1 = Min(alpha1, alpha);
                    }
                }

                DBG_COUT << "alpha0 = " << alpha0 << " alpha1 = " << alpha1 << endl;                

                if (lastOutcode)
                    // heading in, so move to entry point
                    ViewPoint(lastP + alpha0 * (p - lastP), false);
                if (outcode)
                    // heading out, so draw to exit point
                    ViewPoint(lastP + alpha1 * (p - lastP), true);
                else
                    // terminate inside clipping volume, so just draw!
                    ViewPoint(p, true);
            }
    }

    lastOutcode = outcode;
    lastBC[0] = bc[0];
    lastBC[1] = bc[1];
    lastBC[2] = bc[2];
    lastBC[3] = bc[3];
    lastBC[4] = bc[4];
    lastBC[5] = bc[5];
    lastP = p;
}

---