vmap/radiant/points.cpp

/*
   Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
   The following source code is licensed by Id Software and subject to the terms of
   its LIMITED USE SOFTWARE LICENSE AGREEMENT, a copy of which is included with
   GtkRadiant. If you did not receive a LIMITED USE SOFTWARE LICENSE AGREEMENT,
   please contact Id Software immediately at info@idsoftware.com.
 */

#include "points.h"

#include "debugging/debugging.h"

#include "irender.h"
#include "igl.h"
#include "renderable.h"

#include "stream/stringstream.h"
#include "os/path.h"
#include "os/file.h"
#include "cmdlib.h"

#include "map.h"
#include "qe3.h"
#include "camwindow.h"
#include "xywindow.h"
#include "xmlstuff.h"
#include "mainframe.h"
#include "watchbsp.h"
#include "commands.h"


class CPointfile;

void Pointfile_Parse(CPointfile &pointfile);


class CPointfile : public ISAXHandler, public Renderable, public OpenGLRenderable {
    enum {
        MAX_POINTFILE = 8192,
    };
    Vector3 s_pointvecs[MAX_POINTFILE];
    std::size_t s_num_points;
    int m_displaylist;
    static Shader *m_renderstate;
    StringOutputStream m_characters;
public:
    CPointfile()
    {
    }

    ~CPointfile()
    {
    }

    void Init();

    void PushPoint(const Vector3 &v);

    void GenerateDisplayList();

// SAX interface
    void Release()
    {
        // blank because not heap-allocated
    }

    void saxStartElement(message_info_t *ctx, const xmlChar *name, const xmlChar **attrs);

    void saxEndElement(message_info_t *ctx, const xmlChar *name);

    void saxCharacters(message_info_t *ctx, const xmlChar *ch, int len);

    const char *getName();

    typedef const Vector3 *const_iterator;

    const_iterator begin() const
    {
        return &s_pointvecs[0];
    }

    const_iterator end() const
    {
        return &s_pointvecs[s_num_points];
    }

    bool shown() const
    {
        return m_displaylist != 0;
    }

    void show(bool show)
    {
        if (show && !shown()) {
            Pointfile_Parse(*this);
            GenerateDisplayList();
            SceneChangeNotify();
        } else if (!show && shown()) {
            glDeleteLists(m_displaylist, 1);
            m_displaylist = 0;
            SceneChangeNotify();
        }
    }

    void render(RenderStateFlags state) const
    {
        glCallList(m_displaylist);
    }

    void renderSolid(Renderer &renderer, const VolumeTest &volume) const
    {
        if (shown()) {
            renderer.SetState(m_renderstate, Renderer::eWireframeOnly);
            renderer.SetState(m_renderstate, Renderer::eFullMaterials);
            renderer.addRenderable(*this, g_matrix4_identity);
        }
    }

    void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
    {
        renderSolid(renderer, volume);
    }

    static void constructStatic()
    {
        m_renderstate = GlobalShaderCache().capture("$POINTFILE");
    }

    static void destroyStatic()
    {
        GlobalShaderCache().release("$POINTFILE");
    }
};

Shader *CPointfile::m_renderstate = 0;

namespace {
    CPointfile s_pointfile;
}

ISAXHandler &g_pointfile = s_pointfile;

static CPointfile::const_iterator s_check_point;

void CPointfile::Init()
{
    s_num_points = 0;
    m_displaylist = 0;
}

void CPointfile::PushPoint(const Vector3 &v)
{
    if (s_num_points < MAX_POINTFILE) {
        s_pointvecs[s_num_points] = v;
        ++s_num_points;
    }
}

// create the display list at the end
void CPointfile::GenerateDisplayList()
{
    m_displaylist = glGenLists(1);

    glNewList(m_displaylist, GL_COMPILE);

    glBegin(GL_LINE_STRIP);
    for (std::size_t i = 0; i < s_num_points; i++)
        glVertex3fv(vector3_to_array(s_pointvecs[i]));
    glEnd();
    glLineWidth(1);

    glEndList();
}

// old (but still relevant) pointfile code -------------------------------------

void Pointfile_Delete(void)
{
    const char *mapname = Map_Name(g_map);
    StringOutputStream name(256);
    name << StringRange(mapname, path_get_filename_base_end(mapname)) << ".lin";
    file_remove(name.c_str());
}

// advance camera to next point
void Pointfile_Next(void)
{
    if (!s_pointfile.shown()) {
        return;
    }

    if (s_check_point + 2 == s_pointfile.end()) {
        globalOutputStream() << "End of pointfile\n";
        return;
    }

    CPointfile::const_iterator i = ++s_check_point;


    CamWnd &camwnd = *g_pParentWnd->GetCamWnd();
    Camera_setOrigin(camwnd, *i);
    g_pParentWnd->GetXYWnd()->SetOrigin(*i);
    {
        Vector3 dir(vector3_normalised(vector3_subtracted(*(++i), Camera_getOrigin(camwnd))));
        Vector3 angles(Camera_getAngles(camwnd));
        angles[CAMERA_YAW] = static_cast<float>( radians_to_degrees(atan2(dir[1], dir[0])));
        angles[CAMERA_PITCH] = static_cast<float>( radians_to_degrees(asin(dir[2])));
        Camera_setAngles(camwnd, angles);
    }
}

