net.risingworld.api.worldelements

Class World3DModel

java.lang.Object

net.risingworld.api.worldelements.WorldElement

net.risingworld.api.worldelements.World3DModel

public class World3DModel
extends WorldElement

A custom 3D model in the game world.

Constructor Summary

Constructors

Constructor and Description
World3DModel(ModelInformation model, ImageInformation texture) Creates a new World3DModel element with the provided model and texture.
World3DModel(ModelInformation model, ImageInformation texture, Vector3f position, Quaternion rotation) Creates a new World3DModel element with the provided model and texture at the given position (with the given rotation).

Method Summary

Modifier and Type	Method and Description
float	getAlpha() Gets the current alpha value (i.e. opacity) of this model.
CollisionShape	getCollisionShape() Gets the current collision shape of this model.
Crosshair	getInteractionCrosshair() Gets the current crosshair that will be shown to the player when he looks at this element (as long as setInteractable(boolean) is set to true).
Interaction	getInteractionPreset() Gets the current interaction preset, or null if no interaction preset was set.
float	getMass() Gets the physical mass of this element.
ModelInformation	getModel() Gets the current ModelInformation object of this element.
Vector3f	getScale() Gets the scale (xyz) of this model.
ImageInformation	getTexture() Gets the current ImageInformation object of this element.
Vector2f	getTextureOffset() Gets the offset of the texture of this model.
Vector2f	getTextureScale() Gets the scale (xy) of the texture of this model.
boolean	hasCollisionShape() Gets whether or not this model has a collision shape.
boolean	hasInteractionPreset()
boolean	isHittable() Gets whether or not this element is hittable, i.e. if you can hit it with a pickaxe, for example.
boolean	isInteractable() Gets whether or not the player can interact with this object.
boolean	isLightingEnabled() Gets wheter lighting for this model is enabled or not.
boolean	isListeningForCollisions()
boolean	isNpcCollisionEnabled()
boolean	isTransparencyEnabled() Gets whether or not transparency is currently enabled on this model (by default, transparency is disabled).
void	onInteraction(PlayerElementInteractionEvent event) Override this method if you want to get the interaction event (when a player interacts with this element) directly, without having to register an event listener.
void	onItemCollision(ItemElementCollisionEvent event)
void	onPlayerCollision(PlayerElementCollisionEvent event)
void	onPlayerHit(PlayerElementHitEvent event)
void	setAlpha(float alpha) Changes the alpha value (i.e. opacity) of this model. 1 indicates full opacity, 0 indicates full transparency (i.e. the model becomes invisible).
void	setCollisionShape(CollisionShape collisionShape) Sets a collision shape for this model.
void	setHittable(boolean set) Sets this element hittable, i.e. players can hit it with their pickaxe.
void	setInteractable(boolean set) Sets whether or not the player can interact with this object.
void	setInteractionCrosshair(Crosshair crosshair) Sets the crosshair for this element.
void	setInteractionPreset(Interaction preset) Sets an interaction preset (i.e. add some default behaviour to this object).
void	setLightingEnabled(boolean lighting) Sets if this model should be affected by lighting or not.
void	setListenForCollisions(boolean set) Sets whether or not the element should "listen" for collisions with the player.
void	setMass(float mass) Sets the physical mass of this element.
void	setModel(ModelInformation model) Sets the model information (i.e. the actual 3D model) for this element.
void	setNpcCollisionEnabled(boolean set) If set to true, npcs will collide with this element (irrespective of the collision shape of this element, so this will also work if no collision shape is set).
void	setScale(float scale) Sets the scale for this model.
void	setScale(float sx, float sy, float sz) Sets the scale for this model along the x, y and z axis.
void	setTexture(ImageInformation texture)
void	setTextureOffset(float offsetx, float offsety) Sets the texture offset for this model (this way you can move the texture on the object horizontally and vertically).
void	setTextureScale(float scale) Sets the scale of the texture for this model.
void	setTextureScale(float sx, float sy) Sets the scale of the texture for this model.
void	setTransparencyEnabled(boolean set) Enables or disables transparency for this model.

Methods inherited from class net.risingworld.api.worldelements.WorldElement

deleteAttribute, destroy, getAttribute, getID, getPosition, getRotation, getVisibleRange, hasAttribute, moveTo, moveTo, refresh, setAttribute, setPosition, setPosition, setRotation, setRotation, setVisibleRange

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

