diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/300px-surface_normal.png b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/300px-surface_normal.png
new file mode 100644
index 000000000..3723ad341
Binary files /dev/null and b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/300px-surface_normal.png differ
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/220px-trefoil_knot_arb.png b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/220px-trefoil_knot_arb.png
new file mode 100644
index 000000000..8974e487e
Binary files /dev/null and b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/220px-trefoil_knot_arb.png differ
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/collision_and_intersection.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/collision_and_intersection.html
index 38f8068c7..900144f9e 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/collision_and_intersection.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/collision_and_intersection.html
@@ -4,45 +4,20 @@
-The term collision can be used to refer to physical interactions (where physical objects collide and bump off one another), and also to non-physical intersections. This article is about non-physical (mathematical) collisions.
+The term collision can be used to refer to physical interactions (where physical objects collide, push and bump off one another), and also to non-physical intersections in 3D space. This article is about the non-physical (mathematical) collisions.
-Non-physical collision detection is interesting because they use less computing resources than physical collision detection. You can optimize your game if you find a way to simulate a certain effect in a non-physical way, using mathematical techniques such as ray casting.
+Non-physical collision detection is interesting because it uses less computing resources than physical collision detection. The non-physical calculations are faster because they do not have any side effects such as pushing other objects or bumping off of them. Tasks such as mouse picking are easily implemented using using mathematical techniques such as ray casting and intersections. Experienced developers optimize their games by finding ways to simulate certain (otherwise expensive physical) interactions in a non-physical way.
-One example for an optimization is a physical vehicle's wheels. You could make the wheels fully physical disks, and have jME calculate every tiny force – sounds very accurate, but is total overkill. A more performant solution is to cast four invisible rays down from the vehicle and calculate the intersections with the floor and other obstacles. These non-physical wheels require (in the simplest case) only four calculations to achieve an effect that players can hardly distinguish from the real thing.
+Example: One example for an optimization is a physical vehicle's wheels. You could make the wheels fully physical disks, and have jME calculate every tiny force – sounds very accurate? It's total overkill and too slow for a racing game. A more performant solution is to cast four invisible rays down from the vehicle and calculate the intersections with the floor. These non-physical wheels require (in the simplest case) only four calculations per tick to achieve an effect that players can hardly distinguish from the real thing.
-
-A com.jme3.bounding.BoundingVolume is an interface for dealing with containment of a collection of points. All BoundingVolumes are Collidable and are used as optimization to calculate non-physical collisions more quickly: It's faster to calculate an intersection between simple shapes like spheres and boxes than between complex shapes. In cases where precision is not relevant, you wrap a complex model in a simpler shape to speed up collision detection.
-
-
-
Type.Sphere: com.jme3.bounding.BoundingSphere is a sphere used as a container for a group of vertices of a piece of geometry. A BoundingSphere has a center and a radius.
-
-
Type.AABB = Axis-aligned bounding box. A com.jme3.bounding.BoundingBox is an axis-aligned cuboid used as a container for a group of vertices of a piece of geometry. A BoundingBox has a center and extents from that center along the x, y and z axis.
-
-
Type.OBB = Oriented bounding box. (not in use)
-
-
Type.Capsule = Cylinder with rounded ends. Often used for mobile characters.
-
-
-
-
-
-Note: Physical objects have their own "bounding volumes" called CollisionShapes.
-
-A com.jme3.math.Ray is an infinite line with a beginning, a direction, and no end; whereas a com.jme3.math.Line is an infinite line with only a direction (no beginning, no end).
+A com.jme3.bounding.BoundingVolume is an interface for dealing with containment of a collection of points. All BoundingVolumes are Collidable and are used as optimization to calculate non-physical collisions more quickly: It's always faster to calculate an intersection between simple shapes like spheres and boxes than between complex shapes like models.
-Rays are used to detect where the user or a player is "looking" when performing an action:
+All fast-paced action and shooter games use BoundingVolumes as an optimization. Wrap all complex models into simpler shapes – in the end, you get equally useful collision detection results, but faster.
+
+
+
+Supported types:
+
-
Click to select: You can determine what a user has clicked by casting a ray from the camera in the direction of the camera. Now identify the closest collision of the ray with the rootNode.
+
Type.Sphere: com.jme3.bounding.BoundingSphere is a sphere used as a container for a group of vertices of a piece of geometry. A BoundingSphere has a center and a radius.
+
+
Type.AABB = Axis-aligned bounding box, that means it doesn't rotatewhich makes it less precise. A com.jme3.bounding.BoundingBox is an axis-aligned cuboid used as a container for a group of vertices of a piece of geometry. A BoundingBox has a center and extents from that center along the x, y and z axis.
-
Line of sight: Cast a ray from a player in the direction of another player. Then you detect all collisions of this ray with other entities (walls, foliage, window panes) and use this to calculate whether one can see the other.
+
Type.OBB = Oriented bounding box. This bounding box is more precise because it can rotate with its content, but is computationally more expensive. (Currently not supported.)
+
+
Type.Capsule = Cylinder with rounded ends, also called "swept sphere". Typically used for mobile characters.
-These simple ray-surface intersection tests are called Ray Casting. As opposed to the more advanced Ray Tracing, Ray Casting does not follow a ray's reflection after the first hit, the ray just goes straight on.
+
Note: If you are looking for BoundingVolumes for physical objects, use CollisionShapes.
+
-com.jme3.collision.bih.BIHNode
-com.jme3.scene.CollisionData
+A com.jme3.math.Ray is an infinite line with a beginning, a direction, and no end; whereas a com.jme3.math.Line is an infinite line with only a direction (no beginning, no end).
-
+
+Rays are used to perform line-of-sight calculations. This means you can detect what users were "aiming at" when they clicked or pressed a key. You can also use this to detect whether game characters can see something (or someone) or not.
+
+
+
Click to select: You can determine what a user has clicked by casting a ray from the camera forward in the direction of the camera. Now identify the closest collision of the ray with the rootNode, and you have the clicked object.
+
+
Line of sight: Cast a ray from a player in the direction of another player. Then you detect all collisions of this ray with other entities (walls versus foliage versus window panes) and use this to calculate how likely it is that one can see the other.
These simple but powerful ray-surface intersection tests are called Ray Casting. As opposed to the more advanced Ray Tracing technique, Ray Casting does not follow the ray's reflection after the first hit – the ray just goes straight on.
+
+
+Learn the details of how to implement Mouse Picking here.
+
+
-A com.jme3.collision.SweepSphere implements a collidable "stretched" sphere that is shaped like a capsule (an upright cylinder with half a sphere on top and the second half at the bottom).
-This shape is usually used to simulate simple non-physcial collisions for character entities in games. The sweep sphere can be used to check collision against a triangle or another sweep sphere.
+
A com.jme3.collision.SweepSphere implements a collidable "stretched" sphere that is shaped like a capsule (an upright cylinder with half a sphere on top and the second half at the bottom). This shape is usually used to simulate simple non-physcial collisions for character entities in games. The sweep sphere can be used to check collision against a triangle or another sweep sphere.
\ No newline at end of file
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/custom_meshes.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/custom_meshes.html
index f3abd834a..92db2cafc 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/custom_meshes.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/custom_meshes.html
@@ -34,7 +34,14 @@ Okay, we want to create a Quad. A quad has four vertices, and is made up of two
The base class for creating meshes is com.jme3.scene.Mesh.
-
Mesh m = new Mesh();
+
Mesh mesh = new Mesh();
+
+
+
+If you create your own Mesh-based class, replace mesh by this in the following examples:
+
+
+
public class MyMesh extends Mesh { }
@@ -110,13 +117,13 @@ The Mesh data is stored in a buffer.
The third parameter describes the number of components of the values. Vertex postions are 3 float values, texture coordinates are 2 float values, and the indices are single ints.
-
In order for JMonkey to correctly show the mesh in the scene, it needs to know the bounds of our new mesh. This can easily be achieved by calling the updateBound() method on it.
+
In order for jMonkey to correctly show the mesh in the scene, it needs to know the bounds of our new mesh. This can easily be achieved by calling the updateBound() method on it.
@@ -133,11 +140,11 @@ Our Mesh is ready! Now we want to see it.
We create a com.jme3.scene.Geometry, apply a simple color material to it, and attach it to the rootNode to make it appear in the scene.
-
Geometry geom = new Geometry("OurMesh", m);
-Material mat = new Material(assetManager, "Common/MatDefs/Misc/SolidColor.j3md");
+
Geometry geo = new Geometry("OurMesh", mesh);
+Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
mat.setColor("Color", ColorRGBA.Blue);
-geom.setMaterial(mat);
-rootNode.attachChild(geom);
@@ -161,21 +168,20 @@ There are more vertex buffers in a Mesh than the three shown above. For an overv
-Vertex coloring is a simple way of coloring meshes. Instead of just assigning one solid color, each vertex (corner) has a color assigned. The faces between the vertices are then colored with a gradient.
-We will use the same mesh m as defined above, but with a special VertexColor material.
+Vertex coloring is a simple way of coloring meshes. Instead of just assigning one solid color, each vertex (corner) has a color assigned. The faces between the vertices are then colored with a gradient. You can use the same mesh mesh object that you defined above.
-
Geometry coloredMesh = new Geometry ("ColoredMesh", m);
-Material matVC = new Material(assetManager, "Common/MatDefs/Misc/VertexColor.j3md");
+
Geometry geo = new Geometry ("ColoredMesh", mesh);
+Material matVC = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-We create a float array color buffer.
+You create a float array color buffer:
-
We assign 4 color values, RGBA, to each vertex.
+
Assign 4 color values, RGBA, to each vertex.
-
To loop over the 4 color values, we use a color index
int colorIndex = 0;
+
To loop over the 4 color values, use a color index
int colorIndex = 0;
@@ -193,7 +199,7 @@ We create a float array color buffer.
-We loop over the colorArray buffer to quickly set some RGBA value for each vertex. As usual, RGBA color values range from 0.0f to 1.0f. Note that the values we use here are arbitrarily chosen! It's just a quick loop to give every vertex a different RGBA value (a purplish gray, purple, a greenish gray, green, see screenshot), without writing too much code. For your own mesh, you'd assign values for the color buffer depending on which color you want your mesh to have.
+Loop over the colorArray buffer to quickly set some RGBA value for each vertex. As usual, RGBA color values range from 0.0f to 1.0f. Note that the color values in this example are arbitrarily chosen. It's just a quick loop to give every vertex a different RGBA value (a purplish gray, purple, a greenish gray, green, see screenshot), without writing too much code. For your own mesh, you'd assign meaningful values for the color buffer depending on which color you want your mesh to have.
for(int i = 0; i < 4; i++){
@@ -212,8 +218,8 @@ We loop over the colorArray buffer to quickly set some RGBA value for each verte
Next, set the color buffer. An RGBA color value contains four float components, thus the parameter 4.
-
+The examples used the mesh together with the Unshaded.j3md material. If you want to use the Mesh with a Phong illuminated material (such as Lighting.j3md), the mesh needs to include information about its normals. (The Normals encode in which direction a mesh polygon is facing, which is important for calculating light and shadow.)
+
+
+
float[] normals = new float[12];
+normals = new float[]{0,0,1, 0,0,1, 0,0,1, 0,0,1};
+mesh.setBuffer(Type.Normal, 3, BufferUtils.createFloatBuffer(normals));
+
+
+
+You need as many normals as the polygon has vertices. For a flat quad, they point all in the same direction. In this case, the direction is the Z unit vector (Vector3f.UNIT_Z), this means the quad is facing the camera.
+
-Geometries have Materials (.j3m), Materials are based on material definitions (.j3md). You can write .j3m files in a text editor, or use the jMonkeyEngine SDK to generate them for you.
+A Geometry (mesh) is just the shape of the object. jMonkeyEngine cannot render a shape without knowing anything about its surface properties. You need to apply a color or texture to the surface of your Geometries to make them visible. In jMonkeyEngine, colors and textures are represented as Material objects.
-This table shows you the material definitions that jMonkeyEngine supplies by default. You want to make the most of your models by using the right material parameters. The developers should be in contact with the graphic designer regarding which of the available jMonkeyEngine features individual Materials and Textures require. You must have an understanding what texture maps are to be able to use textured materials.
+All Geometries have Materials: You either use the setters described here to specifiy the Material's properties in your Java code, or you load a custom .j3m file that lists the properties. To improve performance, reuse Materials for similar models, don't create a new Material object for every Geometry. (E.g. use one bark Material for many tree models.)
+
+Each Material is based on one of the default material definitions (.j3md files) that are included in the engine. The Materials table shows you the material definitions that jMonkeyEngine supports by default. You want to make the most of your models by setting good looking material parameters: The developers should be in contact with the graphic designer regarding which of the available jMonkeyEngine features (listed here) are intended to be used in individual Models' Materials. You must have an understanding what texture maps are to be able to use textured materials.
-There are two types of material definitions below, illuminated and unshaded. Illuminated materials look more naturalistic, unshaded ones look more abstract.
+The following samples assume that you loaded a Geometry, e.g. Spatial myGeometry = assetManager.loadModel("Models/Teapot/Teapot.j3o");
+
Material mat = new Material(assetManager, // Create new material and
+ "Common/MatDefs/Misc/Unshaded.j3md"); // specify .j3md file path.
+mat.setColor("Color", ColorRGBA.Blue); // Set one or more parameters.
+myGeometry.setMaterial(mat); // Use material on Geometry.
-Most parameters are not mandatory, even if they are not explicitly marked optional. For example, it is okay to specify solely the DiffuseMap and NormalMap when using Lighting.j3md, and leave the rest empty. You are only using a subset of the available features, but that's fully acceptable if it already results in the material you want. You can always add more texture maps later.
+or
1) Looks confusing? Start with Unshaded.j3md, and then Lighting.j3md.
+Most Material parameters are not mandatory. For example, it is normal to specify solely the DiffuseMap and NormalMap when using Lighting.j3md, and leave the rest empty. You are only using a subset of the advanced features, but that's acceptable if it results in the material looking the way you want. You can always add more texture maps later.
+
+
+
+
1) Looks confusing? Start with Unshaded.j3md, then look into Lighting.j3md.
2) The jMonkeyEngine SDK offers a visual editor where you can set properties and preview the outcome. The SDK Palette contains code snippets to load materials.
-3) If you don't know what an optional setting means, you're likely not using it.
+3) If you don't know what an obscure parameter means, you're likely not using it.
+
+jMonkeyEngine supports illuminated and unshaded Material Definitions.
+
+
+
Phong Illuminated materials look more naturalistic.
-Standard materials look slightly abstract because they ignore light sources. They work even if the scene does not include a light source. They are single-colored or textured and have no shadows.
+"Unshaded" materials look somewhat abstract because they ignore lighting and shading. Unshaded Materials work even if the scene does not include a light source. These Materials can be single-colored or textured. For example, they are used for cards and tiles, for the sky, billboards and UI elements, for toon-style games, or for testing.
-
Basic Material Definition
Usage
Parameter : Type
+
Basic Material Definition
Usage
Parameter
-
Common/MatDefs/Misc/Unshaded.j3md
Standard, non-illuminated Materials. Use this for simple coloring, simple texturing, simple glow, simple transparency.
-See also: Hello Material
ColorMap : Texture
-LightMap : Texture
-Color : Color
-VertexColor : Boolean
-SeparateTexCoord : Boolean
-GlowMap : Texture
-GlowColor: Color
+
Common/MatDefs/Misc/Unshaded.j3md
Standard, non-illuminated Materials.
+Use this for simple coloring and texturing, glow, and transparency.
+See also: Hello Material
A multi-layered texture for terrains.
@@ -93,31 +124,31 @@ Texture regions can overlap.
For example: Specify a seafloor texture for the lowest areas,
a sandy texture for the beaches,
a grassy texure for inland areas,
-and a rocky texture for mountain tops.
Used with texture masks for particle effects, or for point sprites.
The Quadratic value scales the particle for perspective view ().
Does support an optional colored glow effect.
-See also: Hello Effects
-Illuminated materials require a light source added to at least one of their parent nodes! (e.g. rootNode) Illuminated materials are darker on the sides facing away from light sources. They do not automatically cast drop shadows. They use Phong illumination model (default), or the Ward isotropic gaussian specular shader (WardIso) which looks more plastic like.
+Illuminated materials require a light source added to at least one of their parent nodes! (e.g. rootNode.) Illuminated materials are darker on the sides facing away from light sources. They use Phong illumination model (default), or the Ward isotropic gaussian specular shader (WardIso) which looks more like plastic. They do not cast drop shadows unless you use a FilterPostProcessor.
-
Illuminated Material Definition
Usage
Parameters
+
Illuminated Material Definition
Usage
Setter, Parameter, Type
-
Common/MatDefs/Light/Lighting.j3md
Standard lit material with Phong Illumination.
+
Common/MatDefs/Light/Lighting.j3md
Commonly used Material with Phong illumination.
Use this material together with DiffuseMap, SpecularMap, BumpMap (NormalMaps, ParalaxMap) textures.
Supports shininess, transparency, and plain material colors (Diffuse, Ambient, Specular colors).
-See also: Hello Material
- Glowing materials require a FilterPostProcessor!
Same kind of multi-layered splat texture as Terrain.j3md, but with illumination and shading.
@@ -177,69 +208,140 @@ For every 3 splat textures, you need one alpha map.
You can use a total of 11 texture maps in the terrain's splat texture:
Note that diffuse and normal maps all count against that.
For example, you can use a maximum of 9 diffuse textures, two of which can have normal maps;
-or, five textures with both diffuse and normal maps.
Diffuse : Color
-Ambient : Color
-Shininess : Float
-Specular : Color
-SpecularMap : Texture
-WardIso : Boolean
-useTriPlanarMapping : Boolean
-isTerrainGrid : Boolean
-Texture Splat Maps
-DiffuseMap : Texture
-DiffuseMap_0_scale : Float
-NormalMap : Texture
-DiffuseMap_1 : Texture
-DiffuseMap_1_scale : Float
-NormalMap_1 : Texture
-DiffuseMap_2 : Texture
-DiffuseMap_2_scale : Float
-NormalMap_2 : Texture
-DiffuseMap_3 : Texture
-DiffuseMap_3_scale : Float
-NormalMap_3 : Texture
+or, five textures with both diffuse and normal maps.
Reflective glass material with environment map (CubeMap/SphereMap). See also:
Texture : Texture
-SphereMap: Boolean
+
Material Definition
Usage
+
+
+
Common/MatDefs/Misc/ShowNormals.j3md
A color gradient calculated from the model's surface normals. You can use this built-in material to debug the generation of normals in meshes, to preview models that have no material, or as fall-back default material. This built-in material has no parameters.
Shininess Tip: To deactivate Shininess, do not set Shininess to 0, but instead set the Specular color to ColorRGBA.Black!
-
+A NormalMap (alos called BumpMap) describes the fine bumpy details of the Material surface that are not part of the mesh itself. E.g. cracks, pores, creases, notches.
+
+
Generate normals for the Mesh (not for the Geometry!)
Bumpiness Tip: Before you can use NormalMaps, you must generate normals for the mesh (not the Geometry). TangentBinormalGenerator.generate(mesh);
-
+
+To activate Shininess:
+
+
Specify the Shininess intensity.
+A float value between 1 (rough surface with blurry shininess) and 128 (very smooth surface with focused shininess)
+
+
Specify a Color as Specular value.
+The ColorRGBA value of the light source, e.g. often RGBA.White.
+
+
(Optionally for some Materials) Specify a SpecularMap texture.
+This grayscale texture outlines in detail where the DiffuseMap texture should be shiny (white) and were not (black), instead of rendering the whole material evenly shiny.
+
+
+
+
+
+To deactivate shininess
+
+
+
Set the Specular color to ColorRGBA.Black. Do not just set Shininess to 0.
A color gradient calculated from the model's surface normals. You can use this built-in material to test models that have no material, or as fall-back default material.
Specify a Color as Glow value.
+A ColorRGBA value of your choice, e.g. choose a warm or cold color for different effects.
+
+
(Optionally for some Materials) Specify a GlowMap texture.
+This texture outlines in detail where the DiffuseMap texture glows, instead of making the whole material glow everwhere evenly.
Additive alpha blending adds colors in a commutative way, i.e. the result does not depend on the order of transparent layers. Adds the scene's background pixel color to the current pixel color. Note that viewed in front of a white scene, these textures become fully transparent. This is useful if you have many transparent textures overlapping.
Used for particle effect textures that have a black color background.
Additive alpha blending adds colors in a commutative way, i.e. the result does not depend on the order of transparent layers, since it adds the scene's background pixel color to the current pixel color. This is useful if you have lots of transparent textures overlapping and don't care about the order.
+Viewed in front of a white background, Additive textures become fully transparent!
Used for particle effect textures that have a black color background.
Pre-multiplied alpha blending. E.g. if the color of the object has already been multiplied by its alpha, this is used instead of "Alpha" blend mode.
For use with Premult Alpha textures.
-
+
-Also note the AlphaDiscardThreshold value for materials based on Lighting.j3md. The renderer does not render pixels whose transparancy is below the threshold.
+
For partially transparent Materials based on Lighting.j3md, consider setting the AlphaDiscardThreshold value. The renderer only renders pixels above your alpha threshold, and does not render pixels below the threshold. This means, that gradients in the AlphaMap are no longer interpreted as soft translucency, but parts of the texture become either fully opaque or fully transparent. You typically activate Alpha Testing for partially transparent objects such as foliage, hair, etc.
+
+
Activate back-face culling. Mesh faces that are not visible are not rendered, which saves time. Backface culling is activated by default as an optimization.
Activate back-face culling. Mesh faces that are not facing the camera are not rendered, which saves time. Backface culling is activated by default as a major optimization.
The backside of mesh polygons (and the inside of models) is invisible.
Activate both back- and frontface culling. Use this as an efficient way to make an object temporarily invisible. All it's other in-game properties, collision shapes, interactions, etc remain active.
Use this as an efficient way to make an object temporarily invisible, while keeping all its other in-game properties (node attachment, collision shapes, interactions, etc) active.
Enables point-sprite mode, so meshes with "Mode.Points" will be rendered as textured sprites. Note that gl_PointCoord must be set in the shader. Point sprites are used for hardware accelerated particle effects.
+
getAdditionalRenderState().setPointSprite(true);
Enables point-sprite mode, e.g. meshes with "Mode.Points" will be rendered as textured sprites. Note that gl_PointCoord must be set in the shader.
Point sprites are used internally for hardware accelerated particle effects.
-
mat.getAdditionalRenderState().setPolyOffset();
Enable polygon offset. Use this when you have meshes that have triangles really close to each over (e.g. ), it will shift the depth values to prevent .
+
getAdditionalRenderState().setPolyOffset();
Enable polygon offset.
Use this when you have meshes that have triangles really close to each over (e.g. ), it will shift the depth values to prevent .
-
+
1)
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/nurbs_3-d_surface.png b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/nurbs_3-d_surface.png
new file mode 100644
index 000000000..b22f7090d
Binary files /dev/null and b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/nurbs_3-d_surface.png differ
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/physics.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/physics.html
index 65d3cee1f..a1324adcf 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/physics.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/advanced/physics.html
@@ -444,15 +444,9 @@ Use the following methods to move physics objects.
applyForce(…)
Move (push) the object once with a certain moment, expressed as a Vector3f. Optionally, you can specify where on the object the pushing force hits.
-
-
applyContinuousForce(…)
Keep moving (pushing) the object with continuous force in one direction, expressed as a Vector3f. Optionally, you can specifiy where on the object the pushing force hits. You can applyContinuousForce(false) to stop the force.
-
applyTorque(…)
Rotate (twist) the object once around its axes, expressed as a Vector3f.
-
-
applyContinuousTorque(…)
Keep rotating (twisting) the object continuously around its axes, expressed as a Vector3f. You can applyContinuousTorque(false) to stop the rotation.
-
applyImpulse(…)
An idealised change of momentum. This is the kind of push that you would use on a pool billiard ball.
@@ -466,7 +460,7 @@ Use the following methods to move physics objects.
clearForces()
Cancels out all forces (force, torque) etc and stops the motion.
-
+
Note: It is technically possible to position PhysicsControls using setLocalTranslation(), e.g. to place them in their start position in the scene. However you must be very careful not to cause an "impossible state" where one physical object overlaps with another! Within the game, you typically use the setters shown here exclusively.
@@ -501,7 +495,7 @@ removeCollideWithGroup(COLLISION_GROUP_01)
Collision Groups are integer
setSleepingThreshold(float,float)
Sets the sleeping thresholds wich define when the object gets deactivated to save ressources. Low values keep the object active when it barely moves. The first value is the linear threshold and the second the angular.
+
Do not mix up these visible Shapes with similarly named classes from the maths package. Choose the right package when letting your IDE fill in the import statements!
@@ -70,7 +88,6 @@ Do not mix up these visible Shapes with similarly named classes from the maths p
These maths objects are invisible and are used for collision testing (ray casting) or to describe motion paths. They cannot be wrapped into a Geometry.
-
@@ -80,7 +97,7 @@ These maths objects are invisible and are used for collision testing (ray castin
-
@@ -119,11 +136,7 @@ You can compose more complex custom Geometries out of simple Shapes. Think of th
-The order is important: First arrange around origin, then transform. Otherwise, transformations are applied around the wrong center (pivot). Of course, you can attach your constellation to other pivot Nodes to create even more complex shapes (a chair, a furnished room, a house, a city, …), but again, arrange them around the origin first before you transform them.
-
-
-Note: Obviously, these composed Geometries are simpler than hand-sculpted meshes from a mesh editor.
-
+The order is important: First arrange around origin, then transform. Otherwise, transformations are applied around the wrong center (pivot). Of course, you can attach your constellation to other pivot Nodes to create even more complex shapes (a chair, a furnished room, a house, a city, …), but again, arrange them around the origin first before you transform them. Obviously, such composed Geometries are simpler than hand-sculpted meshes from a mesh editor.
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/android.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/android.html
index 9f92a39e0..39fd9bd2f 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/android.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/android.html
@@ -11,9 +11,12 @@ This is a draft of a feature that is work in progress. If you have questions or
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/beginner/hello_main_event_loop.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/beginner/hello_main_event_loop.html
index 722f15739..13cf92c6f 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/beginner/hello_main_event_loop.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/beginner/hello_main_event_loop.html
@@ -109,22 +109,37 @@ A rotating object is just a simple example. In the update loop, you typically ha
-Note the contrast: The simpleUpdate() method runs repeatedly, while the simpleInitApp() method is executed only once, right at the beginning. These two are the most important methods in a SimpleApplication-derived game. From these two methods, you create other class instances (your game data) and change their properties (your game state).
+Note the contrast:
+
+
+
The simpleInitApp() method is executed only once, right at the beginning;
+
+
The simpleUpdate() method runs repeatedly, during the game.
+
+
After every update, the jMonkeyEngine automatically redraws (renders) the screen for you!
+
+
+
+
+
+Since rendering is automatic, initialization and updating are the two most important concepts in a SimpleApplication for you right now. These methods are where you load and create game data (once), and (repeatedly) change their properties to update the game state:
simpleInitApp() is the application's "first breath".
-
simpleUpdate() is the application's heartbeat.
+
simpleUpdate() is the application's heartbeat.
+The update time unit is called ticks.
-Basically everything in your game happens in either one or the other method. This means that these methods grow very long over time. There are two strategies how advanced developers can spread out their init and update code over several Java classes:
+
+
Everything in a game happens either during initialization or during the update loop. This means that these two methods grow very long over time. There are two strategies how experienced developers spread out their init and update code over several Java classes:
Move code blocks from the simpleInitApp() method to AppStates.
@@ -134,7 +149,9 @@ Basically everything in your game happens in either one or the other method. Thi
-Keep this in mind for later when your game application grows.
+Keep this in mind for later when your application grows.
+
+
+
+Batching means that all Geometries with the same Material are combined into one mesh. This optimization only has an effect if you use only few (roughly up to 32) Materials total. The pay-off is that batching takes extra time when the game is initialized.
+
+
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/intermediate/headlessserver.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/intermediate/headlessserver.html
index 9ae2df3e9..7ad98c7fa 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/intermediate/headlessserver.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/intermediate/headlessserver.html
@@ -47,7 +47,8 @@
-
+
+
@@ -150,7 +151,7 @@ var NS='jme3:intermediate';var JSINFO = {"id":"jme3:intermediate:headlessserver"
-
+
@@ -306,7 +307,7 @@ You've followed a link to a topic that doesn't exist yet. If permissio
-
+
@@ -348,16 +349,9 @@ You've followed a link to a topic that doesn't exist yet. If permissio
-
-
-
-
-
-
-
-
+
-
+
diff --git a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/terminology.html b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/terminology.html
index 6f9c9d31f..45855ebcc 100644
--- a/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/terminology.html
+++ b/sdk/jme3-core/javahelp/com/jme3/gde/core/docs/jme3/terminology.html
@@ -53,6 +53,10 @@ The jME Context makes settings, renderer, timer, input and even
@@ -60,12 +64,8 @@ The jME Context makes settings, renderer, timer, input and even
-Coordinates represent a location in a coordinate system, relative to the origin (0,0,0). m. In 3D space, you need to specify three coordinate values to locate a point: x,y,z.
-As opposed to a vector (which looks similar), a coordinate does not have a "direction".
-
-
-
-
+Coordinates represent a location in a coordinate system. Coordinates are relative to the origin at (0,0,0). In 3D space, you need to specify three coordinate values to locate a point: X (right), Y (up), Z (towards you).
+In contrast to a vector (which looks similar), a coordinate is a location, not a direction.
@@ -75,8 +75,11 @@ As opposed to a vector (which looks similar), a coordinate does not have a "
-The origin is the central point in the 3D world. It's at the coordinates (0,0,0).
-Code sample: Vector3f origin = new Vector3f( Vector3f.ZERO );
+The origin is the central point in the 3D world, where the three axes meet. It's at the coordinates (0,0,0).
+
+
+
+Example:Vector3f origin = new Vector3f( Vector3f.ZERO );
-A vector has a length and a direction. It is used like an arrow pointing at a point in 3D space. A vector starts at the origin (0,0,0), and ends at the target coordinate (x,y,z). Backwards directions are expressed with negative values.
-Code sample: Vector3f v = new Vector3f( 17 , -4 , 0 );
+A vector has a length and a direction, like an arrow in 3D space. A vector starts at the origin (0,0,0), and ends at the target coordinate (x,y,z). Backwards directions are expressed with negative values.
+
+
+
+Example:Vector3f v = new Vector3f( 17 , -4 , 0 );
@@ -131,12 +137,12 @@ When you normalize a vector, it still has the same direction, but you lose the i
-
-
-A surface normal is a vector that is perpendicular to a plane.
+
+A surface normal is a vector that is perpendicular (orthogonal) to a plane.
You calculate the Surface Normal by calculating the cross product.
@@ -288,7 +294,13 @@ Set the Specular color to ColorRGBA.Black to switch off shininess.
Textures are part of Materials. In the simplest case, an object could have just one texture, the Color Map, loaded from one image file. When you think back of old computer games you'll remember this looks quite plain.
+
+
+
The more information you (the game designer) provide additionally to the Color Map, the higher the degree of detail and realism. Whether you want photo-realistic rendering or "toon" rendering (Cel Shading), everything depends on the quality of your materials and texture maps. Modern 3D graphics use several layers of information to describe one material, each layer is a Texture Map.
+
You have no textures? (including texture maps) from opengameart.org.
+
+
@@ -298,44 +310,39 @@ The more information you (the game designer) provide additionally to the Color M
-
-Bump maps are used to describe detailed shapes that would be too hard or simply too inefficient to sculpt in a mesh editor. You use Normal Maps to model cracks in walls, rust, skin texture, or a canvas weave. You use Height Maps to model whole terrains with valleys and mountains.
@@ -362,11 +369,11 @@ Bump maps are used to describe detailed shapes that would be too hard or simply
-
A well-done Normal Map makes a shape more detailed–without the need to add costly polygons to the mesh. It contains shading information that makes the object appear smoother and more fine-grained.
+
A well-done Normal Map makes a shape more detailed – without the need to add costly polygons to the mesh. It contains shading information that makes the object appear smoother and more fine-grained.
-
The Normal Map is displayed looking like a false-color version of the Color Map–but it is never used for coloring, instead, each RGB value encodes transformation data. This displacement data is represented by Surface Normals of the slopes, hence the name.
+
When you open a Normal Map in an image editor, it looks like a false-color version of the Color Map. Normal maps however are never used for coloring, instead, each the color values encode displacement data of bumps and cracks on the surface. Displacement data is represented by the Surface Normals of the slopes, hence the name.
-
It's hard to draw normal maps by hand. Generally you use software tools to calculate them off 3D models.
+
You cannot draw normal maps by hand, professional designers use software to calculate them off high-quality 3D models.
@@ -381,9 +388,9 @@ Bump maps are used to describe detailed shapes that would be too hard or simply
A Specular Map further improves the realism of an object's surface: It contains extra information about shininess and makes the shape appear more realistically illumated.
-
Start out with a gray value that corresponds to the average shininess/dullness of this material. Then add ligher grays for smoother, shinier, more reflective areas; and darker grays for duller, rougher, worn-out areas. The resulting image file looks similar to a grayscale version of the Color Map.
+
Start out with a copy of the Diffuse Map in a medium gray that corresponds to the average shininess/dullness of this material. Then add ligher grays for smoother, shinier, more reflective areas; and darker grays for duller, rougher, worn-out areas. The resulting image file looks similar to a grayscale version of the Diffuse Map.
-
You can use colors in a specular map to create certain reflective effects (iridiscence, metallic).
+
You can use colors in a specular map to create certain reflective effects (fake iridiscence, metallic effect).
@@ -394,9 +401,11 @@ Bump maps are used to describe detailed shapes that would be too hard or simply
-This is a very simple, commonly used type of texture. When texturing a wide area (e.g. walls, floors), you don't create one huge texture, instead you tile a small texture repeatedly to fill the area.
-A seamless texture is an image file that has been designed so that it can be used as tiles: The right edge matches the left edge, and the top edge matches the bottom edge. The onlooker cannot easily tell where one starts and the next one ends, thus creating an illusion of a huge texture. The downside is that the tiling becomes painfully obvious when the area is viewed from a distance. Also you cannot use it on more complex models such as characters.
+Tiles are a very simple, commonly used type of texture. When texturing a wide area (e.g. walls, floors), you don't create one huge texture – instead you tile a small texture repeatedly to fill the area.
+
+
+A seamless texture is an image file that has been designed so that it can be used as tiles: The right edge matches the left edge, and the top edge matches the bottom edge. The onlooker cannot easily tell where one starts and the next one ends, thus creating an illusion of a huge texture. The downside is that the tiling becomes painfully obvious when the area is viewed from a distance. Also you cannot use it on more complex models such as characters.
@@ -410,7 +419,7 @@ A seamless texture is an image file that has been designed so that it can be use
-Creating a texture for a cube is easy – but what about a character with a face and extremities? For more complex objects, you design the texture in the same ways as a sewing pattern: One image file contains the outline of the front, back, and side of the object, next to one another. Specific areas of the flat texture (UV coordinates) map onto certain areas of your 3D model (XYZ coordinates), hence the name UV map. Using UV Maps, models can have a different texture on each side.
+Creating a texture for a cube is easy – but what about a character with a face and extremities? For more complex objects, you design the texture in the same ways as a flat sewing pattern: One image file contains the outline of the front, back, and side of the object, next to one another. Specific areas of the flat texture (UV coordinates) map onto certain areas of your 3D model (XYZ coordinates), hence the name UV map. Using UV Maps, one model can have different textures on each side.
@@ -428,8 +437,11 @@ Getting the seams and mappings right is crucial: You must use a graphic tool lik
-Environment Maps are used to create the impression of reflections and refractions. You create a Cube Map to represent your environment, similar to a skybox. (Sphere Maps are possible, but often look too distorted.) You give the Cube Map a set of images showing a "360° view" of the completed scene. The renderer uses this as base to texture the reflective surface.
-Of course these reflections are static and not "real", e.g. the player will not see his avatar's face reflected, etc… But they cause the desired "glass/mirror/water" effect, and are fast enough to render in real usecases, it's better than nothing.
+Environment Maps are used to create the impression of reflections and refractions. You create a Cube Map to represent your environment, similar to a skybox. (Sphere Maps are possible, but often look distorted.) You give the Cube Map a set of images showing a "360° view" of the completed scene. The renderer uses this as base to texture the reflective surface.
+
+
+
+Of course the reflected environment is static and not "real", e.g. the player will not see his avatar's face reflected, etc. But EnvMaps cause the desired "glass/mirror/water" effect, and are fast enough to render in real usecases.
@@ -439,7 +451,7 @@ Of course these reflections are static and not "real", e.g. the player
-You provide the texture in two or three resolutions to be stored in one file (MIP = "multum in parvo" = "many in one"). Depending on how close (or far) the camera is, the engine automatically renders a more (or less) detailed texture for the object. Thus objects look smooth from close up, but don't waste resources with unspottable details when far away. Good for everything, but requires more time to create and more space to store textures.
+MIP Map means that you provide one texture in two or three resolutions in one file (MIP = "multum in parvo" = "many in one"). Depending on how close (or far) the camera is, the engine automatically renders a more (or less) detailed texture for the object. Thus objects look smooth from close up, but don't waste resources with unspottable details when far away. Good for everything, but requires more time to create and more space to store textures. If you don't provide custom ones, the jMonkeyEngine creates basic MIP maps automatically as an optimization.
@@ -449,7 +461,7 @@ You provide the texture in two or three resolutions to be stored in one file (MI
-A procedural texture is generated from repeating one small image, plus some pseudo-random, gradient variations (Perlin noise). Procedural textures look more natural than static rectangular textures, for instance, they look less distorted on spheres. On big meshes, their repetitiveness is much less noticable than tiled seamless textures. Procedural textures are ideal for irregular large-area textures like grass, soil, rock, rust, and walls. See also:
+A procedural texture is generated from repeating one small image, plus some pseudo-random, gradient variations (called Perlin noise). Procedural textures look more natural than static rectangular textures, and they look less distorted on spheres. On big meshes, their repetitiveness is much less noticable than with tiled seamless textures. Procedural textures are ideal for irregular large-area textures like grass, soil, rock, rust, and walls. Use the to create them.
+
+A surface normal is a vector that is perpendicular (orthogonal) to a plane.
You calculate the Surface Normal by calculating the cross product.