MTComponent

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.mt4j.components
Class MTComponent

java.lang.Object
  org.mt4j.components.MTComponent

All Implemented Interfaces:: IMTComponent, IMTComponent3D, IMTInputEventListener, IGestureEventListener

Direct Known Subclasses:: AbstractVisibleComponent, Cluster, MTCanvas, MTOverlayContainer, MTSvg

public class MTComponent

extends java.lang.Object

implements IMTComponent3D, IMTInputEventListener, IGestureEventListener

This is the base class for all scenegraph nodes. It provides basic methods for adding and managing child nodes. It also allows for changing the components position and orientation in space. Picking those components with a picking ray is also supported, if intersection testing is properly implemented by extending subclasses.

This base class has no visible representation an thus can be used as a group container node for other scene graph objects.

Author:: Christopher Ruff

Constructor Summary
`MTComponent(processing.core.PApplet pApplet)` Creates a new component.
`MTComponent(processing.core.PApplet pApplet, Icamera attachedCamera)` Creates a new component.
`MTComponent(processing.core.PApplet pApplet, java.lang.String name)` Creates a new component.
`MTComponent(processing.core.PApplet pApplet, java.lang.String name, Icamera attachedCamera)` Creates a new component.

Method Summary
`void`	`addChild(int i, MTComponent tangibleComp)` Adds the child at the specified position in the list of children.
`void`	`addChild(MTComponent tangibleComp)` Adds a component as a child to this component.
`void`	`addChildren(MTComponent[] tangibleComps)` Adds an array of components to this component as children.
`void`	`addGestureListener(java.lang.Class gestureEvtSender, IGestureEventListener listener)` Adds a gesture listener to this component.
`void`	`addInputListener(IMTInputEventListener inputListener)` Adds an input listener to this component.
`void`	`addStateChangeListener(StateChange state, StateChangeListener listener)` Adds the state change listener.
`protected void`	`applyLocalMatrix()` Applies (multiplies) this components local matrix to processings current matrix.
`void`	`attachCamera(Icamera attachedCamera)` Attaches a camera to this component.
`protected boolean`	`componentContainsPointLocal(Vector3D testPoint)` Checks whether the specified point is contained in this component.
`boolean`	`containsChild(MTComponent tangibleComp)` Goes through all children and their children to check if this component tree contains the given component.
`boolean`	`containsDirectChild(MTComponent tangibleComp)` Checks if the given component is a direct child of this component.
`boolean`	`containsPointGlobal(Vector3D testPoint)` Checks whether this, or this component's children contains the specified point.
`void`	`destroy()` Removes this component from its parent.
`protected void`	`destroyComponent()` Override this to clean up resources when destroying a component.
`void`	`drawComponent(processing.core.PGraphics g)` Draws this component only (Not its children!).
`protected void`	`fireInputEvent(MTInputEvent iEvt)`
`protected void`	`fireStateChange(StateChange state)` Fire state change.
`protected void`	`fireStateChange(StateChangeEvent evt)` Fire state change.
`Icamera`	`getAttachedCamera()` Gets the camera attached to this component or null if it doesent have one.
`MTComponent`	`getChildbyID(int ID)` Gets the child by its unique ID.
`MTComponent`	`getChildByIndex(int index)` Gets the child by index.
`MTComponent`	`getChildByName(java.lang.String name)` Gets the child by name.
`Clip`	`getChildClip()` Gets the child clip.
`int`	`getChildCount()` Gets the child count.
`int`	`getChildIndexOf(MTComponent comp)` Gets the child index of a child.
`protected java.util.List<MTComponent>`	`getChildList()` Gets the child list which is also used internally in `MTComponent`.
`MTComponent[]`	`getChildren()` Gets the children.
`Clip`	`getClip()` Gets the clip.
`IMTController`	`getController()` Gets the controller.
`ViewportSetting`	`getCustomViewportSetting()` Gets the custom viewport setting.
`ViewportSetting`	`getDefaultViewportSetting()` Gets the default viewport setting.
`IGestureEventListener[]`	`getGestureListeners()` Returns the gesture listeners.
`Matrix`	`getGlobalInverseMatrix()` Returns the absolute inverse matrix (inverse of the global) which inverts all transforms made from the parents down to this child.
`Matrix`	`getGlobalMatrix()` Multiplies all transformation matrices of the objects parents up the this object and returns it.
`static Vector3D`	`getGlobalVecToParentRelativeSpace(MTComponent referenceComp, Vector3D point)` Transforms the given vector in global space coordinates to be relative to the given reference objects parent space.
`int`	`getID()` Gets the iD.
`IMTInputEventListener[]`	`getInputListeners()` Gets the input listeners.
`AbstractComponentProcessor[]`	`getInputProcessors()` Gets the component input processors.
`Vector3D`	`getIntersectionGlobal(Ray ray)` Checks if the specified ray intersects this component or one if its childcomponents.
`Vector3D`	`getIntersectionLocal(Ray localRay)` Returns the intersection point of the ray and this component (children are not checked for intersections).
`MTLight`	`getLight()` Gets the light.
`Matrix`	`getLocalInverseMatrix()` Gets the local inverse matrix.
`Matrix`	`getLocalMatrix()` Gets the local basis matrix.
`static Vector3D`	`getLocalVecToParentRelativeSpace(MTComponent referenceComp, Vector3D point)` Transforms the point - defined in the objects coordinate space - into parent relative space.
`java.lang.String`	`getName()` Gets the name.
`MTComponent`	`getParent()` Gets the parent.
`processing.core.PApplet`	`getRenderer()` Gets the renderer.
`MTComponent`	`getRoot()` Gets the ancestor.
`static Matrix`	`getTransformToDestinationLocalSpace(MTComponent originComponent, MTComponent destinationComponent)` Gets the transform to destination local space.
`static Matrix`	`getTransformToDestinationParentSpace(MTComponent originComponent, MTComponent destinationComponent)` Calculates the transformation necessary to transform a component to be relative to the destination component.
`java.lang.Object`	`getUserData(java.lang.Object key)` Gets the user data associated with the specified key.
`Icamera`	`getViewingCamera()` Gets the camera through which this component is being viewed.
`Ray`	`globalToLocal(Ray globalRay)` Transforms the global ray into local coordinate space and returns the new ray.
`Vector3D`	`globalToLocal(Vector3D point)` Converts the Vector3D object from the world (global) coordinates to the component's (local) coordinates.
`boolean`	`hasCustomViewPort()` Checks for custom view port.
`boolean`	`isComposite()` Checks if is composite.
`boolean`	`isContainedIn(IFrustum frustum)` Checks if this component is contained in the specified viewing frustum (is currently visible).
`boolean`	`isDepthBufferDisabled()` Checks if is always drawn on top.
`boolean`	`isEnabled()` Checks if the component is enabled.
`boolean`	`isGestureAllowed(java.lang.Class c)` Checks if the gesture is allowed on this component.
`boolean`	`isPickable()` Checks if is pickable.
`boolean`	`isVisible()` Checks if the component is visible.
`Vector3D`	`localToGlobal(Vector3D point)` Converts the Vector3D object from the component's (local) coordinates to the world/canvas (global) coordinates.
`PickResult`	`pick(float x, float y)` Checks which object lies under the specified screen coordinates.
`PickResult`	`pick(float x, float y, boolean onlyPickables)` Checks which object lies under the specified screen coordinates.
`void`	`postDraw(processing.core.PGraphics g)` Post draw.
`void`	`postDrawChildren(processing.core.PGraphics g)` Post draw Children.
`void`	`preDraw(processing.core.PGraphics g)` This method is called just before the components drawComponent method is invoked.
`boolean`	`processGestureEvent(MTGestureEvent gestureEvent)` Processes gesture events.
`boolean`	`processInputEvent(MTInputEvent inEvt)` Processes the input event.
`void`	`registerInputProcessor(AbstractComponentProcessor inputProcessor)` Registers an component input processor with this component.
`void`	`removeAllChildren()` Removes all direct children of this component.
`void`	`removeAllGestureEventListeners()` Removes the all gesture event listeners.
`void`	`removeAllGestureEventListeners(java.lang.Class gestureEvtSender)` Removes the all gesture event listeners who listen to the specified input processor.
`void`	`removeChild(int i)` Tries to remove the specified child from this component.
`void`	`removeChild(MTComponent comp)` Tries to remove the specified child from this component.
`void`	`removeFromParent()` Removes this component from its parent.
`void`	`removeGestureEventListener(java.lang.Class gestureEvtSender, IGestureEventListener listener)` Removes the gesture event listener.
`void`	`removeInputListener(IMTInputEventListener inputListener)` Removes the input listener.
`void`	`removeStateChangeListener(StateChange state, StateChangeListener listener)` Removes the state change listener.
`void`	`reOrthogonalize()` Re orthogonalizes the components local matrix.
`void`	`rotateX(Vector3D rotationPoint, float degree)` X rotate.
`void`	`rotateX(Vector3D rotationPoint, float degree, TransformSpace transformSpace)` X rotate.
`void`	`rotateXGlobal(Vector3D rotationPoint, float degree)` Rotates the component around its x-axis and the rotation point (in global coordiantes).
`void`	`rotateY(Vector3D rotationPoint, float degree)` Y rotate.
`void`	`rotateY(Vector3D rotationPoint, float degree, TransformSpace transformSpace)` Y rotate.
`void`	`rotateYGlobal(Vector3D rotationPoint, float degree)` Rotates the component around its y-axis and the rotation point (in global coordiantes).
`void`	`rotateZ(Vector3D rotationPoint, float degree)` Rotates the obj around the z-axis around the rotationpoint.
`void`	`rotateZ(Vector3D rotationPoint, float degree, TransformSpace transformSpace)` Rotates the component around the specified point on the Z axis.
`void`	`rotateZGlobal(Vector3D rotationPoint, float degree)` Rotates the component around its z-axis and the rotation point (in world coordiantes).
`void`	`scale(float X, float Y, float Z, Vector3D scalingPoint)` CURRENTLY DOES NOT REALLY SUPPORT NON-UNIFORM SCALING!
`void`	`scale(float X, float Y, float Z, Vector3D scalingPoint, TransformSpace transformSpace)` Scales the obj around the scalingPoint.
`void`	`scaleGlobal(float X, float Y, float Z, Vector3D scalingPoint)` Scales the component in world from the scalingpoint (in world coordiantes) in the 3 axis.
`protected void`	`sendChildToFront(MTComponent child)` Puts this child to the end of the children list of this component.
`void`	`sendToFront()` Puts this components to the end of the children list of its parent.
`void`	`setChildClip(Clip childClip)` Sets the clip mask for this components children.
`void`	`setClip(Clip clip)` Sets the clip mask for this component.
`void`	`setComposite(boolean composite)` Setting a components `setComposite` to 'true' will result in THIS component getting picked and returned when a child of this component is picked.
`IMTController`	`setController(IMTController controller)` This attaches a controller object to the component.
`void`	`setDepthBufferDisabled(boolean drawOnTop)` If the depth buffer is disabled, the order in which the components are drawn alone decides which objects will appear ontop of others, instead of their distance to the camera.
`void`	`setEnabled(boolean enabled)` Sets the component enabled.
`void`	`setGestureAllowance(java.lang.Class c, boolean allowed)` Sets the gesture allowance.
`void`	`setLight(MTLight light)` Sets the light.
`void`	`setLocalMatrix(Matrix localBasisMatrix)` Sets a matrix by which this component and its children will be transformed.
`void`	`setMatricesDirty(boolean matricesDirty)` Informs the object (and its children), that its matrix - OR ONE OF ITS PARENT'S MATRIX - has been altered.
`void`	`setName(java.lang.String name)` Sets the name of the component.
`void`	`setPickable(boolean pickable)` If set to true, this component will be testable for intersections.
`void`	`setUserData(java.lang.Object key, java.lang.Object value)` Sets user data for this component.
`void`	`setViewPortSettings(ViewportSetting viewPortSettings)` Sets the view port settings.
`void`	`setVisible(boolean visible)` Sets the visibility.
`java.lang.String`	`toString()`
`void`	`transform(Matrix transformMatrix)` Transforms the shapes local coordinate space by the specified matrix.
`void`	`translate(Vector3D dirVect)` Translates this component in the give direction, relative to its parent component.
`void`	`translate(Vector3D dirVect, TransformSpace transformSpace)` Translate.
`void`	`translateGlobal(Vector3D dirVect)` Translates the object in the given direction relative to the global world coordinate frame.
`void`	`unregisterAllInputProcessors()` Unregister all previously registered component input processors.
`void`	`unregisterInputProcessor(AbstractComponentProcessor inputProcessor)` Unregister a component input processor.
`void`	`updateComponent(long timeDelta)` Tells the component to update its state if neccessary.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