World3DModel

public World3DModel(ModelInformation model,
                    ImageInformation texture)

Creates a new World3DModel element with the provided model and texture.

Parameters:

model - the actual model.

texture - the texture of this model.

World3DModel

public World3DModel(ModelInformation model,
                    ImageInformation texture,
                    Vector3f position,
                    Quaternion rotation)

Creates a new World3DModel element with the provided model and texture at the given position (with the given rotation).

Parameters:

model - the actual model.

texture - the texture of this model.

position - the global world position of this element.

rotation - the world rotation of this element.

Method Detail

setInteractable

public void setInteractable(boolean set)

Sets whether or not the player can interact with this object. If set to true, the player will see the specified crosshair (can be set by calling setInteractionCrosshair(net.risingworld.api.utils.Crosshair)), and when pressing the interaction key, a PlayerElementInteractionEvent event will be triggered.
By default, interactions are disabled for a world element.

Parameters:

set - set to true to enable interactions with this element, false to disable it.

See Also:

PlayerElementInteractionEvent

isInteractable

public boolean isInteractable()

Gets whether or not the player can interact with this object.

Returns:

true if the player can interact with this object, false if not.

See Also:

PlayerElementInteractionEvent

setInteractionCrosshair

public void setInteractionCrosshair(Crosshair crosshair)

Sets the crosshair for this element. If setInteractable(boolean) is set to true, this crosshair will be visible when the player looks at this element.
This method does nothing if setInteractable(boolean) is set to false.

Parameters:

crosshair - the crosshair you want to set.

See Also:

PlayerElementInteractionEvent

getInteractionCrosshair

public Crosshair getInteractionCrosshair()

Gets the current crosshair that will be shown to the player when he looks at this element (as long as setInteractable(boolean) is set to true).

Returns:

the currently set crosshair.

setInteractionPreset

public void setInteractionPreset(Interaction preset)

Sets an interaction preset (i.e. add some default behaviour to this object). For example you could add a chair preset to this model, so it behaves like a chair ingame (players could sit on the model).
Set the interaction preset to null to remove any default behaviour from this model.
Remember to enable interactions with this model, otherwise it won't work (see setInteractable(boolean)).

Parameters:

preset - the interaction preset.

Example: Create a 3D model and make it behave like a chair

1	// load model file (obj) and texture (dds) from the plugin jar
2	ModelInformation modelInfo = new ModelInformation(this, "/rw/plugin/models/chair.obj");
3	ImageInformation imageInfo = new ImageInformation(this, "/rw/plugin/models/chair_texture.dds");
4
5	// create 3D model
6	World3DModel model = new World3DModel(modelInfo, imageInfo);
7
8	// now create a chair/sitting preset (sit position has an offset of [0.0f|0.5f|0.0f] units)
9	Interaction sitting = Interaction.createChairPreset(new Vector3f(0f, 0.5f, 0f));
10
11	// set 3D model interactable, set a crosshair and add the preset
12	model.setInteractable(true);
13	model.setInteractionCrosshair(Crosshair.Sitdown);
14	model.setInteractionPreset(sitting);

getInteractionPreset

public Interaction getInteractionPreset()

Gets the current interaction preset, or null if no interaction preset was set.

Returns:

the interaction preset, or null if no preset was set.

hasInteractionPreset

public boolean hasInteractionPreset()

setListenForCollisions

public void setListenForCollisions(boolean set)

Sets whether or not the element should "listen" for collisions with the player. If set to true, a PlayerElementCollisionEvent will be triggered when the player "collides" with the element collision shape. This only works if a collision shape is set for this element.
This method can be useful if you want to implement a button the player just has to "touch" (without having to interact with it), or a pressure plate, or a trap (e.g. apply damage to the player if he touches the trap) etc.

Parameters:

set - true to listen for collision events, false to disable it.

isListeningForCollisions

public boolean isListeningForCollisions()

setHittable

public void setHittable(boolean set)

Sets this element hittable, i.e. players can hit it with their pickaxe.

Parameters:

set - true to set this element hittable, false to disable this behaviour.

See Also:

PlayerElementHitEvent

isHittable

public boolean isHittable()

Gets whether or not this element is hittable, i.e. if you can hit it with a pickaxe, for example.

