ReAdded Obsidian API and updated models 'nd Stuff

dependencies/ObsidianAPI-1.0.0-sources/META-INF/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

src/main/java/com/dabigjoe/obsidianAPI/MathHelper.java

@@ -0,0 +1,44 @@
+package com.dabigjoe.obsidianAPI;
+
+public class MathHelper {
+
+    /**
+     * Rotate a vertex by a given rotation around a given rotation point.
+     */
+    public static void rotateVertex(float[] v, float[] rotationMatrix, float[] rotationPoint)
+    {
+        float[] vector = new float[] {v[0] - rotationPoint[0], v[1] - rotationPoint[1], v[2] - rotationPoint[2]};
+
+        v[0] = vector[0] * rotationMatrix[0] + vector[1] * rotationMatrix[3] + vector[2] * rotationMatrix[6] + rotationPoint[0];
+        v[1] = vector[0] * rotationMatrix[1] + vector[1] * rotationMatrix[4] + vector[2] * rotationMatrix[7] + rotationPoint[1];
+        v[2] = vector[0] * rotationMatrix[2] + vector[1] * rotationMatrix[5] + vector[2] * rotationMatrix[8] + rotationPoint[2];
+    }
+
+	public static float[] createRotationMatrixFromAngles(float[] rotation)
+	{
+		return createRotationMatrixFromAngles(rotation[0], rotation[1], rotation[2]);
+	}
+
+	public static float[] createRotationMatrixFromAngles(float rotX, float rotY, float rotZ)
+	{
+		double sx = Math.sin(-rotX);
+		double sy = Math.sin(-rotY);
+		double sz = Math.sin(-rotZ);
+		double cx = Math.cos(-rotX);
+		double cy = Math.cos(-rotY);
+		double cz = Math.cos(-rotZ);
+
+		float m0 = (float) (cy * cz);
+		float m1 = (float) (sx * sy * cz - cx * sz);
+		float m2 = (float) (cx * sy * cz + sx * sz);
+		float m3 = (float) (cy * sz);
+		float m4 = (float) (sx * sy * sz + cx * cz);
+		float m5 = (float) (cx * sy * sz - sx * cz);
+		float m6 = (float) -sy;
+		float m7 = (float) (sx * cy);
+		float m8 = (float) (cx * cy);
+
+		return new float[] {m0, m1, m2, m3, m4, m5, m6, m7, m8};
+	}
+
+}

src/main/java/com/dabigjoe/obsidianAPI/ObsidianAPI.java

@@ -0,0 +1,15 @@
+package com.dabigjoe.obsidianAPI;
+
+import com.dabigjoe.obsidianAPI.event.ObsidianEventBus;
+
+import net.minecraftforge.fml.common.Mod;
+
+@Mod(modid = ObsidianAPI.MODID, name = ObsidianAPI.MODNAME, version = ObsidianAPI.VERSION)
+public class ObsidianAPI {
+
+    public static final String MODID = "obsidian_api";
+    public static final String MODNAME = "Obsidian API";
+    public static final String VERSION = "1.0.0";
+    public static final ObsidianEventBus EVENT_BUS = new ObsidianEventBus();
+
+}

src/main/java/com/dabigjoe/obsidianAPI/ObsidianAPIUtil.java

@@ -0,0 +1,73 @@
+package com.dabigjoe.obsidianAPI;
+
+import java.util.Map;
+
+import com.dabigjoe.obsidianAPI.animation.AnimationPart;
+import com.dabigjoe.obsidianAPI.animation.AnimationSequence;
+import com.dabigjoe.obsidianAPI.animation.ai.IEntityAIAnimation;
+import com.dabigjoe.obsidianAPI.animation.wrapper.IEntityAnimated;
+import com.dabigjoe.obsidianAPI.properties.EntityAnimationProperties;
+import com.dabigjoe.obsidianAPI.render.ModelObj;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.ai.EntityAIBase;
+import net.minecraft.entity.ai.EntityAITasks.EntityAITaskEntry;
+
+public class ObsidianAPIUtil
+{
+
+	public static float getAnimationFrameTime(long startTimeMillis, float startTimeFrame, int fps, float multiplier)
+	{
+		return (System.currentTimeMillis() - startTimeMillis)/1000F*fps*multiplier + startTimeFrame;
+	}
+
+	public static float getAnimationFrameTime(long now, long startTimeMillis, float startTimeFrame, int fps, float multiplier)
+	{
+		return (float) ((now - startTimeMillis) / 1000D * fps * multiplier + startTimeFrame);
+	}
+
+	public static AnimationSequence createTransition(ModelObj model, String animName, Map<String, float[]> from, Map<String, float[]> to, float duration)
+    {
+        AnimationSequence seq = new AnimationSequence(model.entityName, "transition_"+ animName);
+        seq.setFPS(10);
+
+        for (Map.Entry<String, float[]> entry : from.entrySet())
+        {
+            float[] fromPart = entry.getKey().equals("entitypos") ? new float[] {0f, entry.getValue()[1], 0f} : entry.getValue();
+            float[] toPart = to.get(entry.getKey());
+
+            AnimationPart part = new AnimationPart(0, (int) (duration * 10f), fromPart, toPart, model.getPartFromName(entry.getKey()));
+            seq.addAnimation(part);
+        }
+
+        return seq;
+    }
+
+	public static boolean isEntityMoving(EntityLivingBase entity) {
+		boolean isMoving;
+		if(entity instanceof IEntityAnimated)
+			isMoving = ((IEntityAnimated) entity).isMoving();
+		else
+			isMoving = entity.limbSwingAmount > 0.02F;
+		return isMoving;
+	}
+
+	public static boolean isEntityAITaskActive(EntityLiving entity, String AIName) {
+		for(Object obj : entity.tasks.taskEntries) {
+			EntityAITaskEntry taskEntry = (EntityAITaskEntry) obj;
+			EntityAIBase task = taskEntry.action;
+			if(task instanceof IEntityAIAnimation) {
+				IEntityAIAnimation animatedTask = (IEntityAIAnimation) task;
+				if(animatedTask.getAIName().equals(AIName) && animatedTask.isExecuting())
+					return true;
+			}
+		}
+		return false;
+	}
+
+	public static boolean isAnimatedEntity(Entity entity) {
+		return entity != null ? EntityAnimationProperties.get(entity) != null : false;
+	}
+}