MTComponent

public MTComponent(processing.core.PApplet pApplet)

Creates a new component. The component has no initial visual representation.

Parameters:: pApplet - the applet

MTComponent

public MTComponent(processing.core.PApplet pApplet,
                   java.lang.String name)

Creates a new component. The component has no visual representation.

Parameters:: pApplet - the applet; name - the name

MTComponent

public MTComponent(processing.core.PApplet pApplet,
                   Icamera attachedCamera)

Creates a new component. The component has no visual representation.

Parameters:: pApplet - the applet; attachedCamera - the camera to view this and this components children with

MTComponent

public MTComponent(processing.core.PApplet pApplet,
                   java.lang.String name,
                   Icamera attachedCamera)

Creates a new component. The component has no visual representation.

Parameters:: pApplet - the applet; name - the name of the component; attachedCamera - a camera to view this and this components children with

Method Detail

addInputListener

public void addInputListener(IMTInputEventListener inputListener)

Adds an input listener to this component. The listener will be informed if this component recieves an input event.

Parameters:: inputListener - the input listener

removeInputListener

public void removeInputListener(IMTInputEventListener inputListener)

Removes the input listener.

Parameters:: inputListener - the input listener

getInputListeners

public IMTInputEventListener[] getInputListeners()

Gets the input listeners.

