allocation reduction work

docs/src/progress/renderertodo.md

@@ -2136,6 +2136,7 @@ Fix many places where entity position being set on vector fetched from getPositi
  - Fixed first person model placement update
  - Fixed skybox placement update
 Undo getPosition new alloc to lower memory footprint
+Work to reduce allocations
 
 
 

src/main/java/electrosphere/collision/CollisionEngine.java

@@ -45,7 +45,6 @@ import electrosphere.engine.time.Timekeeper;
 import electrosphere.entity.Entity;
 import electrosphere.entity.EntityDataStrings;
 import electrosphere.entity.EntityUtils;
-import electrosphere.entity.state.collidable.Impulse;
 import electrosphere.entity.state.physicssync.ServerPhysicsSyncTree;
 import electrosphere.logger.LoggerInterface;
 
@@ -688,7 +687,7 @@ public class CollisionEngine {
                     Vector3d calculatedPosition = new Vector3d(rawPos.x,rawPos.y,rawPos.z);
                     Vector3d suggestedPosition = this.suggestMovementPosition(collisionWorldData, calculatedPosition);
                     if(calculatedPosition.distance(suggestedPosition) > 0){
-                        collidable.addImpulse(new Impulse(new Vector3d(), new Vector3d(), new Vector3d(), 0, Collidable.TYPE_WORLD_BOUND));
+                        collidable.addImpulse(Collidable.TYPE_WORLD_BOUND);
                     }
                     Quaterniond newRotation = null;
                     if(rigidBody != null){

src/main/java/electrosphere/collision/collidable/Collidable.java

@@ -148,6 +148,18 @@ public class Collidable {
         }
     }
 
+    /**
+     * Adds an impulse the collidable
+     * @param impulse The impulse
+     */
+    public void addImpulse(String type){
+        if(this.impulseCount < MAX_IMPULSES){
+            impulses[this.impulseCount].setType(type);
+            impulses[this.impulseCount].setForce(0);
+            this.impulseCount++;
+        }
+    }
+
     public Entity getParent() {
         return parent;
     }

src/main/java/electrosphere/entity/state/gravity/ServerGravityTree.java

@@ -61,14 +61,18 @@ public class ServerGravityTree implements BehaviorTree {
     }
     
     public void start(){
-        setState(GravityTreeState.ACTIVE);
+        if(this.state == GravityTreeState.NOT_ACTIVE){
+            this.setState(GravityTreeState.ACTIVE);
+        }
         if(state == GravityTreeState.NOT_ACTIVE){
             frameCurrent = 0;
         }
     }
     
     public void stop(){
-        setState(GravityTreeState.NOT_ACTIVE);
+        if(this.state == GravityTreeState.ACTIVE){
+            this.setState(GravityTreeState.NOT_ACTIVE);
+        }
     }
 
     /**

src/main/java/electrosphere/net/server/ServerConnectionHandler.java

@@ -530,6 +530,14 @@ public class ServerConnectionHandler implements Runnable {
         this.characterId = characterId;
     }
 
+    /**
+     * Gets the network parser
+     * @return The network parser
+     */
+    public NetworkParser getNetworkParser(){
+        return this.networkParser;
+    }
+
     
 
 }

src/main/java/electrosphere/net/server/protocol/EntityProtocol.java

