src/lib/bgllwm.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.

// bgllwm.cc : LWM BGL process

#include <stdio.h>
#include <string.h>
#include <math.h>

#include "bgllwm.hpp"
#include "bbox.hpp"

//////////////////////////////////////////////////////////////////
// LwmDataChunk

void LwmDataChunk::DataAreaFill(int blocksz, int attr, int u, int v)
{
        if (attr == 1) {
                return; // land polygon ::: ad hoc... ###
        }

        switch (blocksz) {
        case 1:
                databuf->sprintf("\tLWMDataAreaFill1x1 0, %d, 1, %d, %d\n", attr, u, v);
                break;

        case 2:
        case 4:
        case 8:
        case 16:
                databuf->sprintf("\tLWMDataAreaFill%dx%d 0, %d, 0, 1, %d, 0, %d\n", 
                       blocksz, blocksz, 
                       attr, u/blocksz, v/blocksz);
                break;

        default:        
                /* oops!!! */
                break;
        }
        if (attr == 0 || attr == 2 || true) {//###
                databuf->sprintf("\tLWMDataAreaHeight -9999, 0\n");
        }
}

void LwmDataChunk::DataAreaDrawPolygons(int PolyCount, int u, int v)
{
        if (PolyCount <= 6) {
                databuf->sprintf(
                        "\tLWMDataAreaDrawPolygons %d, %d, %d, %d, %d\n",
                        PolyCount,      // poly count
                        3,              // attr (must be 3)
                        1,              // flag (must be 1)
                        u,              // col
                        v               // row
                        );
        } else {
                databuf->sprintf(
                        "\tLWMDataAreaDrawPolygonsEx %d, %d, %d, %d, %d, %d\n",
                        7,              // poly ex flag (must be 7)
                        3,              // attr (must be 3)
                        1,              // flag (must be 1)
                        u,              // col
                        v,              // row
                        PolyCount - 7   // ExPolyCount
                        );
        }
}

void LwmDataChunk::Polygon(int NumVertices, int type)
{
        if (NumVertices <= 62) {
                databuf->sprintf(
                        "\tLWMPoly2 %d, %d, %d, %d, %d\n",
                        NumVertices,    // PointCount
                        0,              // reserved
                        type,           // attr (0 = water, 1 = land)
                        -9999,          // Height
                        0               // Fraction
                        );
        } else {
                databuf->sprintf(
                        "\tLWMPoly2Ex %d, %d, %d, %d, %d, %d\n",
                        63,             // PointCount (must be 63)
                        0,              // reserved
                        type,           // attr (0 = water, 1 = land)
                        -9999,          // Height
                        0,              // Fraction
                        NumVertices-63  // ExPointCount
                        );
        }
}

void LwmDataChunk::Point(int x, int y)
{
        databuf->sprintf("\t\tLWMPoint %d, %d\n", x, y);
}

/////////////////////////////////////////////////////////////////
// LwmBgl

LwmBgl::LwmBgl()
{
        // nothing to do
}

LwmBgl::~LwmBgl()
{
        // nothing to do
}

DataChunk *LwmBgl::NewDataChunk(int u, int v, BoundingBox &bb)
{
        LwmDataChunk *data = new LwmDataChunk();
        data->setuv(u, v);

        datachunk.push_back(data);

        UpdateBoundingBox(bb);

        return data;
}

void LwmBgl::WriteBGL(const char *fname)
{
        OpenFile(fname);

        int count = datachunk.size();
        int i;

        // Write BGL + TerrainHeader
        WriteBGLHeader("LWMHeader", NULL);

        // Write LWM Header
        fprintf(fp,"LWMHeader label word\n");
        fprintf(fp,"\tLWMFileHeader 201h, LWMIndexStart, LWMDataStart, LWMEnd\n\n");

        fprintf(fp,"LWMStart  label word\n");
        fprintf(fp,"DataStart label word\n\n");
        fprintf(fp,";--------------------------------------------------------\n");

        // Data
        fprintf(fp, "LWMDataStart label word\n");
        for (i = 0; i < count; i++) {
                fprintf(fp, "LWMDataStart_%d label word\n", i);
                datachunk[i]->WriteDataChunk(fp);
                fprintf(fp, "LWMDataEnd_%d label word\n", i);
        }
        fprintf(fp, "LWMDataEnd label word\n");

        // Index Header
        fprintf(fp, ";--------------------------------------------------------\n");

        fprintf(fp, "\n");

        fprintf(fp, "LWMIndexStart label word\n");
        fprintf(fp, "\tLWMIndexHeader %d, LWMIndexData\n", count);
        fprintf(fp, "\n");

        // Index Entry
        fprintf(fp, "LWMIndexData label word\n");
        for (i = 0; i < count; i++) {
                int u, v;
                datachunk[i]->getuv(u, v);

                fprintf(fp, "\tCell_id_%d_%d  EQU LWMCellID 0, 0, %d, %d, %d\n", u, v, 
                        1/*fill with land!*/, u, v);
                fprintf(fp, "\tLWMIndexEntry Cell_id_%d_%d, LWMStart"
                        ", LWMDataStart_%d, LWMDataEnd_%d\n\n", 
                        u, v, i, i);
        }

        // End
        fprintf(fp, "LWMEnd label word\n");
        fprintf(fp, ";EOF\n");
}
        