Returns:: the input listeners

fireInputEvent

protected void fireInputEvent(MTInputEvent iEvt)

getViewingCamera

public Icamera getViewingCamera()

Description copied from interface: IMTComponent3D

Gets the camera through which this component is being viewed. This is the attached camera of this, or one of its parant's attached cameras.

Specified by:: getViewingCamera in interface IMTComponent3D

Returns:: the responsible camera

getAttachedCamera

public Icamera getAttachedCamera()

Gets the camera attached to this component or null if it doesent have one.

Returns:: the attached camera

attachCamera

public void attachCamera(Icamera attachedCamera)

Attaches a camera to this component. This component and all its children will be viewed through the specified camera.

Parameters:: attachedCamera - the attached camera

registerInputProcessor

public void registerInputProcessor(AbstractComponentProcessor inputProcessor)

Registers an component input processor with this component. Input processors are used to process the input events a component recieves by checking them for special patterns and conditions and firing gesture events back to the component. To recognize a multi-touch drag gesture on a component for example, we would register a DragProcessor object with this component.

Parameters:: inputProcessor - the input processor

unregisterInputProcessor

public void unregisterInputProcessor(AbstractComponentProcessor inputProcessor)

Unregister a component input processor.

Parameters:: inputProcessor - the input processor

unregisterAllInputProcessors

public void unregisterAllInputProcessors()

Unregister all previously registered component input processors.

getInputProcessors

public AbstractComponentProcessor[] getInputProcessors()

Gets the component input processors.

Returns:: the input processors

addGestureListener

public void addGestureListener(java.lang.Class gestureEvtSender,
                               IGestureEventListener listener)

Adds a gesture listener to this component. The specified gesture listener's processGestureEvent(..) method will be called when a gesture event is processed by this component. The IInputProcessor paramter type specifies the source of the gesture event we are interested in. So to listen to drag events only for example, we would specify the DragProcessor.class as the first parameter.

Parameters:: gestureEvtSender - the gesture evt sender; listener - the listener