src/main/java/com/dabigjoe/obsidianAPI/ObsidianEventHandler.java

@@ -0,0 +1,50 @@
+package com.dabigjoe.obsidianAPI;
+
+import com.dabigjoe.obsidianAPI.network.AnimationNetworkHandler;
+import com.dabigjoe.obsidianAPI.network.MessagePlayerLimbSwing;
+import com.dabigjoe.obsidianAPI.properties.EntityAnimationProperties;
+import com.dabigjoe.obsidianAPI.properties.EntityAnimationPropertiesProvider;
+import com.dabigjoe.obsidianAPI.registry.AnimationRegistry;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
+import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+
+public class ObsidianEventHandler 
+{
+
+	@SubscribeEvent
+	public void onEntityUpdate(LivingUpdateEvent e) {
+		EntityLivingBase entity = e.getEntityLiving();
+		if(!entity.world.isRemote && ObsidianAPIUtil.isAnimatedEntity(entity)) {
+			EntityAnimationProperties animationProps = EntityAnimationProperties.get(entity);
+			if(animationProps != null) {	
+				animationProps.updateActiveAnimation();
+				animationProps.runAnimationTick();
+			}
+		}
+
+		if(entity.world.isRemote && entity instanceof EntityPlayer)
+			AnimationNetworkHandler.network.sendToServer(new MessagePlayerLimbSwing(entity));	
+	}
+
+	@SubscribeEvent
+	public void onEntityJoin(EntityJoinWorldEvent e) {
+		Entity entity = e.getEntity();
+		if(entity.world.isRemote)
+			ObsidianEventHandlerClient.handleOnEntityJoin(e);
+
+		if(AnimationRegistry.isRegisteredClass(entity.getClass())) {
+			if(FMLCommonHandler.instance().getEffectiveSide().isClient())
+				EntityAnimationPropertiesProvider.register(entity, Side.CLIENT);
+			else
+				EntityAnimationPropertiesProvider.register(entity, Side.SERVER);
+		}
+	}
+
+}

src/main/java/com/dabigjoe/obsidianAPI/ObsidianEventHandlerClient.java

@@ -0,0 +1,21 @@
+package com.dabigjoe.obsidianAPI;
+
+import com.dabigjoe.obsidianAPI.network.AnimationNetworkHandler;
+import com.dabigjoe.obsidianAPI.network.MessageRequestEntityAnimation;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
+
+public class ObsidianEventHandlerClient {
+
+	private static final int ANIMATION_RANGE = 20;
+
+	public static void handleOnEntityJoin(EntityJoinWorldEvent e) {
+		Entity entity = e.getEntity();
+		if(entity.world.isRemote && ObsidianAPIUtil.isAnimatedEntity(entity) && entity.getDistance(Minecraft.getMinecraft().player) < ANIMATION_RANGE)
+			AnimationNetworkHandler.network.sendToServer(new MessageRequestEntityAnimation((EntityLivingBase) e.getEntity()));
+	}
+
+}

src/main/java/com/dabigjoe/obsidianAPI/Quaternion.java