@@ -36,6 +36,7 @@ public class EntityProtocol implements ServerProtocolTemplate<EntityMessage> {
                 targetEntity = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(targetEntity != null){
                     CreatureUtils.serverAttachEntityMessageToMovementTree(targetEntity,message);
+                    connectionHandler.getNetworkParser().release(message);
                 }
                 break;
             case ATTACKUPDATE:
@@ -54,6 +55,7 @@ public class EntityProtocol implements ServerProtocolTemplate<EntityMessage> {
                 targetEntity = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(targetEntity != null && ServerPlayerViewDirTree.hasTree(targetEntity)){
                     ServerPlayerViewDirTree.getTree(targetEntity).setPlayerViewDir(message.getpropertyType(), message.getyaw(),message.getpitch(),message.gettime());
+                    connectionHandler.getNetworkParser().release(message);
                 }
             } break;
             case INTERACT: {

src/main/java/electrosphere/renderer/shader/ShaderUtils.java

@@ -1,5 +1,6 @@
 package electrosphere.renderer.shader;
 
+import java.nio.FloatBuffer;
 import java.util.Map;
 
 import org.joml.Matrix4d;
@@ -11,6 +12,7 @@ import org.joml.Vector3f;
 import org.joml.Vector3i;
 import org.joml.Vector4d;
 import org.joml.Vector4f;
+import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL40;
 
 import electrosphere.engine.Globals;
@@ -22,19 +24,14 @@ import electrosphere.renderer.OpenGLState;
 public class ShaderUtils {
 
     /**
-     * Private float array for setting uniforms
+     * Size of the buffers
      */
-    private static final float[] float16Arr = new float[16];
+    private static final int BUFF_SIZE = 16;
 
     /**
      * Private float array for setting uniforms
      */
-    private static final float[] float4Arr = new float[4];
+    private static final FloatBuffer floatBuff = BufferUtils.createFloatBuffer(BUFF_SIZE);
-
-    /**
-     * Private float array for setting uniforms
-     */
-    private static final float[] float3Arr = new float[3];
 
     /**
      * Private double array for setting uniforms
@@ -72,7 +69,24 @@ public class ShaderUtils {
             //matrix4f
             if(value instanceof Matrix4f){
                 Matrix4f currentUniform = (Matrix4f)value;
-                GL40.glUniformMatrix4fv(uniformLocation, false, currentUniform.get(float16Arr));
+                floatBuff.put(currentUniform.m00());
+                floatBuff.put(currentUniform.m01());
+                floatBuff.put(currentUniform.m02());
+                floatBuff.put(currentUniform.m03());
+                floatBuff.put(currentUniform.m10());
+                floatBuff.put(currentUniform.m11());
+                floatBuff.put(currentUniform.m12());
+                floatBuff.put(currentUniform.m13());
+                floatBuff.put(currentUniform.m20());
+                floatBuff.put(currentUniform.m21());
+                floatBuff.put(currentUniform.m22());
+                floatBuff.put(currentUniform.m23());
+                floatBuff.put(currentUniform.m30());
+                floatBuff.put(currentUniform.m31());
+                floatBuff.put(currentUniform.m32());
+                floatBuff.put(currentUniform.m33());
+                floatBuff.flip();
+                GL40.glUniformMatrix4fv(uniformLocation, false, floatBuff);
                 Globals.renderingEngine.checkError();
                 if(uniformMap.containsKey(uniformLocation)){
                     ((Matrix4f)uniformMap.get(uniformLocation)).set(currentUniform);
@@ -84,7 +98,24 @@ public class ShaderUtils {
                 //matrix4d
             } else if(value instanceof Matrix4d){
                 Matrix4d currentUniform = (Matrix4d)value;
-                GL40.glUniformMatrix4fv(uniformLocation, false, currentUniform.get(float16Arr));
+                floatBuff.put((float)currentUniform.m00());
+                floatBuff.put((float)currentUniform.m01());
+                floatBuff.put((float)currentUniform.m02());
+                floatBuff.put((float)currentUniform.m03());
+                floatBuff.put((float)currentUniform.m10());
+                floatBuff.put((float)currentUniform.m11());
+                floatBuff.put((float)currentUniform.m12());
+                floatBuff.put((float)currentUniform.m13());
+                floatBuff.put((float)currentUniform.m20());
+                floatBuff.put((float)currentUniform.m21());
+                floatBuff.put((float)currentUniform.m22());
+                floatBuff.put((float)currentUniform.m23());
+                floatBuff.put((float)currentUniform.m30());
+                floatBuff.put((float)currentUniform.m31());
+                floatBuff.put((float)currentUniform.m32());
+                floatBuff.put((float)currentUniform.m33());
+                floatBuff.flip();
+                GL40.glUniformMatrix4fv(uniformLocation, false, floatBuff);
                 Globals.renderingEngine.checkError();
                 if(uniformMap.containsKey(uniformLocation)){
                     ((Matrix4d)uniformMap.get(uniformLocation)).set(currentUniform);
@@ -96,12 +127,14 @@ public class ShaderUtils {
                 //vector4d
             } else if(value instanceof Vector4d){
                 Vector4d currentUniform = (Vector4d)value;
-                float4Arr[0] = (float)currentUniform.x;
+                floatBuff.put((float)currentUniform.x);
-                float4Arr[1] = (float)currentUniform.y;
+                floatBuff.put((float)currentUniform.y);
-                float4Arr[2] = (float)currentUniform.z;
+                floatBuff.put((float)currentUniform.z);
-                float4Arr[3] = (float)currentUniform.w;
+                floatBuff.put((float)currentUniform.w);
-                GL40.glUniform4fv(uniformLocation, float4Arr);
+                floatBuff.flip();
+                GL40.glUniform4fv(uniformLocation, floatBuff);
                 Globals.renderingEngine.checkError();
+                floatBuff.limit(BUFF_SIZE);
                 if(uniformMap.containsKey(uniformLocation)){
                     ((Vector4d)uniformMap.get(uniformLocation)).set(currentUniform);
                 } else {
@@ -112,12 +145,14 @@ public class ShaderUtils {
                 //vector4f
             } else if(value instanceof Vector4f){
                 Vector4f currentUniform = (Vector4f)value;
-                float4Arr[0] = currentUniform.x;
+                floatBuff.put(currentUniform.x);
-                float4Arr[1] = currentUniform.y;
+                floatBuff.put(currentUniform.y);
-                float4Arr[2] = currentUniform.z;
+                floatBuff.put(currentUniform.z);
-                float4Arr[3] = currentUniform.w;
+                floatBuff.put(currentUniform.w);
-                GL40.glUniform4fv(uniformLocation, float4Arr);
+                floatBuff.flip();
+                GL40.glUniform4fv(uniformLocation, floatBuff);
                 Globals.renderingEngine.checkError();
+                floatBuff.limit(BUFF_SIZE);
                 if(uniformMap.containsKey(uniformLocation)){
                     ((Vector4f)uniformMap.get(uniformLocation)).set(currentUniform);
                 } else {
@@ -128,11 +163,13 @@ public class ShaderUtils {
                 //vector3d
             } else if(value instanceof Vector3f){
                 Vector3f currentUniform = (Vector3f)value;
-                float3Arr[0] = currentUniform.x;
+                floatBuff.put(currentUniform.x);
-                float3Arr[1] = currentUniform.y;
+                floatBuff.put(currentUniform.y);
-                float3Arr[2] = currentUniform.z;
+                floatBuff.put(currentUniform.z);
-                GL40.glUniform3fv(uniformLocation, float3Arr);
+                floatBuff.flip();
+                GL40.glUniform3fv(uniformLocation, floatBuff);
                 Globals.renderingEngine.checkError();
+                floatBuff.limit(BUFF_SIZE);
                 if(uniformMap.containsKey(uniformLocation)){
                     ((Vector3f)uniformMap.get(uniformLocation)).set(currentUniform);
                 } else {

src/main/java/electrosphere/renderer/shader/VisualShader.java

@@ -17,6 +17,7 @@ import org.lwjgl.opengl.GL45;
 
 import electrosphere.engine.Globals;
 import electrosphere.logger.LoggerInterface;
+import electrosphere.logger.Logger.LogLevel;
 import electrosphere.renderer.OpenGLState;
 import electrosphere.renderer.RenderingEngine;
 import electrosphere.util.FileUtils;
@@ -351,7 +352,9 @@ public class VisualShader implements Shader {
         //
         //set the uniform
         if(uniformLocation == INVALID_UNIFORM_NAME){
-            LoggerInterface.loggerRenderer.DEBUG_LOOP("Searched for uniform in a shader that does not contain it. Uniform name: \"" + uniformName + "\"");
+            if(LoggerInterface.loggerRenderer.getLevel() == LogLevel.LOOP_DEBUG){
+                LoggerInterface.loggerRenderer.DEBUG_LOOP("Searched for uniform in a shader that does not contain it. Uniform name: \"" + uniformName + "\"");
+            }
         } else {
             ShaderUtils.setUniform(openGLState, this.uniformValueMap, uniformLocation, value);
         }