removeGestureEventListener

public void removeGestureEventListener(java.lang.Class gestureEvtSender,
                                       IGestureEventListener listener)

Removes the gesture event listener.

Parameters:: gestureEvtSender - the gesture evt sender; listener - the listener

removeAllGestureEventListeners

public void removeAllGestureEventListeners()

Removes the all gesture event listeners.

removeAllGestureEventListeners

public void removeAllGestureEventListeners(java.lang.Class gestureEvtSender)

Removes the all gesture event listeners who listen to the specified input processor.

Parameters:: gestureEvtSender - the gesture evt sender

getGestureListeners

public final IGestureEventListener[] getGestureListeners()

Returns the gesture listeners.

Returns:: the gesture listeners

addStateChangeListener

public void addStateChangeListener(StateChange state,
                                   StateChangeListener listener)

Adds the state change listener.

Parameters:: state - the state; listener - the listener

removeStateChangeListener

public void removeStateChangeListener(StateChange state,
                                      StateChangeListener listener)

Removes the state change listener.

Parameters:: state - the state; listener - the listener

fireStateChange

protected void fireStateChange(StateChangeEvent evt)

Fire state change.

Parameters:: evt - the evt

fireStateChange

protected void fireStateChange(StateChange state)

Fire state change.

Parameters:: state - the state

destroy

public void destroy()

Removes this component from its parent.
Calls destroyComponent on this component which can be used to free resources that the component used.

Recursively calls destroy on alls its child components

destroyComponent

protected void destroyComponent()

Override this to clean up resources when destroying a component. This method gets called by the destroy method. So you shouldnt invoke this method directly.

applyLocalMatrix

protected void applyLocalMatrix()

Applies (multiplies) this components local matrix to processings current matrix.

setMatricesDirty

public void setMatricesDirty(boolean matricesDirty)

Informs the object (and its children), that its matrix - OR ONE OF ITS PARENT'S MATRIX - has been altered.
Usually this shouldnt be called by the user himself.

Parameters:: matricesDirty - the matrices dirty

getLocalMatrix

public Matrix getLocalMatrix()

Gets the local basis matrix. This is the matrix responsible for transforming this component relative to its parent.

Returns:: the local basis matrix The matrix describing the local coordinate space of this object.

setLocalMatrix

public void setLocalMatrix(Matrix localBasisMatrix)

Sets a matrix by which this component and its children will be transformed.
Also calculates and sets the corresponding local inverse matrix. (expensive call!)

Parameters:: localBasisMatrix - the local basis matrix

getLocalInverseMatrix

public Matrix getLocalInverseMatrix()

Gets the local inverse matrix.

Returns:: the local inverse matrix the local inverse transform matrix

getGlobalMatrix

public Matrix getGlobalMatrix()

Multiplies all transformation matrices of the objects parents up the this object and returns it.
This is so to speak the "global matrix" of the object. This matrix can be used to transform points in the components local space to the global space, the space where they actually appear in 3D space.

Returns:: the local to global matrix the absolute transformation (global) matrix of the object

getGlobalInverseMatrix

public Matrix getGlobalInverseMatrix()

Returns the absolute inverse matrix (inverse of the global) which inverts all transforms made from the parents down to this child. This matrix can be used to transform a point in global space to the component's local object space (untransformed space).

Returns:: the absolute global to local matrix , the absolute inverse transformation matrix of the object

getLocalVecToParentRelativeSpace

public static Vector3D getLocalVecToParentRelativeSpace(MTComponent referenceComp,
                                                        Vector3D point)

Transforms the point - defined in the objects coordinate space - into parent relative space. This is done by multiplying the point with the objects local basis matrix.

Parameters:: referenceComp - the reference comp; point - the point
Returns:: the obj space vec to parent relative space

getGlobalVecToParentRelativeSpace

public static Vector3D getGlobalVecToParentRelativeSpace(MTComponent referenceComp,
                                                         Vector3D point)

Transforms the given vector in global space coordinates to be relative to the given reference objects parent space.
Applies the inverse transforms associated with this parents actor and its ancestors to the vector.
NOTE: This transforms the global vector into the reference objects partent space! Not the reference obj's local space!
Example:
If we would want to rotate an object that is in an arbitrary transformation hierarchy in the scene graph, around a point that is defined in Global coordinates, we have to transform the point to be relative to the object's parent transformation space.
This is done by transforming the point by the inverse Global matrix of the objects parent.

Parameters:: referenceComp - the vector will be relative to this components parent space; point - the point
Returns:: the global vec to parent relative space the transformed Vector

getTransformToDestinationParentSpace

public static Matrix getTransformToDestinationParentSpace(MTComponent originComponent,
                                                          MTComponent destinationComponent)

Calculates the transformation necessary to transform a component to be relative to the destination component.

So for example, if you want to add a component from a random position in the scence graph to a different component somewhere else in the scene graph, with the component remaining at the same global position, you would transform the first component with the Matrix from the call of getTransformToDestinationParentSpace(originComponent,destinationComponent). Then you would add the component to the destination component as its child. The component will have the same global coordinates as before, but will now be under the influence of the new parents transforms etc.

Parameters:: originComponent - the origin component; destinationComponent - the destination component
Returns:: the transform to destination parent space the matrix

getTransformToDestinationLocalSpace

public static Matrix getTransformToDestinationLocalSpace(MTComponent originComponent,
                                                         MTComponent destinationComponent)

