1.02 jpct.ae.wrapper.JWorld JpctWorld com.threed.jpct.World process checkCameraCollisionSpherical Moves the camera moveSpeed units from its current position and regarding its current orientation into "mode" direction, if this is possible. Uses a sphere-polygon collision detection. This method can be used in CAMERA_DONT_MOVE-mode too, where the camera will only be adjusted automatically if anything that is a collider has moved in its way. - mode - the direction (relative to its orientation) radius - the radius of the sphere. A collision will only be detected within this radius. moveSpeed - the number of units the camera should move slideMode - indicates if the camera should slide or just stand still in case of collision boolean mode int radius float moveSpeed float slideMode boolean FOGGING_DISABLED No linear distance fogging will be used (default). int checkCollision 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. The method can be used to implement various kinds of collision detection/response and uses a ray-polygon collision detection. All objects should have been set to an appropiate collision mode. - org - the position vector of "something" dr - the direction vector of "something" (a unit vector, if not it'll be made one) step - the length of the casted ray (a collision will only be detected of it takes place within this range) int org com.threed.jpct.SimpleVector dr com.threed.jpct.SimpleVector step float addPolyline Adds a new Polyline to the world. A Polyline is a line strip with a color that will be drawn into the scene after all other objects has been drawn. A Polyline's coordinates are to be given in world space. You can add multiple Polylines to a world. - line - the Polyline void line com.threed.jpct.Polyline checkCameraCollision3 Moves the camera moveSpeed units from its current position and regarding its current orientation into "mode" direction, if this is possible. Uses a ray-polygon collision detection. - mode - the direction (relative to its orientation) moveSpeed - the number of units the camera should move distance - the maximum distance the position vector can have from the polygon before a collision is detected. slideMode - indicates if the camera should slide or just stand still in case of collision boolean mode int moveSpeed float distance float slideMode boolean checkCameraCollision4 Moves the camera moveSpeed units from its current position into an arbitrary direction, if this is possible. Uses a ray-polygon collision detection. - direction - the direction (should be a normalized vector (i.e. a length of 1)) moveSpeed - the number of units the camera should move distance - the maximum distance the position vector can have from the polygon before a collision is detected. slideMode - indicates if the camera should slide or just stand still in case of collision boolean direction com.threed.jpct.SimpleVector moveSpeed float distance float slideMode boolean checkCameraCollision Moves the camera moveSpeed units from its current position and regarding its current orientation into "mode" direction, if this is possible. If not, the camera will "slide" in the remaining directions. Uses a ray-polygon collision detection. - mode - the direction (relative to its orientation) moveSpeed - the number of units the camera should move boolean mode int moveSpeed float checkCameraCollision2 Moves the camera moveSpeed units from its current position and regarding its current orientation into "mode" direction, if this is possible. Uses a ray-polygon collision detection. - mode - the direction (relative to its orientation) moveSpeed - the number of units the camera should move slideMode - indicates if the camera should slide or just stand still in case of collision boolean mode int moveSpeed float slideMode boolean draw Draws the current scene that has been generated geometry wise by renderScene(). Usually, renderScene() and draw() are used one right after the other (with draw being the last). - buffer - the framebuffer that should be used for rendering void buffer com.threed.jpct.FrameBuffer checkCameraCollisionEllipsoid Moves the camera moveSpeed units from its current position into an arbitrary direction, if this is possible. Uses a (swept)ellipsoid-polygon collision detection. This method will always use sliding. - mode - the direction (relative to its orientation) ellipsoid - the radius of the epplisoid in x,y and z direction moveSpeed - the number of units the camera should move recursionDepth - the max. recursion depth of the collision detection. A higher value will improve the accuracy of the collision detection but reduce performance. Reasonable values lie between 1 and 5. boolean mode int ellipsoid com.threed.jpct.SimpleVector moveSpeed float recursionDepth int removeAllLights Removes all lights from the world. The scene will be lit by ambient lighting only after calling this method. void setFogParameters2 Sets the parameters for the linear distance fog (if enabled). - start - where the fog actually starts. distance - the distance in camera-space coordinates at which the fog reaches its maximum density (150 is default, 1 is minimum) red - the red component of the fog ([0..255], 0 is default) green - the green component of the fog ([0..255], 0 is default) blue - the blue component of the fog ([0..255], 0 is default) void start float distance float red float green float blue float calcMinDistanceAndObject3D 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. It only takes polygons into consideration that have at least one vertex that is closer than ignoreIfLarger units to the position vector and whose bounding box/octree-node is closer than that value too. In addition to calcMinDistance(), this method returns the object to which the polygon belongs. - orig - a SimpleVector containing the x,y,z-coordinates of the position vector dir - a SimpleVector array containing the x,y,z-coordinates of the direction vector (a unit vector) ignoreIfLarger - only polygons/bounding boxes/octree-nodes within this range will be taken into account java.lang.Object[] orig com.threed.jpct.SimpleVector dir com.threed.jpct.SimpleVector ignoreIfLarger float renderScene Transforms and lights all the polygons. This method does everything required to start drawing the current scene. It just doesn't scanconvert the results. This is done by the draw()-method. This method has to be called at least once before blitting into the FrameBuffer will work correctly. If you are not abusing jPCT as a pure 2D blitting engine, then this shouldn't be a problem anyway. - buffer - the framebuffer that should be used for rendering void buffer com.threed.jpct.FrameBuffer compileAllObjects Compiles all objects in the world for better gpu processing. You don't have to call this method, because it will be done in demand anyway. However, it may be better to compile all objects before starting the actual render loop to avoid hick-ups when auto-compiling while drawing things. Already compiled objects won't be affected. void calcMinDistance 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. It only takes polygons into consideration that have at least one vertex that is closer than ignoreIfLarger units to the position vector and whose bounding box/octree-node is closer than that value too. - orig - a SimpleVector containing the x,y,z-coordinates of the position vector dir - a SimpleVector array containing the x,y,z-coordinates of the direction vector (a unit vector) ignoreIfLarger - only polygons/bounding boxes/octree-nodes within this range will be taken into account float orig com.threed.jpct.SimpleVector dir com.threed.jpct.SimpleVector ignoreIfLarger float IsInitialized boolean removeAll Removes all lights and objects from the world. void getObject Returns the object with the given ID from the World's object collection. - id - the ID of the object com.threed.jpct.Object3D id int removeObject2 Removes the given object from the World's object collection. This method doesn't check for child/parent objects of the removed object, which will remain intact. - obj - the object to remove void obj com.threed.jpct.Object3D Initialize Initialize the world void removePolyline Removes a Polyline from a world. - line - the line void line com.threed.jpct.Polyline addObjects Adds all objects from the given array to the world. This can be useful, if one wants to add a Object3Ds loaded by the 3DS/OBJ loaders to a world at once. - objs - the objects void objs com.threed.jpct.Object3D[] dispose Disposes the world. This method should be called before the world goes out of scope. This frees some resources that may otherwise be locked. void setAmbientLight Sets the light intensity for the ambient light source. Setting this is negative values will darken the whole scene while positive ones will light up everything. - r - the red component (100 is default) g - the red component (100 is default) b - the red component (100 is default) void r int g int b int removeAllObjects Removes all but the internal objects from the world. The world is empty after calling this method. void drawWireframe Draws the current scene as a single-colored wireframe. This is done using the same buffer draw() draws into. drawWireframe() can be called instead of draw() to get the wireframe only as well as right after draw() to combine the two renderings for some special effects. Calling drawWireframe() before draw() doesn't make much sense. jPCT's wireframe mode is not as optimized as the texturemapped mode is (yet) but it should be "fast enough". - buffer - the framebuffer that should be used for rendering color - the wireframe's color void buffer com.threed.jpct.FrameBuffer color com.threed.jpct.RGBColor setClippingPlanes If set, this overrides the settings in Config for the near and the far clipping plane for this world. If you don't touch this method, the settings in Config will be taken instead. - near - the near plane far - the far plane void near float far float buildAllObjects Calls build() for every object in the world. void setFogParameters Sets the parameters for the linear distance fog (if enabled). - distance - the distance in camera-space coordinates at which the fog reaches its maximum density (150 is default, 1 is minimum) red - the red component of the fog ([0..255], 0 is default) green - the green component of the fog ([0..255], 0 is default) blue - the blue component of the fog ([0..255], 0 is default) void distance float red float green float blue float FOGGING_ENABLED Linear distance fogging will be used. int getObjectByName Returns the object named "name" from the World's object collection. This is an alternative albeit slower way to retrieve objects from the World. A better idea would be not ot lose them anyway...:-) - name - the name of the object com.threed.jpct.Object3D name java.lang.String checkCollisionSpherical 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. The method can be used to implement various kinds of collision detection/response and uses a sphere-polygon collision detection. All objects should have been set to an appropiate collision mode. - org - the position vector of "something" translation - that should be applied to "something" (Note that this method just checks this translation...it doesn't apply it) radius - the radius of the sphere (a collision will only be detected of it takes place within this radius) com.threed.jpct.SimpleVector org com.threed.jpct.SimpleVector translation com.threed.jpct.SimpleVector radius float removeObject Removes the object with the specified ID from the World's object collection. This method doesn't check for child/parent objects of the removed object, which will remain intact. - id - the ID of the object to remove void id int checkCameraCollisionSpherical2 Moves the camera moveSpeed units from its current position into an arbitrary direction, if this is possible. Uses a sphere-polygon collision detection. - direction - the direction (should be a normalized vector (i.e. a length of 1)) radius - the radius of the sphere. A collision will only be detected within this radius. moveSpeed - the number of units the camera should move slideMode - indicates if the camera should slide or just stand still in case of collision boolean direction com.threed.jpct.SimpleVector radius float moveSpeed float slideMode boolean newCamera Resets the camera to origin looking along the z-axis. This is the position and orientation the camera has after creating a new "world". void checkCollisionEllipsoid 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. The method can be used to implement various kinds of collision detection/response and uses a (swept) ellipsoid-polygon collision detection. All objects should have been set to an appropiate collision mode. - org - the position vector of "something" translation - that should be applied to "something" (Note that this method just checks this translation...it doesn't apply it) ellipsoid - the radius of the epplisoid in x,y and z direction recursionDepth - the max. recursion depth of the collision detection. A higher value will improve the accuracy of the collision detection but reduce performance. Reasonable values lie between 1 and 5. com.threed.jpct.SimpleVector org com.threed.jpct.SimpleVector translation com.threed.jpct.SimpleVector ellipsoid com.threed.jpct.SimpleVector recursionDepth int checkCameraCollisionEllipsoid2 Moves the camera moveSpeed units from its current position into an arbitrary direction, if this is possible. Uses a (swept)ellipsoid-polygon collision detection. This method will always use sliding. - direction - the direction (should be a normalized vector (i.e. a length of 1)) ellipsoid - the radius of the epplisoid in x,y and z direction moveSpeed - the number of units the camera should move recursionDepth - the max. recursion depth of the collision detection. A higher value will improve the accuracy of the collision detection but reduce performance. Reasonable values lie between 1 and 5. boolean direction com.threed.jpct.SimpleVector ellipsoid com.threed.jpct.SimpleVector moveSpeed float recursionDepth int addObject Adds an object to the World's object collection. The object will be referenced in this collection by its ID. The ID of the object in the collection is the same as the object's own ID. addObject() also returns this ID due to "historical reasons". So id=addObject(obj) is basically the same as id=obj.getID(); addObject(obj); Note: Current implementation limits the object-World bindings in a way that an object can only be added to one world at a time. This method doesn't check if the object has been added multiple times. This may change later. - obj - the object to be added int obj com.threed.jpct.Object3D Fogging int fog int Returns if fogging is being used or not. DefaultThread java.lang.Thread def java.lang.Thread Returns the default thread or null if none has been set. ObjectsVisibility visible boolean Sets the visibility for all objects that belong to a world. - visible - visible or not? AmbientLight int[] Returns the ambient light's intensities in an int[]-array in r,g,b order. Camera com.threed.jpct.Camera Gets the current camera. CameraTo cam com.threed.jpct.Camera Sets the camera to another one. cam - the camera to use GlobalShader com.threed.jpct.GLSLShader globalShader com.threed.jpct.GLSLShader Returns the global shader or null if none has been set. Objects java.util.Enumeration Returns an Enumeration of all user defined objects in this world. FrameCounter long Returns the number of frames rendered since startup. Size int Returns the number of user defined objects in this World. jpct.ae.wrapper.JVirtualizer JpctVirtualizer com.threed.jpct.Virtualizer process Initialize constructor to Initialize the Virtualizer void finalize Overrides: finalize in class java.lang.Object void Initialize2 Creates a new instance of the Virtualizer with an estimated maximum size. - sizeInMb - the maximum size. It might exceed this size, but not by a huge amount. void sizeInMb int IsInitialized boolean cleanUp Cleans up the Virtualizer. This will delete virtualized (but not cached) files. void Context ctx android.content.Context Sets the context. Without it, the Virtualizer can't work. - ctx - the context jpct.ae.wrapper.JTextureManager JpctTextureManager com.threed.jpct.TextureManager process Initialize Initialize the TextureManager void TEXTURE_NOTFOUND The id of a none-existent texture. int getTextureByID Returns the texture with the ID or null if no such texture can be found. - id - int the ID com.threed.jpct.Texture id int getTextureID Returns the numerical ID of the texture. This value is used internally to access textures faster than by using their names. Some methods use this ID instead of the unique name or the texture itself for performance reasons. - name - the name of the texture int name java.lang.String containsTexture Checks if a texture has already been added to the texture-manager (or better: if a texture with this name exists within the manager instance). - name - the name of the texture boolean name java.lang.String virtualize Virtualizes a textures if a Virtualizer has been set. This means that the texture might (and most likely will) be swapped to disk instead of being kept in memory. This doesn't affect the texture data uploaded to the GPU of course. Note that you can't use an ITextureEffect on a virtualized texture. - tex - the Texture to virtualize. If it is virtual already, no actions will be taken. void tex com.threed.jpct.Texture getNameByID Gets the name with which the texture with the given ID has been added to the manager. - id - the texture's ID java.lang.String id int removeAndUnload Combines removal and unload of a texture. Everything mentioned in the single methods applies here too. - name - the texture's name from - the FrameBuffer void name java.lang.String from com.threed.jpct.FrameBuffer addTexture Adds a texture with the given name to the manager. The name has to be unique, otherwise no texture will be added. The added texture will be filled with a dummy texture and may be replaced by another one later. This could be useful to render something without every texture being loaded (for slow connections for example). - name - the (unique) name for this texture void name java.lang.String compress Compresses all texture known to the TextureManager so that they use less main memory. This doesn't effect the memory used inside the gpu. Compressed textures require some more time to upload. void removeTexture Removes a texture from the manager. Because the manager doesn't know if a texture is still in use by some object, you have to be sure that it isn't before calling this method. This method removes the texture from the manager only. That doesn't mean, that it will be unloaded from video memory. To ensure this, call unloadTexture() in addition or use removeAndUnload(). Please note that you can't expect an object that uses this texture to get a new texture that you might add with the same name after removing this one. If you want to replace textures on objects, use replaceTexture() instead. - name - the name of the texture to be removed void name java.lang.String unloadTexture Unloads a texture from the contexts of the renderers of the given frame buffer. This isn't done immediatly but in the next render pass for that buffer. You can try to unload any texture, it doesn't have to belong to the manager (...any longer). If a texture hasn't been uploaded, it will be ignored. If it's used after the unload, the renderer will upload it again. - from - the FrameBuffer texture - the texture to unload void from com.threed.jpct.FrameBuffer texture com.threed.jpct.Texture flush Flushes the textures in the manager. In other words: The manager doesn't contain any textures after calling flush(). void getTexture Returns the texture being named 'name'. - name - the name of the texture that should be retrieved com.threed.jpct.Texture name java.lang.String replaceTexture Replaces a texture with the given name with another one. It might be required to call unloadTexture() before to ensure that the old texture has been unloaded from the GPU in case it's no longer used somewhere else. - name - the (unique) name of the texture to replace tex - the new texture void name java.lang.String tex com.threed.jpct.Texture preWarm Does some work that may otherwise happen during runtime and can cause hick-ups like uploading all known textures if needed before the renderer is going to use them anyway. This only affects the textures that the TextureManager currently knows. It has to be called within the render thread, i.e. within onDraw() for example. - buffer - the current frame buffer. void buffer com.threed.jpct.FrameBuffer addTexture2 Adds a texture with the given name to the manager. The name has to be unique, otherwise no texture will be added. - name - the (unique) name for this texture tex - the texture void name java.lang.String tex com.threed.jpct.Texture IsInitialized boolean TextureCount int Returns the number of textures the TextureManager holds. MemoryUsage long Returns the VM memory used to store the texture data. Doesn't take the GPU memory into account. State java.util.List dump java.util.List Dumps the current state of the TextureManager to a Vector. If you are serializing this Vector, you may later setup the TextureManager at once with the deserialized dump. If you are not using serialization, ignore this method. DummyTexture com.threed.jpct.Texture texture com.threed.jpct.Texture Returns the current dummy texture. Virtualizer com.threed.jpct.Virtualizer textureVirtualizer com.threed.jpct.Virtualizer Returns the current Virtualizer. By default, none is set. Names java.util.HashSet Gets all the names of the textures that have been added to the manager. jpct.ae.wrapper.JTextureInfo JpctTextureInfo com.threed.jpct.TextureInfo process Initialize Creates a new TextureInfo. This is a shortcut to the method above, if the u/v-coordinates are not required. - texID - int the ID of the Texture as the TextureManager sees it. void texID int set Sets the values of an existing layer. This is a shortcut to the method above, if the u/v-coordinates are not required. - texID - int the ID of the Texture as the TextureManager sees it. stageCnt - int the stage mode - int the combination mode void texID int stageCnt int mode int MODE_BLEND Use blending for adding this texture layer. int add Adds another texture layer. This is a shortcut to the method above, if the u/v-coordinates are not required. - texID - int the Texture's ID mode - int the combination mode void texID int mode int MODE_MODULATE Use multiplication of color values for adding this texture layer. int add2 Adds another texture layer. - texID - int the ID of the Texture as the TextureManager sees it. u0 - float the u-coordinate for the first vertex v0 - float the v-coordinate for the first vertex u1 - float the u-coordinate for the second vertex v1 - float the v-coordinate for the second vertex u2 - float the u-coordinate for the third vertex v2 - float the v-coordinate for the third vertex mode - int the combination mode void texID int u0 float v0 float u1 float v1 float u2 float v2 float mode int MODE_REPLACE For the sake of completeness. Every texture from a lower stage is replaced by the texture in the stage that uses this mode. int MODE_ADD Use addition for adding this texture layer. int MAX_PHYSICAL_TEXTURE_STAGES The maximum number of physical texture layers available. If the hardware supports more, jPCT will simply ignore them. int Initialize2 Creates a new TextureInfo. - texID - int the ID of the Texture as the TextureManager sees it. u0 - float the u-coordinate for the first vertex v0 - float the v-coordinate for the first vertex u1 - float the u-coordinate for the second vertex v1 - float the v-coordinate for the second vertex u2 - float the u-coordinate for the third vertex v2 - float the v-coordinate for the third vertex void texID int u0 float v0 float u1 float v1 float u2 float v2 float set2 Sets the values of an existing layer. - texID - int the ID of the Texture as the TextureManager sees it. stageCnt - int the stage u0 - float the u-coordinate for the first vertex v0 - float the v-coordinate for the first vertex u1 - float the u-coordinate for the second vertex v1 - float the v-coordinate for the second vertex u2 - float the u-coordinate for the third vertex v2 - float the v-coordinate for the third vertex mode - int the combination mode void texID int stageCnt int u0 float v0 float u1 float v1 float u2 float v2 float mode int IsInitialized boolean jpct.ae.wrapper.JTextureEffect JpctTextureEffect jpct.ae.wrapper.TextureEffect process TextureEffect(dest() As Int, src() As Int) Initialize Initialize the Texture Effect eventName - the name of the Texture Effect's event void ba anywheresoftware.b4a.BA eventName java.lang.String containsAlpha boolean IsInitialized boolean jpct.ae.wrapper.JTexture JpctTexture com.threed.jpct.Texture process enable4bpp Makes jPCT converting this texture to use 4 bits per pixel/alpha (respectively 5/1 without a dedicated alpha channel) instead of 8, i.e. use 16 bit textures. Default is false unless you call Texture.defaultTo4bpp(true); - doit - should we? void doit boolean defaultTo4bpp Static method to set the textures' default depth to 4bpp (respectively 5bpp without a dedicated alpha channel). This doesn't affect the Texture instances themselves but the data uploaded to the graphics card. - doit - should 4bpp be the default? void doit boolean add Adds a textures color (and alpha) information to this one. - ta - the texture whose color should be added weight - the weight of the second texture's data. May be even negative. void ta com.threed.jpct.Texture weight float applyEffect Applies the effect to the texture. Depending on the implementation of the effect, this can be slow. void keepPixelData Should a texture's pixels be kept even when the texture has been uploaded to the GPU? Default is false. - keepData - should they? void keepData boolean Initialize8 Creates a black texture with alpha in the given dimensions. - width - the width of the texture. Has to be a power of 2. If its not, it will be adjusted accordingly. height - the height of the texture. Has to be a power of 2. If its not, it will be adjusted accordingly. alpha - the alpha value (0..255) void width int height int alpha int defaultToKeepPixels Static method to set the textures' default behaviour for keeping the pixel data after uploading to the gpu. Default is true. - doit - should we keep the pixles void doit boolean defaultToMipmapping Static method to make all textures use mipmaps by default. Default setting is false. - doit - should mipmapping be the default? void doit boolean Initialize9 Creates a colored texture with no alpha in the given dimensions. - width - the width of the texture. Has to be a power of 2. height - the height of the texture. Has to be a power of 2. col - the color. Can be null for render targets. void width int height int col com.threed.jpct.RGBColor Initialize6 Creates a texture using a Drawable. jPCT supports every format that JAVA supports for creating images from files as long as the result is a 24bpp image. A texture has to be added to a TextureManager to be of any use for the engine. Supported texture sizes are 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 and 8192 pixels in width and height. Any texture using other dimensions will raise an error. This method can be used to load a texture that provides an additional alpha channel. - image - the Drawable useAlpha - use alpha information from texture? void image android.graphics.drawable.Drawable useAlpha boolean Initialize7 Creates a black texture with no alpha in the given dimensions. - width - the width of the texture. Has to be a power of 2. height - the height of the texture. Has to be a power of 2. void width int height int Initialize4 Creates a texture using a Bitmap. jPCT supports every format that JAVA supports for creating images from files as long as the result is a 24bpp image. A texture has to be added to a TextureManager to be of any use for the engine. Supported texture sizes are 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 and 8192 pixels in width and height. Any texture using other dimensions will raise an error. This method can be used to load a texture that provides an additional alpha channel. - image - the Bitmap useAlpha - use alpha information from texture? void image android.graphics.Bitmap useAlpha boolean Initialize5 Creates a texture using a Drawble. jPCT supports every format that JAVA supports for creating images from files as long as the result is a 24bpp image. A texture has to be added to a TextureManager to be of any use for the engine. Supported texture sizes are 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 and 8192 pixels in width and height. Any texture using other dimensions will raise an error. - image - the Bitmap void image android.graphics.drawable.Drawable Initialize2 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. A texture has to be added to a TextureManager to be of any use for the engine. Supported texture sizes are 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 and 8192 pixels in width and height. Any texture using other dimensions will raise an error. This variant can be used to get the data from an InputStream (for accessing files via getResourceAsStream() for example) This method can be used to load a texture that provides an additional alpha channel. - is - the InputStream containing the data useAlpha - use alpha information from texture? void is java.io.InputStream useAlpha boolean Initialize3 Creates a texture using a Bitmap. jPCT supports every format that JAVA supports for creating images from files as long as the result is a 24bpp image. A texture has to be added to a TextureManager to be of any use for the engine. Supported texture sizes are 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 and 8192 pixels in width and height. Any texture using other dimensions will raise an error. - image - the Bitmap void image android.graphics.Bitmap IsInitialized boolean Initialize 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. A texture has to be added to a TextureManager to be of any use for the engine. Supported texture sizes are 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 and 8192 pixels in width and height. Any texture using other dimensions will raise an error. This variant can be used to get the data from an InputStream (for accessing files via getResourceAsStream() for example) - is - the InputStream for the data void is java.io.InputStream DEFAULT_HEIGHT The default height of a texture (16 pixels). int removeAlpha Removes any alpha information from a texture. void isEnabled Returns if the texture is enabled or not. A disabled texture won't show up when used on any texture stage except the first one. - boolean compress Compresses the texture so that is uses less main memory. This doesn't effect the memory used inside the gpu. Compressed textures require some more time to upload. If the saved space is less than 5% of the original size, the texture won't be compressed. void DEFAULT_WIDTH The default width of a texture (16 pixels). int removeEffect Removes an ITextureEffect from the Texture void Enabled isEnabled boolean Sets the texture to enable/disabled. A disabled texture won't show up when used on any texture stage except the first one. Default it true. - isEnabled - is it enabled? Mipmap mipmap boolean Enabled/Disables mip map setting for a texture. Default is true. mipmap - true, if there's no override. false means no mip mapping/trilinear for this texture Filtering filter boolean Sets the bilinear filtering state on textures. Setting this to false forces jPCT to use a pick nearest on the textures. This may also affect mip mapping. - filter - the mode, true for bilinear, false for pick nearest ArraySize int Returns the size of the texture array. Clamping clamping boolean Set texture coordinate to clamping or wrapping/repeating. Calling this on an already uploaded texture forces a new texture upload to the graphics card. - clamping - clamping or wrapping/repeating? Height int Returns the height of the texture in pixels. Effect effect com.threed.jpct.ITextureEffect Sets an effect for this texture. The effect is an implementation of ITextureEffect. - effect - the effect AsShadowMap isShadowMap boolean Marks this texture as a shadow map. This only affects the OpenGL ES 2.0 mode. - isShadowMap - is it a shadow map or not? TextureCompression enabled boolean Enables ETC1-texture compression if available on the platform. If not, jPCT-AE will fall back to normal textures. This is an experimental feature for now. The usual restrictions for ETC1 apply. - enabled - enable ETC1 texture compression DepthBuffer com.threed.jpct.DepthBuffer depthBuffer com.threed.jpct.DepthBuffer ? Width int Returns the width of the texture in pixels. jpct.ae.wrapper.JSkyBox jpctSkyBox com.threed.jpct.util.SkyBox process Initialize Creates a new skybox. This constructor assumes that the textures for front, back, left, right, up and down have already been added to the TextureManager and that their names are equal to their purpose, i.e. the front texture is called "front", the left one "left" and so on. - size - the size of the box. The box will extend in all directions by half the size when viewed from the center. void size float dispose Disposes the skybox. It can't be used after this. void compile Can be used to compile the skybox to avoid compilation at runtime. Usually not needed, just here from compatibility with desktop jPCT. void Initialize2 Creates a new skybox. This constructor assumes that the textures for front, back, left, right, up and down have already been added to the TextureManager. - left - the name of the texture for the left side front - the name of the texture for the front side right - the name of the texture for the right side back - the name of the texture for the back side up - the name of the texture for the up side down - the name of the texture for the down side size - the size of the box. The box will extend in all directions by half the size when viewed from the center. void left java.lang.String front java.lang.String right java.lang.String back java.lang.String up java.lang.String down java.lang.String size float IsInitialized boolean render Renders the skybox. This should be called before rendering the actual scene or the skybox may overwrite transparent polygons. - world - the world that contains the scene buffer - the frame buffer void world com.threed.jpct.World buffer com.threed.jpct.FrameBuffer Center trans com.threed.jpct.SimpleVector Sets the center of the skybox. This can be useful if the scene's center is way off from the origin. Default is the origin. - trans - World com.threed.jpct.World Gets the world that this skybox uses. This might be needed if you want to make additional adjustments to it. By default, it's a default world instance with an ambient light of white. The first object in this world is the sky box. jpct.ae.wrapper.JSimpleVector JpctSimpleVector com.threed.jpct.SimpleVector process matMul Multiplies the SimpleVector with a matrix, i.e. it applies the matrix's transformation to the SimpleVector. - mat - Matrix the matrix (usually a rotation or a translation matrix) void mat com.threed.jpct.Matrix calcCross Calculates the cross product of two SimpleVectors. - vec - the second SimpleVector com.threed.jpct.SimpleVector vec com.threed.jpct.SimpleVector sub Subtracts another SimpleVector from this SimpleVector without creating a new instance. - vec - the SimpleVector to subtract void vec com.threed.jpct.SimpleVector calcAngleFast Calculates the angle between this SimpleVector and another one. This method is faster than the "normal" method, but less accurate. - vec - the other vector float vec com.threed.jpct.SimpleVector calcAdd Add two SimpleVectors to a new SimpleVector. - vec - the second SimpleVector com.threed.jpct.SimpleVector vec com.threed.jpct.SimpleVector rotate Rotates this SimpleVector using the angles (x,y,z) of rotVector. The result is a new SimpleVector. If you want to rotate the SimpleVector itself without creating a new one, use rotateX(), rotateY() and rotateZ() instead. - rotVector - the rotation vector containing the angles for the rotations around x,y and z axis. com.threed.jpct.SimpleVector rotVector com.threed.jpct.SimpleVector set Sets the x,y and z values of the SimpleVector to the given floats. - x - float y - float z - float void x float y float z float rotateX Rotates the SimpleVector around the x-axis. This method modifies the SimpleVector itself (unlike rotate()). - angle - the angle void angle float calcDot Calculates the dot product of two SimpleVectors. - vec - the second SimpleVector float vec com.threed.jpct.SimpleVector hashCode Overrides hashCode() from java.lang.Object. This is required when overriding equals(), which this implementation does, so... int rotateZ Rotates the SimpleVector around the z-axis. This method modifies the SimpleVector itself (unlike rotate()). - angle - the angle void angle float rotateY Rotates the SimpleVector around the y-axis. This method modifies the SimpleVector itself (unlike rotate()). - angle - the angle void angle float add Adds another SimpleVector to this SimpleVector without creating a new instance. - vec - the SimpleVector to add void vec com.threed.jpct.SimpleVector create2 Another way to create a SimpleVector. Using this way, the returned SimpleVector may come from an internal cache of SimpleVectors. Don't use this method to create SimpleVectors that live long but consider to use it for short-living objects. - sv - the source vector com.threed.jpct.SimpleVector sv com.threed.jpct.SimpleVector create3 Another way to create a SimpleVector. Using this way, the returned SimpleVector may come from an internal cache of SimpleVectors. Don't use this method to create SimpleVectors that live long but consider to use it for short-living objects. - x - the x component y - the y component z - the z component com.threed.jpct.SimpleVector x float y float z float makeEqualLength Makes this SimpleVector the length of another SimpleVector, but only if its longer than this. - vec - the SimpleVector that defines the length void vec com.threed.jpct.SimpleVector normalize Normalizes a SimpleVector and returns a normalized vector as a new SimpleVector. To reach a higher numerical accuracy, this method works with doubles instead of float internally. com.threed.jpct.SimpleVector distance Returns the distance between this SimpleVector and another position vector. - pos - float pos com.threed.jpct.SimpleVector normalize2 Normalizes a SimpleVector and returns a normalized vector as a new SimpleVector. To reach a higher numerical accuracy, this method works with doubles instead of float internally. This variant takes a SimpleVector to fill, i.e. it avoids the creation of a new SimpleVector. - sv - the SimpleVector to fill com.threed.jpct.SimpleVector sv com.threed.jpct.SimpleVector length Gives the length of this SimpleVector float Initialize4 Creates a new SimpleVector from an existing one - s - the SimpleVector to "copy" void s com.threed.jpct.SimpleVector Initialize5 Creates a new SimpleVector from an array[3] of floats vector - the array containing the x, y and z components of the vector - in [0],[1] and [2]. void vector float[] getRotationMatrix3 Creates a rotation matrix that can be used to rotate a vector pointing to (0,0,1) to match the direction of this vector. This method takes a matrix to fill, i.e. it doesn't create a new one for each call. - mat - the Matrix to fill com.threed.jpct.Matrix mat com.threed.jpct.Matrix Initialize2 Creates a new SimpleVector by setting the x,y and z components of the vector - x - the x component y - the y component z - the z component void x float y float z float getRotationMatrix4 Creates a rotation matrix that can be used to rotate a vector pointing to (0,0,1) to match the direction of this vector. This method takes a matrix to fill, i.e. it doesn't create a new one for each call. - up - the up vector used in the calculation mat - the Matrix to fill com.threed.jpct.Matrix mat com.threed.jpct.Matrix up com.threed.jpct.SimpleVector Initialize3 Creates a new SimpleVector by setting the x,y and z components of the vector. This method takes doubles as arguments which are internally casted into floats. - x - the x component y - the y component z - the z component void x double y double z double IsInitialized boolean getRotationMatrix2 Creates a rotation matrix that can be used to rotate a vector pointing to (0,0,1) to match the direction of this vector. - up - the up vector used in the calculation com.threed.jpct.Matrix up com.threed.jpct.SimpleVector Initialize Constructor to Initialize the SimpleVector void toArray Returns an float[3]-array containing the components of the vector so that [0]=x, [1]=y and [2]=z. This method can be used to use SimpleVectors for methods that requires float[3]-arrays. The returned array is allowed to be the same instance over different calls. float[] equals Overrides the equals()-method from java.lang.Object. Two SimpleVectors are equal, if their x,y and z components are equal. - obj - the SimpleVector that should be compared to this one boolean obj java.lang.Object calcSub Calculates the difference vector of two SimpleVectors. - vec - the second SimpleVector com.threed.jpct.SimpleVector vec com.threed.jpct.SimpleVector scalarMul Multiplies the SimpleVector with a scalar. - scalar - the scalar to multiply with void scalar float create Another way to create a SimpleVector. Using this way, the returned SimpleVector may come from an internal cache of SimpleVectors. Don't use this method to create SimpleVectors that live long but consider to use it for short-living objects. com.threed.jpct.SimpleVector ORIGIN A SimpleVector representing the origin (0,0,0). com.threed.jpct.SimpleVector calcAngle Calculates the angle between this SimpleVector and another one. - vec - the other vector float vec com.threed.jpct.SimpleVector toString Returns this SimpleVector as a String. Useful for debugging. java.lang.String reflect Reflects this vector on a plane with the given normal. faceNormal - the face normal of the reflective plane com.threed.jpct.SimpleVector faceNormal com.threed.jpct.SimpleVector 2 s com.threed.jpct.SimpleVector Sets the x,y and z values of this SimpleVector to the ones of the given SimpleVector. s - SimpleVector RotationMatrix com.threed.jpct.Matrix Creates a rotation matrix that can be used to rotate a vector pointing to (0,0,1) to match the direction of this vector. z float z float Set/Get The Z value of the SimpleVector. y float y float Set/Get The Y value of the SimpleVector. x float x float Set/Get The X value of the SimpleVector. jpct.ae.wrapper.JShaderLocator JpctShaderLocator com.threed.jpct.ShaderLocator process Initialize Constructor to Initialize the ShaderLocater void getShaderCode This is important for OpenGL ES 2.0 support only. If you aren't using this, ignore this class. - name - java.lang.String name java.lang.String Initialize2 This is important for OpenGL ES 2.0 support only. If you aren't using this, ignore this class. - assets - void assets android.content.res.AssetManager Initialize3 This is important for OpenGL ES 2.0 support only. If you aren't using this, ignore this class. - res - Resources rawResourceId - int void res android.content.res.Resources rawResourceId int IsInitialized boolean jpct.ae.wrapper.JRGBColor JpctRGBColor com.threed.jpct.RGBColor process Initialize Creates a new Black color with alpha. void Initialize2 Creates a new color with alpha. - r - Red (0 - 255) g - Green (0 - 255) b - Blue (0 - 255) void r int g int b int Initialize3 Creates a new color with alpha. r,g,b,a: as int void r int g int b int a int IsInitialized boolean setTo Modifies and existing instance of RGBColor. - r - Red (0 - 255) g - Green (0 - 255) b - Blue (0 - 255) void r int g int b int a int NormalizedGreen float Returns the green value in normalized form (0..1). ARGB int Returns the color as an int argb value with alpha. Blue int Returns the blue value (0..255). Alpha int Returns the alpha value (0..255). Red int Returns the red value (0..255). NormalizedBlue float Returns the blue value in normalized form (0..1). NormalizedAlpha float Returns the alpha value in normalized form (0..1). Green int Returns the green value (0..255). NormalizedRed float Returns the red value in normalized form (0..1). jpct.ae.wrapper.JRenderHook JpctRenderHook jpct.ae.wrapper.RenderHook process RenderHook(rhEvent As Int, polyID As Int, obj As JpctObject3D, transparency As Float, shader As JpctGLSLShader) EVENT_SET_TRANSPARENCY Event type - SET_TRANSPARENCY - of the callback event raised by the RenderHook. int Initialize Initialize the Render Hook eventName - the name of the Render Hook's event void ba anywheresoftware.b4a.BA eventName java.lang.String repeatRendering boolean EVENT_SET_OBJECT3D Event type - SET_OBJECT3D - of the callback event raised by the RenderHook. int EVENT_BEFORE_RENDERING Event type - BEFORE_RENDERING - of the callback event raised by the RenderHook. int EVENT_DISPOSE Event type - DISPOSE - of the callback event raised by the RenderHook. int EVENT_AFTER_RENDERING Event type - AFTER_RENDERING - of the callback event raised by the RenderHook. int EVENT_SET_SHADER Event type - SET_SHADER - of the callback event raised by the RenderHook. int IsInitialized boolean jpct.ae.wrapper.JPrimitives JpctPrimitives com.threed.jpct.Primitives process getBox Returns a box (a 3-dimensional rectangle) - scale - the scaling of the box scaleHeight - the height relative to the width (i.e. a scaleHeight-value of 1 will return a cube). com.threed.jpct.Object3D scale float scaleHeight float getEllipsoid Returns an ellipsoid with 20 faces. - scale - the scaling in x-direction scaleHeight - the scaling of the height relative to the width (1 creates a sphere) com.threed.jpct.Object3D scale float scaleHeight float getSphere Returns a sphere with 20 faces. - scale - the scaling of the sphere com.threed.jpct.Object3D scale float getCone3 Returns a cone with the given number of faces. - faces - the number of faces scale - the scaling of the cone scaleHeight - the height relative to the width com.threed.jpct.Object3D faces int scale float scaleHeight float getCone2 Returns a cone with the given number of faces. - faces - the number of faces scale - the scaling of the cone com.threed.jpct.Object3D faces int scale float getDoubleCone Returns a double cone with 90 faces. - scale - the scaling of the double cone com.threed.jpct.Object3D scale float getCone Returns a cone with 90 faces. - scale - the scaling of the cone com.threed.jpct.Object3D scale float getPlane Returns a plane consisting of (quads^2)*2 polygons each "scale" units in size. The plane lies within the X-Y-plane and has a depth of 0; - quads - the number of quads the plane has in x as well as in y direction scale - the size of each quad com.threed.jpct.Object3D quads int scale float getPyramide2 Returns a pyramide - scale - the scaling of the pyramide scaleHeight - the height relative to the width com.threed.jpct.Object3D scale float scaleHeight float getCube Returns a cube - scale - the scaling of the cube com.threed.jpct.Object3D scale float getCylinder Returns a cylinder with 90 faces. - scale - the scaling of the cylinder com.threed.jpct.Object3D scale float getCylinder3 Returns a cylinder with the given number of faces. - faces - the number of faces scale - the scaling of the cylinder scaleHeight - the height relative to the width com.threed.jpct.Object3D faces int scale float scaleHeight float getDoubleCone2 Returns a double cone with the given number of faces. - faces - the number of faces scale - the scaling of the double cone com.threed.jpct.Object3D faces int scale float getCylinder2 Returns a cylinder with the given number of faces. - faces - the number of faces scale - the scaling of the cylinder com.threed.jpct.Object3D faces int scale float IsInitialized boolean getPyramide Returns a pyramide - scale - the scaling of the pyramide com.threed.jpct.Object3D scale float jpct.ae.wrapper.JPostProcessor JpctPostProcessor jpct.ae.wrapper.PostProcessor process PostProcessor (ppEvent As Int, buffer As JpctFrameBuffer) Initialize Initialize PostProcessor eventName - the name of the Vertex Controller's event void ba anywheresoftware.b4a.BA eventName java.lang.String EVENT_DISPOSE The collision event was caused by a sphere-polygon collision detection. int EVENT_PROCESS The collision event was caused by a ray-polygon collision detection. int EVENT_INIT The collision event was caused by a ellipsoid-polygon collision detection. int IsInitialized boolean jpct.ae.wrapper.JPolyline JpctPolyline com.threed.jpct.Polyline process update Updates the line strip. The new data has to be equal in size or smaller than the initial strip. - newPoints - the new points void newPoints com.threed.jpct.SimpleVector[] Initialize Creates a new, static Polyline. - points - The coordinates in world space color - The color void points com.threed.jpct.SimpleVector[] color com.threed.jpct.RGBColor essai dimension int Create array for PolyLine Points. com.threed.jpct.SimpleVector[] setColor color com.threed.jpct.RGBColor SetColor for PolyLine. void setTransparencyMode TransparencyMode int Set TransparencyMode for PolyLine. void setParent obj com.threed.jpct.Object3D SetParent for PolyLine. void setPointMode pointMode boolean SetParent for PolyLine. void setWidth width float SetWidth for PolyLine. void setPercentage percentage float Set percentage longitude 0..1 visibility for PolyLine. void setVisible visible boolean Set Visible for PolyLine. void isVisible Returns the visibility of the line. boolean IsInitialized boolean Percentage float percentage float Returns the percentage (a value between 0 and 1 that defines how much of the line is actually visible). Visible visible boolean Sets the visibility of the line. - visible - visible or not? TransparencyMode int transparencyMode int Returns the current transparency mode. Length int Returns the length of the line strip. This is the actual length * the value set as percentage. Width float width float Returns the line width. Default is 1. Color com.threed.jpct.RGBColor color com.threed.jpct.RGBColor Returns the color of the line strip. jpct.ae.wrapper.JPolygonManager JpctPolygonManager com.threed.jpct.PolygonManager process Initialize Initialize PolygonManager object3D - the object you want PolygonManager to handle void object3D com.threed.jpct.Object3D getPolygonTextures2 Returns the texture IDs of a polygon or null in case of an error. The corresponding textures can be obtained from the TextureManager. The returned array is allowed to contain TextureManager.TEXTURE_NOTFOUND-IDs. In that case, you can break after finding the first one. - polyID - int the ID of the polygon int[] polyID int getTransformedVertex Returns a polygon's vertex transformed into world space. - polyID - int the ID of the polygon vertexNumber - int the number if the vertex (0..2) com.threed.jpct.SimpleVector polyID int vertexNumber int setVertexAlpha Sets the alpha value for an objects vertex. Once done on an object, the overall transparency value for this object is obsolete and all transparency will be calculated using the alpha values assigned to the vertices, default is 1. - polyID - int the ID of the polygon vertexNumber - int the number if the vertex (0..2) alpha - the new alpha value in a range of (0..1) void polyID int vertexNumber int alpha float getTextureUV Returns the normalized texture coordinates mapped to a SimpleVector's x and y component. - polyID - int the ID of the polygon vertexNumber - int the number if the vertex (0..2) com.threed.jpct.SimpleVector polyID int vertexNumber int addTexture Adds a texture to next free stage, if another free stage is available. - polyID - the polygon id tid - the texture's id mode - the blending mode (as defined in TextureInfo) void polyID int tid int mode int setPolygonTexture Sets the texture for a polygon. The texture ID is the ID of the texture in the World instance to which this object is assigned. It can be obtained by calling TextureManager.getTextureID(). The polygon's ID is what the picking methods in Interact2D or a CollisionEvent may return. - polyID - the ID of the polygon textureID - the ID of the texture void polyID int textureID int getPolygonTexture Returns the texture ID of a polygon or -1 in case of an error. The corresponding texture can be obtained from the TextureManager. - polyID - int the ID of the polygon int polyID int getTransformedNormal Returns a polygon's face normal transformed into world space. - polyID - int the ID of the polygon com.threed.jpct.SimpleVector polyID int IsInitialized boolean MaxPolygonID int Returns the maximum polygon ID for the object. jpct.ae.wrapper.JPaintListener JpctPaintListener jpct.ae.wrapper.PaintListener process PaintListener(plEvent as int) Initialize Initialize the Paint Listener eventName - the name of the Paint Listener's event void ba anywheresoftware.b4a.BA eventName java.lang.String EVENT_FINISHED Called when the renderer has finished painting. int EVENT_START Called when the renderer starts painting. int IsInitialized boolean jpct.ae.wrapper.JOverlay JpctOverlay com.threed.jpct.util.Overlay process Initialize Creates a new overlay that covers the whole screen. - world - the world buffer - the current frame buffer textureName - the name of the texture that should be used as an overlay. The TextureManager has to know this texture. void world com.threed.jpct.World buffer com.threed.jpct.FrameBuffer textureName java.lang.String update Updates the overlay. It shouldn't be required to call this method from a normal application. - buffer - void buffer com.threed.jpct.FrameBuffer dispose Disposes the overlay and frees its resources. It can't be used after calling this method void setRotationPivot Sets the pivot point for the rotation in screen coordinates. - x - the x position y - the y position void x int y int unlink Unlinks the overlay. It shouldn't be required to call this method from a normal application. void setSourceCoordinates Sets new source coordinates. Only the defined part of the source texture will be used as an overlay. Setting this will slow the overlay down a tiny little bit, but that shouldn't be noticable. - upperLeftX - the upper left corner's x-coordinate in texture coordinates upperLeftY - the upper left corner's y-coordinate in texture coordinates lowerRightX - the lower right corner's x-coordinate in texture coordinates lowerRightY - the lower right corner's y-coordinate in texture coordinates void upperLeftX int upperLeftY int lowerRightX int lowerRightY int Initialize2 Creates a new overlay of arbritary size. - world - the world upperLeftX - the upper left corner's x-coordinate in screen coordinates upperLeftY - the upper left corner's y-coordinate in screen coordinates lowerRightX - the lower right corner's x-coordinate in screen coordinates lowerRightY - the lower right corner's y-coordinate in screen coordinates textureName - the name of the texture that should be used as an overlay. The TextureManager has to know this texture. void world com.threed.jpct.World upperLeftX int upperLeftY int lowerRightX int lowerRightY int textureName java.lang.String Initialize3 Creates a new overlay of arbritary size with (optional) modifiable uv-coordinates. - world - the world upperLeftX - the upper left corner's x-coordinate in screen coordinates upperLeftY - the upper left corner's y-coordinate in screen coordinates lowerRightX - the lower right corner's x-coordinate in screen coordinates lowerRightY - the lower right corner's y-coordinate in screen coordinates textureName - the name of the texture that should be used as an overlay. The TextureManager has to know this texture. modifyUV - if true, uv-coordinates can be modified. void world com.threed.jpct.World upperLeftX int upperLeftY int lowerRightX int lowerRightY int textureName java.lang.String modifyUV boolean setNewCoordinates Sets new coordinates for the overlay. - upperLeftX - the upper left corner's x-coordinate in screen coordinates upperLeftY - the upper left corner's y-coordinate in screen coordinates lowerRightX - the lower right corner's x-coordinate in screen coordinates lowerRightY - the lower right corner's y-coordinate in screen coordinates void upperLeftX int upperLeftY int lowerRightX int lowerRightY int IsInitialized boolean Transparency trans int Set the transparency of the overlay. The trans-value behaves as the value in Object3D's setTransparency()-method. By default, the overlay is opaque. - trans - the transparency value Object3D com.threed.jpct.Object3D Returns the internal Object3D that is the actual Overlay. Handle with care! TransparencyMode mode int Sets the transparency mode similar to setTransparencyMode() in Object3D. - mode - the mode Visibility visible boolean Sets the visibility similar to setVisibility() in Object3D. - visible - should it be visible or not? Rotation angle float Rotates the Overlay around it's midpoint. - angle - the angle Depth depth float Sets the depth of the overlay. By default the overlay is bound to Config.nearPlane with a small offset. By setting this to a higher value, the overlay will ovberlap differently with other objects in the world while still filling the whole screen. Useful for using an (pseudo-)overlay as static backdrop. When using a large overlay, the accuracy may suffer. In this case, it might also help to increase the depth value. - depth - the new depth (should be positive) Texture2 textureInfo com.threed.jpct.TextureInfo Changes the texture of the overlay. - textureInfo - the new TextureInfo. Texture textureName java.lang.String Changes the texture of the overlay. - textureName - the new texture's name as the TextureManager knows it. Color color com.threed.jpct.RGBColor Sets a new additional color. With this, it's possible to give the overlay another coloring. Default is white, i.e. the overlay shows the same colors like they are defined in the texture. - color - the new Color jpct.ae.wrapper.JOcTree JpctOcTree com.threed.jpct.OcTree process Initialize Initialize OcTree void RENDERING_DONT_USE Don't use this octree to speed up rendering. boolean MODE_NORMAL Builds the octree in the "normal" way. int COLLISION_DONT_USE Don't use this octree to speed up collision detection. boolean MODE_OPTIMIZED Tries to build a more optimized octree. In the current implementation, this will reduce the size of the tree in memory but it may take a bit longer to build the tree. int COLLISION_USE Use this octree to speed up collision detection. boolean isOfOrderZero If the root-node is the only node in the tree, the tree is of order zero. In that case, using the generated octree is at least questionable. This can be used to assign (to an Object3D) trees of a higher order only. boolean Initialize4 Builds a new octree from an Object3D. The tree may then be assigned to the object (this is NOT done automatically). This constructor doesn't set the maximum depth of the OcTree, so the tree may become very big and the recursion may fail on large objects. - obj - the object from which's mesh the octree should be constructed maxPoly - the maximum number of polygons a single node may contain. The smaller this number is, the more complex the octree gets. It depends on the object and its usage which number will be the best. mode - the mode that should be used to construct the object void obj com.threed.jpct.Object3D maxPoly int mode int Initialize5 Builds a new octree from an Object3D. The tree may then be assigned to the object (this is NOT done automatically). - obj - the object from which's mesh the octree should be constructed maxPoly - the maximum number of polygons a single node may contain. The smaller this number is, the more complex the octree gets. It depends on the object and its usage which number will be the best. maxDepth - the maximum depth of the tree. The recursion will end at this depth regardless of the number of polygons in the node. mode - the mode that should be used to construct the object void obj com.threed.jpct.Object3D maxPoly int maxDepth int mode int Initialize2 Builds a new octree from an Object3D. The tree may then be assigned to the object (this is NOT done automatically). This constructor doesn't set the maximum depth of the OcTree, so the tree may become very big and the recursion may fail on large objects. - mesh - the mesh from which the octree should be constructed maxPoly - the maximum number of polygons a single node may contain. The smaller this number is, the more complex the octree gets. It depends on the object and its usage which number will be the best. mode - the mode that should be used to construct the object void mesh com.threed.jpct.Mesh maxPoly int mode int Initialize3 Builds a new octree from an Object3D. The tree may then be assigned to the object (this is NOT done automatically). - mesh - the mesh from which the octree should be constructed maxPoly - the maximum number of polygons a single node may contain. The smaller this number is, the more complex the octree gets. It depends on the object and its usage which number will be the best. maxDepth - the maximum depth of the tree. The recursion will end at this depth regardless of the number of polygons in the node. mode - the mode that should be used to construct the object void mesh com.threed.jpct.Mesh maxPoly int maxDepth int mode int RENDERING_USE Use this octree to speed up rendering. boolean IsInitialized boolean FilledLeafs java.util.ArrayList ? RadiusMultiplier float mul float Returns the current radius multiplier for this octree. CollisionUse boolean useIt boolean Gets the collision detection setting for this octree. RenderingUse boolean useIt boolean Gets the rendering usage setting for this octree. jpct.ae.wrapper.JObject3D JpctObject3D com.threed.jpct.Object3D process animate 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). If seq is zero, the whole animation will be treated as a sub-sequence. - index - the "time-index" into the sub-sequence of the animation seq - the number of the sub.sequence (sub-sequence start at 1, 0 stands for the animation as a whole) void index float seq int isTransparent Returns if the object is transparent of not. boolean setBoundingBox Sets a new AABB for the object. Usually, this shouldn't be required as it is automatically done by the build()-method. - minx - the lowest x-value of the AABB maxx - the highest x-value of the AABB miny - the lowest y-value of the AABB maxy - the highest y-value of the AABB minz - the lowest z-value of the AABB maxz - the highest z-value of the AABB void minx float maxx float miny float maxy float minz float maxz float clearShader Removes a shader and reverts to the default shader set. This is only valid when using OpenGL ES 2.0. void setOrientation Sets the orientation of this object by giving a direction and an up-vector. - dir - the direction up - the up-vector void dir com.threed.jpct.SimpleVector up com.threed.jpct.SimpleVector TRANSPARENCY_MODE_ADD An alternative transparency mode for additive blending. int IsInitialized boolean build2 Initializes some basic object properties that are needed for almost all further processing. build() has to be called if the object is "ready to render" (loaded, Textures assigned, placed, rendering modes set, animations and vertex controllers assigned). This method is a special purpose method that has to be used if an UV-coordinates are supposed to be modified. staticUV - void staticUV boolean COLLISION_CHECK_SELF This Object3D may collide with other objects int hasVertexAlpha Returns true, if this object uses vertex alpha values. False, if it doesn't, which is default. boolean shareTextureData 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). If you do this, changing the texture on one object will change it on all sharing objects too. This helps to save some memory, especially on objects that use multiple textures. - source - the source of the texturing information void source com.threed.jpct.Object3D SPECULAR_DISABLED Specular highLights won't be calculated. boolean sphereIntersectsAABB Checks if a given sphere intersects the axis aligned bounding box (in object-space) of this object. This can be useful to speed up some calculations. jPCT is using this method for faster collision detection. "Intersection" means everything from touching it to being completely covered by it in this case. If the object doesn't have a bounding box for whatever reason, false will be returned. - org - the position vector of the sphere (the sphere's center) radius - the radius of the sphere boolean org com.threed.jpct.SimpleVector radius float getInverseWorldTransformation2 getInverseWorldTransformation ? mat - Matrix ? com.threed.jpct.Matrix mat com.threed.jpct.Matrix calcTextureWrapSpherical "Wraps" a texture around the object in a spherical way. Usually, this method produces better results than calcTextureWrap(), but it depends on the object. This method is well suited to assign texture-coordinates to objects that were generated using the Primitives class. This method recalculates the center of the object, so any modification to the center or the rotation-pivot will be lost after calling this method. void removeChild Removes an object from the child-collection of this. The object itself won't be removed. - obj - the Object3D to remove void obj com.threed.jpct.Object3D resetNextID Resets the internal object-counter. void calcBoundingBox Calculates an AABB (Axis Aligned Bounding Box) for this object in object-space. The box will then be transformed together with the object so that it becomes an OBB (oriented bounding box) when the object will be transformed. Normally, there is no need to call this method directly, because it will already be called from the build() method. Exceptions could be the use of objects meshes for animation and similar tasks. void touch Touches an object. This has a meaning for dynamically compiled objects and for objects that use lazy transformations. If touched, changes in vertices (and u/v-coordinates if supported) will be retransfered to the graphics card and the transformation matrices of objects using lazy transformations will be recalculated. void enableLazyTransformations Enables "lazy transformations". When lazy transformations are being used, the world-transformation matrix (as well as its inverse if needed) is calculated only once and used from there on until lazy transformations are being disabled again. This helps to improve performance for static objects and it can be VERY helpful to speed-up collision detection with such objects. It may also be used on none-static objects if they aren't moving/rotating for some time (for example: if a lot of objects should be checked for collision, it could be helpful to enable lazy transformations before doing this and disabling it right after the tests). Enabling this again after it already has been clears the stored values, i.e. you can use this to update the calculated matrix inbetween without disabling the mode entirely. void addChild Defines an object as a child of this. A child object will inherit all transformations but no other attributes of this object. - obj - the object that should become a child of this. void obj com.threed.jpct.Object3D checkForCollisionEllipsoid Checks if the current object collides with something when moving into a particular direction. This is just a check, so no translations are being performed. A collision can only be detected with objects that are set to COLLISION_CHECK_OTHERS. This method uses a (swept)ellipsoid-polygon collision detection. - translation - the translation the object should perform ellipsoid - the radius of the epplisoid in x,y and z direction recursionDepth - the max. recursion depth of the collision detection. A higher value will improve the accuracy of the collision detection but reduce performance. Reasonable values lie between 1 and 5. com.threed.jpct.SimpleVector translation com.threed.jpct.SimpleVector ellipsoid com.threed.jpct.SimpleVector recursionDepth int shareCompiledData Enables a compiled object to share data with another compiled one. This helps to save system or GPU memory, depending on the used mode for compilation. The object you would like to share data with must not share data itself with some other, it must not use an octree. Furthermore, both objects have to use the same mesh (not just the same data but the exact same instance), this object must not share data with some other. This object will inherit all texture coordinates and vertex alpha values from the source object no matter what may have been assigned to it. - withObj - the object to share data with void withObj com.threed.jpct.Object3D ellipsoidIntersectsAABB Checks if a given ellipsoid intersects the axis aligned bounding box (in object-space) of this object. This can be useful to speed up some calculations. jPCT is using this method for faster collision detection. "Intersection" means everything from touching it to being completely covered by it in this case. If the object doesn't have a bounding box for whatever reason, false will be returned. - org - the position vector of the ellipsoid (the ellipsoid's center) ellipsoid - the radius of the ellipsoid in x,y and z-direction as a SimpleVector boolean org com.threed.jpct.SimpleVector ellipsoid com.threed.jpct.SimpleVector forceGeometryIndices Forces the object to be compiled to indexed geometry no matter what. Default is false and jPCT will try to figure out, what is best for an object. If this is true, it will override this detection. Compiling to indexed geometry is more expensive, the result might be smaller in memory and depending on the device, it will be rendered faster or slower... This has to be set before calling build() to have an effect. - force - should we? void force boolean COLLISION_DETECTION_OPTIMIZED Enables an automated optimization for speeding up collision detection in some case. May cause problems on dynamically changing geometry. boolean build Initializes some basic object properties that are needed for almost all further processing. build() has to be called if the object is "ready to render" (loaded, Textures assigned, placed, rendering modes set, animations and vertex controllers assigned). void addParent Defines an object as a parent of this. this will inherit all transformations from its parent and no other attributes. Defining child and parent object is basically the same. Child object of A will internally be stored by assigning A as their parent. It's a matter of taste which kind of logic one may use. Therefor, both are supported but the parent-logic is closer to the implementation...then again: Who cares? - obj - the object that should become a parent of this. void obj com.threed.jpct.Object3D UNKNOWN_OBJECTSIZE The object is empty int invert Physically "inverts" the object, which means that the backface culling works the other way round. This could be used for example on a cube that is usually viewed from outside to make it possible to view it from the inside (and still use backface culling on it). Inverting an object is a costly operation. void ELLIPSOID_TRANSFORMED The object's ellipsoid will be transformed when performing collision detection. int compile Mainly needed to ease porting from the desktop version of jPCT. By default, jPCT-AE does this call automatically, so usually there's no need to call this method directly. void animate2 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. Because no sub-sequence is indicated, the complete animation will be used. - index - the "time-index" into the animation void index float getWorldTransformation2 Variant of getWorldTransformation() to avoid the creation of an additional matrix where not needed. The given matrix will be filled with the returns and returned in addition. - mat - the matrix to be filled com.threed.jpct.Matrix mat com.threed.jpct.Matrix getTransformedCenter Returns the center of the object in worldspace, i.e. after the object's current transformations have been applied to it. The returned SimpleVector is the same one as the one given as parameter. This is useful to save the creation of an additional object. If null is given, a new one will be created. - toFill - com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector hasParent Tests an object for being a parent object of the current object. The object inherits all the transformations from its parent object. - obj - the object that should be tested for being a parent of this boolean obj com.threed.jpct.Object3D TRANSPARENCY_MODE_DEFAULT The default transparency mode. int SHADING_FAKED_FLAT Indicates that (faked) flat shading should be used. Faked, because it sits on top of gouraud, i.e. it's not faster than using gouraud shading. In fact it may be slower because it hinders the usage of triangle strips. int translate Translates ("moves") the object in worldspace by modifying the translation matrix. The translation will be applied the next time the object is rendered. - trans - the translation vector void trans com.threed.jpct.SimpleVector createDummyObj Static method that creates a dummy Object3D. This dummy object is basically a normal but empty object. This method should be used to create an object that won't be added to the world but linked to another object as a child object. This could be useful to enhance the flexiblity of the object bindings (like a moon spinning around a planet...it may be useful to link the moon to the planet via a dummy object placed in the planet's center. This enables the moon not only to inherit the transformations of the planet but also the transformations of the dummy object). There is no need nor any sense in adding a dummy object directly to the world. com.threed.jpct.Object3D BILLBOARDING_DISABLED The object won't use billboarding (default). boolean clearAnimation Clears the animation for this object. The object ist no longer animated. Its mesh data will be that of the last frame interpolation. void COLLISION_CHECK_OTHERS Other Object3Ds/rays/spheres/ellipsoids may collide with this object int disableVertexSharing Disables the automatic vertex sharing that jPCT does for triangles added by addTriangle. This can be useful if single polygons of the object are supposed to change their positions independantly from the others (by using an IVertexController for example). It will hurt performance though. void addTriangle5 Adds a triangle to the object. The vertices have to be defined counter-clockwise because jPCT backface culls them by default. One may also add them clockwise and call invert() afterwards to "invert" the order. This method takes a TextureInfo instead of the discrete u/v-coordinates and the textureID. - vert1 - the first vertex vert2 - the second vertex vert3 - the third vertex tInf - the TextureInfo int vert1 com.threed.jpct.SimpleVector vert2 com.threed.jpct.SimpleVector vert3 com.threed.jpct.SimpleVector tInf com.threed.jpct.TextureInfo addTriangle4 Adds a triangle to the object. The vertices have to be defined counter-clockwise because jPCT backface culls them by default. One may also add them clockwise and call invert() afterwards to "invert" the order. - vert1 - the first vertex u - the u component of the texture position at the first vertex v - the v component of the texture position at the first vertex vert2 - the second vertex u2 - the u component of the texture position at the second vertex v2 - the v component of the texture position at the second vertex vert3 - the third vertex u3 - the u component of the texture position at the third vertex v3 - the v component of the texture position at the third vertex textureID - the ID of the texture as returned by TextureManager.getTextureID() sec - ? int vert1 com.threed.jpct.SimpleVector u float v float vert2 com.threed.jpct.SimpleVector u2 float v2 float vert3 com.threed.jpct.SimpleVector u3 float v3 float textureID int sec int getTranslation2 Returns the translation of the object. The returned SimpleVector is the same one as the one given as parameter. This is useful to save the creation of an additional object. If null is given, a new one will be created. - trns - the SimpleVector to fill and return com.threed.jpct.SimpleVector trns com.threed.jpct.SimpleVector addTriangle3 Adds a triangle to the object. Using the method, the sector will be set to undefined. The vertices have to be defined counter-clockwise because jPCT backface culls them by default. One may also add them clockwise and call invert() afterwards to "invert" the order. - vert1 - the first vertex u - the u component of the texture position at the first vertex v - the v component of the texture position at the first vertex vert2 - the second vertex u2 - the u component of the texture position at the second vertex v2 - the v component of the texture position at the second vertex vert3 - the third vertex u3 - the u component of the texture position at the third vertex v3 - the v component of the texture position at the third vertex textureID - the ID of the texture as returned by TextureManager.getTextureID() int vert1 com.threed.jpct.SimpleVector u float v float vert2 com.threed.jpct.SimpleVector u2 float v2 float vert3 com.threed.jpct.SimpleVector u3 float v3 float textureID int addTriangle2 Adds a triangle to the object. Using the method, the texture of the object won't be set and the sector will be set to undefined. The vertices have to be defined counter-clockwise because jPCT backface culls them by default. One may also add them clockwise and call invert() afterwards to "invert" the order. - vert1 - the first vertex u - the u component of the texture position at the first vertex v - the v component of the texture position at the first vertex vert2 - the second vertex u2 - the u component of the texture position at the second vertex v2 - the v component of the texture position at the second vertex vert3 - the third vertex u3 - the u component of the texture position at the third vertex v3 - the v component of the texture position at the third vertex int vert1 com.threed.jpct.SimpleVector u float v float vert2 com.threed.jpct.SimpleVector u2 float v2 float vert3 com.threed.jpct.SimpleVector u3 float v3 float compile3 Mainly needed to ease porting from the desktop version of jPCT. By default, jPCT-AE does this call automatically, so usually there's no need to call this method directly. - dynamic - if the mesh dynamic? staticUV - does it use static uv-coordinates void dynamic boolean staticUV boolean rotateX Rotates the object's rotation matrix around the x-axis by the given angle w (radian, counter clockwise for positive values). This rotation is then applied to the object when it's rendered the next time. - w - the angle by which should be rotated void w float checkForCollision Checks if the current object collides with something when moving into a particular direction. This is just a check, so no translations are being performed. A collision can only be detected with objects that are set to COLLISION_CHECK_OTHERS. This method uses a ray-polygon collision detection. - dirVec - the direction vector (a unit vector) step - the length of the casted ray (a collision will only be detected of it takes place within this range) int dirVec com.threed.jpct.SimpleVector step float rotateZ Rotates the object's rotation matrix around the z-axis by the given angle w (radian, counter clockwise for positive values). This rotation is then applied to the object when it's rendered the next time. - w - the angle by which should be rotated void w float OBJ_INVISIBLE The object is invisible and won't be processed, rendered...nothing... boolean rotateY Rotates the object's rotation matrix around the y-axis by the given angle w (radian, clockwise for positive values). This rotation is then applied to the object when it's rendered the next time. - w - the angle by which should be rotated void w float COLLISION_NONE Signals that no collision has been detected for this object float BILLBOARDING_ENABLED The object will use billboarding (i.e. it always faces the camera) boolean align2 Aligns this object with another Object3D. This basically means that both objects will face into the same direction after calling this method. Keep in mind that the rotation pivot influences the outcome too. This method works on the object's own rotation matrix only. It doesn't take transformations of parent objects into account. - object - the object this object should be aligned with void object com.threed.jpct.Object3D enableCollisionListeners (Re-)enables all collision listerner of this object. void calcTextureWrap "Wraps" a texture around the object. This may not look correct on every object, but it's a fast and easy way to assign texture coordinates to objects that didn't have any. This kind of wrapping is basically a kind of static environment mapping. void calcTangentVectors Tangent vectors are needed for some calculation in shaders. If you are using shaders (i.e. OpenGL ES 2.0) and your shader needs these vectors and jPCT-AE wasn't able to detect this (by searching for "attribute vec4 tangent" in the vertex shader, you might want to trigger this calculation manually. By default, the calculation happens automatically during build() if the need has been detected. void ELLIPSOID_ALIGNED The object's ellipsoid won't be transformed when performing collision detection (default). int Initialize4 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. Consider this to be a kind of "workaround" for the fact that you can't extend a loaded (by Loader) or created (by Primitives) Object3D directly. - obj - the Object3D to construct this Object3D from reuseMesh - if true, the new object will use the same mesh void obj com.threed.jpct.Object3D reuseMesh boolean clearObject Clears the object by removing all vertex/mesh information from it. This also affects objects that have been cloned from this object, because they will lose their mesh-data too. Every other property of the object stays intact. void Initialize2 Creates a new instance of Object3D. Usually, an object is created to be added to some instance of World. You may also create dummy objects, that are just "lending" there transformations to their child-objects, but this should be done by using createDummyObj(). - maxTriangles - the maximum number of triangles for this object. void maxTriangles int ENVMAP_ENABLED Environment mapping is enabled. boolean Initialize3 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. Consider this to be a kind of "workaround" for the fact that you can't extend a loaded (by Loader) or created (by Primitives) Object3D directly. - obj - the Object3D to construct this Object3D from void obj com.threed.jpct.Object3D rotateAxis Rotates the object's rotation matrix around an arbitrary axis. The method is more powerful than the normal rotate-around-an-axis methods, but also a bit slower. The resulting matrix will be orthonormalized to ensure numerical stability. - axis - a direction-vector pointing into the axis direction with the object's rotation pivot as position vector angle - the angle of the rotation void axis com.threed.jpct.SimpleVector angle float Initialize1 Constructor for creating an Object3D out of indexed geometry in bulk form. This can be useful to create an Object3D at once from data loaded by one's own file loader. - coordinates - the coordinates [x1,y1,z1,x2,y2,z2,...] uvs - the texture coordinates [u1,v1,u2,v2,...] indices - the indices indexing the tuples/triples in the coordinate arrays textureId - the texture id. If not known, just use TextureManager.TEXTURE_NOTFOUND void coordinates float[] uvs float[] indices int[] textureId int COLLISION_CHECK_NONE Don't perform any kind of collision detection for this object. int mergeObjects Static method that merges two objects into a third one. This should be done before calling build() on any of these objects and it does not copy other properties of the object (like rendering modes etc...). Merging objects is quite expensive in terms of memory usage. Merged objects are not compressed by default. - first - the first object to merge second - the second object to merge com.threed.jpct.Object3D first com.threed.jpct.Object3D second com.threed.jpct.Object3D rayIntersectsAABB Checks if a given ray intersects with the axis aligned bounding box (in object-space) of this object. This can be useful to speed up some calculations. jPCT is using this method for faster collision detection. If the object doesn't have a bounding box for whatever reason, RAY_MISSES_BOX will be returned. - org - the position vector of the ray dr - the direction vector of the ray isNormalized - indicates, that dr is already normalized. So the method can spare another normalization. float org com.threed.jpct.SimpleVector dr com.threed.jpct.SimpleVector isNormalized boolean RAY_MISSES_BOX Signals that a ray/box-intersection test has failed (the ray doesn't intersect with the box) float align Aligns this object with a Camera using the camera's backbuffer matrix. This means that the object (i.e. its positive z-axis) will face into the same direction as the camera does. Calling this method modifies the object's rotation matrix, but not its translation or origin matrix, i.e. the object is facing into the camera's direction but it's not automatically placed at the camera's position. This has to be done "by hand" if required. Keep in mind that the rotation pivot of this object influences the outcome too. - camera - the Camera the Object3D should be aligned with void camera com.threed.jpct.Camera removeCollisionListener Removes a collision listener from the list of listeners. - listener - the listener to remove void listener com.threed.jpct.CollisionListener decoupleMesh Decouples the current mesh from the object. This may be useful to assign another mesh to the object without affecting cloned objects (from this object). Without the use of cloned objects, the results of clearObject() and decoupleMesh() are the same (= an empty object). void strip Frees some memory by stripping some data that isn't needed anymore unless you want to modify the object afterwards by using a PolygonManager. void CULLING_DISABLED Backface culling won't be applied to this object. boolean isEnvmapped Returns if environment mapping is used or not. boolean wasTargetOfLastCollision True, if this object was a target of the last collision detection that took place (regardless of what kind it was). Otherwise false. "A target" in this context means, that something has collided with this object, i.e. if one checks object A for collision with other objects and it collides with an object B, B is the target and A is the source. A collision is not automatically detected. One has to use one of the various ways jPCT offers for collision detection to detect it. boolean clearTranslation Resets the current translation to the initial value, i.e. no translation at all. void rotateMesh Rotates the raw mesh data using the rotation matrix specified for this object. This rotation is applied directly onto the mesh and therefor it's permanent. This could be useful for defining animation keyframes via object meshes or for altering objects in objectspace. Rotating a mesh forces the object's bounding box to be recalculated afterwards (automatically done). The rotation matrix of the object won't be reset by this method. void compile2 Mainly needed to ease porting from the desktop version of jPCT. By default, jPCT-AE does this call automatically, so usually there's no need to call this method directly. - dynamic - if the mesh dynamic? void dynamic boolean disableCollisionListeners Disables all collision listeners of this object, so that none of them will be notified in case of a collision. void calcNormals Calculates the object's vertex normals by calculating the face normals of the adjacent polygons of each vertex and averaging them. The normals are required for lighting and mapping, so they need to be calculated for every object. Usually, this is already done by calling the object's build() method. (Respective by the loader for MD2-files). void calcCenter Tries to calculate the center of the object using its mesh data. This is a very rough approach and while it works very well on most objects, it may fail on others. This method sets both the center and the rotation pivot. This method is called by the build() method. void translateMesh Translates the raw mesh data using the translation and the origin matrix of this object. This translation is applied directly onto the mesh and therefor it's permanent. This could be useful for defining animation keyframes via object meshes or for altering objects in objectspace. Translating a mesh forces the object's bounding box to be recalculated afterwards (automatically done). void hasChild Tests an object for being a child object of the current object. A child object inherits all the transformations of its parent. - obj - the object that should be tested for being a child of this boolean obj com.threed.jpct.Object3D LIGHTING_ALL_ENABLED Indicates that all kinds of light (lightsources, ambient and additional color) will be used on this object. This is default. int wasVisible Returns if the object was visible (or at least supposed to be) in the last frame. This can be useful for some rough optimizations on the application level, but beware of assuming too much frame coherence. The method doesn't take overdraw into account. boolean cloneObject Clones the current object. A cloned object A' of an object A is a copy of A at the point when the cloning takes places. This means that A' inherits all rotations, translations and rendering properties from A. However, A' and A are sharing the same mesh data (to save memory). This will cause A' to inherit all keyframe animations from A and vice versa. Keep this in mind when cloning animated objects. Cloning an object is a costly operation that should only be done when needed. If multiple copies of an object are required during runtime, it may be helpful to create them at startup. This method also copies properties like lazy transformation settings and similar, so take care to adjust afterwards on the cloned object if needed. Cloning doesn't clone collision modes. com.threed.jpct.Object3D mergeAll Merges all objects in the array into one large object. The array will be empty afterwards. - objs - the objects com.threed.jpct.Object3D objs com.threed.jpct.Object3D[] invertCulling Inverts culling order if set to true. This affects culling only, not the mesh itself (unlike invert()). - inv - invert the culling? void inv boolean clearAdditionalColor Removes additional color information form the object. Calling this method is equal to call setAdditionalColor(Color.black). void clearRotation Resets the current rotation to the initial value, i.e. no rotation at all. This will also reset the scale. void checkForCollisionSpherical Checks if the current object collides with something when moving into a particular direction. This is just a check, so no translations are being performed. A collision can only be detected with objects that are set to COLLISION_CHECK_OTHERS. This method uses a sphere-polygon collision detection. - translation - the translation the object should perform radius - the radius of the sphere (a collision will only be detected of it takes place within this radius) com.threed.jpct.SimpleVector translation com.threed.jpct.SimpleVector radius float calcMinDistance2 Returns the minimal distance to some polygon of the object from a particular position vector looking into a specific direction. This version is a special purpose version of calcMinDistance() which only takes polygons into consideration that have at least one vertex that is closer than ignoreIfLarger units to the position vector. Can be useful to optimize calculations in situations where it is known how far away the polygon with the minimal distance can be at max. - org - a SimpleVector containing the position vector dr - a SimpleVector containing the direction vector ignoreIfLarger - only polygons within this range will be taken into account float org com.threed.jpct.SimpleVector dr com.threed.jpct.SimpleVector ignoreIfLarger float calcMinDistance Returns the minimal distance to some polygon of the object from a particular position vector looking into a specific direction. - org - a SimpleVector containing the position vector dr - a SimpleVector containing the direction vector float org com.threed.jpct.SimpleVector dr com.threed.jpct.SimpleVector SHADING_GOURAUD Indicates that gouraud shading should be used (default) int SPECULAR_ENABLED Specular highLights will be calculated. boolean COLLISION_DETECTION_NOT_OPTIMIZED Disables (default) an automated optimization for collision detection in case of problems with this optimization. boolean translate2 Translates ("moves") the object in worldspace by modifying the translation matrix. The translation will be applied the next time the object is rendered. - x - the number of units the object should be translated parallel to the x axis y - the number of units the object should be translated parallel to the y axis z - the number of units the object should be translated parallel to the z axis void x float y float z float LIGHTING_NO_LIGHTS Indicates that no lightsources will be taken into account to calculate an object's lighting. Ambient light and the additional color will be used. int CULLING_ENABLED Backface culling will be applied to this object before rendering. boolean ENVMAP_DISABLED Environment mapping is disabled boolean removeParent Removes an object from the parent-collection of this. The object itself won't be removed. - obj - the Object3D to remove void obj com.threed.jpct.Object3D rayIntersectsAABB2 Checks if a given ray intersects with the axis aligned bounding box (in object-space) of this object. This can be useful to speed up some calculations. jPCT is using this method for faster collision detection. If the object doesn't have a bounding box for whatever reason, RAY_MISSES_BOX will be returned. - org - the position vector of the ray dr - the direction vector of the ray float org com.threed.jpct.SimpleVector dr com.threed.jpct.SimpleVector OBJ_VISIBLE The object is visible. boolean addCollisionListener Adds a collision listener to this object. A collision listener gets notified in case of a collision with or caused by this object. - listener - the listener void listener com.threed.jpct.CollisionListener NO_OBJECT The "ID" of an Object3D that doesn't exist. If a method that usually returns an Object-ID returns this value, no appropiate Object3D has been found. int resetCollisionStatus 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. This is done automatically the next time a collision detection method is being called. void addTriangle Adds a triangle to the object. Using the method, the texture of the object won't be set and the sector will be set to undefined. Texture coordinates won't be set (= set to (0,0) for all vertices). The vertices have to be defined counter-clockwise because jPCT backface culls them by default. One may also add them clockwise and call invert() afterwards to "invert" the order. - vert1 - the first vertex vert2 - the second vertex vert3 - the third vertex int vert1 com.threed.jpct.SimpleVector vert2 com.threed.jpct.SimpleVector vert3 com.threed.jpct.SimpleVector cullingIsInverted Returns true, if inverted culling is used on this object. False otherwise. boolean disableLazyTransformations Disables "lazy transformations". This is the default setting for every new object. void RotationPivot com.threed.jpct.SimpleVector pivot com.threed.jpct.SimpleVector Returns the rotation pivot of the object Translation com.threed.jpct.SimpleVector Returns the translation of the object (from its origin to its current position) Virtualizer com.threed.jpct.Virtualizer virtualizer com.threed.jpct.Virtualizer Returns the current Virtualizer. By default, none is set. SortOffset offset float Sets on offset for the z-Sorting. Usually this is not needed, but it could be helpful for transparent objects that are sorted incorrectly otherwise. - offset - the offset ZAxis com.threed.jpct.SimpleVector Returns the z-axis of the object. This is an imaginary axis useful for movement und rotations relative to the object. This is based on the rotation matrix only. It doesn't take any parent objects into account. Origin com.threed.jpct.SimpleVector origin com.threed.jpct.SimpleVector Returns the origin of the object (as set by setOrigin()). SpecularLighting mode boolean Enables/Disables specular lighting for the object. The specular lighting pass is applied in addition to ambient and diffuse lighting. Specular lighting may cause objects to look more reflective and realistic. It requires some extra processing but usually it's just a matter of taste if it will be used on a particular object or not. Specular lighting is disabled by default. - mode - the specular mode Texture texname java.lang.String Sets the texture for the object. When using normal texturemapping, this texture is the only one used. With environment mapping enabled, this texture is used as an environment map. With environment bumpmapping enabled, this texture is pertubed by the bumpmap. - texname - the name of the texture as set in the TextureManager.addTexture()-method WorldTransformation com.threed.jpct.Matrix Returns the transformation matrix used to transform the object from objectspace into worldspace. Could be useful for debugging purposes, but usually this information shouldn't be needed. NextID int next int Static method that returns the ID the next object will get. This is useful to know if (and only if) you want to serialize your world, because this value isn't serialized by default. ID int Returns the object's ID. The ID is automatically generated and set in the constructor. This ID is used to manage the object once it has been added to an instance of World. In some cases, it could be necessary to reset the ID. AdditionalColor com.threed.jpct.RGBColor col com.threed.jpct.RGBColor Returns the additional color. Center com.threed.jpct.SimpleVector center com.threed.jpct.SimpleVector Returns the center of the object (in object-space, i.e. unaffected by any transformation). Scale float scale float Returns the cumulated scale value for this object. Parents com.threed.jpct.Object3D[] Returns all parents of this Object3D in an array. PolygonManager com.threed.jpct.PolygonManager Returns the PolygonManager for this object. A PolygonManager can be used to access an object's polygons. While you can obtain a PolygonManager from a stripped object, you can't safely modify the object. LightCount int Returns the number of lights that have an influence on this object. This is only valid during rendering, i.e. only when called from within an IRenderHook. TransformedCenter com.threed.jpct.SimpleVector Returns the center of the object in worldspace, i.e. after the object's current transformations have been applied to it. CollisionListeners java.util.Iterator Returns the collision listeners of this object as an enumeration. The enumeration is empty if no listeners have been assigned. OriginMatrix com.threed.jpct.Matrix Returns the object's origin-translation matrix. This matrix is a kind of static translation matrix for the object used to initially place the object into worldspace. Without using child/parent-objects, there is no difference between using the translation and the origin matrix, but only the former will be applied to child objects of this object. It is advised to use the origin matrix to place the object into worldspace once and to execute all further translations by using the translation matrix (or by using the translate()-method which already does this for you). XAxis com.threed.jpct.SimpleVector Returns the x-axis of the object. This is an imaginary axis useful for movement und rotations relative to the object. This is based on the rotation matrix only. It doesn't take any parent objects into account. CollisionMode mode int Sets if and how the object will respond to collisions. Setting mode to COLLISION_CHECK_NONE (which is default) means, that the object can't be partner in a collision with other objects. Setting it to COLLISION_CHECK_OTHERS means that other objects may collide with this object and setting it to COLLISION_CHECK_SELF means, that the object itself may collide with other objects. The modes may be combined by using the or-operator | . - mode - The desired mode (COLLISION_CHECK_NONE, COLLISION_CHECK_OTHERS, COLLISION_CHECK_SELF or combinations) Culling boolean mode boolean Returns the current culling mode. TransparencyMode int mode int Returns the current transparency mode. Envmapped mode boolean Enables/Disables environment mapping for the object. If enabled, the texturemap assigned to the object will be used as a spherical environment map. - mode - the environment mapping mode EllipsoidMode int mode int Returns the current ellipsoid mode. Visibility boolean mode boolean Returns the current visibility state of the object. Billboarding mode boolean Enables/disables billboarding for this object. A billboarded object will ingore its own rotation matrix and will always face the camera. - mode - the billboarding mode TranslationMatrix com.threed.jpct.Matrix mat com.threed.jpct.Matrix Returns the object's current translation matrix. YAxis com.threed.jpct.SimpleVector Returns the y-axis of the object. This is an imaginary axis useful for movement und rotations relative to the object. This is based on the rotation matrix only. It doesn't take any parent objects into account. OcTree com.threed.jpct.OcTree arg0 com.threed.jpct.OcTree Returns the OcTree assigned to this object or null, if none has been assigned. Lighting int mode int Gets the lighting mode. MaxLights int lightCount int Returns the maximum number of lights that should have an influence on this object. Default is 8. CollisionOptimization optimized boolean Sets an optimization for collision detection to be used/not used. This optimization may cause problems on dynamically updated geometry from an animation or an IVertexController. Therefor, it's disabled by default. Couldn't hurt to try it anyway...:-) This optimization affects collisions WITH this object, not OF this object. - optimized - should the collision detection be optimized or not Mesh com.threed.jpct.Mesh mesh com.threed.jpct.Mesh Returns the current mesh of the object. This is useful for using an object's mesh data as keyframes for an animation. The returned mesh can also be added to another object by using setMesh(). If you do so, both objects will share the same instance of mesh. That isn't a problem as long as you don't want to modify the mesh of one object without changing the other's. In this case, you should better use a copy of the mesh obtained from Mesh.cloneMesh(). InverseWorldTransformation com.threed.jpct.Matrix getInverseWorldTransformation ? FixedPointMode useFixedPoint boolean If set to true, some operations will be using fixed point instead of floating point. This is less accurate and may cause problems with large coordinates, but is usually faster. Default is true. - useFixedPoint - use it? Shader com.threed.jpct.GLSLShader shader com.threed.jpct.GLSLShader Returns the shader, if another one than the default shader is set. This is only valid when using OpenGL ES 2.0. AnimationSequence com.threed.jpct.Animation anim com.threed.jpct.Animation Returns the animation sequence. Transparency int trans int Returns the current tranparency setting. ShadingMode mode int jPCT always uses gouraud shading and that can't be disabled. Anyway, with this method it's possible to enable a kind of faked flat shading. It will look like flat shading, but it isn't any faster than gouraud. It may even be slower, because triangle strips and some other optimizations jPCT can apply are disabled when using faked flat shading. - mode - the shading mode Texture2 tInf com.threed.jpct.TextureInfo Sets the texture for the object via an instance of TextureInfo. Texture coordinates for all layers are taken from the coordinates defined for the base layer of the Object3D, i.e. u/v coordinates given to this TextureInfo will be ignored. - tInf - the TextureInfo RenderHook com.threed.jpct.IRenderHook hook com.threed.jpct.IRenderHook Returns the render hook or null, if none has been set. Name java.lang.String n java.lang.String Returns the name of the object. By default, this is set to "object" plus the object's internal ID. It may be overwritten using setName(). TextureMatrix com.threed.jpct.Matrix mat com.threed.jpct.Matrix Returns the current texture matrix of null if none is set. UserObject java.lang.Object obj java.lang.Object Return the user defined object. RotationMatrix com.threed.jpct.Matrix mat com.threed.jpct.Matrix Returns the object's current rotation matrix. jpct.ae.wrapper.JNVDepthConfigChooser JpctNVDepthConfigChooser com.threed.jpct.util.NVDepthConfigChooser process Initialize Creates a new NVDepthConfigChooser - view - the GLSurfaceView void view android.opengl.GLSurfaceView Initialize2 Creates a new NVDepthConfigChooser with optional alpha for the framebuffer. - view - the GLSurfaceView withAlpha - alpha channel (for transparent framebuffers)? void view android.opengl.GLSurfaceView withAlpha boolean chooseConfig chooseConfig - egl - EGL10 display - EGLDisplay javax.microedition.khronos.egl.EGLConfig egl javax.microedition.khronos.egl.EGL10 display javax.microedition.khronos.egl.EGLDisplay IsInitialized boolean jpct.ae.wrapper.JNPOTTexture JpctNPOTTexture com.threed.jpct.NPOTTexture process Initialize Creates a new NPOT texture. - width - the width of the texture. height - the height of the texture. col - the color. Can be null for render targets. void width int height int col com.threed.jpct.RGBColor enable4bpp Makes jPCT converting this texture to use 4 bits per pixel/alpha (respectively 5/1 without a dedicated alpha channel) instead of 8, i.e. use 16 bit textures. Default is false unless you call Texture.defaultTo4bpp(true); - doit - should we? void doit boolean removeAlpha Removes any alpha information from a texture. void defaultTo4bpp Static method to set the textures' default depth to 4bpp (respectively 5bpp without a dedicated alpha channel). This doesn't affect the Texture instances themselves but the data uploaded to the graphics card. - doit - should 4bpp be the default? void doit boolean add Adds a textures color (and alpha) information to this one. - ta - the texture whose color should be added weight - the weight of the second texture's data. May be even negative. void ta com.threed.jpct.Texture weight float applyEffect Applies the effect to the texture. Depending on the implementation of the effect, this can be slow. void isEnabled Returns if the texture is enabled or not. A disabled texture won't show up when used on any texture stage except the first one. boolean compress Compresses the texture so that is uses less main memory. This doesn't effect the memory used inside the gpu. Compressed textures require some more time to upload. If the saved space is less than 5% of the original size, the texture won't be compressed. void keepPixelData Should a texture's pixels be kept even when the texture has been uploaded to the GPU? Default is false. - keepData - should they? void keepData boolean defaultToKeepPixels Static method to set the textures' default behaviour for keeping the pixel data after uploading to the gpu. Default is true. - doit - void doit boolean defaultToMipmapping Static method to make all textures use mipmaps by default. Default setting is false. - doit - should mipmapping be the default? void doit boolean removeEffect Removes an ITextureEffect from the Texture void IsInitialized boolean Enabled isEnabled boolean Sets the texture to enable/disabled. A disabled texture won't show up when used on any texture stage except the first one. Default it true. - isEnabled - is it enabled? Mipmap mipmap boolean Enabled/Disables mip map setting for a texture. Default is true. - mipmap - true, if there's no override. false means no mip mapping/trilinear for this texture Filtering filter boolean Sets the bilinear filtering state on textures. Setting this to false forces jPCT to use a pick nearest on the textures. This may also affect mip mapping. - filter - the mode, true for bilinear, false for pick nearest ArraySize int Returns the size of the texture array. Clamping clamping boolean Set texture coordinate to clamping or wrapping/repeating. Calling this on an already uploaded texture forces a new texture upload to the graphics card. - clamping - clamping or wrapping/repeating? Height int Returns the height of the texture in pixels. Effect effect com.threed.jpct.ITextureEffect Sets an effect for this texture. The effect is an implementation of ITextureEffect. - effect - the effect AsShadowMap isShadowMap boolean Marks this texture as a shadow map. This only affects the OpenGL ES 2.0 mode. - isShadowMap - is it a shadow map or not? TextureCompression enabled boolean Enables ETC1-texture compression if available on the platform. If not, jPCT-AE will fall back to normal textures. This is an experimental feature for now. The usual restrictions for ETC1 apply. - enabled - enable ETC1 texture compression DepthBuffer com.threed.jpct.DepthBuffer depthBuffer com.threed.jpct.DepthBuffer ? Width int Returns the width of the texture in pixels. jpct.ae.wrapper.JMultiTouch.JMotionEvent JpctMotionEvent process getPressure Returns the current pressure of this event for the given pointer index. float pointerIndex int getY Returns the Y coordinate of this event for the given pointer index. float pointerIndex int getX Returns the X coordinate of this event for the given pointer index. float pointerIndex int getPointerId Return the pointer identifier associated with a particular pointer data index in this event. int pointerIndex int getSize Returns a scaled value of the approximate size for the given pointer index (use getPointerId(int) to find the pointer identifier for this index). float pointerIndex int findPointerIndex Given a pointer identifier, find the index of its data in the event. int pointerId int DownTime long Returns the time (in ms) when the user originally pressed down to start a stream of position events. Action int Returns the kind of action being performed. EventTime long Retrieve the time this event occurred, in the uptimeMillis() timebase. ActionMasked int Returns the masked action being performed, without pointer index information. PointerCount int The number of pointers of data contained in this event. RawY float Returns the original raw Y coordinate of this event. RawX float Returns the original raw X coordinate of this event. Y float For the first/primary/only pointer index (maybean arbitrary pointer identifier). X float For the first/primary/only pointer index (maybe an arbitrary pointer identifier). ActionIndex int For ACTION_POINTER_DOWN or ACTION_POINTER_UP as returned by getActionMasked(), this returns the associated pointer index, Otherwise it's returning always 0. ACTION_POINTER_DOWN Constant = 5 for getActionMasked(): A non-primary pointer has gone down. int ACTION_MASK bit mask = 255 of the parts of the action code that are the action itself. int ACTION_POINTER_INDEX_SHIFT bit shift = 8 for the action bits holding the pointer index as defined by ACTION_POINTER_INDEX_MASK. int ACTION_DOWN Constant = 0 for getActionMasked(): Apressed gesture has started, the motion contains the initial starting location. int ACTION_POINTER_UP Constant = 6 for getActionMasked(): A non-primary pointer has gone up. int ACTION_UP Constant = 1 for getActionMasked(): A pressed gesture has finished, the motion contains the final release location as well as any intermediate points since the last down or move event. int ACTION_MOVE Constant = 2 for getActionMasked(): Achange has happened during a press gesture (between ACTION_DOWN and ACTION_UP). int ACTION_POINTER_INDEX_MASK bits = 65280 in the action code that represent a pointer index, used with ACTION_POINTER_DOWN and ACTION_POINTER_UP. int ACTION_CANCEL Constant = 3 for getActionMasked(): The current gesture has been aborted. int INVALID_POINTER_ID Constant for getActionMasked(): The current gesture has been aborted. int jpct.ae.wrapper.JMultiTouch.JScaleEvent JpctScaleEvent --------------------------------------------------------------------------------------- JScaleEvent Detects scaling transformation gestures using the supplied MotionEvents. The callback will notify users when a particular gesture event has occurred. This class should only be used with MotionEvents reported via touch. ---------------------------------------------------------------------------------------- process isInProgress Returns true if a scale gesture is in progress. boolean PreviousSpan float Return the previous average distance between each of the pointers forming the gesture in progress through the focal point. CurrentSpan float Return the average distance between each of the pointers forming the gesture in progress through the focal point. EventTime long Return the event time of the current event being processed. TimeDelta long Return the time difference in milliseconds between the previous accepted scaling event and the current scaling event. ScaleFactor float Return the scaling factor from the previous scale event to the current event. FocusX float Get the X coordinate of the current gesture's focal point. FocusY float Get the Y coordinate of the current gesture's focal point. jpct.ae.wrapper.JMultiTouch.JGestureEvent JpctGestureEvent process FlingVelocityX The velocity of this fling measured in pixels per second along the x axis. float ScrollDistanceX The distance along the X axis that has been scrolled since the last call to onScroll. float ScrollDistanceY The distance along the Y axis that has been scrolled since the last call to onScroll. float onSingleTapUp Notified when a tap occurs with the up MotionEvent that triggered it. boolean onFling Notified of a fling event when it occurs with the initial on down MotionEvent and the matching up MotionEvent. boolean isInProgress Returns true if a scale gesture is in progress. boolean onDown Notified when a tap occurs with the down MotionEvent that triggered it. This will be triggered immediately for every down event. boolean onShowPress The user has performed a down MotionEvent and not performed a move or up yet. boolean onDoubleTapEvent Notified when an event within a double-tap gesture occurs, including the down, move, and up events. boolean onDoubleTap Notified when a double-tap occurs. boolean FlingVelocityY The velocity of this fling measured in pixels per second along the y axis. float onLongPress Notified when a long press occurs with the initial on down MotionEvent that trigged it. boolean onScroll Notified when a scroll occurs with the initial on down MotionEvent and the current move MotionEvent. boolean onSingleTapConfirmed Notified when a single-tap occurs. Unlike onSingleTapUp, this will only be called after the detector is confident that the user's first tap is not followed by a second tap leading to a double-tap gesture. boolean jpct.ae.wrapper.JMesh JpctMesh com.threed.jpct.Mesh process Initialize Initialize Mesh - object3D - the object you want to assign its mesh void object3D com.threed.jpct.Object3D SERIALIZE_LOW_PRECISION float data will be saved as 16 bit precision. on the average ~0.3 percent of precision will be lost int DONT_COMPRESS The mesh won't be compressed. boolean COMPRESS The mesh will be compressed. boolean strip Removes triangle information from this mesh. This is useful to save some memory for meshes that are used for keyframing only (triangle information are not needed in that case). For any other meshes: Don't call this method. It will break your mesh! void cloneMesh Returns a copy of this mesh. A copy of a mesh can be used to take a mesh from an existing object and modify it without modifying the source mesh. With this, you can also use meshes from existing objects (not only temporary ones) as meshes for a keyframe animation [like: Animation.addKeyFrame(obj.getMesh().cloneMesh(...))]. Cloning a compressed mesh without letting cloneMesh compress it again will result in an uncompressed one (eats up more memory, but triangles may be added to such a mesh again). - compressed - indicates if compress() should by called after cloning the mesh or not com.threed.jpct.Mesh compressed boolean setVertexController Sets the VertexController for this Mesh. A VertexController is the only way for an application to modify the vertex data of jPCT's meshes after build-time. Usually, a custom VertexController extend the GenericVertexController the API provides. An instance can only be assigned to one mesh at a time. This mesh should include vertex normals, i.e. it has to belong to an object for which build() has been called already. If that's not the case, jPCT will print out a warning message. - controller - the controller modify - the mode, i.e. if the modifications are cumulative or not void controller com.threed.jpct.IVertexController modify boolean applyVertexController Executes the apply() method of the assigned VertexController and updates the mesh's vertex data with the new values generated by the controller. void isLocked Returns if this mesh has been locked or not! boolean removeVertexController Removes the VertexController from this mesh. When doing so, the controller's destroy() method will be called. void SERIALIZE_ALL normal serialization (default). int Initialize2 Initialize Mesh - mesh - the mesh you want to assign (you can get it by cloneMesh) void mesh com.threed.jpct.Mesh forceCompress Compresses the mesh by removing unused information from it. When creating a mesh, it is usually not known how many unique vertices it may contain, so space is reserved for the extreme case that no vertex-sharing is possible within this mesh (the vertex sharing is something that jPCT automatically takes care of). The more vertices are sharable between the triangles of the mesh, the more space remains unused. compress() frees this space at the cost that no additional vertices can be added to the mesh after compressing it. If one is sure that this is not required, compressing a mesh can be helpful to save memory. Meshes of loaded MD2- and 3DS-models are compressed by default. void SERIALIZE_VERTICES_ONLY Normals will not be serialized and will have to be recalculated during deserialization. This saves a lot of space but increases load time. int IsInitialized boolean TriangleCount int The number of triangles for this mesh. VertexCount int Returns the number of vertices this mesh consists of BoundingBox float[] Returns the bounding box in object space of this mesh in a float array. Format is minX, maxX, minY, maxY, minZ, maxZ. Calculation is done everytime this method is being called, so don't call it without need. SerializeMethod method int Sets the serialization method. Can be used to decrease the size of a serialized Mesh at the cost of loading speed and/or accuracy. - method - Either SERIALIZE_ALL, DONT_SERIALIZE_NORMALS or SERIALIZE_LOW_PRECISION. Methods can be combined by using the or-operator. Locked locked boolean Locks an object. A locked mesh can't and won't be stripped even if you call the corresponding methods. This can be used to strip Object3Ds that are sharing Meshes. locked - should it be locked? UniqueVertexCount int Returns the number of unique vertices. Unlike getVertexCount(), this number takes into account that vertices are shared between triangles whenever possible to lower geometry processing time. jPCT does only transform as many vertices as this number indicates. jpct.ae.wrapper.JMemoryHelper JpctMemoryHelper com.threed.jpct.util.MemoryHelper process Initialize Initialize MemoryHelper void compact Tries to free some memory but forcing gc and finalization. Write current memory usage to the log. This can be used to trigger some gc work that might otherwise interrupt the application causing an animation to stutter or similar. However, this method can't avoid that...it just increases the chance that won't happen or at least not that often. void IsInitialized boolean printMemory Prints current memory usage into the log. void jpct.ae.wrapper.JMatrix JpctMatrix com.threed.jpct.Matrix process matMul Multiplies this matrix with another one. - maty - the matrix to multiply with void maty com.threed.jpct.Matrix getZAxis Returns the z-axis this matrix would represent when viewed as a rotation matrix. This method fills the given SimpleVector in addition to returning it. - toFill - the vector to fill com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector transpose Calculates the transposed matrix of this matrix. com.threed.jpct.Matrix setRow Inject values directly into a matrix' row. - row - thw row v1 - the first value v2 - the second value v3 - the third value v4 - the fourth value void row int v1 float v2 float v3 float v4 float set Injects a value directly into the matrix at a position. - row - the row col - the column value - the value to set void row int col int value float rotateX Rotates the matrix around the X-axis (counter clockwise for positive w). - w - the rotation angle void w float rotateZ Rotates the matrix around the Z-axis (counter clockwise for positive w). - w - the rotation angle void w float rotateY Rotates the matrix around the Y-axis (clockwise for positive w). - w - the rotation angle void w float invert Calculates the inverse of this matrix. com.threed.jpct.Matrix isIdentity Returns true, if this matrix is the identity matrix. boolean interpolate Fills the matrix with data interpolated between the source and the destination matrix. The interpolation is (source*(1-weight)+dest*weigth), so it's a simple linear interpolation. The interpolated matrix is orthonormal. However, it's possible that the interpolation will result in a NaN-Matrix, if the matrices to interpolate are too different from each other. Keep that in mind... - source - the source matrix dest - the destination matrix weight - the weight of the destination matrix (0-1) void source com.threed.jpct.Matrix dest com.threed.jpct.Matrix weight float setOrientation Sets the orientation of a rotation matrix by giving a direction and an up-vector. - dir - the direction up - the up-vector void dir com.threed.jpct.SimpleVector up com.threed.jpct.SimpleVector Initialize2 Creates a matrix from a given one. The new matrix will bi initialized with the same values that the source matrix has. - m - the source matrix void m com.threed.jpct.Matrix rotateAxis Rotates the matrix around an arbitrary axis. The method is more powerful than the normal rotate-around-an-axis methods, but also a bit slower. The resulting matrix will be orthonormalized to ensure numerical accuracy. - axis - a direction-vector pointing into the axis direction angle - the angle of the rotation void axis com.threed.jpct.SimpleVector angle float setColumn Inject values directly into a matrix' column. - col - thw column v1 - the first value v2 - the second value v3 - the third value v4 - the fourth value void col int v1 float v2 float v3 float v4 float getYAxis Returns the y-axis this matrix would represent when viewed as a rotation matrix. This method fills the given SimpleVector in addition to returning it. - toFill - the vector to fill com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector IsInitialized boolean Initialize Initialize Matrix void cloneMatrix Creates a copy of this matrix. com.threed.jpct.Matrix orthonormalize Orthonormalizes a matrix using the Gramm-Schmidt orthonormalization algorithm. This can be useful for rotation matrices to ensure that they stay orthonormal over time (i.e. after a lot of rotations have been applied to them). jPCT doesn't do this automatically, because there seems to be no need for it at the moment. But if there ever is, here is the method for doing it... void get Returns the value at a position in the matrix. - row - the row col - the column float row int col int equals Overrides equals in class java.lang.Object boolean obj java.lang.Object translate2 Applies a translation to this matrix. This implementation should help to avoid the unnecessary creation of a SimpleVector if the coordinates already exist as three seperated ones. - x - the x component of the translation y - the y component of the translation z - the z component of the translation void x float y float z float invert3x3_2 Calculates the inverse of this matrix as if this matrix would be a 3x3 one (instead of the 4x4 it actually is). This can be useful to invert matrices that are rotation matrices only, because they usually can be treated as 3x3 and it's much faster to do it this way than to use the normal invert()-method. In case of doubt, one may be better off using the normal invert()-method though. Fills the result into the given matrix (which will be returned in addition). - toFill - the matrix to fill com.threed.jpct.Matrix toFill com.threed.jpct.Matrix setIdentity (Re-)sets this matrix to the identity matrix. void scalarMul Multiplies this matrix with a scalar (the left upper 3x3 part only). - scalar - the scalar to multiply with void scalar float invert3x3 Calculates the inverse of this matrix as if this matrix would be a 3x3 one (instead of the 4x4 it actually is). This can be useful to invert matrices that are rotation matrices only, because they usually can be treated as 3x3 and it's much faster to do it this way than to use the normal invert()-method. In case of doubt, one may be better off using the normal invert()-method though. com.threed.jpct.Matrix fillDump Dumps a matrix row-wise into a given float[16]-array and returns it. - dump - the "dump" float[] dump float[] transformToGL Transforms a matrix from jPCT's coordinate system into OpenGL's (and vice versa) void toString Overrides toString in class java.lang.Object java.lang.String translate Applies a translation to this matrix. - trans - the translation void trans com.threed.jpct.SimpleVector invert2 Calculates the inverse of this matrix and fills the result into the given matrix (which will be returned in addition). - dst - the matrix to fill with the result. com.threed.jpct.Matrix dst com.threed.jpct.Matrix getXAxis Returns the x-axis this matrix would represent when viewed as a rotation matrix. This method fills the given SimpleVector in addition to returning it. - toFill - the vector to fill com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector Translation com.threed.jpct.SimpleVector Returns the translation this matrix would represent when viewed as a translation matrix. YAxis com.threed.jpct.SimpleVector Returns the y-axis this matrix would represent when viewed as a rotation matrix. Dump float[] dump float[] Dumps a matrix row-wise into a float[16]-array. To source com.threed.jpct.Matrix Sets this matrix' values to the ones of the source matrix. - source - the source matrix ZAxis com.threed.jpct.SimpleVector Returns the z-axis this matrix would represent when viewed as a rotation matrix. XAxis com.threed.jpct.SimpleVector Returns the x-axis this matrix would represent when viewed as a rotation matrix. jpct.ae.wrapper.JLogger JpctLogger com.threed.jpct.Logger process Initialize Initialize Logger void ON_ERROR_EXIT Exit after an error occurs int isDebugEnabled Returns true, if debug log level is active. boolean ON_ERROR_THROW_EXCEPTION Throw a RuntimeException in case of an error (default) int LL_ONLY_ERRORS Log-Level: log errors only int log2 Logs a message, error or warning. Errors and warnings are logged with a time-stamp. - msg - the message to log type - the type of message void msg java.lang.String type int log Logs a message. A short cut to log(, Logger.MESSAGE); - msg - the message void msg java.lang.String LL_VERBOSE Log-Level: log everything but debug (default) int MESSAGE The message is just that: a message int LL_ERRORS_AND_WARNINGS Log-Level: log errors and warnings int ON_ERROR_RESUME_NEXT Try to continue even in case of an error int LL_DEBUG Log-Level: log everything including debug int DEBUG A debug message int IsInitialized boolean LogLevel int level int Returns the log-level. return the log-level OnError mode int Sets error behaviour. The logger can terminate the VM in case of an error, throw an exception or try to continue. Throwing an exception is default. - mode - the error mode jpct.ae.wrapper.JLoader JpcLoader com.threed.jpct.Loader process clearCache Empties the file-cache. Useful to free some memory after loading has definitly finished. void arrayToList Converts array Object3D[] to B4A List. anywheresoftware.b4a.objects.collections.List Obj3D com.threed.jpct.Object3D[] loadOBJ Loads a file in OBJ-format into an array of objects. OBJ is Wavefront's Advanced Visualizer format supported by many converter tools. A OBJ-file can contain many different objects/groups. Each object will be named like its OBJ-name (the name this object has in the file) plus a suffix "_jPCT" plus the object's internal ID. This loader loads polygonal information only (i.e. no splines and similar things) and supports polygons with up to 4 vertices. Everything higher will be loaded with a warning and most likely not displayed correctly. The loader will read the textures' names out of the OBJ-file and will add dummy textures with these names to the texture-manager (If the name is already in use, no new dummy texture will be added). So one may load some textures and add them to the manager with the appropiate names before loading the OBJ-file or replace the ones generated by the loader after loading is finished. If the materials used in the file are not using textures, small, single colored textures will be generated that represent the diffuse colors of the materials. This method is for accessing files from an InputStream. - objStream - the InputStream of the actual OBJ-file mtlStream - the InputStream of the material file. May be null. scale - a scaling parameter to scale the object right after loading. Should be set to 1 to avoid rescaling com.threed.jpct.Object3D[] objStream java.io.InputStream mtlStream java.io.InputStream scale float loadSerializedObjectArray Loads an object in serialized format. This format can't be created by jPCT-AE but by using the desktop version of jPCT by using the DeSerializer. This is the fastest and least memory intense way to load an object in jPCT-AE. - is - the inputstream com.threed.jpct.Object3D[] is java.io.InputStream load3DSMerged Loads a file in 3DS-format and merges all its sub-objects into single object. 3DS is a 3D-Studio format supported by many converter tools. A 3DS-file can contain many different objects. Each object will be named like its 3DS-name (the name this object has in 3D-Studio) plus a suffix "_jPCT" plus the object's internal ID. The loader will read the textures' names out of the 3DS-file and will add dummy textures with these names to the texture-manager (If the name is already in use, no new dummy texture will be added). So one may load some textures and add them to the manager with the appropiate names before loading the 3DS-file or replace the ones generated by the loader after loading is finished. If the materials used in the file are not using textures, small, single colored textures will be generated that represent the diffuse colors of the materials. This method is for accessing files from an InputStream. - stream - the InputStream scale - a scaling parameter to scale the object right after loading. Should be set to 1 to avoid rescaling com.threed.jpct.Object3D stream java.io.InputStream scale float loadSerializedObject Loads an object in serialized format. This format can't be created by jPCT-AE but by using the desktop version of jPCT by using the DeSerializer. This is the fastest and least memory intense way to load an object in jPCT-AE. - is - the inputstream com.threed.jpct.Object3D is java.io.InputStream readTextureNames3DS Reads the texture names from a 3DS-file. - stream - the input stream for the file java.lang.String[] stream java.io.InputStream load3DS Loads a file in 3DS-format into an array of objects. 3DS is a 3D-Studio format supported by many converter tools. A 3DS-file can contain many different objects. Each object will be named like its 3DS-name (the name this object has in 3D-Studio) plus a suffix "_jPCT" plus the object's internal ID. The loader will read the textures' names out of the 3DS-file and will add dummy textures with these names to the texture-manager (If the name is already in use, no new dummy texture will be added). So one may load some textures and add them to the manager with the appropiate names before loading the 3DS-file or replace the ones generated by the loader after loading is finished. If the materials used in the file are not using textures, small, single colored textures will be generated that represent the diffuse colors of the materials. This method is for accessing files from an InputStream. - stream - the InputStream scale - a scaling parameter to scale the object right after loading. Should be set to 1 to avoid rescaling com.threed.jpct.Object3D[] stream java.io.InputStream scale float loadOBJMerged Loads a file in OBJ-format and merges all its sub-objects into single object. OBJ is Wavefront's Advanced Visualizer format supported by many converter tools. A OBJ-file can contain many different objects/groups. Each object will be named like its OBJ-name (the name this object has in the file) plus a suffix "_jPCT" plus the object's internal ID. This loader loads polygonal information only (i.e. no splines and similar things) and supports polygons with up to 4 vertices. Everything higher will be loaded with a warning and most likely not displayed correctly. The loader will read the textures' names out of the OBJ-file and will add dummy textures with these names to the texture-manager (If the name is already in use, no new dummy texture will be added). So one may load some textures and add them to the manager with the appropiate names before loading the OBJ-file or replace the ones generated by the loader after loading is finished. If the materials used in the file are not using textures, small, single colored textures will be generated that represent the diffuse colors of the materials. This method is for accessing files from an InputStream. - objStream - the InputStream of the actual OBJ-file mtlStream - the InputStream of the material file. May be null. scale - a scaling parameter to scale the object right after loading. Should be set to 1 to avoid rescaling com.threed.jpct.Object3D objStream java.io.InputStream mtlStream java.io.InputStream scale float loadTextFile Loads a text-file into a String. Used internally by jPCT and maybe useful for other applications. This method is for accessing files from an InputStream. - stream - the InputStream java.lang.String stream java.io.InputStream loadMD2 Loads an object out of a file in MD2-format (Quake2 model format). The object is loaded including all keyframes so that the returned object already contains the animation for this object. The texture indicated in the file is ignored (the texture coordinates are of course not). All meshes of the animation will be stored in compressed format. This method is for accessing files from an InputStream. - stream - the InputStream newScale - a scaling parameter, 1 means no changes to the mesh com.threed.jpct.Object3D ba anywheresoftware.b4a.BA stream java.io.InputStream newScale float loadASC Loads a file in ASC-format into an object. ASC is an ASCII-based 3D-Studio format supported by many converter tools. This method is for accessing files from an InputStream. - stream - the InputStream scale - a scaling parameter to scale the object right after loading. Should be set to 1 to avoid rescaling swap - if set to true, y and z coordinates of the object will be swaped. This could be helpful for correct backface culling on some Object3Ds. com.threed.jpct.Object3D stream java.io.InputStream scale float swap boolean IsInitialized boolean VertexOptimization enabled boolean Enables(default)/Disables vertex optimizations for the Loader. Using this, vertices can be combined to one if they cover exactly the same point in space. This reduces vertex count. If you disable this, be sure to have a reason... This setting affects ASC, 3DS and OBJ files only. If used for loading 3DS or OBJ files, the vertex sharing information from the files will be used instead (Could be helpful to use these files as keyframes). - enabled - optimize vertex usage jpct.ae.wrapper.JLight JpcLight com.threed.jpct.Light process Initialize Creates a new light in the world. The light will be placed at (0,0,0) and with an intensity of (255,255,255). - world - the instance of world void world com.threed.jpct.World LIGHT_INVISIBLE he light is not visible boolean rotate Rotates the light around a rotation pivot. Unlike the similar methods in World, this doesn't cause the light to execute this rotation every frame (which was stupid idea anyway...:-)). This is done, when you are calling the method. Not more, not less. - degrees - a SimpleVector that contains the rotation angles in its x,y,z-components pivot - SimpleVector the rotation pivot void degrees com.threed.jpct.SimpleVector pivot com.threed.jpct.SimpleVector enable Enables a light. Each new light is enabled by default. void isEnabled Is the light enabled? boolean LIGHT_VISIBLE The light is visible boolean getPosition2 Returns the position of this light in world space. - store - an optional SimpleVector (may be null), in which the position will be stored. If given, this is the vector that will be returned too. com.threed.jpct.SimpleVector store com.threed.jpct.SimpleVector setIntensity2 Sets the light's intensity. - red - the red intensity green - the green intensity blue - the blue intensity void red float green float blue float disable Disables a light. The light is still part of the world, just not visible. void IsInitialized boolean DistanceOverride float distance float Returns the overriden distance. If none is set, -1 will be returned. DiscardDistance float dist float Gets the discard distance of this light, if it has be set before. If it hasn't, the result of this call in undefined (but lower than -1). Intensity com.threed.jpct.SimpleVector inty com.threed.jpct.SimpleVector gets a SimpleVector that contains the intensities of r,g,b in its x,y,z-components. Position com.threed.jpct.SimpleVector pos com.threed.jpct.SimpleVector Returns the position of this light in world space. Attenuation float att float Returns the light's attenuation. jpct.ae.wrapper.JLensFlare JpctLensFlare com.threed.jpct.util.LensFlare process update Updates the lens flare. Skipping this method and calling render only will cause the lens flare to remain static. This method should be called if either the camera or, if hiding is enabled, the hiding objects are moving. - buffer - the frame buffer world - the world void buffer com.threed.jpct.FrameBuffer world com.threed.jpct.World Initialize Create a new lens flare for a light source. - lightPos - the position of the light source burst - the name of the burst texture as added to the TextureManager halo1 - the name of the first halo texture as added to the TextureManager halo2 - the name of the second halo as added to the TextureManager halo3 - the name of the third halo texture added to the TextureManager void lightPos com.threed.jpct.SimpleVector burst java.lang.String halo1 java.lang.String halo2 java.lang.String halo3 java.lang.String IsInitialized boolean render Renders the effect. - buffer - the frame buffer void buffer com.threed.jpct.FrameBuffer Hiding hides boolean 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. - hides - should geometry hide it or not? GlobalScale scale float Sets the global scale of the effect. - scale - the scale Transparency trans int Sets the transparency of the effect. - trans - the transparency. 0 is lowest LightPosition lightPos com.threed.jpct.SimpleVector Sets a new light position. - lightPos - the new position MaximumDistance distance float If hiding is enabled, this value specifies how far away from the camera a polygon can maximally be to be considered as a blocker. Anything farer away can't hide the effect. Lowering this value can improve performance but may lead to flares where non should be. -1 is default, which means no limits. - distance - the distance Direction lightToCam boolean If hiding is enabled, the visibility calculations can be done camera->light (default) or light->camera. Depending on the scene, one or the other will be faster. - lightToCam - do it light->camera or vice versa jpct.ae.wrapper.JIntList JpctIntList com.threed.jpct.IntList process clear Clears the list. void Initialize Initialize IntList void compact Truncates unused parts from the internal storage list, so that the resulting list doesn't require more memory than it has to. However, calling this method will cause a little memory usage peak. void get Adds an int to the list. - i - the int int pos int add Adds an int to the list. - i - the int void i int IsInitialized boolean size Returns the size of the list. int jpct.ae.wrapper.JInteract2D JpctInteract2D com.threed.jpct.Interact2D process reproject2D3DWS Reprojects a 2D vector (a screen/framebuffer coordinate in most cases) back into 3D (world space). The Z-value is assumed to be 1. - camera - the camera used to render the scene buffer - the framebuffer containing the rendered image x - the x position in 2D y - the y position in 2D com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer x int y int projectCenter3D2D2 Gets the center of the object in screen-coordinates (2D) by transforming and projecting it from 3D objectspace into 2D screenspace. Useful to "attach" bitmaps to objects for example. This method uses the current camera of the World the object has been assigned to. - camera - the camera that represents the worldspace->cameraspace transformation. The frontbuffer matrix of the camera will be used. If the camera is null, the one from the object's World will be used instead. buffer - the framebuffer the object will be (or has been) rendered into obj - the object itself com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer obj com.threed.jpct.Object3D reproject2D3DWS2 Reprojects a 2D vector (a screen/framebuffer coordinate in most cases) back into 3D (world space). The Z-value is assumed to be 1. - camera - the camera used to render the scene buffer - the framebuffer containing the rendered image x - the x position in 2D y - the y position in 2D toFill - a SimpleVector that will be filled with the result com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer x int y int toFill com.threed.jpct.SimpleVector reproject2D3D Reprojects a 2D vector (a screen/framebuffer coordinate in most cases) back into 3D. The Z-value is assumed to be 1. - camera - the camera used to render the scene buffer - the framebuffer containing the rendered image x - the x position in 2D y - the y position in 2D com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer x int y int reproject2D3D2 Reprojects a 2D vector (a screen/framebuffer coordinate in most cases) back into 3D. The Z-value is assumed to be 1. - camera - the camera used to render the scene buffer - the framebuffer containing the rendered image x - the x position in 2D y - the y position in 2D toFill - a SimpleVector that will be filled with the result com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer x int y int toFill com.threed.jpct.SimpleVector reproject2D3D3 Reprojects a 2D vector (a screen/framebuffer coordinate in most cases) back into 3D with a given z (in 3D). - camera - the camera used to render the scene buffer - the framebuffer containing the rendered image x - the x position in 2D y - the y position in 2D z - the z position of the "picking plane" (in 3D) com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer x int y int z float reproject2D3D4 Reprojects a 2D vector (a screen/framebuffer coordinate in most cases) back into 3D with a given z (in 3D). - camera - the camera used to render the scene buffer - the framebuffer containing the rendered image x - the x position in 2D y - the y position in 2D z - the z position of the "picking plane" (in 3D) toFill - a SimpleVector that will be filled with the result com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer x int y int z float toFill com.threed.jpct.SimpleVector project3D2D Projects a vertex from world space into screen space. camera - the Camera used for the projection buffer - the Framebuffer vertex - the vertex in world space com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer vertex com.threed.jpct.SimpleVector project3D2D2 Projects a vertex from world space into screen space. This variant takes a SimpleVector to fill instead of creating a new one for each call. - camera - the Camera used for the projection buffer - the Framebuffer vertex - the vertex in world space toFill - the SimpleVector that will be filled with the result com.threed.jpct.SimpleVector camera com.threed.jpct.Camera buffer com.threed.jpct.FrameBuffer vertex com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector projectCenter3D2D Gets the center of the object in screen-coordinates (2D) by transforming and projecting it from 3D objectspace into 2D screenspace. Useful to "attach" bitmaps to objects for example. This method uses the current camera of the World the object has been assigned to. - buffer - the framebuffer the object will be (or has been) rendered into obj - the object itself com.threed.jpct.SimpleVector buffer com.threed.jpct.FrameBuffer obj com.threed.jpct.Object3D IsInitialized boolean jpct.ae.wrapper.JGLSurfaceView JpctSurface android.opengl.GLSurfaceView activity SurfaceTouch(motionEvent As JpctMotionEvent, scaleEvent As JpctScaleEvent, gestureEvent As JpctGestureEvent) As Boolean SurfaceCreated SurfaceChanged(Width as int, Height as int) SurfaceDraw BufferWidth FrameBuffer's Width int RequestFocus boolean BringToFront void RGBX_8888 PixelFormat_RGBX_8888 int RemoveView void SetBackgroundImage void arg0 android.graphics.Bitmap OPAQUE PixelFormat_OPAQUE int DEBUG_CHECK_GL_ERROR Check glError() after every GL call and throw an exception if glError indicates that an error has occurred. This can be used to help track down which OpenGL ES call is causing an error. Constant Value: 1 int Invalidate3 void arg0 int arg1 int arg2 int arg3 int onResume Inform the view that the activity is resumed. The owner of this view must call this method when the activity is resumed. Calling this method will recreate the OpenGL display and resume the rendering thread. Must not be called before a renderer has been set. void Invalidate2 void arg0 android.graphics.Rect RGB_565 PixelFormat_RGB_565 int Initialize2 Initialize the GLSurfaceView for some devices (i.e Samsung I7500) EventName - The name of event that will get the updates/notifications glVersion - sets the required OpenGL version (Default 1) renderMode - sets the surface's render mode (Default CONTINUOUSLY=1) debug - turn-on error-checking/logging I.e:<code> Dim jpctView As JpctSurface jpctView.Initialize2("jpctEvent", 1, jpctView.RENDER_CONTINUOUSLY, True)</code> void ba anywheresoftware.b4a.BA EventName java.lang.String glVersion int renderMode int debug boolean Initialize3 Initialize a customized GLSurfaceView EventName - The name of event that will get the updates/notifications glVersion - sets the required OpenGL version (Default 1) redSize - the red size of the FrameBuffer greenSize - the green size of the FrameBuffer blueSize - the blue size of the FrameBuffer alphaSize - the alpha size of the FrameBuffer depthSize - the depth size of the FrameBuffer stencilSize - the stencil size of the FrameBuffer antiAliasing - - Enable/Disable OpenGL 2.0 Anti-Aliasing feature renderMode - sets the surface's render mode (Default CONTINUOUSLY=1) debug - error-checking/logging transparentSurface - need transparent surfaceView? I.e:<code> Dim jpctView As JpctSurface jpctView.Initialize3("jpctEvent", 1, 8, 8, 8, 8, 16, 4, True, jpctView.RENDER_CONTINUOUSLY, False, jpctView.RGBA_8888)</code> void ba anywheresoftware.b4a.BA EventName java.lang.String glVersion int redSize int greenSize int blueSize int alphaSize int depthSize int stencilSize int antiAliasing boolean renderMode int debug boolean pixelFormat int RENDER_WHEN_DIRTY The renderer only renders when the surface is created, or when requestRender() is called. Constant Value: 0 int IsInitialized boolean Initialize1 Initialize the GLSurfaceView EventName - The name of event that will get the updates/notifications glVersion - sets the required OpenGL version antiAliasing - Enable/Disable OpenGL 2.0 Anti-Aliasing feature renderMode - sets the surface's render mode debug - error-checking/logging transparentSurface - need transparent surfaceView? I.e:<code> Dim jpctView As JpctSurface jpctView.Initialize1("jpctEvent", 1, True, jpctView.RENDER_CONTINUOUSLY, False, jpctView.TRANSLUCENT)</code> void ba anywheresoftware.b4a.BA EventName java.lang.String glVersion int antiAliasing boolean renderMode int debug boolean pixelFormat int Initialize Initialize the GLSurfaceView EventName - The name of event that will get the updates/notifications glVersion - sets the required OpenGL version renderMode - sets the surface's render mode I.e:<code> Dim jpctView As JpctSurface jpctView.Initialize("jpctEvent", 1, jpctView.RENDER_WHEN_DIRTY)</code> void ba anywheresoftware.b4a.BA EventName java.lang.String glVersion int renderMode int destroyDrawingCache Destroy the drawing cache void TRANSLUCENT PixelFormat_TRANSLUCENT int RGBA_4444 PixelFormat_RGBA_4444 int RENDER_CONTINUOUSLY The renderer is called continuously to re-render the scene. Constant Value: 1 int DEBUG_LOG_GL_CALLS Log GL calls to the system log at "verbose" level with tag "GLSurfaceView". Constant Value: 2 int RGB_332 PixelFormat_RGB_332 int glContext OpenGL Context javax.microedition.khronos.opengles.GL10 SendArrayDataTo Send Data (Array of Objects) To UI thread SubName, Name of the Sub to send to, ie. "MySub" ArrayData, The Array of Data Objects you need to send void SubName java.lang.String ArrayData java.lang.Object[] SetLayout void arg0 int arg1 int arg2 int arg3 int Invalidate void TRANSPARENT PixelFormat_TRANSPARENT int BufferHeight FrameBuffer's Height int onPause Inform the view that the activity is paused. The owner of this view must call this method when the activity is paused. Calling this method will pause the rendering thread. Must not be called before a renderer has been set. void RequestRender Request that the renderer render a frame. This method is typically used when the render mode has been set to RENDER_WHEN_DIRTY, so that frames are only rendered on demand. May be called from any thread. Must not be called before a renderer has been set. void RGBA_8888 PixelFormat_RGBA_8888 int RGBA_5551 PixelFormat_RGBA_5551 int RGB_888 PixelFormat_RGB_888 int SendToBack void SendDataTo Send Data (Single Object) To UI thread SubName: Name of the Sub to send to, ie. "MySub" Data: The Data Object you need to send void SubName java.lang.String Data java.lang.Object Top int arg0 int Enabled boolean arg0 boolean DebugFlags int debugFlags int Get the current value of the debug flags. Visible boolean arg0 boolean Background android.graphics.drawable.Drawable arg0 android.graphics.drawable.Drawable Height int arg0 int Left int arg0 int Color arg0 int GLWrapper glWrapper android.opengl.GLSurfaceView.GLWrapper Set the glWrapper. If the glWrapper is not null, its wrap(GL) method is called whenever a surface is created. A GLWrapper can be used to wrap the GL object that's passed to the renderer. Wrapping a GL object enables examining and modifying the behavior of the GL calls made by the renderer. Tag java.lang.Object arg0 java.lang.Object Width int arg0 int RenderMode int Get the current rendering mode. May be called from any thread. Must not be called before a renderer has been set. jpct.ae.wrapper.JGLSLShader JpctGLSLShader com.threed.jpct.GLSLShader process addReplacement With this, you can override the default shaders by making jPCT-AE use your own shader code instead. Valid names for key are: defaultFragmentShader.src defaultFragmentShaderDepth.src defaultFragmentShaderFog.src defaultFragmentShaderFogLight0.src defaultFragmentShaderTex0.src defaultFragmentShaderTex0Amb.src defaultFragmentShaderTex0Light0.src defaultFragmentShaderTex1.src defaultVertextShader.src defaultVertexShaderDepth.src defaultVertexShaderFog.src defaultVertexShaderFogLight0.src defaultVertexShaderTex0.src defaultVertexShaderTex0Amb.src defaultVertexShaderTex0Light0.src defaultVertexShaderTex1.src void key java.lang.String shaderSrc java.lang.String setUniform Sets a new integer uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform val - the value void name java.lang.String val int setStaticUniform5 Sets a new SimpleVector uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setUniform(...) instead. - name - the name of the uniform val - the value. void name java.lang.String val com.threed.jpct.SimpleVector setStaticUniform4 Sets a new array of SimpleVector uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setUniform(...) instead. - name - the name of the uniform val - the value. void name java.lang.String vals com.threed.jpct.SimpleVector[] setStaticUniform Sets a new integer uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setUniform(...) instead. - name - the name of the uniform val - the value void name java.lang.String val int setStaticUniform6 Sets a new Matrix uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setUniform(...) instead. - name - the name of the uniform m - the matrix. It won't be transposed. void name java.lang.String m com.threed.jpct.Matrix setStaticUniform2 Sets a new float uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setUniform(...) instead. - name - the name of the uniform val - the value void name java.lang.String val float setStaticUniform3 Sets a new float|vecX uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setUniform(...) instead. - name - the name of the uniform val - the value. Supports array-lengths from 1 to 4. void name java.lang.String val float[] finalize finalize in class java.lang.Object void IsInitialized boolean Initialize Creates a new instance. This instance can then be passed to any Object3D that should use this shader. You may pass one instance to multiple Object3D's. Please note that both parameters are not the paths to the shader sources but the shader sources themselves. The shaders won't be compiled before their first usage, so you may pass bogus shader code here, but you'll not notice it, until you are trying to render the object using that shader. - vertexShaderSrc - the source of the vertex shader fragmentShaderSrc - the source of the fragment shader void vertexShaderSource java.lang.String fragmentShaderSource java.lang.String dispose Disposes the shader. Usually, there's no need to call this. void getHandle ? int name java.lang.String setFloatArrayUniform Sets a new float[] uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform val - the value. Supports array-lengths from 1 to 4. void name java.lang.String val float[] setUniform6 Sets a new Matrix uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform m - the matrix. It won't be transposed. void name java.lang.String m com.threed.jpct.Matrix setUniform3 Sets a new SimpleVector uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform val - the value void name java.lang.String val com.threed.jpct.SimpleVector setStaticFloatArrayUniform Sets a new float[] uniform. Static means, that this value will be set only once. If you want to change the value at runtime, use setFloatArrayUniform(...) instead. - name - the name of the uniform val - the value. void name java.lang.String val float[] setUniform2 Sets a new float uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform val - the value void name java.lang.String val float setUniform5 Sets a new float|vecX uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform val - the value. Supports array-lengths from 1 to 4. void name java.lang.String val float[] setUniform4 Sets a new array of SimpleVectors uniform. This value will be set each time the shader is executed. You may change it at runtime. - name - the name of the uniform val - the value void name java.lang.String val com.threed.jpct.SimpleVector[] ShaderLocator locator com.threed.jpct.ShaderLocator Sets a new shader locator. If this is needed, it has to be done before instantiating the frame buffer. Please refer to the documention of the ShaderLocator for more information. - locator - the new locator Program int Returns the id of the shader program. Can be useful if you want to fiddle around with the shader behind jPCT-AE's back. jpct.ae.wrapper.JGenericVertexController JpctVertexController jpct.ae.wrapper.VertexController process VertexController(vcEvent as int) Initialize Initialize the Vertex Controller eventName - the name of the Vertex Controller's event void ba anywheresoftware.b4a.BA eventName java.lang.String refreshMeshData Refreshes the controller's data with the data taken directly from the Mesh. This can be useful to reflect changes to the controller that have been applied to the mesh outside of the controller. void ALTER_SOURCE_MESH The VertexController will modify the source data when applied, i.e. everything the controller does to the mesh is cumulative over time. boolean EVENT_CLEANUP the type - CLEANUP - of the callback event raised by the controller int EVENT_SETUP the type - SETUP - of the callback event raised by the controller int EVENT_APPLY the type - APPLY - of the callback event raised by the controller int getPolygonIDs Returns the polygon IDs of the polygons that are using the vertex "number". This can be used to determine which vertices belong to a polygon, which could be useful in some VertexControllers. This should be done at setup time, not at runtime. vertex - the number of the vertex max - the maximum of IDs to return int[] vertex int max int PRESERVE_SOURCE_MESH The VertexController will start with a "fresh" source mesh everytime it's being applied. boolean IsInitialized boolean MeshSize int Returns the size of the mesh. This is the length all SimpleVector-array returned by the methods above will have. DestinationNormals com.threed.jpct.SimpleVector[] Returns the destination mesh's normals. The new normals will be stored in these SimpleVectors. Calculating the vertex normal of a modified vertex is not always cheap. In some cases, one may get away with not modifying the normals at all. This will cause slightly wrong lighting, but eases the calculations. Write into the SimpleVectors of this array, don't read from them. SourceNormals com.threed.jpct.SimpleVector[] Returns the source mesh's normals, i.e. the normals that need modification. Every SimpleVector in this array represents a normal in the mesh. The normal at the specific index is the normal of the corresponding vertex in the SourceMesh-array. Read the data from this array, but don't modify it. SourceMesh com.threed.jpct.SimpleVector[] Returns the source mesh's vertex data, i.e. the vertex-data that needs modification. Every SimpleVector in this array represents a vertex in the mesh. However, there's no information which vertex exactly (because they don't have ids or something). Read the data from this array, but don't modify it. DestinationMesh com.threed.jpct.SimpleVector[] Returns the destination mesh's vertex data. The new vertices will be stored in these SimpleVectors. There's no need to replace the SimpleVectors in this array with new ones. Just set their x,y and z components to the new values. Write into the SimpleVectors of this array, don't read from them. jpct.ae.wrapper.JFrameBuffer JpctFrameBuffer com.threed.jpct.FrameBuffer process removeRenderTarget Removes the render target from the framebuffer. After this, all rendering is done into the framebuffer again. If no render target has been set, this method does nothing. void clearZBufferOnly Clears only the ZBuffer, not the color buffer. Can be useful for special effects like rendering two worlds into one frame buffer. Using this method may cause strange renderings on some devices, because they seem to rely on a cleared framebuffer each frame for an unknown reason. void addPostProcessor Adds an IPostProcessor to run a post processing on the framebuffer. This isn't done automatically but has to be triggered by the application by calling runPostProcessors() on this framebuffer. Enabling or disabling renderers on this framebuffer causes all post processors to be disposed and then removed from this framebuffer. - proc - the post processor void proc com.threed.jpct.IPostProcessor runPostProcessors Runs all post processors that have been added to this framebuffer. A post processor is an implementation of the IPostProcessor interface. The processing is done on the framebuffer's back buffer in its current state, i.e. if you run it before blitting, the blitting won't be affected. If you run it afterwards, it will. void clearColorBufferOnly Clears only the color bufferr, not the depth buffer. col - the fill color void col com.threed.jpct.RGBColor setRenderTarget4 Sets the render target of the framebuffer to a texture. From here on, all rendering is done into that texture instead of the actual framebuffer. The texture has to be smaller or equal to the framebuffer. This is a special purpose version of this method that allows to define a border that isn't affected by the rendering. While possible, it's not recommended to blit into a render target. If possible, use OpenGL ES 2.0 mode when using this, because it's much more compatible. - tex - the texture to render into left - the width of the left border top - the width of the upper border right - the width of the right border bottom - the width of the lower border clearAll - if true, the border won't affect the clearing of texture. If set to false, it will. void tex com.threed.jpct.Texture left int top int right int bottom int clearAll boolean blit Copies a part of a bitmap (taken from a Texture in this case) into the framebuffer. If you want your blitted content to lay on top of the rendered image, it has to be applied after calling update() on the buffer. This method is useful to copy 2D-GUI elements into the rendered image (or for similar tasks). Blitting requires that the current world has been rendered at least once into the framebuffer where the blitting should be applied to (for doing some intialization work). Usually, that shouldn't be a problem unless you are abusing jPCT as a "blitting engine" only. Be sure that the texture's height is 2^x. Everything else might produce unpredictable results. This method should be prefered over the int[]-array-blit whenever possible. - src - the texture that contains the source bitmap srcX - the starting x-position in the source bitmap srcY - the starting y-position in the source bitmap destX - the starting x-position in the destination bitmap destY - the starting y-position in the destination bitmap width - the width of the region to copy height - the height of the region to copy transparent - black (or at least almost black) pixels won't be copied if this is set to TRANSPARENT_BLITTING. Any color-value which leads to a result of zero when "anded" with #f0f0f0 will be taken as black unless your texture specifies its own alpha channel. void src com.threed.jpct.Texture srcX int srcY int destX int destY int width int height int transparent boolean setRenderTarget2 Sets the render target of the framebuffer to a texture. From here on, all rendering is done into that texture instead of the actual framebuffer. The texture has to be smaller or equal to the framebuffer, when FBO are not used/available. Rendering into a texture can be slow on some hardware like Intel onboard chipsets. This is a special purpose version of this method that allows to define a border that isn't affected by the rendering. While possible, it's not recommended to blit into a render target. - texID - the ID of the texture to render into. left - the width of the left border top - the width of the upper border right - the width of the right border bottom - the width of the lower border clearAll - if true, the border won't affect the clearing of texture. If set to false, it will. void texID int left int top int right int bottom int clearAll boolean clear Clears the framebuffer and the z-buffer. If you are not doing this every frame, it will lead to strange results on some devices... void sync Synchronizes GPU and CPU and flushes the render pipeline.. This isn't needed (and not even wanted) in most cases. void removePostProcessor Removes a post processor from the framebuffer. The processor will be disposed and then removed. - proc - The post processor to be removed void proc com.threed.jpct.IPostProcessor Initialize2 Creates a new framebuffer with a width of x and a height of y. The created buffer will be accessed by OpenGL ES 1.0/1.1. Make sure that your OpenGL context is 2.x before using this. - Width - the width of the framebuffer Height - the height of the framebuffer void Width int Height int IsInitialized boolean Initialize1 Creates a new framebuffer with a width of x and a height of y. This is for initializing the OpenGL ES2.0 pipeline. Make sure that your OpenGL context is 1.0 before using this. - glContext - a valid gl context Width - the width of the framebuffer Height - the height of the framebuffer void glContext javax.microedition.khronos.opengles.GL10 Width int Height int dispose Should be called before this FrameBuffer won't be used anymore to do some clean up work. For example, if you are reusing a buffer variable to assign a new FrameBuffer for it, dispose the former one before doing so. void getPixels2 Returns the raw pixel-data. This can be useful, if one wants to copy parts of the FrameBuffer into an Image out of jPCT's focus. getPixels() should be called after calling update(), because otherwise it is not guaranteed that the returned array contains the most current pixels. The returned array contains the pixel-data in RGB-format and with no alpha information. This method is very slow, because it has to read all the pixels out of the VRAM and write them into the FrameBuffer's internal pixel-buffer. This method takes an array to fill. The array has to have to proper size (i.e. framebuffer's height*width). - toFill - the array to fill int[] toFill int[] OPAQUE_BLITTING 2D texture-blitting into the framebuffer is done by copying the source 1-to-1 into the destination bitmap boolean freeMemory Frees some native memory used by the gl context. Might be helpful to use this on a framebuffer before the context is about to get lost, i.e. before the gl context becomes invalid. void display Displays the rendered image. void isInit Checks if the FrameBuffer and the renderer have been initialized correctly. true, if the FrameBuffer is fine. Otherwise false. boolean TRANSPARENT_BLITTING 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. boolean removeAllPostProcessors Removes all post processors from the framebuffer. The processors will be disposed and then removed. void setVirtualDimensions This has a meaning only if a render target has been set. By default the fov calculations will use the render target's dimensions. With this, you can set some other dimensions. - width - the virtual width of the render target height - the virtual height of the render target void width int height int flush Flushes the render pipeline. This isn't needed (and not even wanted) in most cases. void clear2 Clears the framebuffer with the given color. If you are not doing this every frame, it will lead to strange results on some devices... - col - the color the framebuffer is filled with void col com.threed.jpct.RGBColor blit2 Special version of blit() that allows for scaling, i.e. it doesn't make 1-to-1 copies but can up- or down-scale. In addition, it offers support for transparency, a different blending mode and an additional color. If you want your blitted content to lay on top of the rendered image, it has to be applied after calling update() on the buffer. This method is useful to copy 2D-GUI elements into the rendered image (or for similar tasks). Blitting requires that the current world has been rendered at least once into the framebuffer where the blitting should be applied to (for doing some intialization work). Usually, that shouldn't be a problem unless you are abusing jPCT as a "blitting engine" only. There is no int[]-array-version of this method. Using this method is quite to similar to using the Overlay-class. The difference is, that Overlay takes care of itself and that it has a real depth. - src - the texture that contains the source bitmap srcX - the starting x-position in the source bitmap srcY - the starting y-position in the source bitmap destX - the starting x-position in the destination bitmap destY - the starting y-position in the destination bitmap sourceWidth - the width of the source region to copy sourceHeight - the height of the source region to copy destWidth - the width of the copied region in the destination bitmap destHeight - the height of the copied region in the destination bitmap transValue - the transparency, -1 is none, 0 is highest transparency. Higher values less transparency. additive - if true, the blending is additive, otherwise default addColor - an additional color. If null, Color.WHITE is taken instead void src com.threed.jpct.Texture srcX int srcY int destX int destY int sourceWidth int sourceHeight int destWidth int destHeight int transValue int additive boolean addColor com.threed.jpct.RGBColor blit4 Copies a part of a bitmap (taken from an int[] containing pixels in RGB-format and with no alpha) into the framebuffer. If you want your blitted content to lay on top of the rendered image, it has to be applied after calling update() on the buffer. Can be combined with getPixels() to achieve some special effects with the framebuffer. Blitting requires that the current world has been rendered at least once into the framebuffer where the blitting should be applied to (for doing some intialization work). Usually, that shouldn't be a problem unless you are abusing jPCT as a "blitting engine" only. This method is very slow, because the int[] has to be converted and uploaded to the GPU every time. To avoid this in some cases, Config.glUseIgnorantBlits can be set to true...but one should be aware of the consequences. As a rule of thumb: If it's possible to avoid this method and use a texture-based-blit instead...do it! - src - the int-array that contains the source bitmap srcWidth - the width of the source bitmap srcHeight - the height of the source bitmap srcX - the starting x-position in the source bitmap srcY - the starting y-position in the source bitmap destX - the starting x-position in the destination bitmap destY - the starting y-position in the destination bitmap width - the width of the region to copy height - the height of the region to copy transparent - black (or at least almost black) pixels won't be copied if this is set to TRANSPARENT_BLITTING. Any color-value which leads to a result of zero when "anded" with #f0f0f0 will be taken as black. void src int[] srcWidth int srcHeight int srcX int srcY int destX int destY int width int height int transparent boolean blit3 Special version of blit() that allows for scaling, i.e. it doesn't make 1-to-1 copies but can up- or down-scale. In addition, it offers support for transparency, a different blending mode and an additional color. If you want your blitted content to lay on top of the rendered image, it has to be applied after calling update() on the buffer. This method is useful to copy 2D-GUI elements into the rendered image (or for similar tasks). Blitting requires that the current world has been rendered at least once into the framebuffer where the blitting should be applied to (for doing some intialization work). Usually, that shouldn't be a problem unless you are abusing jPCT as a "blitting engine" only. There is no int[]-array-version of this method. Using this method is quite to similar to using the Overlay-class. The difference is, that Overlay takes care of itself and that it has a real depth. - src - the texture that contains the source bitmap srcX - the starting x-position in the source bitmap srcY - the starting y-position in the source bitmap destX - the starting x-position in the destination bitmap destY - the starting y-position in the destination bitmap sourceWidth - the width of the source region to copy sourceHeight - the height of the source region to copy destWidth - the width of the copied region in the destination bitmap destHeight - the height of the copied region in the destination bitmap transValue - the transparency, -1 is none, 0 is highest transparency. Higher values less transparency. additive - if true, the blending is additive, otherwise default void src com.threed.jpct.Texture srcX int srcY int destX int destY int sourceWidth int sourceHeight int destWidth int destHeight int transValue int additive boolean RenderTarget1 texID int Sets the render target of the framebuffer to a texture. From here on, all rendering is done into that texture instead of the actual framebuffer. The texture has to be smaller or equal to the framebuffer. While possible, it's not recommended to blit into a render target. - texID - the ID of the texture to render into. CenterX float Returns the x-coord of the midpoint of the framebuffer. This value represents the internally used width/2. OpenGLMajorVersion int Returns the major version of OpenGL (1 or 2) that this FrameBuffer uses. Pixels int[] Returns the raw pixel-data. This can be useful, if one wants to copy parts of the FrameBuffer into an Image out of jPCT's focus. getPixels() should be called after calling update(), because otherwise it is not guaranteed that the returned array contains the most current pixels. The returned array contains the pixel-data in RGB-format and with no alpha information. This method is very slow, because it has to read all the pixels out of the VRAM and write them into the FrameBuffer's internal pixel-buffer. CenterY float Returns the y-coord of the midpoint of the framebuffer. This value represents the internally used height/2. RenderTarget3 tex com.threed.jpct.Texture Sets the render target of the framebuffer to a texture. From here on, all rendering is done into that texture instead of the actual framebuffer. The texture has to be smaller or equal to the framebuffer. While possible, it's not recommended to blit into a render target. If possible, use OpenGL ES 2.0 mode when using this, because it's much more compatible. - tex - the texture to render into ID java.lang.Long Returns a unique ID for this FrameBuffer. Height int Returns the height of the framebuffer. Width int Returns the width of the framebuffer. PaintListener listener com.threed.jpct.IPaintListener Adds a listener to the renderer. The listener will be notified before the renderer starts to paint polygons and after it has finished. - listener - IPaintListener the listener or null to clear it jpct.ae.wrapper.JDepthBuffer JpctDepthBuffer com.threed.jpct.DepthBuffer process Initialize Creates a new depth buffer. width - the width height - the height void width int height int IsInitialized boolean Height int Returns the height. Width int Returns the width. jpct.ae.wrapper.JConfig JpctConfig com.threed.jpct.Config process useVBO Makes the engine use vertex buffer objects if possible instead of plain vertex arrays. boolean glTriangleStrips Default is true. boolean glDither Use dithering. boolean collideOffset 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. float collideEdgeMul 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. float aggressiveStripping A debug switch...might go away in later versions. boolean oldStyle3DSLoader 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. boolean collideSectorOffset 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. float maxAnimationSubSequences The maximum number of sub-sequences an Animation may contain. int maxPolysVisible The maximum size of the VisList. int disableNativeBufferCopies Disables support for native buffer copies via libgdx even if it's present in the classpath if set to true. boolean renderTargetsAsSubImages If true, render targets will be filled using a method to copy sub images. boolean getParameterValue Gets the current value of the parameter with the given name. Because if type of the value is unknown, this method simply returns an Object. It's up to you to convert it correctly. - name - the name java.lang.Object name java.lang.String setParameterValue Sets a parameter with the given name to a value. This method can be used to access the configuration variables via their names instead of setting them directly. This is more suitable for setting them from some configuration file's data, but its slower than direct access, because it uses reflection. - name - the name value - the value void name java.lang.String value java.lang.Object IsInitialized boolean flashSortThreshold If the number of instances to sort exceeds this value, a flash sort will be used instead of the default quick sort. int glBatchSize When compiling an Object3D, the renderer has to assume an ideal batch size for the underlying hardware. int glUseIgnorantBlits Forces the renderer to skip the texture conversion from the FrameBuffer's blit(int[]...) boolean vectorCacheSize Size of an internal cache for storing SimpleVectors. int useRotationPivotFrom3DS By default, jPCT-AE calculates a rotation pivot based on the mesh's geometry when calling build(). boolean glTrilinear Use trilinear filtering between mip-map level. boolean glTransparencyOffset Modifies the offset for the transparency calculations in jPCT-AE. float internalMipmapCreation If true, jPCT-AE will always use its own mipmap generation code even if the GPU or driver could do it on its own. boolean glIgnoreNearPlane If set to true, the renderer will ignore the configured near plane for creating the frustum and use a default value instead. boolean autoMaintainAspectRatio Ensures that the aspect ratio doesn't change when changing framebuffer size. boolean nearPlane The near clipping plane. float maxLights The maximum number of lightsources that the Lights instance of a World may handle. int glTransparencyMul Modifies the multiplicator for the transparency calculations in jPCT-AE. float specPow The sharpness of specular highlights. float viewportOffsetY 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. float farPlane The far clipping plane. float collideEllipsoidThreshold A threshold that limits recursion for ellipsoid collision detection. float specTerm An "amplifier"-value for specular highlights. float aaMode Don't fiddle around with this! int glRevertADDtoMODULATE When setting this to true, every texture blending operation that uses the additive mode will be treated as if it were using modulation instead. boolean useNormalsFromOBJ By default, jPCT calculates normals based on the mesh's geometry when calling build(). boolean vertexBufferSize Internal buffer used to upload vertex data to the gpu. int glDebugLevel Wraps gl calls to be printed out by the Logger if not set to 0. int defaultCameraFOV The default FOV for the camera. float stateOrientedSorting If true, sorting will be state oriented. boolean glForceEnvMapToSecondStage By default, an environment map will be applied to the first texture stage if environment mapping is used on an object. boolean polygonIDLimit A value that defines how many polygon IDs that were part of a collision will be stored before additional polygon IDs will be rejected. int viewportOffsetX 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. float cacheCompressedTextures Experimental! boolean maxTextureLayers The maximum number of texture that a polygon can have. int glForceHighPrecision Forces high precision for shaders even if the shader source states otherwise. boolean maxParentObjects The maximum number of parent objects every object may have. usually, an object has only one parent object anyway. int unloadImmediately If true, textures will be unloaded immediately when calling one of the unload-methods in the TextureManager. boolean maxTextures The inital number of textures the texture-manager can handle. int ParameterNames java.lang.String[] Returns the names of all public fields in Config, all configuration options. Version java.lang.String Returns the version of this release. jpct.ae.wrapper.JCollisionListener JpctCollisionListener jpct.ae.wrapper.CollisionListenerInterface process CollisionListener(getAlgorithm As Int, getPolygonIDs() As Int, getType As Int, toString As String, getFirstContact As JpctSimpleVector, getObject As JpctObject3D, getSource As JpctObject3D, getTargets() As JpctObject3D) Initialize Initialize the Collision Listener eventName - the name of the Vertex Controller's event requiresPolygonIDs - return which polygons affected by collision? void ba anywheresoftware.b4a.BA eventName java.lang.String requiresPolygonIDs boolean EVENT_ALGORITHM_RAY The collision event was caused by a ray-polygon collision detection int EVENT_ALGORITHM_SPHERE The collision event was caused by a sphere-polygon collision detection int EVENT_ALGORITHM_ELLIPSOID The collision event was caused by a ellipsoid-polygon collision detection int EVENT_TYPE_SOURCE The object is the source of the collision that has caused the event int EVENT_TYPE_TARGET The object is a target of the collision that has caused the event int IsInitialized boolean jpct.ae.wrapper.JCamera JpctCamera com.threed.jpct.Camera process rotateCameraZ Rotates the camera around the z-axis. Unlike the rotateZ()-method inherited from BufferedMatrix, this method takes care of the fact that rotating the camera using an angle w actually means that the world rotates around -w. - angle - the angle void angle float CAMERA_MOVEOUT Move the camera backwards (relative to its current direction) int convertRADAngleIntoFOV Converts an angle in radians into a FOV value that jPCT can handle (=2*tan(angle/2)). angle - the angle in radians float angle float rotateCameraX Rotates the camera around the x-axis. Unlike the rotateX()-method inherited from BufferedMatrix, this method takes care of the fact that rotating the camera using an angle w actually means that the world rotates around -w. - angle - the angle void angle float CAMERA_MOVEIN Move the camera forward (relative to its current direction) int rotateCameraY Rotates the camera around the y-axis. Unlike the rotateAxisY()-method inherited from BufferedMatrix, this method takes care of the fact that rotating the camera using an angle w actually means that the world rotates around -w. - angle - the angle void angle float getProjectionMatrix Returns the projection matrix. buffer - the framebuffer com.threed.jpct.Matrix buffer com.threed.jpct.FrameBuffer rotateX Rotates the camera around the x-axis. angle - the angle void angle float decreaseFOV Decreases the FOV. Useful for zoomout effects. void dec float rotateZ Rotates the camera around the z-axis. angle - the angle void angle float rotateY Rotates the camera around the y-axis. angle - the angle void angle float increaseFOV Increases the FOV. Useful for zoomin effects. void inc float convertDEGAngleIntoFOV Converts an angle in degrees into a FOV value that jPCT can handle. angle - the angle in degrees float angle float getDirection2 Returns the direction vector of the camera in world space and fills the given SimpleVector with the result. The returned SimpleVector is already normalized (it should always be normalized due to the nature of the rotation matrix it comes from, but to avoid any possible rounding errors, it's renormalized again within this method). - toFill - the vector that should contain the position com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector transform Transforms a vertex from world into camera space. vertex - the vertex in world space com.threed.jpct.SimpleVector vertex com.threed.jpct.SimpleVector ELLIPSOID_TRANSFORMED The camera's ellipsoid will be transformed when performing collision detection. int CAMERA_MOVEUP Move the camera up (relative to its current direction). int rotateCameraAxis Rotates the camera around an arbitrary axis. The method is more powerful than the normal rotate-around-an-axis methods, but also a bit slower. The resulting matrix will be orthonormalized to ensure numerical accuracy. Unlike the rotateAxis() method inherited from BufferedMatrix, this method takes care of the fact that rotating the camera using an angle w actually means that the world rotates around -w. - axis - a direction-vector pointing into the axis direction angle - the angle of the rotation void axis com.threed.jpct.SimpleVector angle float DONT_SLIDE Camera stops in front of obstacles. boolean ELLIPSOID_ALIGNED The camera's ellipsoid won't be transformed when performing collision detection (default). int setOrientation Sets the orientation of the camera by giving a direction and an up-vector. Make sure that these vectors are orthogonal. - dir - the direction up - the up-vector void dir com.threed.jpct.SimpleVector up com.threed.jpct.SimpleVector rotateAxis Rotates the backbuffer matrix around an arbitrary axis. The method is more powerful than the normal rotate-around-an-axis methods, but also a bit slower. The resulting matrix will be orthonormalized to ensure numerical accuracy. - axis - a direction-vector pointing into the axis direction angle - the angle of the rotation void axis com.threed.jpct.SimpleVector angle float setFOVtoDefault Resets the FOV to the default value configured in Config. void IsInitialized boolean Initialize Initialize the Camera void CAMERA_MOVELEFT Move the camera left (relative to its current direction) int CAMERA_DONT_MOVE Don't move the camera before checking for a collision. int setFOVLimits Sets the limits for FOV jPCT should permit. Anything lower or higher will be clipped to the lowest or highest possible value. - lower - the lowest possible FOV (default is 0.5) higher - the highest possible FOV (default is 1.5) void lower float higher float moveCamera2 Moves (translates) the camera with a given speed in an arbitrary direction (should be a normalized vector). - direction - the direction speed - the speed (positional change in units) void direction com.threed.jpct.SimpleVector speed float align Aligns the camera with the (transformed) positive z-axis of an Object3D. This method works on the object's own rotation matrix only. It doesn't take transformations of parent objects into account. - object - the object the camera should be aligned with void object com.threed.jpct.Object3D setPosition Sets the camera to a position in worldspace. This method may be useful if x, y and z are already discrete values. This method replaces the deprecated setCamera()-method. - x,y,z - the components of the position vector void x float y float z float CAMERA_MOVEDOWN Move the camera down (relative to its current direction) int getPosition2 Gets the current position of the camera and fills the given SimpleVector with the result. - toFill - the vector that should contain the position com.threed.jpct.SimpleVector toFill com.threed.jpct.SimpleVector lookAt Rotates the camera so that is looks at the given position in world-space. (it will only rotate, not move...). - lookAt - the position vector to look at void lookAt com.threed.jpct.SimpleVector CAMERA_MOVERIGHT Move the camera right (relative to its current direction) int moveCamera Moves (translates) the camera with a given speed into "mode" direction relative to its current direction. - mode - the direction speed - the speed (positional change in units) void mode int speed float SLIDE Camera slides along obstacles. boolean YAxis com.threed.jpct.SimpleVector Returns the (virtual) y-axis of the camera. UpVector com.threed.jpct.SimpleVector Returns the up vector of the camera in world space. The returned SimpleVector is already normalized (it should always be normalized due to the nature of the rotation matrix it comes from, but to avoid any possible rounding errors, it's renormalized again within this method). ZAxis com.threed.jpct.SimpleVector Returns the (virtual) z-axis of the camera. XAxis com.threed.jpct.SimpleVector Returns the (virtual) x-axis of the camera. SideVector com.threed.jpct.SimpleVector Returns the side vector of the camera in world space. The returned SimpleVector is already normalized (it should always be normalized due to the nature of the rotation matrix it comes from, but to avoid any possible rounding errors, it's renormalized again within this method). Direction com.threed.jpct.SimpleVector Returns the direction vector of the camera in world space. The returned SimpleVector is already normalized (it should always be normalized due to the nature of the rotation matrix it comes from, but to avoid any possible rounding errors, it's renormalized again within this method). Back com.threed.jpct.Matrix mat com.threed.jpct.Matrix Returns the Matrix that is used as the backbuffer matrix. YFOV2 tanFOV float Sets the FOV in y-direction (within the limits set by setFOVLimits). tanFOV - the y-FOV (default is -1, which means that its derived from the x-FOV) YFOV float Returns the fov in y-direction. Default is -1, which means that the FOV-value in y-direction will be calculated from the x-fov depending on the aspect-ratio-setting in Config. Any other value will override this calculation with a fixed value. PositionToCenter object com.threed.jpct.Object3D Sets the camera to the position of the transformed center of an Object3D. object - the object MinFOV float Gets the lowest possible FOV. FOV float tanFOV float Returns the FOV. EllipsoidMode int mode int Returns the current ellipsoid mode. Position com.threed.jpct.SimpleVector pos com.threed.jpct.SimpleVector Gets the current position of the camera. MaxFOV float Gets the highest possible FOV. jpct.ae.wrapper.JBitmapHelper JpctBitmapHelper com.threed.jpct.util.BitmapHelper process Initialize Initialize BitmapHelper void rescale Rescales a Bitmap. - bitmap - the bitmap width - the new width height - the new height android.graphics.Bitmap bitmap android.graphics.Bitmap width int height int loadImage Creates a Bitmap from an Inputstream by using Android's BitmapFactory. if invalid InputStream passed, it will return null. is - the stream Return type: @return:Bitmap or null android.graphics.Bitmap is java.io.InputStream convert Creates a Bitmap from a Drawable. This bypasses Android's BitmapFactory. However, Android is free to scale these resources on loading, so you might have to rescale them to fit. Prefer to put your images for textures into raw if possible. - drawable - the Drawable android.graphics.Bitmap drawable android.graphics.drawable.Drawable IsInitialized boolean jpct.ae.wrapper.JAnimation JpctAnimation com.threed.jpct.Animation process USE_CLAMPING Use clamping when the interpolation reaches the end of a sub-sequence. int Initialize Creates a new animation sequence that consist of keyframeCount keyframes - keyframeCount int void keyframeCount int createSubSequence Creates a new sub-sequence. A sub-sequence is a part of the complete animation that can be played stand-alone (like running, jumping etc.). Using the sub-sequence concept, it is possible to store all sub-animations for an object into one animation, so that switching (and maybe interaction) between them is fast and comfortable. Before adding the first keyframe you have to create a sub-sequence. The sub-sequence will be numbered starting from 1. 0 is a special case as is represents the animation as a whole. - name - the name of this sequence int name java.lang.String getSequenceBorders Gets the position of the start and the end frame of a sequence. - seq - a sequencean Returns int[2]-array with the positions int[] seq int LINEAR Use linear interpolation between keyframes. int remove Removes data of a sequence from an animation. The actual sequence is still there, just without any data. Accessing it will cause a crash. This is useful to save memory on animations that doesn't use all sequences. - seq - the sequence void seq int KEYFRAMESONLY Use no interpolation between keyframes. int addKeyFrame Add a keyframe to a animation sequence. A keyframe is simply a mesh. A mesh can be obtained from an object by calling its getMesh()-method. Don't add a mesh as a keyframe that is already bound to an object that should use this animation, because this will result in the object to animate it's own mesh instead of the keyframes. If you want to use a mesh from such an object, don't add the mesh from getMesh() directly but make a copy of it using cloneMesh(). It's a good way to generate meshes by getting them from temporary objects. Don't forget to calc the bounding box and the normals for these meshes (for example by calling build() for the temporary object). All the meshes of an animation have to have the same mesh-size (as well as the object that should use this animation). - keyFrame - the mesh of this keyframe void keyFrame com.threed.jpct.Mesh strip Removes triangle information from this animation's meshes. This is useful to save some memory for meshes that are used for keyframing only (triangle information are not needed in that case). For any other meshes: Don't call this method. It will break your mesh! - usesCache boolean void USE_WRAPPING Use wrapping when the interpolation reaches the end of a sub-sequence. int getName Returns the name of a sequence. - seq - a sequence java.lang.String seq int getSequence Returns a sequence index for a given name. If non is found, -1 will be returned. - name - the sequence's name Returns the index or -1 int name java.lang.String IsInitialized boolean InterpolationMethod method int Sets the method that should be used to interpolate vertices between keyframes. - method - the method KeyFrames com.threed.jpct.Mesh[] Returns the key frames of an animation as an array of Mesh. - the key frames SequenceCount int Returns the number of sequences used. Sequence 0 is implicit as it stands for the animation as a whole. So a return value of 2 means, that you may play sub-sequence 1 or 2...or the whole animation using 0. Caching usesCache boolean If enabled, animations will be processed faster, you'll get a higher frame rate. However, it consumes some more memory. Default is true. - usesCache boolean ClampingMode mode int Sets the clamping mode for animations. mode - the clamping mode jpct.ae.wrapper.JAAConfigChooser JpctAAConfigChooser com.threed.jpct.util.AAConfigChooser process Initialize Creates a new EGLConfigChooser that supports anti-aliasing. view - the JpctSurfaceView void view android.opengl.GLSurfaceView Initialize2 Creates a new EGLConfigChooser that supports anti-aliasing with optional alpha for the FrameBuffer. view - the JpctSurfaceView withAlpha - alpha channel (for transparent FrameBuffers)? void view android.opengl.GLSurfaceView withAlpha boolean chooseConfig chooseConfig - ? egl - display - javax.microedition.khronos.egl.EGLConfig egl javax.microedition.khronos.egl.EGL10 display javax.microedition.khronos.egl.EGLDisplay IsInitialized boolean 1.0 Alhowiriny jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae jpct_ae