public void setBrushColor(MTColor color) {
   this.brushColor = color;
   if (this.drawShape != null) {
     drawShape.setFillColor(color);
     drawShape.setStrokeColor(color);
   }
 }
  /**
   * Instantiates a new default button click action.
   *
   * @param poly the poly
   */
  public DefaultButtonClickAction(AbstractShape poly) {
    this.polyButton = poly;
    this.sizeChangeValue = 3;

    this.width = polyButton.getWidthXY(TransformSpace.RELATIVE_TO_PARENT);

    this.height = polyButton.getHeightXY(TransformSpace.RELATIVE_TO_PARENT);
  }
 public void setBrush(AbstractShape brush) {
   this.drawShape = brush;
   this.localBrushCenter = drawShape.getCenterPointLocal();
   this.brushWidthHalf = drawShape.getWidthXY(TransformSpace.LOCAL) / 2f;
   this.brushHeightHalf = drawShape.getHeightXY(TransformSpace.LOCAL) / 2f;
   this.stepDistance = brushWidthHalf / 2.8f;
   this.drawShape.setFillColor(this.brushColor);
   this.drawShape.setStrokeColor(this.brushColor);
 }
Example #4
0
  public void drawBrush(int steps, Vector3D whatToAdd) {
    int i = 0;
    do {
      i++;
      cPos.addLocal(whatToAdd);
      // Draw new brush into FBO at correct position
      Vector3D diff = cPos.getSubtracted(drawLine.getCenterPointLocal());

      drawApp.pushMatrix();
      drawApp.translate(diff.x, diff.y);
      // Draw brush

      drawLine.setStrokeColor(lineColor);
      drawLine.setFillColor(lineColor);
      drawLine.drawComponent(drawApp.g);

      drawApp.popMatrix();
    } while (i < steps);
  }
 /**
  * Sets the svg options recursive.
  *
  * @param comp the comp
  * @param boundsBehaviour the bounds behaviour
  */
 private void setSvgOptionsRecursive(MTComponent comp, int boundsBehaviour) {
   comp.setGestureAllowance(DragProcessor.class, false);
   comp.setGestureAllowance(RotateProcessor.class, false);
   comp.setGestureAllowance(ScaleProcessor.class, false);
   comp.setGestureAllowance(TapProcessor.class, false);
   //		comp.unregisterAllInputProcessors();
   //		/*
   if (comp instanceof AbstractShape) {
     AbstractShape shape = (AbstractShape) comp;
     if (!shape.isBoundingShapeSet()
         && !(shape.getBoundingShape() instanceof BoundsZPlaneRectangle)) {
       shape.setBoundingShape(new BoundsZPlaneRectangle(shape));
     }
     shape.setBoundsBehaviour(boundsBehaviour);
   }
   //		*/
   for (MTComponent child : comp.getChildren()) {
     setSvgOptionsRecursive(child, boundsBehaviour);
   }
 }
  /** Private method, fiducial has been updated */
  private void updated() {
    AbstractShape component = FiducialRegistry.getInstance().getFiducialComponent(EventID);

    if (component != null) {
      component.setPositionGlobal(event.getPosition());
      float oldAngle = (Float) component.getUserData("angle"); // retrieve the "old" angle
      float newAngle = event.getAngle();
      if (oldAngle != newAngle) {
        float diff = newAngle + oldAngle;
        component.setUserData("angle", newAngle);
        diff = MTApplication.degrees(diff); // our rotation expects degrees (not radians)
        component.rotateZ(component.getCenterPointRelativeToParent(), diff);
      }
    }
  }