Gets the transform to destination local space.

Parameters:: originComponent - the origin component; destinationComponent - the destination component
Returns:: the transform to destination local space

localToGlobal

public Vector3D localToGlobal(Vector3D point)

Converts the Vector3D object from the component's (local) coordinates to the world/canvas (global) coordinates.

This method allows you to convert any given x, y and z coordinates from values that are relative to the origin (0,0) of a specific component (local coordinates) to values that are relative to the origin of the canvas (global coordinates).

To use this method, first create an instance of the Vector3D class. The x, y and z values that you assign represent local coordinates because they relate to the origin of the component.

You then pass the Vector3D instance that you created as the parameter to the localToGlobal() method.
The method returns a new Vector3D object with x, y and z values that relate to the origin of the global/canvas instead of the origin of the component.

Parameters:: point - the point
Returns:: A vector3D object with coordinates relative to the global/canvas.

globalToLocal

public Vector3D globalToLocal(Vector3D point)

Converts the Vector3D object from the world (global) coordinates to the component's (local) coordinates.

To use this method, first create an instance of the Vector3D class.
The x, y and z values that you assign represent global coordinates because they relate to the origin (0,0) of the main display area. Then pass the Vector3D instance as the parameter to the globalToLocal() method.
The method returns a new Vector3D object with x and y values that relate to the origin of the component instead of the origin of the world.

Parameters:: point - the point
Returns:: the vector3D object with coordinates relative to the component.

globalToLocal

public Ray globalToLocal(Ray globalRay)

Transforms the global ray into local coordinate space and returns the new ray.

Parameters:: globalRay - the global ray
Returns:: the ray

transform

public void transform(Matrix transformMatrix)

Transforms the shapes local coordinate space by the specified matrix. This operation can be quite costly since it involves a matrix multiplication and a calculation of its inverse.

Parameters:: transformMatrix - the transform matrix

translate

public void translate(Vector3D dirVect,
                      TransformSpace transformSpace)

Translate. Move the component in the direction of the specified vector. The transformspace specifies the space, which the translation should be relative to.

Parameters:: dirVect - the dir vect; transformSpace - the transform space

translateGlobal

public void translateGlobal(Vector3D dirVect)

Description copied from interface: IMTComponent

Translates the object in the given direction relative to the global world coordinate frame.

Specified by:: translateGlobal in interface IMTComponent

Parameters:: dirVect - the direction vect

translate

public void translate(Vector3D dirVect)

Translates this component in the give direction, relative to its parent component.

Parameters:: dirVect - the dir vect

rotateX

public void rotateX(Vector3D rotationPoint,
                    float degree,
                    TransformSpace transformSpace)

X rotate. The transformspace parameter indicates in which coordinate space the point is specified in.

Parameters:: rotationPoint - the rotation point; degree - the degree; transformSpace - the transform space

rotateXGlobal

public void rotateXGlobal(Vector3D rotationPoint,
                          float degree)

Description copied from interface: IMTComponent3D

Rotates the component around its x-axis and the rotation point (in global coordiantes).

Specified by:: rotateXGlobal in interface IMTComponent3D

Parameters:: rotationPoint - the rotation point; degree - the degree

rotateX

public void rotateX(Vector3D rotationPoint,
                    float degree)

X rotate. Rotates relative to the parent coordinate space.

Parameters:: rotationPoint - the rotation point; degree - the degree

rotateY

public void rotateY(Vector3D rotationPoint,
                    float degree,
                    TransformSpace transformSpace)

Y rotate. The transformspace parameter indicates in which coordinate space the point is specified in.

Parameters:: rotationPoint - the rotation point; degree - the degree; transformSpace - the transform space

rotateYGlobal

public void rotateYGlobal(Vector3D rotationPoint,
                          float degree)

Description copied from interface: IMTComponent3D

Rotates the component around its y-axis and the rotation point (in global coordiantes).

Specified by:: rotateYGlobal in interface IMTComponent3D

Parameters:: rotationPoint - the rotation point; degree - the degree

rotateY

public void rotateY(Vector3D rotationPoint,
                    float degree)

Y rotate. Rotates relative to the parent coordinate space.

Parameters:: rotationPoint - the rotation point; degree - the degree

rotateZ

public void rotateZ(Vector3D rotationPoint,
                    float degree,
                    TransformSpace transformSpace)

Rotates the component around the specified point on the Z axis. The transformspace parameter indicates in which coordinate space the point is specified in.

Parameters:: rotationPoint - the rotation point; degree - the degree; transformSpace - the transform space

rotateZGlobal

public void rotateZGlobal(Vector3D rotationPoint,
                          float degree)

Description copied from interface: IMTComponent

Rotates the component around its z-axis and the rotation point (in world coordiantes).

Specified by:: rotateZGlobal in interface IMTComponent

Parameters:: rotationPoint - the rotation point; degree - the degree

rotateZ

public void rotateZ(Vector3D rotationPoint,
                    float degree)

Rotates the obj around the z-axis around the rotationpoint. The rotation point is parent-transformation space-relative.

Parameters:: rotationPoint - the rotation point; degree - the degree

scale

public void scale(float X,
                  float Y,
                  float Z,
                  Vector3D scalingPoint,
                  TransformSpace transformSpace)

Scales the obj around the scalingPoint. The transformspace parameter indicates in which coordinate space the point is specified in.
Note: Non-uniform scaling may lead to bad results!

