src/util/pointedthing.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "pointedthing.h"
  21
  22 #include "serialize.h"
  23 #include "exceptions.h"
  24 #include <sstream>
  25
  26 PointedThing::PointedThing(const v3s16 &under, const v3s16 &above,
  27         const v3s16 &real_under, const v3f &point, const v3s16 &normal,
  28         u16 box_id, f32 distSq):
  29         type(POINTEDTHING_NODE),
  30         node_undersurface(under),
  31         node_abovesurface(above),
  32         node_real_undersurface(real_under),
  33         intersection_point(point),
  34         intersection_normal(normal),
  35         box_id(box_id),
  36         distanceSq(distSq)
  37 {}
  38
  39 PointedThing::PointedThing(s16 id, const v3f &point, const v3s16 &normal,
  40         f32 distSq) :
  41         type(POINTEDTHING_OBJECT),
  42         object_id(id),
  43         intersection_point(point),
  44         intersection_normal(normal),
  45         distanceSq(distSq)
  46 {}
  47
  48 std::string PointedThing::dump() const
  49 {
  50         std::ostringstream os(std::ios::binary);
  51         switch (type) {
  52         case POINTEDTHING_NOTHING:
  53                 os << "[nothing]";
  54                 break;
  55         case POINTEDTHING_NODE:
  56         {
  57                 const v3s16 &u = node_undersurface;
  58                 const v3s16 &a = node_abovesurface;
  59                 os << "[node under=" << u.X << "," << u.Y << "," << u.Z << " above="
  60                         << a.X << "," << a.Y << "," << a.Z << "]";
  61         }
  62                 break;
  63         case POINTEDTHING_OBJECT:
  64                 os << "[object " << object_id << "]";
  65                 break;
  66         default:
  67                 os << "[unknown PointedThing]";
  68         }
  69         return os.str();
  70 }
  71
  72 void PointedThing::serialize(std::ostream &os) const
  73 {
  74         writeU8(os, 0); // version
  75         writeU8(os, (u8)type);
  76         switch (type) {
  77         case POINTEDTHING_NOTHING:
  78                 break;
  79         case POINTEDTHING_NODE:
  80                 writeV3S16(os, node_undersurface);
  81                 writeV3S16(os, node_abovesurface);
  82                 break;
  83         case POINTEDTHING_OBJECT:
  84                 writeS16(os, object_id);
  85                 break;
  86         }
  87 }
  88
  89 void PointedThing::deSerialize(std::istream &is)
  90 {
  91         int version = readU8(is);
  92         if (version != 0) throw SerializationError(
  93                         "unsupported PointedThing version");
  94         type = (PointedThingType) readU8(is);
  95         switch (type) {
  96         case POINTEDTHING_NOTHING:
  97                 break;
  98         case POINTEDTHING_NODE:
  99                 node_undersurface = readV3S16(is);
 100                 node_abovesurface = readV3S16(is);
 101                 break;
 102         case POINTEDTHING_OBJECT:
 103                 object_id = readS16(is);
 104                 break;
 105         default:
 106                 throw SerializationError("unsupported PointedThingType");
 107         }
 108 }
 109
 110 bool PointedThing::operator==(const PointedThing &pt2) const
 111 {
 112         if (type != pt2.type)
 113         {
 114                 return false;
 115         }
 116         if (type == POINTEDTHING_NODE)
 117         {
 118                 if ((node_undersurface != pt2.node_undersurface)
 119                                 || (node_abovesurface != pt2.node_abovesurface)
 120                                 || (node_real_undersurface != pt2.node_real_undersurface))
 121                         return false;
 122         }
 123         else if (type == POINTEDTHING_OBJECT)
 124         {
 125                 if (object_id != pt2.object_id)
 126                         return false;
 127         }
 128         return true;
 129 }
 130
 131 bool PointedThing::operator!=(const PointedThing &pt2) const
 132 {
 133         return !(*this == pt2);
 134 }