* This is part of SketchChair, an open-source tool for designing your own furniture.

*     www.sketchchair.cc

*    

*     Copyright (C) 2012, Diatom Studio ltd.  Contact: hello@diatom.cc

*

*     This program 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 3 of the License, or

*     (at your option) any later version.

*

*     This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

******************************************************************************/

* The SketchChair Class represents one SketchChair or SketchObject in the program,

* This Class Brings together a chairs geometry and settings specific to that chair.

*   

*<pre>

*       |\|\|\|\|\

*       || | | | |

*       || | | | |

*       || | | | |

*       || | | | |

*       ||\ \ \ \ \

*       || \ \ \ \ \

*        ||  \ \ \ \ \

*       ||  || | | |||

*       ||  ||      ||

*           ||      ||

*          ||      ||

*

* </pre> 

*

* @author Diatom Studio

*/

  float slatSpacingX = 39f;

  boolean built = false;

  private boolean builtOuline = false;

  Vec3D centreOfMass = new Vec3D();

  float coverLength = 0;

  float coverWidth = 0;

  // private SketchSpline crossSpline;

  // SlicePlane curSlicePlane = null;

  boolean destroy;

  public transient RigidBody rigidBody = null;

  transient Vector3f rigidRenderOffset = new Vector3f();

  public SlicePlanes selectedPlanes = new SlicePlanes();

  // SketchShapes sketchShapes = new SketchShapes();

  // SketchSpline sketchSpline = new SketchSpline();

  float slicePlaceSpacing = SETTINGS_SKETCH.slat_x_spacing;// spacing in

  public SlicePlanes slicePlanesSlatSlices = new SlicePlanes();

  public SlicePlanes slicePlanesY = new SlicePlanes();

  public CrossSliceSelections crossSliceSelections = new CrossSliceSelections();

  public CrossSliceSelection creossSelectionTempOver = null;

  transient public DefaultMotionState startMotionState;

  transient public Transform startWorldTransform;

  transient public Transform currentWorldTransform = new Transform();

  transient GImpactMeshShape trimesh = null;

  private boolean updateCollisionMesh = false;

  private float width = SETTINGS.chair_width; // 600mm

  private boolean reScaling = false;

  transient private Generic6DofConstraint chairCentreConstraint;

  // private FeltCover feltCover;

  private float scale = 1f;

  private float mass = 8f;

  private boolean dragging;

  public float startCoverPercent = 0;

  public float endCoverPercent = .5f;

  private boolean personSeated = false;

  private float imgBorder = 25;

  public String cloudID = null;

  public String localSavelocation = null;

  public boolean rebuildLength;

  public int chairColour = 255;

  private float density = 0.0001f;

  private TriangleIndexVertexArray indexVertexArrays;

  private float rotateRend = 0;

  private float materialWidth;

  private boolean initailSliceAdded = false;

  public int selectedPlaneNumber;

  SketchChair() {

    // this.sketchSpline.slots_on_inside = true;

    // this.sketchShapes.add(this.sketchSpline);

    // this.sketchShapes.currentShape = sketchSpline;

    GLOBAL.undo.addOperation(new UndoAction(this, UndoAction.ADD_CHAIR));

    //GLOBAL.planesWidget.planes = this.getSlicePlanesY();

    buildWidth();

    rebuildWidth();

  }

  /**

   * Build design from a XML element

   * @param element

   */

  public SketchChair(Element element) {

    // wrong type

    if (!element.getLocalName().equals("SketchChair"))

      return;

    // get slat spacing

    if (element.getAttributeValue("cloudID") != null)

      cloudID = element.getAttributeValue("cloudID");

    // get slat spacing

    if (element.getAttributeValue("slatSpacingX") != null)

      slatSpacingX = Float.valueOf(element

          .getAttributeValue("slatSpacingX"));

    if (element.getAttributeValue("materialWidth") != null)

      SETTINGS.materialThickness = Float.valueOf(element

          .getAttributeValue("materialWidth"));

    if (element.getAttributeValue("scale") != null)

      SETTINGS.scale = Float.valueOf(element.getAttributeValue("scale"));

    element.addAttribute(new Attribute("materialWidth", String

        .valueOf(SETTINGS.materialThickness)));

    element.addAttribute(new Attribute("scale", String

        .valueOf(SETTINGS.scale)));

    for (int i = 0; i < element.getChildCount(); i++) {

      Element child = (Element) element.getChild(i);

      if (child.getLocalName().equals("SlicePlanes"))

        this.setSlicePlanesY(new SlicePlanes(child));

      if (child.getLocalName().equals("CrossSliceSelections"))

        this.crossSliceSelections = new CrossSliceSelections(child,

            this.getSlicePlanesY(), this);

    }

    if (GLOBAL.widgetMaterials != null

        && GLOBAL.widgetMaterials.slotSizeTextfield != null) {

      GLOBAL.widgetMaterials.slotSizeTextfield.setText(

          Float.toString(SETTINGS.materialThickness));

    }

    // now we are a "live" object again, so let's run rebuild and start

    this.currentWorldTransform = new Transform();

    this.selectedPlanes.empty();

    this.selectedPlanes.add(this.getSlicePlanesY());

    this.selectedPlanes.buildCurrentSketch();

    // this.updateCollisionShape();

    LOGGER.debug("SketchChair: finished load: about to build chair for the first time");

    this.buildPreview();

    this.addRigidModel();

    //buildWidth();

    //move the model to the ground plane

    this.setAtGroundHeightCentred();

    this.personSeated = false;

    setCurrentPositionAsStartTransform();

    GLOBAL.jBullet.update();

    this.update();

    this.initailSliceAdded = true;

    //  seatPerson();

    //buildWidth();

  }

  /**

   * Build design from SketchShape element

   * @param shape

   */

  public SketchChair(SketchShape shape) {

    SlicePlane plane = new SlicePlane(new Plane(new Vec3D(0, 0, 0),

        new Vec3D(0, 0, -1)));

    plane.setSelected(true);

    plane.getSketch().getSketchShapes().add(shape);

    this.selectedPlanes.add(plane);

    this.mouseReleased(0, 0);

   

  }

  /**

   * Constrain the current design to the center plane in physics engine. This stops the design from falling over.x

   */

  void addCentrePlaneConstraint() {

    /*

     *

     * Transform localA = new Transform(); Transform localB = new

     * Transform();

     *

     * localA.setIdentity();

     *

     * localB.setIdentity(); Vec3D centre = this.getCentreOfMass();

     * localA.origin.set(centre.x, centre.y, centre.z);

     *

     * localB.origin.set(0f, 0f, 0f);

     *

     * CollisionShape ZeroShape = null; jBullet.ZeroBodyChair = new

     * RigidBody(0.0f, null, ZeroShape);

     *

     * Transform Rotation = new Transform(); Rotation.setIdentity();

     *

     * MatrixUtil.setEulerZYX(Rotation.basis, BulletGlobals.SIMD_PI, 0, 0);

     *

     * jBullet.ZeroBodyChair.setWorldTransform(Rotation);

     *

     * this.chairCentreConstraint = new

     * Generic6DofConstraint(this.rigidBody, jBullet.ZeroBodyChair, localA,

     * localB, false);

     *

     * this.chairCentreConstraint.setLimit(0, 1, 0); // Disable X axis

     * limits this.chairCentreConstraint.setLimit(1, 1, 0); // Disable Y

     * axis limits this.chairCentreConstraint.setLimit(2, 1, 0); // Set the

     * Z axis to // always be equal to // zero

     * this.chairCentreConstraint.setLimit(3, 0, 0); // Disable X rotational

     * // axes this.chairCentreConstraint.setLimit(4, 0, 0); // Disable Y

     * rotational // axes this.chairCentreConstraint.setLimit(5, 1, 0); //

     * Uncap the rotational // axes

     *

     * // this.rotationConstrains = new Vector3f(0,0,1); //

     * this.rigidBody.setMassProps(this.mass ,rotationConstrains);

     * GLOBAL.jBullet.update();

     */

    /*

     *

     * this.chairCentreConstraint.setLimit(0,1,0); // Disable X axis limits

     * this.chairCentreConstraint.setLimit(1,1,0); // Disable Y axis limits

     * this.chairCentreConstraint.setLimit(2,0,0); // Set the Z axis to

     * always be equal to zero

     * //this.chairCentreConstraint.setLimit(3,(float)-Math.PI+

     * .001f,(float)-Math.PI+.01f); // Disable X rotational axes // this

     * this

     * .chairCentreConstraint.setLimit(3,(float)-Math.PI,(float)Math.PI); //

     * Disable X rotational axes // this

     *

     * //this.chairCentreConstraint.setLimit(3,0,0); // Disable X rotational

     * axes // this this.chairCentreConstraint.setLimit(4,0,0); // Disable Y

     * rotational axes this.chairCentreConstraint.setLimit(5,1,0); // Uncap

     * the Z rotational axes //#endif

     */

    // GLOBAL.jBullet.myWorld.addConstraint(this.chairCentreConstraint,

    // true);

    // this.rigidBody.setAngularFactor(.001f);

    this.rigidBody.setAngularFactor(new Vector3f(0, 0, 1));

    // GLOBAL.jBullet.myWorld

    // EnableVelocityXYZ(body,true,true,false);

    // EnableRotationXYZ(body,false,false,true);

    // GLOBAL.jBullet.myWorld.

    // EnableWorldRotationXYZ(false,false,true);

  }

  private void addCrossPlanes() {

    // add all of our profiles in the z dir and link them to a sketch

    // int numSlices = (int)(this.width / this.slicePlaceSpacing);

  }

  /**

   * Add a new slice plane to the design.

   */

  public void addNewSlicePlane() {

    SketchShape selected = this.selectedPlanes.getSelectedShape();

    SlicePlane selectedPlane = this.selectedPlanes.getSelectedShapePlane();

    if (selected != null && selectedPlane != null) {

      if (selected instanceof SketchSpline) {

        SketchSpline SketchSpline = (SketchSpline) selected;

        selected = SketchSpline.getPath();

      }

      CrossSliceSelection selection = new CrossSliceSelection(selected,

          selectedPlane, .1f, .5f, 25f, this);

      selection.editing = true;

      this.crossSliceSelections.add(selection);

    }

  }

  /**

   * Add a new layer to the design.

   */

  public void addLayer() {

    if (this.selectedPlanes.size() > 0) {

      SlicePlane copyPlane = this.selectedPlanes.getFirst().clone();

      int index = this.getSlicePlanesY().indexOf(

          this.selectedPlanes.getFirst());

      this.getSlicePlanesY().add(index, copyPlane);

      this.rebuildWidth();

    } else {

      SlicePlane copyPlane = this.getSlicePlanesY().getFirst().clone();

      this.getSlicePlanesY().add(copyPlane);

      this.rebuildWidth();

    }

    //  SETTINGS.slat_num++;

  }

  /**

   * Set the current designs position as the start position to start from after rewinding.

   */

  public void setCurrentPositionAsStartTransform() {

    Transform startTransform = new Transform();

    Vector3f localInertia = new Vector3f(0, 0, 0);

    float mass = this.getMass();

    trimesh.calculateLocalInertia(mass, localInertia);

    startTransform.origin.set(

        this.rigidBody.getMotionState().getWorldTransform(

            currentWorldTransform).origin.x,

        this.rigidBody.getMotionState().getWorldTransform(

            currentWorldTransform).origin.y,

        this.rigidBody.getMotionState().getWorldTransform(

            currentWorldTransform).origin.z);

    DefaultMotionState myMotionState = new DefaultMotionState(

        startTransform);

    this.startWorldTransform = startTransform;

  }

  /**

   * Return the centre position of the design in physics space.

   * @return

   */

  public Vec3D getPhysicsOrigin() {

    if (currentWorldTransform == null || rigidBody == null)

      return new Vec3D(0, 0, 0);

    float scaleBy = 1f / GLOBAL.jBullet.getScale();

    Transform myTransform = new Transform();

    myTransform = rigidBody.getMotionState().getWorldTransform(myTransform);

    Vector3f center = new Vector3f();

    rigidBody.getCenterOfMassPosition(center);

    return new Vec3D(center.x, center.y, center.z);

  }

 

 

 

  /**

   * Generate a collision mesh for the design and add this to the physics engine.

   */

  public void addRigidModel() {

    // create trimesh

    //if already contains a rigid model remove it.

    if (this.chairCentreConstraint != null)

      GLOBAL.jBullet.myWorld.removeConstraint(this.chairCentreConstraint);

    if (this.rigidBody != null) {

      removeRigidModel();

      GLOBAL.jBullet.myWorld.removeRigidBody(this.rigidBody);

      GLOBAL.jBullet.rigidBodies.remove(this.rigidBody);

      GLOBAL.jBullet.myWorld.stepSimulation(1);

    }

    Vec3D centreOfMass = this.getCentreOfMass();

    this.centreOfMass = centreOfMass;

    indexVertexArrays = this.getVertexArray(centreOfMass.x, centreOfMass.y,

        centreOfMass.z);

    //this.buildCoverMesh(indexVertexArrays, centreOfMass);

    if (indexVertexArrays == null)

      return;

    // if(indexVertexArrays.getIndexedMeshArray().size() < 2)

    // return;

    trimesh = new GImpactMeshShape(indexVertexArrays);

    trimesh.setLocalScaling(new Vector3f(1f, 1f, 1f));

    trimesh.updateBound();

    if (trimesh == null)

      return;

    CollisionDispatcher dispatcher = (CollisionDispatcher) GLOBAL.jBullet.myWorld

        .getDispatcher();

    if (dispatcher == null)

      return;

    GImpactCollisionAlgorithm.registerAlgorithm(dispatcher);

    Transform startTransform = new Transform();

    Vector3f localInertia = new Vector3f(0, 0, 0);

    float mass = this.getMass();

    trimesh.calculateLocalInertia(mass, localInertia);

    startTransform.origin.set(centreOfMass.x, centreOfMass.y,

        centreOfMass.z);

    DefaultMotionState myMotionState = new DefaultMotionState(

        startTransform);

    this.startWorldTransform = startTransform;

    RigidBodyConstructionInfo rbInfo = new RigidBodyConstructionInfo(mass,

        myMotionState, trimesh, localInertia);

    rigidBody = new RigidBody(rbInfo);

    Transform center = new Transform();

    center.origin.set(centreOfMass.x, centreOfMass.y, centreOfMass.z);

    rigidBody.setCenterOfMassTransform(center);

    rigidBody.setDamping(SETTINGS.chair_damping_linear,

        SETTINGS.chair_damping_ang);

    rigidBody.setDeactivationTime(0.8f);

    rigidBody.setSleepingThresholds(1.6f, 2.5f);

    rigidBody.setFriction(SETTINGS.chair_friction);

    // rigidBody.setCcdMotionThreshold(1f);

    GLOBAL.jBullet.myWorld.addRigidBody(rigidBody);

    GLOBAL.jBullet.rigidBodies.add(rigidBody);

    GImpactCollisionAlgorithm.registerAlgorithm(GLOBAL.jBullet.dispatcher);

    // just to load everything in

    GLOBAL.jBullet.update();

    rigidBody.getWorldTransform(this.currentWorldTransform);

    this.addCentrePlaneConstraint();

  }

 

 

 

  /**

   * Add the current design to the 2D shape packing engine.

   */

  void addToShapePack() {

    this.buildRender();

   

    GLOBAL.shapePack.empty();

    // GLOBAL.shapePack.pdf_pixels_per_mm = SETTINGS.pixels_per_mm;

    GLOBAL.shapePack.content_scale = SETTINGS.scale;

    //GLOBAL.shapePack.ZOOM = ((float) GLOBAL.applet.height) / 390f;

    for (int i = 0; i < this.getSlicePlanesY().size(); i++) {

      SlicePlane slicePlane = this.getSlicePlanesY().get(i);

      if (!slicePlane.guide) {

        spShape shape = slicePlane.getspShape();

        shape.shapePack = GLOBAL.shapePack; //hacky

        shape.build();

        shape.setLabel(((char) ('A' + i)) + "");

        shape.linkedObject = slicePlane;

        GLOBAL.shapePack.add(shape);

      }

    }

    for (int i = 0; i < this.slicePlanesSlatSlices.size(); i++) {

      SlicePlane slicePlane = this.slicePlanesSlatSlices.get(i);

      if (!slicePlane.guide) {

        spShape shape = slicePlane.getspShape();

        shape.shapePack = GLOBAL.shapePack; //hacky

        shape.build();

        shape.setLabel("" + (i + 1));

        shape.linkedObject = slicePlane;

        GLOBAL.shapePack.add(shape);

      }

    }

    GLOBAL.shapePack.scaleAll(SETTINGS.scale);

    GLOBAL.shapePack.build();

    this.buildPreview();

    /*

     *

     * spShape coverShape = new spShape(); ArrayList l = new ArrayList();

     * l.add(new Vec2D(0, 0)); l.add(new Vec2D(this.coverWidth, 0));

     * l.add(new Vec2D(this.coverWidth, this.coverLength)); l.add(new

     * Vec2D(0, this.coverLength)); coverShape.addOutline(l);

     * GLOBAL.shapePack.add(coverShape);

     */

  }

 

 

 

  /**

   * Add the current design to the 2D shape packing engine.

   */

  public void addToPreviewShapePack(spShapePack shapePack) {

    LOGGER.debug("addToPreviewShapePack");

    for (int i = 0; i < this.getSlicePlanesY().size(); i++) {

      SlicePlane slicePlane = this.getSlicePlanesY().get(i);

      if (!slicePlane.guide) {

        spShape shape = slicePlane.getspShape();

        shape.shapePack = shapePack; //hacky

        shape.build();

        shape.linkedObject = slicePlane;

        shapePack.add(shape);

      }

    }

    for (int i = 0; i < this.slicePlanesSlatSlices.size(); i++) {