Parameters:: X - the x; Y - the y; Z - the z; scalingPoint - the scaling point; transformSpace - the transform space

scaleGlobal

public void scaleGlobal(float X,
                        float Y,
                        float Z,
                        Vector3D scalingPoint)

Description copied from interface: IMTComponent

Scales the component in world from the scalingpoint (in world coordiantes) in the 3 axis.

Specified by:: scaleGlobal in interface IMTComponent

Parameters:: X - the factor x; Y - the factor y; Z - the factor z; scalingPoint - the scaling point

scale

public void scale(float X,
                  float Y,
                  float Z,
                  Vector3D scalingPoint)

CURRENTLY DOES NOT REALLY SUPPORT NON-UNIFORM SCALING!

Scales the polygon around the scalingPoint.

Parameters:: X - the x; Y - the y; Z - the z; scalingPoint - the scaling point

preDraw

public void preDraw(processing.core.PGraphics g)

This method is called just before the components drawComponent method is invoked. It sets up the components matrix, clipping and other stuff.

Parameters:: g - the graphics context

drawComponent

public void drawComponent(processing.core.PGraphics g)

Draws this component only (Not its children!).
This method can be overridden in subclasses and filled with drawing commands.

Specified by:: drawComponent in interface IMTComponent

Parameters:: g - the graphics context

postDraw

public void postDraw(processing.core.PGraphics g)

Post draw. Called immediatly after drawing this component.

Parameters:: g -

postDrawChildren

public void postDrawChildren(processing.core.PGraphics g)

Post draw Children. Called after drawing this component and its children.

Parameters:: g - the graphics context

getClip

public Clip getClip()

Gets the clip.

Returns:: the clip

setClip

public void setClip(Clip clip)

Sets the clip mask for this component. This restricts the drawing of this component to the specified clip area.
NOTE: Only supported when using OpenGL as the renderer!

Parameters:: childClip - the child clip mask

getChildClip

public Clip getChildClip()

Gets the child clip.

Returns:: the child clip

setChildClip

public void setChildClip(Clip childClip)

Sets the clip mask for this components children. Only children contained in the specified clipping shape will be visible.
NOTE: Only supported when using OpenGL as the renderer!

Parameters:: childClip - the child clip mask

setLight

public void setLight(MTLight light)

Sets the light.
NOTE: Only supported when using OpenGL as the renderer!

Parameters:: light - the new light

getLight

public MTLight getLight()

Gets the light.

Returns:: the light

updateComponent

public void updateComponent(long timeDelta)

Tells the component to update its state if neccessary. This is called shortly before the component's drawComponent() method is invoked. The timeDelta parameter indicates the time passed since the last frame was drawn and can be used for animation for example.
Also, this updates the associated IMTController object if existing. If overriden, the superclass implementation should always be called!

Specified by:: updateComponent in interface IMTComponent

Parameters:: timeDelta - the time delta

addChild

public void addChild(MTComponent tangibleComp)

Adds a component as a child to this component. By doing this, it will be under the influence of the parents transformations.
NOTE: adding children during traversal of the component hierarchy will result in a concurrent modification error (e.g. in methods like drawComponent or updateComponent). To resolve this, we can use the AddNodeActionThreadSafe class to add as an IPreDrawAction to our current scene (looking something like this: yourScene.addPreDrawAction(new AddNodeActionThreadSafe(..));) The component will then be added before the next rendering loop.

Parameters:: tangibleComp - the tangible comp

addChild

public void addChild(int i,
                     MTComponent tangibleComp)

Adds the child at the specified position in the list of children.

Parameters:: i - the i; tangibleComp - the tangible comp
See Also:: addChild

addChildren

public void addChildren(MTComponent[] tangibleComps)

Adds an array of components to this component as children.

Parameters:: tangibleComps - the tangible comps

getChildList

protected java.util.List<MTComponent> getChildList()

Gets the child list which is also used internally in MTComponent. Therefor, this should be used for read operations only!

This method is provided for performance reasons, because getChildren() contains overhead because it creates a new array for each call.

Returns:: the child list

getChildren

public MTComponent[] getChildren()

Gets the children.

Returns:: the children

getChildbyID

public MTComponent getChildbyID(int ID)

Gets the child by its unique ID.
NOTE: the specified number is the unique component ID, not the index in the children array!

Parameters:: ID - the iD
Returns:: the child

getChildByIndex

public MTComponent getChildByIndex(int index)

Gets the child by index.

Parameters:: index - the index
Returns:: the child by index

getChildByName

public MTComponent getChildByName(java.lang.String name)

Gets the child by name.

Parameters:: name - the name
Returns:: the child by name

containsChild

public boolean containsChild(MTComponent tangibleComp)

Goes through all children and their children to check if this component tree contains the given component.

Parameters:: tangibleComp - the tangible comp
Returns:: true, if contains child

containsDirectChild

public boolean containsDirectChild(MTComponent tangibleComp)

Checks if the given component is a direct child of this component.

Parameters:: tangibleComp - the tangible comp
Returns:: true, if contains direct child

getRoot

public MTComponent getRoot()

Gets the ancestor.

Returns:: the ancestor the ancestor - the upper most parent in the hierarchy of this component

getChildCount

public int getChildCount()

Gets the child count.

Returns:: the child count the number of childs this component has

getParent

public MTComponent getParent()

Gets the parent.

Returns:: the parent the parent of this child or null if it has none.

removeChild

public void removeChild(int i)