Example #7
0
  // Global input processor listener implementation (IMTInputEventListener)
  public boolean processInputEvent(MTInputEvent inEvt) {
    if (inEvt instanceof MTFiducialInputEvt) {
      MTFiducialInputEvt fEvt = (MTFiducialInputEvt) inEvt;
      int fID = fEvt.getFiducialId();
      Vector3D position = fEvt.getPosition();

      AbstractShape comp;
      switch (fEvt.getId()) {
        case MTFiducialInputEvt.INPUT_STARTED:
          // Create a new component for the fiducial
          AbstractShape newComp = createComponent(fID, position);
          fiducialIDToComp.put(fID, newComp); // Map id to component
          // Move component to fiducial position
          newComp.setPositionGlobal(position);
          // Save the absolute rotation angle in the component for late
          newComp.setUserData("angle", fEvt.getAngle());
          // Rotate the component
          newComp.rotateZ(
              newComp.getCenterPointRelativeToParent(), MTApplication.degrees(fEvt.getAngle()));
          // Add the component to the canvas to draw it
          getCanvas().addChild(newComp);
          break;
        case MTFiducialInputEvt.INPUT_UPDATED:
          // Retrieve the corresponding component for the fiducial ID from the map
          comp = fiducialIDToComp.get(fID);
          if (comp != null) {
            // Set the new position
            comp.setPositionGlobal(position);
            // Set the rotation (we have to do a little more here because
            // mt4j does incremental rotations instead of specifying an absolute angle)
            float oldAngle = (Float) comp.getUserData("angle"); // retrieve the "old" angle
            float newAngle = fEvt.getAngle();
            if (oldAngle != newAngle) {
              float diff = newAngle - oldAngle;
              comp.setUserData("angle", newAngle);
              diff = MTApplication.degrees(diff); // our rotation expects degrees (not radians)
              comp.rotateZ(comp.getCenterPointRelativeToParent(), diff);
            }
          }
          break;
        case MTFiducialInputEvt.INPUT_ENDED:
          comp = fiducialIDToComp.get(fID);
          if (comp != null) {
            comp.destroy();
            fiducialIDToComp.remove(fID);
          }
          break;
        default:
          break;
      }
    }
    return false;
  }
  /** Private method, handle a new fiducial */
  private void started() {
    AbstractShape roundingcircle =
        new MTEllipse(app, new Vector3D(event.getPosition()), 180, 180, 100);
    roundingcircle.setNoFill(false);
    float r = ToolsMath.getRandom(20, 255);
    float g = ToolsMath.getRandom(20, 255);
    float b = ToolsMath.getRandom(20, 255);
    roundingcircle.setFillColor(new MTColor(r, g, b, 200));
    roundingcircle.setNoStroke(false);
    roundingcircle.setStrokeWeight(1);
    roundingcircle.setStrokeColor(new MTColor(r, g, b, 200));
    roundingcircle.unregisterAllInputProcessors();

    AbstractShape component = new MTEllipse(app, new Vector3D(event.getPosition()), 20, 20, 20);
    component.setNoFill(false);
    float r1 = ToolsMath.getRandom(20, 255);
    float g1 = ToolsMath.getRandom(20, 255);
    float b1 = ToolsMath.getRandom(20, 255);
    component.setFillColor(new MTColor(r1, g1, b1, 200));
    component.setNoStroke(false);
    component.setStrokeWeight(1);
    component.setStrokeColor(new MTColor(r1, g1, b1, 200));
    component.unregisterAllInputProcessors(); // Dont process input/gestures on this component

    roundingcircle.addChild(component);

    MTColor white = new MTColor(255, 255, 255);

    IFont fontArial = FontManager.getInstance().createFont(app, "arial.ttf", 50, white);

    MTTextArea text = new MTTextArea(app, fontArial);
    text.setFillColor(new MTColor(0, 0, 0, 0));
    text.setStrokeColor(new MTColor(0, 0, 0, 0));
    text.unregisterAllInputProcessors();
    roundingcircle.addChild(text);
    text.setPositionRelativeToParent(
        new Vector3D(event.getPosition().x, event.getPosition().y - 120));

    roundingcircle.setUserData("angle", event.getAngle());

    MTKeyboard keys = KeyboardPool.getInstance(app).getKeyboard();
    roundingcircle.addChild(keys);
    keys.setPositionRelativeToParent(
        new Vector3D(event.getPosition().x, event.getPosition().y + 150));
    keys.setUserData("fiducialID", EventID);

    text.setExpandDirection(ExpandDirection.UP);
    text.unregisterAllInputProcessors();
    /*
     * Need to find a way to keep the text centred at all times.
     */
    // text.setEnableCaret(true);

    keys.addTextInputListener(text);
    keys.addInputListener(text);

    FiducialRegistry.getInstance().putFiducialCompoent(EventID, roundingcircle);

    String searchTerm = "Doctor Who";
    TwitterSearch twsearch = new TwitterSearch();
    twsearch.search(searchTerm);

    canvas.addChild(roundingcircle);
  }
 /** Private method, dispose of fiducial */
 private void ended() {
   AbstractShape component = FiducialRegistry.getInstance().getFiducialComponent(EventID);
   component.destroy();
 }
 /**
  * Unhighlight button.
  *
  * @param shape the shape
  * @param opacity the opacity
  */
 private void unhighlightButton(AbstractShape shape, float opacity) {
   MTColor c = shape.getFillColor();
   c.setAlpha(opacity);
   shape.setFillColor(c);
 }
 /**
  * Highlight button.
  *
  * @param shape the shape
  */
 private void highlightButton(AbstractShape shape) {
   MTColor c = shape.getFillColor();
   c.setAlpha(255);
   shape.setFillColor(c);
 }
  /**
   * Inits the.
   *
   * @param x the x
   * @param y the y
   * @param width the width
   * @param height the height
   */
  private void init(float x, float y, float width, float height) {
    this.setNoStroke(true);
    this.setFillColor(new MTColor(255, 255, 255, 150));

    overlayGroup = new MTOverlayContainer(app, "Window Menu Overlay Group");

    if (menuImage == null) {
      menuImage =
          app.loadImage(
              MT4jSettings.getInstance().getDefaultImagesPath() + "blackRoundSolidCorner64sh2.png");
    }

    if (MT4jSettings.getInstance().isOpenGlMode()) {
      GLTextureSettings ts = new GLTextureSettings();
      ts.wrappingHorizontal = WRAP_MODE.CLAMP;
      ts.wrappingVertical = WRAP_MODE.CLAMP;
      GLTexture glTex = new GLTexture(app, menuImage.width, menuImage.height, ts);
      glTex.loadGLTexture(menuImage);
      this.setTexture(glTex);
    } else {
      this.setTexture(menuImage);
    }

    AbstractShape menuShape = this;
    menuShape.unregisterAllInputProcessors();
    menuShape.removeAllGestureEventListeners(DragProcessor.class);
    menuShape.registerInputProcessor(new DragProcessor(app));

    float buttonWidth = 80;
    float buttonHeight = 80;
    final float buttonOpacity = 170;

    // CLOSE BUTTON
    //		Vector3D a = new Vector3D(-width * 1.2f, height/2f);
    Vector3D a = new Vector3D(-width * 1.55f, 0);
    a.rotateZ(PApplet.radians(80));
    final MTRectangle closeButton =
        new MTRectangle(app, x + a.x, y + a.y, buttonWidth, buttonHeight);

    if (closeButtonImage == null) {
      closeButtonImage =
          app.loadImage(MT4jSettings.getInstance().getDefaultImagesPath() + "closeButton64.png");
    }

    closeButton.setTexture(closeButtonImage);
    closeButton.setFillColor(new MTColor(255, 255, 255, buttonOpacity));
    closeButton.setNoStroke(true);
    closeButton.setVisible(false);
    closeButton.removeAllGestureEventListeners(DragProcessor.class);
    closeButton.removeAllGestureEventListeners(RotateProcessor.class);
    closeButton.removeAllGestureEventListeners(ScaleProcessor.class);
    this.addChild(closeButton);

    // Check if this menu belongs to a window Scene (MTSceneWindow)
    // or was added to a normal scene
    // -> if its not a windowed scene we dont display the Restore button
    if (this.windowedScene) {
      // RESTORE BUTTON
      Vector3D b = new Vector3D(-width * 1.55f, 0);
      b.rotateZ(PApplet.radians(10));
      final MTRectangle restoreButton =
          new MTRectangle(app, x + b.x, y + b.y, buttonWidth, buttonHeight);

      if (restoreButtonImage == null) {
        restoreButtonImage =
            app.loadImage(
                MT4jSettings.getInstance().getDefaultImagesPath() + "restoreButton64.png");
      }

      restoreButton.setTexture(restoreButtonImage);
      restoreButton.setFillColor(new MTColor(255, 255, 255, buttonOpacity));
      restoreButton.setNoStroke(true);
      restoreButton.setVisible(false);
      restoreButton.removeAllGestureEventListeners(DragProcessor.class);
      restoreButton.removeAllGestureEventListeners(RotateProcessor.class);
      restoreButton.removeAllGestureEventListeners(ScaleProcessor.class);
      this.addChild(restoreButton);

      menuShape.addGestureListener(
          DragProcessor.class,
          new IGestureEventListener() {
            public boolean processGestureEvent(MTGestureEvent ge) {
              DragEvent de = (DragEvent) ge;
              switch (de.getId()) {
                case MTGestureEvent.GESTURE_STARTED:
                  restoreButton.setVisible(true);
                  closeButton.setVisible(true);
                  unhighlightButton(closeButton, buttonOpacity);
                  unhighlightButton(restoreButton, buttonOpacity);
                  break;
                case MTGestureEvent.GESTURE_UPDATED:
                  // Mouse over effect
                  if (closeButton.containsPointGlobal(de.getTo())) {
                    highlightButton(closeButton);
                  } else {
                    unhighlightButton(closeButton, buttonOpacity);
                  }
                  if (restoreButton.containsPointGlobal(de.getTo())) {
                    highlightButton(restoreButton);
                  } else {
                    unhighlightButton(restoreButton, buttonOpacity);
                  }
                  break;
                case MTGestureEvent.GESTURE_ENDED:
                  unhighlightButton(closeButton, buttonOpacity);
                  unhighlightButton(restoreButton, buttonOpacity);

                  InputCursor cursor = de.getDragCursor();
                  Vector3D restoreButtonIntersection =
                      restoreButton.getIntersectionGlobal(
                          Tools3D.getCameraPickRay(
                              getRenderer(),
                              restoreButton,
                              cursor.getCurrentEvtPosX(),
                              cursor.getCurrentEvtPosY()));
                  if (restoreButtonIntersection != null) {
                    logger.debug("--> RESTORE!");
                    MTSceneMenu.this.sceneTexture.restore();
                  }
                  Vector3D closeButtonIntersection =
                      closeButton.getIntersectionGlobal(
                          Tools3D.getCameraPickRay(
                              getRenderer(),
                              closeButton,
                              cursor.getCurrentEvtPosX(),
                              cursor.getCurrentEvtPosY()));
                  if (closeButtonIntersection != null) {
                    //							if (app.popScene()){
                    //								app.removeScene(scene); //FIXME wont work if the scene has a
                    // transition because we cant remove the still active scene
                    ////								destroy(); //this will be destroyed with the scene
                    //								sceneTexture.destroy(); //destroys also the MTSceneWindow and with it
                    // the scene
                    //								logger.debug("--> CLOSE!");
                    //							}
                    if (sceneTexture.restore()) {
                      //								app.removeScene(scene); //FIXME wont work if the scene has a
                      // transition because we cant remove the still active scene
                      //								destroy(); //this will be destroyed with the scene
                      sceneTexture
                          .destroy(); // destroys also the MTSceneWindow and with it the scene
                      logger.debug("--> CLOSE!");
                    }
                  }

                  restoreButton.setVisible(false);
                  closeButton.setVisible(false);
                  break;
                default:
                  break;
              }
              return false;
            }
          });
    } else {
      if (scene != null) {
        menuShape.addGestureListener(
            DragProcessor.class,
            new IGestureEventListener() {
              public boolean processGestureEvent(MTGestureEvent ge) {
                DragEvent de = (DragEvent) ge;
                switch (de.getId()) {
                  case MTGestureEvent.GESTURE_STARTED:
                    closeButton.setVisible(true);
                    unhighlightButton(closeButton, buttonOpacity);
                    break;
                  case MTGestureEvent.GESTURE_UPDATED:
                    // Mouse over effect
                    if (closeButton.containsPointGlobal(de.getTo())) {
                      highlightButton(closeButton);
                    } else {
                      unhighlightButton(closeButton, buttonOpacity);
                    }
                    break;
                  case MTGestureEvent.GESTURE_ENDED:
                    unhighlightButton(closeButton, buttonOpacity);

                    InputCursor cursor = de.getDragCursor();
                    Vector3D closeButtonIntersection =
                        closeButton.getIntersectionGlobal(
                            Tools3D.getCameraPickRay(
                                getRenderer(),
                                closeButton,
                                cursor.getCurrentEvtPosX(),
                                cursor.getCurrentEvtPosY()));
                    if (closeButtonIntersection != null) {
                      if (app.popScene()) {
                        destroy(); // Destroy this
                        scene.destroy(); // Destroy the scene
                        logger.debug("--> CLOSE!");
                      }
                    }
                    closeButton.setVisible(false);
                    break;
                  default:
                    break;
                }
                return false;
              }
            });
      }
    }
  }