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

// bglvtp.cc : VTP bgl

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

#include "bglvtp.hpp"
#include "bbox.hpp"
#include "opt.hpp"

//////////////////////////////////////////////////////////////////
// VtpDataChunk

void VtpDataChunk::DataArea(int u, int v, int numTexture, int autocalc)
{
        databuf->sprintf(
                "\tVTPDataArea %d, %d, %d, %d\n",
                1,              // layer count
                autocalc,       // autocalc
                u,              // row
                v);             // column
        databuf->sprintf(
                "\t\tVTPLayer %d, %d\n",
                8,      // layer (8 : shoreline)
                1);     // replace (1 : replace all previous data in the same layer)
        databuf->sprintf(
                "\t\tVTPNumTexturesInLayer %d, 0\n",
                numTexture);
}

void VtpDataChunk::TextureStart(int PolyCount)
{
        databuf->sprintf(
                "\t\tVTPTextureId 0, 0\n"
                "\t\tVTPPolyCount %d, 0\n", PolyCount);
}

void VtpDataChunk::PolyStart(int PointCount)
{
        if (PointCount <= 30) {
                databuf->sprintf(
                        "\t\tVTPPolyMethod2 %d, %d, 0\n",
                        PointCount,
                        1);     // IsLine (0:fan 1:line)
        } else {
                databuf->sprintf(
                        "\t\tVTPPolyMethod2 %d, %d, 0\n",
                        31,     // must be 31
                        1);     // IsLine (0:fan 1:line)
                databuf->sprintf(
                        "\t\tVTPPolyMethod2Ex %d\n",
                        PointCount - 31);
        }
}

void VtpDataChunk::WidePoint(int x, int y, int usewidth)
{
        databuf->sprintf("\t\t\tVTPWidePoint %d, %d, %d, %d\n",
                         x,             // X
                         usewidth,      // use width?
                         y,             // Y
                         0);            // reserved
}

void VtpDataChunk::WidePointWidth(int w)
{
        databuf->sprintf("\t\t\tVTPWidePointWidth %d\n", w);
}


/////////////////////////////////////////////////////////////////
// VtpBgl

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

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

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

        datachunk.push_back(data);

        UpdateBoundingBox(bb);

        return data;
}

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

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

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

        // Write VTPFileHeader
        fprintf(fp,"VTPHeader label word\n");
        fprintf(fp, "\tVTPFileHeader 256, VTPIndexStart, TextureStart, VTPEnd\n\n");
        fprintf(fp,";--------------------------------------------------------\n");

        // Data
        fprintf(fp, "VTPDataStart label word\n");
        for (i = 0; i < count; i++) {
                fprintf(fp, "VTPDataStart_%d label word\n", i);
                datachunk[i]->WriteDataChunk(fp);
                fprintf(fp, "VTPDataEnd_%d label word\n", i);
        }
        fprintf(fp, "VTPDataEnd label word\n");

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

        fprintf(fp, "VTPIndexStart label word\n");
        fprintf(fp, "\tVTPIndexHeader %d, VTPIndexData, VTPDataStart\n", count);
        fprintf(fp, "\n");

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

                fprintf(fp, "\tCell_id_%d_%d  EQU VTPCellID 0, %d, %d\n", u, v, u, v);
                fprintf(fp, "\tVTPIndexEntry Cell_id_%d_%d, VTPDataStart"
                        ", VTPDataStart_%d, VTPDataEnd_%d\n\n", 
                        u, v, i, i);
        }

        // Texture names
        fprintf(fp, ";--------------------------------------------------------\n\n");
        
        fprintf(fp, 
                "TextureStart label word\n"
                "\tVTPTextureListHeader 1, TextureIndexStart, TextureDataStart, TextureDataEnd\n");
        fprintf(fp,
                "TextureIndexStart label word\n"
                "\tVTPTextureListEntry TextureDataStart, TextureDataStart_0, TextureDataEnd_0\n");
        
        fprintf(fp,
                "TextureDataStart label word\n"
                "TextureDataStart_0 label word\n"
                "\tVTPTextureName \"%s\"\n"
                "\tVTPTextureType 2, 0, 0, 4\n"
                "TextureDataEnd_0 label word\n"
                "TextureDataEnd label word\n",
                AcOpts.textureName);

        // end
        fprintf(fp, "VTPEnd label word\n");
        fprintf(fp, ";EOF\n");
}