Tries to remove the specified child from this component.

Parameters:: i - the i

removeFromParent

public void removeFromParent()

Removes this component from its parent.

removeChild

public void removeChild(MTComponent comp)

Tries to remove the specified child from this component.

Parameters:: comp - the comp

removeAllChildren

public void removeAllChildren()

Removes all direct children of this component.

getChildIndexOf

public int getChildIndexOf(MTComponent comp)

Gets the child index of a child.

Parameters:: comp - the comp
Returns:: the child index of

setDepthBufferDisabled

public void setDepthBufferDisabled(boolean drawOnTop)

If the depth buffer is disabled, the order in which the components are drawn alone decides which objects will appear ontop of others, instead of their distance to the camera. This is useful to avoid "z-fighting" when drawing co-planar objects (ie. 2D windows with ui objects on them). If set to true, this component and all its children will always be drawn above all previously drawn objects, even if the other objects are "in front" of this component.

Parameters:: drawOnTop - the draw on top option

isDepthBufferDisabled

public boolean isDepthBufferDisabled()

Checks if is always drawn on top.

Returns:: true, if is always drawn on top

sendToFront

public void sendToFront()

Puts this components to the end of the children list of its parent. This will result in this component being drawn last and on top of others at the same z-position.

sendChildToFront

protected void sendChildToFront(MTComponent child)

Puts this child to the end of the children list of this component. This will result in this child being drawn last and on top of others at the same Z-position.

Parameters:: child - the child

setVisible

public void setVisible(boolean visible)

Description copied from interface: IMTComponent

Sets the visibility.

Specified by:: setVisible in interface IMTComponent

Parameters:: visible - the new visible

isEnabled

public boolean isEnabled()

Description copied from interface: IMTComponent

Checks if the component is enabled.

Specified by:: isEnabled in interface IMTComponent

Returns:: true, if is enabled

setEnabled

public void setEnabled(boolean enabled)

Description copied from interface: IMTComponent

Sets the component enabled. If enabled, the component will process input events.

Specified by:: setEnabled in interface IMTComponent

Parameters:: enabled - the new enabled

getID

public int getID()

Description copied from interface: IMTComponent

Gets the iD.

Specified by:: getID in interface IMTComponent

Returns:: the iD

setName

public void setName(java.lang.String name)

Description copied from interface: IMTComponent

Sets the name of the component.

Specified by:: setName in interface IMTComponent

Parameters:: name - the new name

getName

public java.lang.String getName()

Description copied from interface: IMTComponent

Gets the name.

Specified by:: getName in interface IMTComponent

Returns:: the name the name of this component

getRenderer

public processing.core.PApplet getRenderer()

Description copied from interface: IMTComponent

Gets the renderer.

Specified by:: getRenderer in interface IMTComponent

Returns:: the renderer

isVisible

public boolean isVisible()

Description copied from interface: IMTComponent

Checks if the component is visible.

Specified by:: isVisible in interface IMTComponent

Returns:: true, if is visible

isPickable

public boolean isPickable()

Description copied from interface: IMTComponent3D

Checks if is pickable.

Specified by:: isPickable in interface IMTComponent3D

Returns:: true, if is pickable

setPickable

public void setPickable(boolean pickable)

Description copied from interface: IMTComponent3D

If set to true, this component will be testable for intersections.

Specified by:: setPickable in interface IMTComponent3D

Parameters:: pickable - the pickable

containsPointGlobal

public boolean containsPointGlobal(Vector3D testPoint)

Description copied from interface: IMTComponent

Checks whether this, or this component's children contains the specified point. The point is assumed to be in global space coordinates.

Specified by:: containsPointGlobal in interface IMTComponent

Parameters:: testPoint - the test point
Returns:: true, if successful

componentContainsPointLocal

protected boolean componentContainsPointLocal(Vector3D testPoint)

Checks whether the specified point is contained in this component. This method gets called from the componentContainsPointGlobal method. So in a extending class we would override the componentContainsPointLocal with our intersection code only!

Parameters:: testPoint - the test point
Returns:: true, if successful

getIntersectionGlobal

public Vector3D getIntersectionGlobal(Ray ray)

Description copied from interface: IMTComponent3D

Checks if the specified ray intersects this component or one if its childcomponents. The ray is assumed to be defined in global coordinates.

Specified by:: getIntersectionGlobal in interface IMTComponent3D

Parameters:: ray - global ray used for intersecting.
Returns:: the intersection point in global coordinates the intersection point or null when no intersection occured

getIntersectionLocal

public Vector3D getIntersectionLocal(Ray localRay)

Returns the intersection point of the ray and this component (children are not checked for intersections).
The ray is assumed to already be in component space (not in global space).
If the component is not intersected, null is returned.

Parameters:: localRay - the rays, in local space
Returns:: the component intersection point
See Also:: globalToLocal(org.mt4j.util.math.Vector3D)

pick

public PickResult pick(float x,
                       float y)

Checks which object lies under the specified screen coordinates. The the results are stored in the returned PickResult object. This component and its children will be checked.

Parameters:: x - the x; y - the y
Returns:: the pick result

pick

public PickResult pick(float x,
                       float y,
                       boolean onlyPickables)

Checks which object lies under the specified screen coordinates. The the results are stored in the returned PickResult object. This component and its children will be checked.

Parameters:: x - the x; y - the y; onlyPickables - check the only pickable components
Returns:: the pick result

getDefaultViewportSetting

