src/lib/area.cpp

//
// AutoCoast: Automatic Coastline scenery generator for Flight Simulator
//
// Copyright (c) 2004, Takuya Murakami. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// cellarea.cc : Cell/Area process

#include <math.h>
#include "area.hpp"
#include "bgl.hpp"

///////////////////////////////////////////////////////////////////////
// Area

Area::Area()
{
        polygon = NULL;
}

void Area::setid(int uu, int vv, BoundingBox & cellbox)
{
        u = uu;
        v = vv;

        bbox.xmin = cellbox.xmin + (cellbox.xmax - cellbox.xmin) * u / 32.0;
        bbox.xmax = cellbox.xmin + (cellbox.xmax - cellbox.xmin) * (u+1) / 32.0;

        bbox.ymax = cellbox.ymax - (cellbox.ymax - cellbox.ymin) * v / 32.0;
        bbox.ymin = cellbox.ymax - (cellbox.ymax - cellbox.ymin) * (v+1) / 32.0;
}

void Area::Clipping(DataSet *source)
{
        polygon = source->Clipping(bbox);
}

//
// decide Area type
//
void Area::setType(void)
{
        areaType = T_WATER;     // default: water

        for (int i = 1; i <= NUM_LEVEL; i++) {
                // If there are no polygons, go to next level.
                if (polygon->get(i)->isEmpty()) continue;

                if (polygon->get(i)->isFull(bbox)) {
                        // Whole the area is covered with one polygon.
                        // Change area type.
                        if (i == LV_LAND || i == LV_LAKE_ISLAND) {
                                areaType = T_LAND;
                        } else {
                                areaType = T_WATER;
                        }
                }
                else {
                        // The area is partially covered with some polygons.
                        areaType = (areaType == T_LAND) ? T_MIX_LAND : T_MIX_WATER;
                        break;
                }
        }
        //printf("%d %d %d\n", u, v, areaType); //DEBUG
}

/////////////////////////////////////////////////////////////////////////
// LWM Process

void Area::DrawLwmPolygon(LwmDataChunk *chunk)
{
        if (areaType != T_MIX_LAND && areaType != T_MIX_WATER) return;

        for (int level = 1; level <= 4; level++) {
                GpcPolygon *p = polygon->get(level);

                // Is drawing needed?
                if (p->isEmpty() || p->isFull(bbox)) continue;

                chunk->DataAreaDrawPolygons(p->numVList(), u, v);

                for (int i = 0; i < p->numVList(); i++) {
                        GpcVertexList *vlist = p->getVList(i);

                        chunk->Polygon(vlist->numVertices(),
                                     (level == LV_LAND || level == LV_LAKE_ISLAND) ? 1 : 0);

                        for (int j = 0; j < vlist->numVertices(); j++) {
                                int x = (int)((vlist->vx(j) - bbox.xmin) / (bbox.xmax - bbox.xmin) * 255.0);
                                int y = (int)((bbox.ymax - vlist->vy(j)) / (bbox.ymax - bbox.ymin) * 255.0);
                                
                                chunk->Point(x, y);
                        }
                }
        }
}

void Area::FillLand(LwmDataChunk *chunk)
{
        ASSERT(areaType == T_LAND);

        chunk->DataAreaDrawPolygons(1, u, v);
        chunk->Polygon(4, 1);

        chunk->Point(0, 0);
        chunk->Point(255, 0);
        chunk->Point(255, 255);
        chunk->Point(0, 255);
}