// advance camera to previous point
void Pointfile_Prev(void)
{
    if (!s_pointfile.shown()) {
        return;
    }

    if (s_check_point == s_pointfile.begin()) {
        globalOutputStream() << "Start of pointfile\n";
        return;
    }

    CPointfile::const_iterator i = --s_check_point;

    CamWnd &camwnd = *g_pParentWnd->GetCamWnd();
    Camera_setOrigin(camwnd, *i);
    g_pParentWnd->GetXYWnd()->SetOrigin(*i);
    {
        Vector3 dir(vector3_normalised(vector3_subtracted(*(++i), Camera_getOrigin(camwnd))));
        Vector3 angles(Camera_getAngles(camwnd));
        angles[CAMERA_YAW] = static_cast<float>( radians_to_degrees(atan2(dir[1], dir[0])));
        angles[CAMERA_PITCH] = static_cast<float>( radians_to_degrees(asin(dir[2])));
        Camera_setAngles(camwnd, angles);
    }
}

int LoadFile(const char *filename, void **bufferptr)
{
    FILE *f;
    long len;

    f = fopen(filename, "rb");
    if (f == 0) {
        return -1;
    }

    fseek(f, 0, SEEK_END);
    len = ftell(f);
    rewind(f);

    *bufferptr = malloc(len + 1);
    if (*bufferptr == 0) {
        return -1;
    }

    fread(*bufferptr, 1, len, f);
    fclose(f);

    // we need to end the buffer with a 0
    ((char *) (*bufferptr))[len] = 0;

    return len;
}

void Pointfile_Parse(CPointfile &pointfile)
{
    int size;
    char *data;
    char *text;
    int line = 1;

    const char *mapname = Map_Name(g_map);
    StringOutputStream name(256);
    name << StringRange(mapname, path_get_filename_base_end(mapname)) << ".lin";

    size = LoadFile(name.c_str(), (void **) &data);
    if (size == -1) {
        globalErrorStream() << "Pointfile " << name.c_str() << " not found\n";
        return;
    }

    // store a pointer
    text = data;

    globalOutputStream() << "Reading pointfile " << name.c_str() << "\n";

    pointfile.Init();

    while (*data) {
        Vector3 v;
        if (sscanf(data, "%f %f %f", &v[0], &v[1], &v[2]) != 3) {
            globalOutputStream() << "Corrupt point file, line " << line << "\n";
            break;
        }

        while (*data && *data != '\n') {
            if (*(data - 1) == ' ' && *(data) == '-' && *(data + 1) == ' ') {
                break;
            }
            data++;
        }
        // deal with zhlt style point files.
        if (*data == '-') {
            if (sscanf(data, "- %f %f %f", &v[0], &v[1], &v[2]) != 3) {
                globalOutputStream() << "Corrupt point file, line " << line << "\n";
                break;
            }

            while (*data && *data != '\n') {
                data++;
            }

        }
        while (*data == '\n') {
            data++; // skip the \n
            line++;
        }
        pointfile.PushPoint(v);
    }

    g_free(text);
}

void Pointfile_Clear()
{
    s_pointfile.show(false);
}

void Pointfile_Toggle()
{
    s_pointfile.show(!s_pointfile.shown());

    s_check_point = s_pointfile.begin();
}

void Pointfile_Construct()
{
    CPointfile::constructStatic();

    GlobalShaderCache().attachRenderable(s_pointfile);

    GlobalCommands_insert("TogglePointfile", makeCallbackF(Pointfile_Toggle));
    GlobalCommands_insert("NextLeakSpot", makeCallbackF(Pointfile_Next),
                          Accelerator('K', (GdkModifierType) (GDK_SHIFT_MASK | GDK_CONTROL_MASK)));
    GlobalCommands_insert("PrevLeakSpot", makeCallbackF(Pointfile_Prev),
                          Accelerator('L', (GdkModifierType) (GDK_SHIFT_MASK | GDK_CONTROL_MASK)));
}

void Pointfile_Destroy()
{
    GlobalShaderCache().detachRenderable(s_pointfile);

    CPointfile::destroyStatic();
}


// CPointfile implementation for SAX-specific stuff -------------------------------
void CPointfile::saxStartElement(message_info_t *ctx, const xmlChar *name, const xmlChar **attrs)
{
    if (string_equal(reinterpret_cast<const char *>( name ), "polyline")) {
        Init();
        // there's a prefs setting to avoid stopping on leak
        if (!g_WatchBSP_LeakStop) {
            ctx->stop_depth = 0;
        }
    }
}

void CPointfile::saxEndElement(message_info_t *ctx, const xmlChar *name)
{
    if (string_equal(reinterpret_cast<const char *>( name ), "polyline")) {
        // we are done
        GenerateDisplayList();
        SceneChangeNotify();
        s_check_point = begin();
    } else if (string_equal(reinterpret_cast<const char *>( name ), "point")) {
        Vector3 v;
        sscanf(m_characters.c_str(), "%f %f %f\n", &v[0], &v[1], &v[2]);
        PushPoint(v);
        m_characters.clear();
    }
}

// only "point" is expected to have characters around here
void CPointfile::saxCharacters(message_info_t *ctx, const xmlChar *ch, int len)
{
    m_characters.write(reinterpret_cast<const char *>( ch ), len);
}

const char *CPointfile::getName()
{
    return "Map leaked";
}