public ViewportSetting getDefaultViewportSetting()

Description copied from interface: IMTComponent3D

Gets the default viewport setting.

Specified by:: getDefaultViewportSetting in interface IMTComponent3D

Returns:: the default viewport setting

getCustomViewportSetting

public ViewportSetting getCustomViewportSetting()

Description copied from interface: IMTComponent3D

Gets the custom viewport setting.

Specified by:: getCustomViewportSetting in interface IMTComponent3D

Returns:: the custom viewport setting

setViewPortSettings

public void setViewPortSettings(ViewportSetting viewPortSettings)

Sets the view port settings.

Parameters:: viewPortSettings - the new view port settings

hasCustomViewPort

public boolean hasCustomViewPort()

Description copied from interface: IMTComponent3D

Checks for custom view port.

Specified by:: hasCustomViewPort in interface IMTComponent3D

Returns:: true, if successful

processInputEvent

public boolean processInputEvent(MTInputEvent inEvt)

Description copied from interface: IMTComponent

Processes the input event.

Specified by:: processInputEvent in interface IMTComponent
Specified by:: processInputEvent in interface IMTInputEventListener

Parameters:: inEvt - the in evt
Returns:: true, if successful

processGestureEvent

public boolean processGestureEvent(MTGestureEvent gestureEvent)

Processes gesture events.
Fires the specified gesture event to the attached IGestureEventListers of this component.

Specified by:: processGestureEvent in interface IGestureEventListener

Parameters:: gestureEvent - the gesture event
Returns:: TODO

isComposite

public boolean isComposite()

Checks if is composite.

Returns:: true, if is composite

setComposite

public void setComposite(boolean composite)

Setting a components setComposite to 'true' will result in THIS component getting picked and returned when a child of this component is picked. So this component sort of consumes all picking of its children. This behaviour is desireable if we have a component with children that should be treated as one component as a whole by gestures etc.

Parameters:: composite - the composite

getController

public IMTController getController()

Gets the controller.

Returns:: the controller

setController

public IMTController setController(IMTController controller)

This attaches a controller object to the component. The controller's update method is called everytime the component's updateComponent method is called. This allows to update the component from the outside, without extending the component and overriding its update method.

Parameters:: controller - the controller
Returns:: the old IMT controller (may be null)

isGestureAllowed

public boolean isGestureAllowed(java.lang.Class c)

Description copied from interface: IMTComponent

Checks if the gesture is allowed on this component.

Specified by:: isGestureAllowed in interface IMTComponent

Parameters:: c - The Class of the InputAnalyzer (Gesture Analyzer)
Returns:: true, if this gesture is allowed

setGestureAllowance

public void setGestureAllowance(java.lang.Class c,
                                boolean allowed)

Sets the gesture allowance.

Parameters:: c - the c; allowed - the allowed

isContainedIn

public boolean isContainedIn(IFrustum frustum)

Checks if this component is contained in the specified viewing frustum (is currently visible).

Parameters:: frustum - the frustum
Returns:: true, if is contained in

reOrthogonalize

public void reOrthogonalize()

Re orthogonalizes the components local matrix. As we use incremental matrix operations, floating point errors can add up and lead to loss of precision and matrix orthogonality. This method re-orthogonalizes the matrix.
EXPERIMENTAL! - I think that this will destroy any shearing of the matrix

setUserData

public void setUserData(java.lang.Object key,
                        java.lang.Object value)

Sets user data for this component. This mechanism can be used to attach arbitrary information to this component by storing a key and a corresponding value object. The value object can then later be retrieved if the key is provided.

Parameters:: key - the key; value - the value
See Also:: org.mt4j.component.MTComponent#getUserData()

getUserData

public java.lang.Object getUserData(java.lang.Object key)

Gets the user data associated with the specified key.

Parameters:: key - the key
Returns:: the user data

toString

public java.lang.String toString()

Overrides:: toString in class java.lang.Object

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.mt4j.components Class MTComponent

MTComponent

MTComponent

MTComponent

MTComponent

addInputListener

removeInputListener

getInputListeners

fireInputEvent

getViewingCamera

getAttachedCamera

attachCamera

registerInputProcessor

unregisterInputProcessor

unregisterAllInputProcessors

getInputProcessors

addGestureListener

removeGestureEventListener

removeAllGestureEventListeners

removeAllGestureEventListeners

getGestureListeners

addStateChangeListener

removeStateChangeListener

fireStateChange

fireStateChange

destroy

destroyComponent

applyLocalMatrix

setMatricesDirty

getLocalMatrix

setLocalMatrix

getLocalInverseMatrix

getGlobalMatrix

getGlobalInverseMatrix

getLocalVecToParentRelativeSpace

getGlobalVecToParentRelativeSpace

getTransformToDestinationParentSpace

getTransformToDestinationLocalSpace

localToGlobal

globalToLocal

globalToLocal

transform

translate

translateGlobal

translate

rotateX

rotateXGlobal

rotateX

rotateY

rotateYGlobal

rotateY

rotateZ

rotateZGlobal

rotateZ

scale

scaleGlobal

scale

preDraw

drawComponent

postDraw

postDrawChildren

getClip

setClip

getChildClip

setChildClip

setLight

getLight

updateComponent

addChild

addChild

addChildren

getChildList

getChildren

getChildbyID

getChildByIndex

getChildByName

containsChild

containsDirectChild

getRoot

getChildCount

org.mt4j.components
Class MTComponent