feat:Improve README.md

Author: Eatgrapes

README.md

@@ -1,17 +1,29 @@
 # Live2D-JavaBinding
 
-A Native Java binding for the Live2D Cubism SDK.
+A native Java binding for the [Live2D Cubism SDK](https://www.live2d.com/en/products/cubism-sdk), enabling seamless integration of Live2D models in Java applications.
 
 > **Status: Work in Progress**  
-> This project is currently under development
+> This project is currently under active development. Contributions are welcome!
 
 ## Features
 
-- **Distributed Separately**: Java logic and native binaries are decoupled. Native JARs are self-contained (statically linked with Cubism Core).
-- **Cross-Platform**: Supports Windows (x64), Linux (x64, arm64), and macOS (x64, arm64).
-- **Simple API**: Easy-to-use Apis to rendering.
+- **Decoupled Distribution**: Java logic and native binaries are separated for flexibility. Native JARs are fully self-contained.
+- **Cross-Platform Support**: Compatible with Windows (x64), Linux (x64, arm64), and macOS (x64, arm64).
+- **Simple and Intuitive API**: Easy-to-use interfaces for model loading, rendering, and interaction.
+- **JNI Integration**: Leverages Java Native Interface (JNI) for high-performance native code execution.
 
-## Quick Usage example
+## About JNI Integration
+
+JNI (Java Native Interface) is a programming framework that enables Java code to interact with native applications and libraries written in languages like C or C++. In this project:
+
+- JNI bridges the Java API (in the `binding/` directory) with the native C++ implementation of the Live2D Cubism SDK (in the `native/` directory).
+- The native components are built using CMake and compiled into platform-specific shared libraries, which are bundled into JAR files for easy distribution.
+
+For more details on JNI, refer to the [official Oracle JNI documentation](https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/jniTOC.html).
+
+## Quick Start
+
+Here's a simple example to get you up and running:
 
 ```java
 import dev.eatgrapes.live2d.CubismFramework;
@@ -23,49 +35,60 @@ CubismFramework.initialize();
 
 // 2. Load Model & Components
 CubismUserModel model = new CubismUserModel();
-model.loadModel(moc3Bytes);
-model.loadPose(poseBytes);
-model.loadPhysics(physicsBytes);
+model.loadModel(moc3Bytes);     // Load model data
+model.loadPose(poseBytes);      // Load pose data
+model.loadPhysics(physicsBytes); // Load physics data
 
 // 3. Setup Renderer
 model.createRenderer();
-model.registerTexture(0, openGLTextureId);
+model.registerTexture(0, openGLTextureId); // Bind textures
 
-// 4. Interaction & Motion
-model.setDragging(nx, ny); // Eye tracking
+// 4. Handle Interactions & Motions
+model.setDragging(nx, ny); // Enable eye tracking or dragging
 model.startMotion(motionBytes, priority, loop, name -> {
-    System.out.println("Motion finished!");
+    System.out.println("Motion finished!"); // Callback on completion
 });
 
-// 5. Update & Draw (in your render loop)
-model.update(deltaTime);
-model.draw(mvpMatrix);
+// 5. Update & Draw (in your main render loop)
+model.update(deltaTime); // Update model state
+model.draw(mvpMatrix);   // Render the model
 ```
 
 ## Project Structure
 
-- `binding/`: Java API and module definitions.
-- `native/`: JNI implementation and CMake build scripts.
-- `scripts/`: Python build automation for all platforms.
-- `example/`: A complete Maven-based example using LWJGL 3
+- **`binding/`**: Contains the Java API definitions and module configurations.
+- **`native/`**: Houses the JNI C++ implementation, along with CMake build scripts for native compilation.
+- **`scripts/`**: Python scripts for automating builds across all supported platforms.
+- **`example/`**: A complete Maven-based demo project using LWJGL 3 for OpenGL integration.
+
+## Building the Project
 
-## Building
+### Prerequisites
+- Python 3.x
+- CMake 3.10+
+- A C++14-compatible compiler (e.g., GCC, Clang, or MSVC)
+- JDK 9 or higher
 
-Requires Python 3, CMake, a C++14 compiler, and JDK 9+.
+### Build Command
+Run the following in the project root:
 
 ```bash
 python3 scripts/build.py
 ```
 
-The artifacts will be generated in the `out/` directory:
-- `live2d-shared.jar` (Java API)
-- `live2d-native-[platform].jar` (Self-contained Native Library)
+This will generate artifacts in the `out/` directory:
+- `live2d-shared.jar`: The core Java API.
+- `live2d-native-[platform].jar`: Platform-specific native libraries (e.g., `live2d-native-windows-x64.jar`).
 
 ## Contributing
 
-Pull Requests (PRs) are welcome! Help us implement more SDK features or improve platform compatibility.
+We welcome Pull Requests (PRs)! Whether it's implementing additional SDK features, enhancing platform support, or fixing bugs, your help is appreciated. Please follow these steps:
+1. Fork the repository.
+2. Create a feature branch.
+3. Commit your changes.
+4. Open a PR with a clear description.
 
 ## License
 
-- **Binding Code**: Distributed under the [MIT License](LICENSE).
-- **Live2D Cubism SDK**: The use of the underlying SDK is governed by the [Live2D Open Software License Agreement](https://www.live2d.com/eula/live2d-open-software-license-agreement_en.html). You must agree to their terms to use the native components.
+- **Binding Code**: Licensed under the [MIT License](LICENSE).
+- **Live2D Cubism SDK**: Usage is subject to the [Live2D Open Software License Agreement](https://www.live2d.com/eula/live2d-open-software-license-agreement_en.html). You must review and agree to their terms before using the native components.