Calculates a new mesh for this object based on the keyframes of its
animation sub-sequence and "index". index is a value between 0 and 1
where 0 is the first keyframe and 1 the last (of the sub-sequence).
Calculates a new mesh for this object based on the keyframes of its
animation sequence and "index". index is a value between 0 and 1 where 0
is the first keyframe and 1 the last.
Initializes some basic object properties that are needed for almost all
further processing. build() should be called if the object is
"ready to render" (loaded, Textures assigned, placed, rendering modes
set...).
Creates a new Camera with default viewing direction (along the z-axis)
and position (at the origin) as well as default FOV (as configured, 1.25
is default).
Returns the minimal distance to some polygon of the world's objects (have
to be colliders) from a particular position vector looking into a
specific direction.
Returns the minimal distance to some polygon of the world's objects (have
to be colliders) from a particular position vector looking into a
specific direction.
Checks if a collision between "something" and an object would take place
if this "something" would move step units from its position into a given
direction.
Checks if a collision between "something" and an object would take place
if this "something" would move step units from its position into a given
direction.
Checks if a collision between "something" and an object would take place
if this "something" would move step units from its position into a given
direction.
When using the sphere-polygon collision detection for the camera, it may
be useful to use a lower sphere radius for sphere-edge-collisions to
ensure that the camera slides around corners in a more realistic way.
If this is enabled, the ellipsoid collision detection will use a kind of
workaround to prevent the detection from producing jerky movement in some
cases.
The maximum number in world units a polygon's corner and/or axis aligned
bounding box/octree-node (is used) may have from a position vector to be
taken into account as a potential collider in the collision detection
methods.
The number of units a position vector may be placed outside of a sector
and still be considered as part of it as far as collision detection is
concerned.
When in OpenGL mode, a texture's image data will be transfered to the
graphics card and a copy will be kept in the Texture object in case that
software rendering will be re-enabled, for applying texture effects or
for multiple uploads into multiple contexts.
The colordepth that the OpenGL framebuffer should have at least. jPCT
will use any videomode that offers a colordepth equal to or larger than
this value (but prefers equality).
If set to true, the OpenGL renderers will ignore the configured near
plane for creating the frustum and use a default value instead.
glMipmap -
Static variable in class com.threed.jpct.Config
Lets jPCT generate (and use) mipmaps for all textures when using an
OpenGL renderer.This has to be set before enabling the OpenGL renderer to
have an effect.
An IPaintListener can be attached to any IRenderer (via the FrameBuffer,
because the actual IRenderer instances are not accessible) and will be
notified before the actual painting of polygons starts and after it has
finished.
Has to return true if the init()-method has run correctly and should
return false after the processor has been disposed (but doesn't have to,
if an implementation requires something else...no problem).
Use this constructor to create a KeyMapper that works in combination with
hardware rendering (i.e. that is using LWJGL's methods to access the
keyboard).
Use this construtor to create a KeyMapper that works on an AWT/Swing
component, which is usually your frame (or whatever) where the rendered
output will be displayed onto.
The rotations and translations of 3D objects in jPCT are not thread-safe
because of performance reasons (and because it is not required in most
cases).
While waiting for a lock to be released, the waiting thread will be
either paused (if lockingTimer is greater zero) for "lockingTimer"
milliseconds or Thread.yield() will be called (if lockingTimer is zero).
This constructor works similar to cloneObject() but it allows to extend
Object3D and still use the static methods from Loader/Primitives by
adding a call to super(Object3D) in the constructor of your class.
This constructor works similar to cloneObject() but it allows to extend
Object3D and still use the static methods from Loader/Primitives by
adding a call to super(Object3D) in the constructor of your class.
jPCT 1.11+ features a fixed 3DS-loader, but the fix is based on
experience, not on file format specs, because they were all different and
inconsistent.
Picks the polygon that is closest to the camera (and belongs to a
"selectable" object) and that is hit by the ray casted from some position
vector into the scene.
Picks the polygon that is closest to the camera (and belongs to a
"selectable" object) and that is hit by the ray casted from some position
vector into the scene.
If this returns true, the same geometry that was rendered will be
rendered again using the exact same settings. beforeRendering() won't be
called again. afterRendering() won't be called yet.
Sets the indicator that the object was a target of the last collision
detection to false, i.e. the object won't be recognized any longer as
part of the collision.
When doing ellipsoid collision detection with a camera, the ellipsoid can
be transformed according to the camera's transformation in camera space
or it remains static in object space (i.e.
When doing ellipsoid collision detection with this object, the ellipsoid
can be transformed according to the objects's transformation and in the
source's object space or it remains static in the target's object space
(i.e.
If true (default), all geometry that is a potential collider hides the effect if it's located in
a direct line between the camera and the light source.
In addition to sharing the actual mesh data, you can also make objects
share the same texturing information (the actual textures, not the
uv-coordinates).
2D texture-blitting into the framebuffer is done by copying the source
into the destination bitmap only at places where the sources bitmap has
none-zero color-values.
Creates a texture using an image from file. jPCT supports every format
that JAVA supports for creating images from files as long as the result
is a 24bpp image.
Creates a texture using an image from file. jPCT supports every format
that JAVA supports for creating images from files as long as the result
is a 24bpp image.
Creates a texture using an image from an URL (intended to be used in
applets). jPCT supports every format that JAVA supports for creating
images from files as long as the result is a 24bpp image.
Creates a texture using an image from an URL (intended to be used in
applets). jPCT supports every format that JAVA supports for creating
images from files as long as the result is a 24bpp image.
Creates a texture using an image from file. jPCT supports every format
that JAVA supports for creating images from files as long as the result
is a 24bpp image.
Creates a texture using an image from file (usually in jpeg format). jPCT
supports every format that JAVA supports for creating images from files
as long as the result is a 24bpp image.
Creates a texture using an image from file (usually in jpeg format). jPCT
supports every format that JAVA supports for creating images from files
as long as the result is a 24bpp image.
Creates a texture using a java.awt.Image. jPCT supports every format that
JAVA supports for creating images from files as long as the result is a
24bpp image.
Creates a texture using a java.awt.Imagem. jPCT supports every format
that JAVA supports for creating images from files as long as the result
is a 24bpp image.
Timeout value in ms after which a threaded renderer is allowed to remove
the unload request of textures that have never been used by the renderer
from the queue.
Shifts the (normalized) viewport into x-direction, i.e. a value of 0.5
lets the rendering start in the middle of the framebuffer so that only
the leftmost half of the image is visible in the right half of the
framebuffer.
Shifts the (normalized) viewport into y-direction, i.e. a value of 0.5
lets the rendering start in the middle of the Framebuffer so that only
the uppermost half of the image is visible in the bottom of the
framebuffer.
W
WARNING -
Static variable in class com.threed.jpct.Logger
The message is a warning
WHITE -
Static variable in class com.threed.jpct.RGBColor