Returns:

true if this element is hittable, false if not.

See Also:

PlayerElementHitEvent

setModel

public void setModel(ModelInformation model)

Sets the model information (i.e. the actual 3D model) for this element.

Parameters:

model - the ModelInformation object which holds information about the particular 3D model.

getModel

public ModelInformation getModel()

Gets the current ModelInformation object of this element.

Returns:

the ModelInformation object, or null if no model information has been set.

setTexture

public void setTexture(ImageInformation texture)

getTexture

public ImageInformation getTexture()

Gets the current ImageInformation object of this element.

Returns:

the ImageInformation object, or null if no image information has been set.

setLightingEnabled

public void setLightingEnabled(boolean lighting)

Sets if this model should be affected by lighting or not. If set to false, the model has always the same light level, independent of the environment.

Parameters:

lighting - set to true to enable lighting, or false to disable it.

isLightingEnabled

public boolean isLightingEnabled()

Gets wheter lighting for this model is enabled or not.

Returns:

true if lighting is enabled, or false if not.

setScale

public void setScale(float scale)

Sets the scale for this model. Default scale is 1.0

Parameters:

scale - the new scale (xyz).

setScale

public void setScale(float sx,
                     float sy,
                     float sz)

Sets the scale for this model along the x, y and z axis. Default scale is 1.0

Parameters:

sx - the new x scale.

sy - the new y scale.

sz - the new z scale.

getScale

public Vector3f getScale()

Gets the scale (xyz) of this model.

Returns:

the scale, as a Vector3f (x, y and z scale).

setTextureScale

public void setTextureScale(float scale)

Sets the scale of the texture for this model. Note that this scales the texture coordinates, i.e. a greater value will scale down the texture. Default texture scale is 1.0

Parameters:

scale - the new texture scale (xy).

setTextureScale

public void setTextureScale(float sx,
                            float sy)

Sets the scale of the texture for this model. Note that this scales the texture coordinates, i.e. a greater value will scale down the texture. Default texture scale is 1.0

Parameters:

sx - the new horizontal (x) texture scale.

sy - the new vertical (y) texture scale.

getTextureScale

public Vector2f getTextureScale()

Gets the scale (xy) of the texture of this model.

Returns:

the texture scale, as a Vector2f (x and y scale).

setTextureOffset

public void setTextureOffset(float offsetx,
                             float offsety)

Sets the texture offset for this model (this way you can move the texture on the object horizontally and vertically). Default texture offset is 0.0

Parameters:

offsetx - the new horizontal (x) texture offset

offsety - the new horizontal (y) texture offset

getTextureOffset

public Vector2f getTextureOffset()

Gets the offset of the texture of this model.

Returns:

the texture offset, as a Vector2f (x and y offset).

setAlpha

public void setAlpha(float alpha)

