Merge pull request #314 from AlmasB/0.3.2

0.3.2

Author: AlmasB

README.md

@@ -10,7 +10,7 @@ JavaFX Game Development Framework
 
 ## Why?
 
-* No native libraries, 0 setup required
+* No native libraries, no setup required
 * Simple and clean API
 * Brings real-world game development techniques to JavaFX
 
@@ -61,7 +61,7 @@ public class BasicGameApp extends GameApplication {
 <dependency>
     <groupId>com.github.almasb</groupId>
     <artifactId>fxgl</artifactId>
-    <version>0.3.1</version>
+    <version>0.3.2</version>
 </dependency>
 ```
 
@@ -73,7 +73,7 @@ repositories {
 }
 
 dependencies {
-    compile 'com.github.almasb:fxgl:0.3.1'
+    compile 'com.github.almasb:fxgl:0.3.2'
 }
 ```
 

fxgl-ai/pom.xml

@@ -32,7 +32,7 @@
     <parent>
         <artifactId>fxgl-framework</artifactId>
         <groupId>com.github.almasb</groupId>
-        <version>0.3.1</version>
+        <version>0.3.2</version>
     </parent>
 
     <artifactId>fxgl-ai</artifactId>

fxgl-core/pom.xml

@@ -32,7 +32,7 @@
     <parent>
         <artifactId>fxgl-framework</artifactId>
         <groupId>com.github.almasb</groupId>
-        <version>0.3.1</version>
+        <version>0.3.2</version>
     </parent>
 
     <artifactId>fxgl-core</artifactId>

fxgl-core/src/main/java/com/almasb/fxgl/core/math/FXGLMath.java

@@ -30,14 +30,18 @@
 
 package com.almasb.fxgl.core.math;
 
+import javafx.geometry.Point2D;
+import javafx.scene.paint.Color;
+
 import java.util.Random;
 
 /**
  * Utility and fast math functions.
  * Thanks to Riven on JavaGaming.org for the basis of sin/cos/floor/ceil.
  *
  * @author Nathan Sweet
- **/
+ * @author Almas Baimagambetov (AlmasB) ([email protected])
+ */
 public final class FXGLMath {
 
     private FXGLMath() {}
@@ -292,6 +296,31 @@ public static float randomTriangular(float min, float max, float mode) {
         return max - (float) Math.sqrt((1 - u) * d * (max - mode));
     }
 
+    /**
+     * @return new random vector of unit length as Vec2
+     */
+    public static Vec2 randomVec2() {
+        return new Vec2(random(-1f, 1f), random(-1f, 1f)).normalizeLocal();
+    }
+
+    /**
+     * @return new random vector of unit length as Point2D
+     */
+    public static Point2D randomPoint2D() {
+        double x = random(-1f, 1f);
+        double y = random(-1f, 1f);
+
+        double length = Math.sqrt(x * x + y * y);
+        if (length < EPSILON)
+            return Point2D.ZERO;
+
+        return new Point2D(x / length, y / length);
+    }
+
+    public static Color randomColor() {
+        return Color.color(random(), random(), random());
+    }
+
     /* RANDOM END */
 
     public static float sqrt(float x) {
@@ -353,6 +382,16 @@ public static double clamp(double value, double min, double max) {
         return value;
     }
 
+    /**
+     * Map value of a given range to a target range.
+     *
+     * @param value the value to map
+     * @return mapped value
+     */
+    public static double map(double value, double currentRangeStart, double currentRangeStop, double targetRangeStart, double targetRangeStop) {
+        return targetRangeStart + (targetRangeStop - targetRangeStart) * ((value - currentRangeStart) / (currentRangeStop - currentRangeStart));
+    }
+
     /**
      * @param fromValue start value
      * @param toValue end value
@@ -514,4 +553,12 @@ public static float log2(float value) {
     public static BezierSpline closedBezierSpline(Vec2[] points) {
         return ClosedBezierSplineFactory.newBezierSpline(points);
     }
+
+    /**
+     * @param t current time * frequency (lower frequency -> smoother output)
+     * @return perlin noise in 1D quality in [0..1)
+     */
+    public static float noise1D(double t) {
+        return PerlinNoiseGenerator.INSTANCE.noise1D((float) t) + 0.5f;
+    }
 }

fxgl-core/src/main/java/com/almasb/fxgl/core/math/Vec2.java

@@ -329,6 +329,19 @@ public boolean distanceGreaterThanOrEqual(double otherX, double otherY, double d
         return distanceSquared(otherX, otherY) >= distance * distance;
     }
 
+    /**
+     * @return new normalized vector
+     */
+    public Vec2 normalizeVec() {
+        float length = length();
+        if (length < FXGLMath.EPSILON) {
+            return new Vec2();
+        }
+
+        float invLength = 1.0f / length;
+        return new Vec2(x * invLength, y * invLength);
+    }
+
     /**
      * Normalize this vector and return the length before normalization.
      * Alters this vector.

fxgl-core/src/main/java/com/almasb/fxgl/core/reflect/ReflectionUtils.java

@@ -26,8 +26,11 @@
 
 package com.almasb.fxgl.core.reflect;
 
+import com.almasb.fxgl.core.collection.Array;
+
+import java.lang.reflect.*;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
@@ -99,4 +102,56 @@ public static <T> T call(Object instance, Method method, Object... args) {
     public static <T, R> Function<T, R> mapToFunction(Object instance, Method method) {
         return input -> call(instance, method, input);
     }
+
+    public static <A extends java.lang.annotation.Annotation> Array<Field>
+        findFieldsByAnnotation(Object instance, Class<A> annotationClass) {
+
+        Array<Field> fields = new Array<>();
+
+        for (java.lang.reflect.Field field : instance.getClass().getDeclaredFields()) {
+            if (field.getDeclaredAnnotation(annotationClass) != null) {
+                fields.add(field);
+            }
+        }
+
+        return fields;
+    }
+
+    /**
+     * Find all fields of instance that have type / subtype of given type parameter.
+     *
+     * @param instance object whose fields to search
+     * @param type super type
+     * @return all fields that meet criteria
+     */
+    public static Array<Field> findFieldsByType(Object instance, Class<?> type) {
+
+        Array<Field> fields = new Array<>();
+
+        for (java.lang.reflect.Field field : instance.getClass().getDeclaredFields()) {
+            if (type.isAssignableFrom(field.getType())) {
+                fields.add(field);
+            }
+        }
+
+        return fields;
+    }
+
+    /**
+     * Injects field of an instance to injectionInstance.
+     *
+     * @param field the field object
+     * @param instance field's object
+     * @param injectionInstance the target value to inject
+     */
+    public static void inject(Field field, Object instance, Object injectionInstance) {
+        try {
+            if (!field.isAccessible()) {
+                field.setAccessible(true);
+            }
+            field.set(instance, injectionInstance);
+        } catch (Exception e) {
+            throw new RuntimeException("Cannot inject " + injectionInstance + " into " + field.getName() + " Error: " + e);
+        }
+    }
 }

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/concurrent/FXCoroutine.kt

@@ -42,12 +42,20 @@ class FXCoroutine<T>(private val func: Callable<T>) : Async<T>() {
     private var value: T? = null
 
     init {
-        Platform.runLater {
+        if (Platform.isFxApplicationThread()) {
             try {
                 value = func.call()
             } finally {
                 latch.countDown()
             }
+        } else {
+            Platform.runLater {
+                try {
+                    value = func.call()
+                } finally {
+                    latch.countDown()
+                }
+            }
         }
     }
 

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/logging/FXGLLogger.kt

@@ -52,7 +52,7 @@ private constructor() {
         @JvmStatic fun configure(fileName: String) {
             cleanOldLogs()
             Configurator.initialize("FXGL", fileName)
-            logSystemInfo()
+            //logSystemInfo()
         }
 
         @JvmStatic fun get(name: String): Logger {

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/math/PerlinNoiseGenerator.kt

@@ -0,0 +1,87 @@
+/*
+ * The MIT License (MIT)
+ *
+ * FXGL - JavaFX Game Library
+ *
+ * Copyright (c) 2015-2017 AlmasB ([email protected])
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.almasb.fxgl.core.math
+
+/**
+ * Adapted from https://github.com/CRYTEK/CRYENGINE/blob/release/Code/CryEngine/CryCommon/CryMath/PNoise3.h
+ *
+ * @author Almas Baimagambetov ([email protected])
+ */
+internal object PerlinNoiseGenerator {
+
+    // from CRYtek
+    private val NOISE_TABLE_SIZE = 256
+    private val NOISE_MASK = 255
+
+    private val gx = FloatArray(NOISE_TABLE_SIZE)
+    private val gy = FloatArray(NOISE_TABLE_SIZE)
+
+    init {
+        setSeedAndReinitialize()
+    }
+
+    private fun setSeedAndReinitialize() {
+        // Generate the gradient lookup tables
+        for (i in 0..NOISE_TABLE_SIZE - 1) {
+            // Ken Perlin proposes that the gradients are taken from the unit
+            // circle/sphere for 2D/3D.
+            // So lets generate a good pseudo-random vector and normalize it
+
+            val v = Vec2()
+            // random is in the 0..1 range, so we bring to -0.5..0.5
+            v.x = FXGLMath.random() - 0.5f
+            v.y = FXGLMath.random() - 0.5f
+            v.normalizeLocal()
+
+            gx[i] = v.x
+            gy[i] = v.y
+        }
+    }
+
+    /**
+     * Generates a value in [-0.5..0.5), t > 0.
+     */
+    fun noise1D(t: Float): Float {
+        // Compute what gradients to use
+        var qx0 = Math.floor(t.toDouble()).toInt()
+        var qx1 = qx0 + 1
+        val tx0 = t - qx0
+        val tx1 = tx0 - 1
+
+        // Make sure we don't come outside the lookup table
+        qx0 = qx0 and NOISE_MASK
+        qx1 = qx1 and NOISE_MASK
+
+        // Compute the dotproduct between the vectors and the gradients
+        val v0 = gx[qx0] * tx0
+        val v1 = gx[qx1] * tx1
+
+        // Modulate with the weight function
+        val wx = (3 - 2 * tx0) * tx0 * tx0
+        return v0 - wx * (v0 - v1)
+    }
+}

fxgl-ecs/pom.xml

@@ -32,7 +32,7 @@
     <parent>
         <artifactId>fxgl-framework</artifactId>
         <groupId>com.github.almasb</groupId>
-        <version>0.3.1</version>
+        <version>0.3.2</version>
     </parent>
 
     <artifactId>fxgl-ecs</artifactId>
@@ -41,6 +41,12 @@
     <description>Simple entity component system (control) framework</description>
 
     <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+
         <dependency>
             <groupId>com.github.almasb</groupId>
             <artifactId>fxgl-io</artifactId>
@@ -56,6 +62,17 @@
 
     <build>
         <plugins>
+            <!-- Compile java -->
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+
+            <!-- Compile kotlin -->
+            <plugin>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-maven-plugin</artifactId>
+            </plugin>
+
             <!-- Create sources.jar -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>