@@ -0,0 +1,172 @@
+package com.dabigjoe.obsidianAPI;
+
+import net.minecraft.util.math.MathHelper;
+
+public class Quaternion {
+
+	public float x, y, z, w;
+
+    public Quaternion() {
+    	setIdentity();
+    }
+
+    public Quaternion(Quaternion src)
+    {
+        this(src.x, src.y, src.z, src.w);
+    }
+
+    public Quaternion(float x, float y, float z, float w)
+    {
+        set(x, y, z, w);
+    }
+
+    public void set(float x, float y, float z, float w) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.w = w;
+	}
+
+    public Quaternion setIdentity() {
+    	this.x = 0;
+    	this.y = 0;
+    	this.z = 0;
+    	this.w = 1;
+		return this;
+	}
+
+    public final float length() {
+		return (float) Math.sqrt(lengthSquared());
+	}
+
+    public float lengthSquared() {
+		return x * x + y * y + z * z + w * w;
+	}
+
+    public Quaternion add(Quaternion q) {
+        return new Quaternion(x + q.x,
+                              y + q.y,
+                              z + q.z,
+                              w + q.w);
+    }
+
+    public Quaternion sub(Quaternion q) {
+        return new Quaternion(x - q.x,
+                              y - q.y,
+                              z - q.z,
+                              w - q.w);
+    }
+
+    public Quaternion negate() {
+		Quaternion dest = new Quaternion();
+		dest.x = -this.x;
+		dest.y = -this.y;
+		dest.z = -this.z;
+		dest.w = this.w;
+		return dest;
+	}
+
+	public Quaternion scale(float scale) {
+		Quaternion dest = new Quaternion();
+		dest.x = this.x * scale;
+		dest.y = this.y * scale;
+		dest.z = this.z * scale;
+		dest.w = this.w * scale;
+		return dest;
+	}
+
+    public Quaternion normalise() {
+		float inv_l = 1f/this.length();
+		Quaternion dest = new Quaternion();
+		dest.set(this.x * inv_l, this.y * inv_l, this.z * inv_l, this.w * inv_l);
+		return dest;
+	}
+
+    /**
+     * Converts this quaternion to XYZ euler angles in radians.
+     */
+    public float[] toEuler()
+    {
+        float[] eulerRotation = new float[3];
+        double test = x * y + z * w;
+        if (test > 0.4999)
+        { // singularity at north pole
+            eulerRotation[0] = (float) (2 * Math.atan2(x, w));
+            eulerRotation[1] = (float) (Math.PI / 2);
+            eulerRotation[2] = 0;
+            return eulerRotation;
+        }
+        if (test < -0.4999)
+        { // singularity at south pole
+            eulerRotation[0] = (float) (-2 * Math.atan2(x, w));
+            eulerRotation[1] = (float) (-Math.PI / 2);
+            eulerRotation[2] = 0;
+            return eulerRotation;
+        }
+        double sqx = x * x;
+        double sqy = y * y;
+        double sqz = z * z;
+        eulerRotation[0] = (float) Math.atan2(2 * y * w - 2 * x * z, 1 - 2 * sqy - 2 * sqz);
+        eulerRotation[1] = (float) Math.asin(2 * test);
+        eulerRotation[2] = (float) Math.atan2(2 * x * w - 2 * y * z, 1 - 2 * sqx - 2 * sqz);
+
+        return eulerRotation;
+    }
+
+    /**
+     * Creates a Quaternion from the given euler angles in radians
+     */
+    public static Quaternion fromEuler(float x, float y, float z)
+    {
+        double c1 = Math.cos(x / 2);
+        double s1 = Math.sin(x / 2);
+        double c2 = Math.cos(y / 2);
+        double s2 = Math.sin(y / 2);
+        double c3 = Math.cos(z / 2);
+        double s3 = Math.sin(z / 2);
+        float qw = (float) (c1 * c2 * c3 - s1 * s2 * s3);
+        float qx = (float) (c1 * c2 * s3 + s1 * s2 * c3);
+        float qy = (float) (s1 * c2 * c3 + c1 * s2 * s3);
+        float qz = (float) (c1 * s2 * c3 - s1 * c2 * s3);
+        return new Quaternion(qx, qy, qz, qw);
+    }
+
+    public static float dot(Quaternion left, Quaternion right) {
+		return left.x * right.x + left.y * right.y + left.z * right.z + left.w
+				* right.w;
+	}
+
+    public static Quaternion slerp(Quaternion q0, Quaternion q1, float alpha) {
+        q0 = new Quaternion(q0);
+        q1 = new Quaternion(q1);
+
+        double dot = Quaternion.dot(q0, q1);
+        if (dot < 0)
+        {
+            q0.x *= -1;
+            q0.y *= -1;
+            q0.z *= -1;
+            q0.w *= -1;
+            dot = -dot;
+        }
+
+        float DOT_THRESHOLD = 0.9995f;
+        if (dot > DOT_THRESHOLD)
+            return lerp(q0, q1, alpha);
+
+        dot = MathHelper.clamp(dot, -1, 1);
+        double theta = Math.acos(dot) * alpha;
+
+        Quaternion q2 = q1.sub(q0.scale((float) dot)).normalise();
+
+        Quaternion scaledq0 = q0.scale((float) Math.cos(theta));
+        return scaledq0.add(q2.scale((float) Math.sin(theta)));
+    }
+
+    private static Quaternion lerp(Quaternion q0, Quaternion q1, float alpha) {
+        return new Quaternion(q0.x + (q1.x - q0.x) * alpha,
+                              q0.y + (q1.y - q0.y) * alpha,
+                              q0.z + (q1.z - q0.z) * alpha,
+                              q0.w + (q1.w - q0.w) * alpha).normalise();
+    }
+}