Changes the alpha value (i.e. opacity) of this model. 1 indicates full opacity, 0 indicates full transparency (i.e. the model becomes invisible). Note that the alpha values of the texture are still used, i.e. this alpha value acts like a "global transparency value" for this model (more precisely, the alpha values of the texture will be multiplied with this alpha value).
Make sure to call setTransparencyEnabled(boolean) to enable transparency on this model (otherwise changes to the alpha value don't have any effect).

Parameters:

alpha - the alpha value (0-1).

Example: Make a half-transparent model ("ghost-like" effect)

1	//Create a new model (load from resource)
2	World3DModel model = new World3DModel(new ModelInformation(this, "/assets/ghost.obj"), new ImageInformation(this, "/assets/ghost.jpg"));
3
4	//Set the model half-transparent (0.5 opacity)
5	model.setAlpha(0.5f);
6
7	//Enable transparency on this model, otherwise our changes have no effect
8	model.setTransparencyEnabled(true);

getAlpha

public float getAlpha()

Gets the current alpha value (i.e. opacity) of this model. By default the alpha value is set to 1.

Returns:

the current alpha value.

setTransparencyEnabled

public void setTransparencyEnabled(boolean set)

Enables or disables transparency for this model. By default transparency is disabled, but when setting this to true, the transparency of the texture (if available) will be used. More precisely, if the texture contains alpha values (e.g. png files), they will be applied to the model accordingly. You can also call setAlpha(float) to set the global alpha value (even if the current texture does not contain any alpha values).

Parameters:

set - true to enable transparency on this model (i.e. the alpha values of this model and the texture will be used), false to disabled transparency (resulting in a fully opaque model).

isTransparencyEnabled

public boolean isTransparencyEnabled()

Gets whether or not transparency is currently enabled on this model (by default, transparency is disabled).

Returns:

true if transparency is enabled, false if not.

setCollisionShape

public void setCollisionShape(CollisionShape collisionShape)

Sets a collision shape for this model. This means that it will have a "hit box", or more precisely, it prevents the player from walking through the mesh.
Note: In most cases a box or sphere collision shape is sufficient (they provide the best performance). If you need better precision, you can use a hull collision shape. If you need max precision, or if the player should be able to walk "inside" the model (e.g. if it's a cabin, door frame etc), you have to use a mesh collision shape.

Parameters:

collisionShape - the CollisionShape for this model. Set to null to disable the collision shape of this model.

See Also:

CollisionShape.createBoxCollisionShape(float, float, float), CollisionShape.createHullCollisionShape(), CollisionShape.createMeshCollisionShape(), CollisionShape.createSphereCollisionShape(float)

Example: Create a hull collision shape for a model

1	World3DModel model = new World3DModel(...);
2	model.setCollisionShape(CollisionShape.createHullCollisionShape());

getCollisionShape

public CollisionShape getCollisionShape()

Gets the current collision shape of this model. Returns null if this model has no collision shape.

Returns:

the collision shape of this model, or null of no collision shape is set.

hasCollisionShape

public boolean hasCollisionShape()

Gets whether or not this model has a collision shape.

Returns:

true if a collision shape is set, false if not.

See Also:

setCollisionShape(CollisionShape), getCollisionShape()

setMass

public void setMass(float mass)

Sets the physical mass of this element. Set to 0 if you don't want this element to be affected by gravity (default). Only works if a collision shape is set! Not compatible with MeshCollisionShape!

Parameters:

mass - the mass of this element. Using a value greater than 0 causes this element to be affected by gravity. Set 0 if you want this element to be static.

See Also:

setCollisionShape(net.risingworld.api.utils.CollisionShape)

getMass

public float getMass()

Gets the physical mass of this element. Default value is 0 (which means the element is not affected by gravity).

Returns:

the physical mass of this element.

setNpcCollisionEnabled

public void setNpcCollisionEnabled(boolean set)

If set to true, npcs will collide with this element (irrespective of the collision shape of this element, so this will also work if no collision shape is set). Otherwise npcs will ignore this element.

Parameters:

set - true to enable npc collisions, false to disable them (i.e. npcs can walk through this element).

isNpcCollisionEnabled

public boolean isNpcCollisionEnabled()

onInteraction

public void onInteraction(PlayerElementInteractionEvent event)

Override this method if you want to get the interaction event (when a player interacts with this element) directly, without having to register an event listener.
Note that this is only triggered if setInteractable(boolean) is set to true.

Parameters:

event - the player interaction event.

See Also:

PlayerElementInteractionEvent

Example:

1	//Create ModelInformation (actual 3d model file) and ImageInformation (texture)
2	ModelInformation modelInfo = new ModelInformation(getPath() + "/assets/myModel.obj");
3	ImageInformation modelTexture = new ImageInformation(getPath() + "/assets/myModelTexture.dds");
4
5	//Create a World3DModel as "anonymous class", i.e. override the onInteraction()
6	//method during initialization. If the player interacts with the model, both
7	//the regular "PlayerElementInteractionEvent" and the "onInteraction()"-method will be called
8	World3DModel model = new World3DModel(modelInfo, modelTexture){
9	@Override
10	public void onInteraction(PlayerElementInteractionEvent event){
11	//Do something, e.g. teleport the player to another position
12	event.getPlayer().setPosition(...);
13	}
14	};
15
16	//Set model interactable (otherwise the method will never be called)
17	model.setInteractable(true);
18
19	//Set model position, for example
20	model.setPosition(0f, 10f, 0f);
21
22	//Remember to add the world element to player
23	player.addWorldElement(model);

onPlayerHit

public void onPlayerHit(PlayerElementHitEvent event)

onPlayerCollision

public void onPlayerCollision(PlayerElementCollisionEvent event)

onItemCollision

public void onItemCollision(ItemElementCollisionEvent event)