update wiki for v0.1

Author: riccardobl

docs/components/index.md

@@ -28,13 +28,12 @@ public interface Component<T> {
 ## Fragments
 !!! abstract "See [Fragment Javadoc](https://javadoc.ngengine.org/org/ngengine/components/fragments/Fragment.html)"
 
-Fragments are interfaces that extend a component’s functionality. By implementing one or more fragment interfaces (e.g., `MainViewPortFragment`, `LogicFragment`), a component signals which engine systems it needs. The manager detects these fragments and handles their lifecycle in a predefined order:
+Fragments are interfaces that extend a component’s functionality. By implementing one or more fragment interfaces (e.g., `AssetLoadingFragment`, `LogicFragment`), a component signals which engine systems it needs. The manager detects these fragments and handles their lifecycle in a predefined order:
 
-1. **Initialization** (`receiveXXX` methods)  
-2. **Loading** (`loadXXX` methods)  
-3. **Enable** (via the component’s `onEnable`)  
-4. **Update** (`updateXXX` methods called on each update tick)  
-5. **Disable** (via the component’s `onDisable`)
+1. **Load** (`loadXXX` methods)  
+2. **Enable** (via the component’s `onEnable`)  
+3. **Update** (`updateXXX` methods called on each update tick)  
+4. **Disable** (via the component’s `onDisable`)
 
 This composition-based design avoids deep inheritance hierarchies. Each fragment represents hooks into specific engine subsystems, allowing the component to participate in various aspects of the game/application lifecycle without being tightly coupled to the engine.
 
@@ -81,4 +80,37 @@ from there you should proceed to implement as many fragments as needed, until yo
     ```
 
 
-A list of available fragments can be found in the [Javadoc](https://javadoc.ngengine.org/org/ngengine/components/fragments/package-summary.html).
+A list of available fragments can be found in the [Javadoc](https://javadoc.ngengine.org/org/ngengine/components/fragments/package-summary.html).
+
+
+ 
+
+## Accessing Engine Objects
+
+Components sometimes need to interact with core engine objects such as input, rendering, or asset management.
+A common but discouraged approach is to inject these dependencies manually (e.g., via constructors or setters). This makes components harder to reuse and more tightly bound to a specific initialization context.
+
+Instead, you should retrieve global engine objects through [`ComponentManager.getGlobalInstance(Class)`](https://javadoc.ngengine.org/org/ngengine/components/ComponentManager.html#getGlobalInstance%28java.lang.Class%29).
+From any point where you have access to a `ComponentManager`, you can request the object class you need.
+
+### Commonly Available Objects
+
+| Class                                  | Description                                                        |
+| -------------------------------------- | ------------------------------------------------------------------ |
+| `com.jme3.input.InputManager`          | Manages input devices, used for advanced input handling            |
+| `com.jme3.renderer.RenderManager`      | Controls low-level rendering features                              |
+| `org.ngengine.store.DataStoreProvider` | Provides access to the persistent data store                       |
+|  |   |
+|  |   |
+| `com.jme3.asset.AssetManager`          | Loads assets synchronously                                         |
+| `org.ngengine.AsyncAssetManager`       | Loads assets synchronously or asynchronously                       |
+|  |   |
+|  |   |
+| `com.jme3.renderer.ViewPort`           | Represents the main scene ViewPort                                 |
+| `com.jme3.renderer.Camera`             | Camera associated with the main ViewPort                           |
+| `org.ngengine.ViewPortManager`         | Provides access to all ViewPorts, including main and GUI ViewPorts |
+|  |   |
+|  |   |
+| `com.jme3.app.Application`             | Legacy: current jME3 Application instance (avoid if possible)      |
+| `com.jme3.app.state.AppStateManager`   | Legacy: manages AppStates (avoid if possible)                      |
+

docs/lights.md

@@ -18,9 +18,13 @@ You control the color and intensity of each light source. Typically you set the
 You can choose to use lights in other colors than white, or darker colors. This influences the scene’s atmosphere and will make the scene appear colder (e.g. `ColorRGBA.Cyan`) or warmer (`ColorRGBA.Yellow`), brighter (higher values) or darker (lower values).
 
 
-Lights attached to a spatial will illuminate only the spatial itself and its children. If you want to illuminate the entire scene, you should attach lights to the root node.
+Lights attached to a spatial will illuminate only the spatial itself and its children. If you want to illuminate the entire scene, you should initialize them as **global** lights by passing `true` as `global` parameter to the light constructor.
 
-You can get a list of all lights added to a Spatial by `calling getWorldLightList()` (includes inherited lights) or `getLocalLightList()` (only directly added lights), and iterating over the result.
+```java
+PointLight globalLight = new PointLight(true);
+```
+
+You can get a list of all lights added to a Spatial by `calling getWorldLightList()` (includes inherited lights and global lights) or `getLocalLightList()` (only directly added lights), and iterating over the result.
 
 
 ## PointLight
@@ -33,7 +37,7 @@ A PointLight has a location and shines from there in all directions as far as it
 !!! example "Example: Lamp, lightbulb, torch, candle"
 
 ```java
-PointLight lamp_light = new PointLight();
+PointLight lamp_light = new PointLight(true); // global light
 lamp_light.setColor(ColorRGBA.Yellow);
 lamp_light.setRadius(4f);
 lamp_light.setPosition(new Vector3f(lamp_geo.getLocalTranslation()));
@@ -51,7 +55,7 @@ A DirectionalLight has no position, only a direction. It sends out parallel beam
 !!! example "Example: Sun light"
 
 ```java
-DirectionalLight sun = new DirectionalLight();
+DirectionalLight sun = new DirectionalLight(true); // global light
 sun.setColor(ColorRGBA.White);
 sun.setDirection(new Vector3f(-.5f,-.5f,-.5f).normalizeLocal());
 rootNode.addLight(sun);
@@ -67,7 +71,7 @@ A SpotLight sends out a distinct beam or cone of light. A SpotLight has a direct
 !!! example "Example: Flashlight"
 
 ```java
-SpotLight spot = new SpotLight();
+SpotLight spot = new SpotLight(true); // global light
 spot.setSpotRange(100f);                           // distance
 spot.setSpotInnerAngle(15f * FastMath.DEG_TO_RAD); // inner light cone (central beam)
 spot.setSpotOuterAngle(35f * FastMath.DEG_TO_RAD); // outer light cone (edge of the light)
@@ -86,7 +90,7 @@ An AmbientLight simply influences the brightness and color of the scene globally
 !!! example "Example: Regulate overall brightness, tinge the whole scene in a warm or cold color"
 
 ```java
-AmbientLight al = new AmbientLight();
+AmbientLight al = new AmbientLight(); // local light
 al.setColor(ColorRGBA.White.mult(1.3f));
 rootNode.addLight(al);
 ```