vertexes.cpp

Go to the documentation of this file.

// libdoomwad: manipulates Doom wad files.
// Copyright (C) 2005  John Gaughan
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// This library is distributed with the full text of the LGPL. Please see
// the accompanying file named COPYING.
// 
// You may contact the author at john@johngaughan.net

// C++ required.
#if !defined __cplusplus
#error C++ compiler required
#endif

// C++ headers
#include <exception>
#include <sstream>
#include <stdexcept>
#include <string>

// Doom headers
#include "global.hpp"
#include "lump.hpp"
#include "vertexes.hpp"
#include "wadentry.hpp"

using namespace Doomwad;

const size_t Vertex::LENGTH        = 0x00000004;
const size_t GLVertex::LENGTH      = 0x00000008;
const size_t GLVertexes::V2_MARKER = 0x674E6432;

const std::string Vertexes::NAME   = "VERTEXES";
const std::string GLVertexes::NAME = "GL_VERT";

Vertex::Vertex (int16 _x, int16 _y) throw () : x (_x), y (_y)
{
}

Vertex::~Vertex (void) throw ()
{
}

size_t Vertex::getLength (void) const throw ()
{
  return LENGTH;
}

bool Vertex::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setInt16 (this->x, i);
    lump.setInt16 (this->y, i + 2);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Vertex::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->x = lump.getInt16 (i);
    this->y = lump.getInt16 (i + 2);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Vertex::toString (void) const throw ()
{
  std::ostringstream str;
  str << '(' << this->x << ',' << this->y << ')';
  return str.str ();
}

GLVertex::GLVertex (int32 _x, int32 _y) throw () : x (_x), y (_y)
{
  return;
}

GLVertex::~GLVertex (void) throw ()
{
  return;
}

bool GLVertex::writeV1 (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setInt16 (this->x, i);
    lump.setInt16 (this->y, i + 2);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool GLVertex::readV1 (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->x = lump.getInt16 (i);
    this->y = lump.getInt16 (i + 2);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

size_t GLVertex::getLength (void) const throw ()
{
  return LENGTH;
}

bool GLVertex::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setInt32 (this->x, i);
    lump.setInt32 (this->y, i + 4);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool GLVertex::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->x = lump.getInt32 (i);
    this->y = lump.getInt32 (i + 4);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string GLVertex::toString (void) const throw ()
{
  std::ostringstream str;
  str << '(' << this->x << ',' << this->y << ')';
  return str.str ();
}

Vertexes::Vertexes (void) throw ()
{
  return;
}

Vertexes::Vertexes (const Lump &lump) throw ()
{
  this->setFromLump (lump);
  return;
}

Vertexes::~Vertexes (void) throw ()
{
  return;
}

bool Vertexes::setFromLump (const Lump &lump) throw ()
{

  // Vertexes lumps must be multiples of 4 bytes
  if (lump.size () % Vertex::LENGTH != 0) return false;

  size_t q = lump.size ();
  Vertex v;

  this->clear ();

  for (size_t i = 0; i < q; i += Vertex::LENGTH)
  {
    v.read (lump, i);
    this->push_back (v);
  }

  return true;
}

Lump Vertexes::toLump (void) const throw ()
{
  Lump lump (NAME, this->size () * Vertex::LENGTH);
  const_iterator iter = this->begin ();
  for (size_t i = 0; iter != this->end (); i += Vertex::LENGTH, ++iter)
  {
    iter->write (lump, i);
  }
  return lump;
}

std::string Vertexes::toString (void) const throw ()
{
  std::ostringstream str;
  for (const_iterator iter = this->begin (); iter != this->end (); ++iter)
    str << iter->toString () << '\n';
  return str.str ();
}

GLVertexes::GLVertexes (void) throw ()
{
  return;
}

GLVertexes::GLVertexes (const Lump &lump) throw ()
{
  this->setFromLump (lump);
  return;
}

GLVertexes::~GLVertexes (void) throw ()
{
  return;
}

bool GLVertexes::setFromLump (const Lump &lump) throw ()
{
  // TODO: implement
  lump.size ();
  return true;
}

Lump GLVertexes::toLump (void) const throw ()
{
  // TODO: implement
  Lump lump (NAME, this->size () * GLVertex::LENGTH);
  return lump;
}

Lump GLVertexes::toLumpV1 (void) const throw ()
{
  // TODO: implement
  Lump lump (NAME, this->size () * GLVertex::LENGTH / 2);
  return lump;
}

std::string GLVertexes::toString (void) const throw ()
{
  std::ostringstream str;
  for (GLVertexes::const_iterator i = this->begin (); i != this->end (); ++i)
    str << i->toString ();
  return str.str ();
}

---