src/cl.uchile.dcc.bnac/Hall.java

   1 /*
   2  *  bnac : virtual museum environment creation/manipulation project
   3  *  Copyright (C) 2010 Felipe Cañas Sabat
   4  *
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 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 General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 package cl.uchile.dcc.bnac;
  20
  21 import java.util.ArrayList;
  22 import java.util.Properties;
  23
  24 import javax.vecmath.Point2f;
  25 import javax.vecmath.Point3f;
  26
  27 public class Hall
  28 {
  29     protected float height;
  30     protected ArrayList<Point2f> corners;
  31     protected ArrayList<Wall> walls;
  32     protected ArrayList<StartingPoint> sps;
  33     protected Point2f min;
  34     protected Point2f max;
  35     protected Properties props;
  36
  37     public Hall (String id)
  38     {
  39         BnacLog.trace("new Hall %s", id);
  40         props = new Properties();
  41         props.setProperty(Attribute.Id.name(), id);
  42         props.setProperty("name", id);
  43
  44         this.height = 3.0f;
  45         this.corners = new ArrayList<Point2f>();
  46         walls = new ArrayList<Wall>();
  47         sps = new ArrayList<StartingPoint>();
  48
  49         Point2f[] cs = {
  50             new Point2f(0.0f, 0.0f),
  51             new Point2f(0.0f, 10.0f),
  52             new Point2f(10.0f, 10.0f),
  53             new Point2f(10.0f, 0.0f)
  54         };
  55         setCorners(cs);
  56     }
  57
  58     public Hall (String id, float height, Point2f[] corners)
  59     {
  60         if (corners.length > 0) {
  61             BnacLog.trace("new Hall %s %.02f >>", id, height);
  62             for (Point2f corner: corners) {
  63                 BnacLog.trace("\t(%.02f,%.02f)", corner.x, corner.y);
  64             }
  65         } else {
  66             BnacLog.trace("new Hall %s %.02f >><<", id, height);
  67         }
  68         BnacLog.trace("<<");
  69         props = new Properties();
  70         props.setProperty(Attribute.Id.name(), id);
  71
  72         this.height = height;
  73         this.corners = new ArrayList<Point2f>();
  74         walls = new ArrayList<Wall>();
  75         sps = new ArrayList<StartingPoint>();
  76
  77         setCorners(corners);
  78     }
  79
  80     public void setHeight (float h)
  81     {
  82         BnacLog.debug("set height %.02f", h);
  83         height = h;
  84     }
  85
  86     public float getHeight () { return height; }
  87
  88     public void setCorners (float[] ps)
  89     {
  90         Point2f[] r = new Point2f[ps.length/2];
  91         for (int i=0; i<ps.length; i+=2) {
  92             r[i/2] = new Point2f(ps[i], ps[i+1]);
  93         }
  94         setCorners(r);
  95     }
  96     public void setCorners (Point2f[] ps)
  97     {
  98         if (!Util.isClockwise(ps)) { return; }
  99
 100         corners.clear();
 101         for (Point2f p: ps) { corners.add(p); }
 102
 103         for (int i=0; i<ps.length; ++i) {
 104             walls.add(new Wall(ps[i], ps[(i+1)%ps.length]));
 105         }
 106
 107         updateMaxMin();
 108     }
 109     public Wall addCorner (int idx, Point2f p)
 110     {
 111         BnacLog.debug("addCorner %d (%.02f,%.02f)", idx, p.x, p.y);
 112         Wall wal = walls.get((idx>0)?idx-1:walls.size()-1);
 113         Wall newwall = wal.split(p);
 114
 115         corners.add(idx, p);
 116         walls.add(idx, newwall);
 117
 118         min = max = null;
 119         for (Point2f corner: corners) {
 120             BnacLog.trace("(%.02f,%.02f)", corner.x, corner.y);
 121         }
 122         for (int i=0; i<walls.size(); ++i) {
 123             BnacLog.trace("%d (%.02f,%.02f)-(%.02f,%.02f)", i,
 124                     walls.get(i).origin2f().x, walls.get(i).origin2f().y,
 125                     walls.get(i).end2f().x, walls.get(i).end2f().y);
 126         }
 127         return newwall;
 128     }
 129     public void moveCorner (int idx, Point2f p)
 130     {
 131         BnacLog.debug("moveCorner %d (%.02f,%.02f)->(%.02f,%.02f)",
 132                 idx, corners.get(idx).x, corners.get(idx).y, p.x, p.y);
 133         int prv = (idx>0) ? idx-1 : corners.size()-1;
 134
 135         corners.get(idx).set(p);
 136         walls.get(prv).setEnd(p);
 137         walls.get(idx).setOrigin(p);
 138
 139         min = max = null;
 140     }
 141     public Wall removeCorner (int idx)
 142     {
 143         BnacLog.debug("removeCorner %d", idx);
 144         if (corners.size() > 3) {
 145             Wall prev = walls.get((idx>0)?idx-1:walls.size()-1);
 146             Wall wall = walls.get(idx);
 147             Wall ret = new Wall(prev.origin2f(), wall.end2f());
 148
 149             corners.remove(idx);
 150             if (idx > 0) {
 151                 walls.remove((idx>0)?idx-1:walls.size()-1);
 152                 walls.remove((idx>0)?idx-1:walls.size()-1);
 153                 walls.add(idx-1, ret);
 154             } else {
 155                 walls.remove(walls.size()-1);
 156                 walls.remove(0);
 157                 walls.add(walls.size(), ret);
 158             }
 159
 160             for (Point2f corner: corners) {
 161                 BnacLog.trace("(%.02f,%.02f)", corner.x, corner.y);
 162             }
 163             for (int i=0; i<walls.size(); ++i) {
 164                 BnacLog.trace("%d (%.02f,%.02f)-(%.02f,%.02f)", i,
 165                         walls.get(i).origin2f().x, walls.get(i).origin2f().y,
 166                         walls.get(i).end2f().x, walls.get(i).end2f().y);
 167             }
 168
 169             return ret;
 170         }
 171         return null;
 172     }
 173     public Point2f getCorner (int idx)
 174     {
 175         return new Point2f(corners.get(idx));
 176     }
 177     public Point2f[] cornerArray () {
 178         return corners.toArray(new Point2f[0]);
 179     }
 180     public int cornerCount () { return corners.size(); }
 181
 182     protected void updateMaxMin ()
 183     {
 184         min = new Point2f(Float.MAX_VALUE, Float.MAX_VALUE);
 185         max = new Point2f(Float.MIN_VALUE, Float.MIN_VALUE);
 186         for (Point2f p: corners) {
 187             if (p.x < min.x) { min.x = p.x; }
 188             else if (p.x > max.x) { max.x = p.x; }
 189             if (p.y < min.y) { min.y = p.y; }
 190             else if (p.y > max.y) { max.y = p.y; }
 191         }
 192     }
 193
 194     public Wall setWall (int idx, Wall w)
 195     {
 196         BnacLog.debug("setWall %d (%.02f,%.02f)-(%.02f,%.02f)", idx,
 197                 w.origin2f().x, w.origin2f().y,
 198                 w.end2f().x, w.end2f().y);
 199         min = max = null;
 200         return walls.set(idx, w);
 201     }
 202     public Wall[] wallArray () { return walls.toArray(new Wall[0]); }
 203     public Wall getWall (int i) { return walls.get(i); }
 204     public int wallCount () { return walls.size(); }
 205
 206     public int getParentWall (String id)
 207     {
 208         for (int i=0; i<walls.size(); ++i) {
 209             if (walls.get(i).getDoor(id) != null ||
 210                     walls.get(i).getPlacedCapture(id) != null) {
 211                 return i;
 212             }
 213         }
 214         return -1;
 215     }
 216
 217     public PlacedCapture getPlacedCapture (String id)
 218     {
 219         return walls.get(getParentWall(id)).getPlacedCapture(id);
 220     }
 221
 222     public Door getDoor (String id)
 223     {
 224         for (Wall wall: walls) {
 225             if (wall.getDoor(id) != null) {
 226                 return wall.getDoor(id);
 227             }
 228         }
 229         return null;
 230     }
 231
 232     public Point2f dif ()
 233     {
 234         Point2f min = min();
 235         Point2f max = max();
 236         return new Point2f(max.x-min.x, max.y-min.y);
 237     }
 238     public Point2f min ()
 239     {
 240         if (min == null || max == null) { updateMaxMin(); }
 241         return new Point2f(min);
 242     }
 243     public Point2f max ()
 244     {
 245         if (min == null || max == null) { updateMaxMin(); }
 246         return new Point2f(max);
 247     }
 248     public Point2f centre2f (boolean negY)
 249     {
 250         return new Point2f(dif().x/2, dif().y/2 * (negY ? -1 : 1));
 251     }
 252     public Point3f centre3f ()
 253     {
 254         return new Point3f(dif().x/2, 0.0f, -dif().y/2);
 255     }
 256
 257     public void set (Attribute prop, String val)
 258     {
 259         props.setProperty(prop.name(), val);
 260     }
 261     public String get (Attribute prop)
 262     {
 263         return props.getProperty(prop.name());
 264     }
 265
 266     public void set (String prop, String val)
 267     {
 268         props.setProperty(prop, val);
 269     }
 270     public String get (String prop)
 271     {
 272         return props.getProperty(prop);
 273     }
 274
 275     public void setId (String id)
 276     {
 277         props.setProperty(Attribute.Id.name(), id);
 278     }
 279     public String getId () { return props.getProperty(Attribute.Id.name()); }
 280
 281     public String getName () { return props.getProperty("name"); }
 282
 283     public void setName (String name) { props.setProperty("name", name); }
 284
 285     public void addStartingPoint (String id, Point2f pos, float angle)
 286     {
 287         sps.add(new StartingPoint(id, pos, angle));
 288     }
 289     public StartingPoint getStartingPoint (String id)
 290     {
 291         for (StartingPoint sp: sps)
 292         {
 293             if (sp.getId().equals(id)) { return sp; }
 294         }
 295         return null;
 296     }
 297     public StartingPoint getFirstStartingPoint () { return sps.get(0); }
 298     public StartingPoint[] startingPointArray ()
 299     {
 300         return sps.toArray(new StartingPoint[0]);
 301     }
 302
 303     public class StartingPoint
 304     {
 305         public String id;
 306         public Point2f pos;
 307         public float angle;
 308
 309         public StartingPoint (String id, Point2f pos, float angle)
 310         {
 311             this.id = id;
 312             this.pos = new Point2f(pos);
 313             this.angle = angle;
 314         }
 315
 316         public String getId () { return id; }
 317         public Point3f getPosition3f ()
 318         {
 319             return new Point3f(pos.x, 1.70f, -pos.y);
 320         }
 321     }
 322 }
 323