halotroop
/
Ginger3D
1
0
Fork 0
Code Pull Requests Packages Releases Activity

JOML IS WORKING SORTA!

pull/12/head
Caroline Bell 2020-02-27 19:44:46 -08:00
parent f6e9c5ebba
commit 2ef60f694a
62 changed files with 203 additions and 3821 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/com/github/halotroop/litecraft/Entity.java
View File

@ -1,7 +1,8 @@
package com.github.halotroop.litecraft;
import org.joml.Vector3f;
import com.github.hydos.ginger.engine.elements.objects.RenderObject;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import com.github.hydos.ginger.engine.render.models.TexturedModel;
public abstract class Entity extends RenderObject

10
src/main/java/com/github/halotroop/litecraft/Litecraft.java
View File

@ -1,22 +1,18 @@
package com.github.halotroop.litecraft;
import java.util.Random;
import org.joml.Vector4i;
import org.joml.*;
import org.lwjgl.glfw.GLFW;
import com.github.halotroop.litecraft.save.LitecraftSave;
import com.github.halotroop.litecraft.screens.TitleScreen;
import com.github.halotroop.litecraft.types.block.*;
import com.github.halotroop.litecraft.world.World;
import com.github.halotroop.litecraft.world.gen.*;
import com.github.halotroop.litecraft.world.gen.Dimensions;
import com.github.hydos.ginger.engine.api.*;
import com.github.hydos.ginger.engine.api.game.*;
import com.github.hydos.ginger.engine.cameras.*;
import com.github.hydos.ginger.engine.elements.objects.*;
import com.github.hydos.ginger.engine.font.FontType;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import com.github.hydos.ginger.engine.obj.ModelLoader;
import com.github.hydos.ginger.engine.obj.shapes.StaticCube;
import com.github.hydos.ginger.engine.render.MasterRenderer;
@ -52,8 +48,6 @@ public class Litecraft extends Game
MouseCallbackHandler.trackWindow(Window.window);
setupKeybinds();
Block b = Blocks.AIR; // make sure blocks are initialised
GingerUtils.init();
Window.setBackgroundColour(0.2f, 0.2f, 0.6f);
TexturedModel dirtModel = ModelLoader.loadGenericCube("block/cubes/stone/brick/stonebrick.png");

2
src/main/java/com/github/halotroop/litecraft/save/LitecraftSave.java
View File

@ -4,7 +4,7 @@ import java.io.*;
import java.util.Random;
import com.github.halotroop.litecraft.world.*;
import com.github.halotroop.litecraft.world.gen.*;
import com.github.halotroop.litecraft.world.gen.Dimension;
import tk.valoeghese.sod.*;

3
src/main/java/com/github/halotroop/litecraft/screens/TitleScreen.java
View File

@ -2,7 +2,7 @@ package com.github.halotroop.litecraft.screens;
import java.util.ArrayList;
import org.joml.Vector4i;
import org.joml.*;
import com.github.halotroop.litecraft.Litecraft;
import com.github.hydos.ginger.engine.api.Ginger;
@ -10,7 +10,6 @@ import com.github.hydos.ginger.engine.elements.GuiTexture;
import com.github.hydos.ginger.engine.elements.buttons.TextureButton;
import com.github.hydos.ginger.engine.font.GUIText;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector2f;
import com.github.hydos.ginger.engine.screen.Screen;
/*

3
src/main/java/com/github/halotroop/litecraft/types/block/BlockEntity.java
View File

@ -1,8 +1,9 @@
package com.github.halotroop.litecraft.types.block;
import org.joml.Vector3f;
import com.github.halotroop.litecraft.world.Chunk;
import com.github.hydos.ginger.engine.elements.objects.RenderObject;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
public class BlockEntity extends RenderObject
{

13
src/main/java/com/github/halotroop/litecraft/world/Chunk.java
View File

@ -3,11 +3,12 @@ package com.github.halotroop.litecraft.world;
import java.util.*;
import java.util.function.ToIntFunction;
import org.joml.Vector3f;
import com.github.halotroop.litecraft.logic.DataStorage;
import com.github.halotroop.litecraft.types.block.*;
import com.github.halotroop.litecraft.world.block.BlockRenderer;
import com.github.halotroop.litecraft.world.gen.WorldGenConstants;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import it.unimi.dsi.fastutil.ints.*;
import it.unimi.dsi.fastutil.longs.*;
@ -68,15 +69,13 @@ public class Chunk implements BlockAccess, WorldGenConstants, DataStorage
renderList.clear();
if (render)
{
for(int i = 0; i < CHUNK_SIZE; i++) {
for(int j = 0; j < CHUNK_SIZE; j++) {
for(int k = 0; k < CHUNK_SIZE; k++) {
for(int i = 0; i < CHUNK_SIZE; i++)
for(int j = 0; j < CHUNK_SIZE; j++)
for(int k = 0; k < CHUNK_SIZE; k++)
{
BlockEntity block = getBlockEntity(i, j, k);
renderList.add(block);
}
}
}
blockRenderer.render(renderList);
}
}

5
src/main/java/com/github/halotroop/litecraft/world/World.java
View File

@ -3,12 +3,13 @@ package com.github.halotroop.litecraft.world;
import java.util.Random;
import java.util.function.LongConsumer;
import org.joml.Vector3f;
import com.github.halotroop.litecraft.save.LitecraftSave;
import com.github.halotroop.litecraft.types.block.Block;
import com.github.halotroop.litecraft.world.block.BlockRenderer;
import com.github.halotroop.litecraft.world.gen.*;
import com.github.hydos.ginger.engine.elements.objects.Player;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import com.github.hydos.ginger.engine.obj.ModelLoader;
import com.github.hydos.ginger.engine.render.models.TexturedModel;
@ -89,7 +90,7 @@ public class World implements BlockAccess, WorldGenConstants
private void populateChunk(int chunkX, int chunkY, int chunkZ, int chunkStartX, int chunkStartY, int chunkStartZ)
{
Random rand = new Random(this.seed + 5828671L * (long) chunkX + -47245139L * (long) chunkY + 8972357 * (long) chunkZ);
Random rand = new Random(this.seed + 5828671L * chunkX + -47245139L * chunkY + 8972357 * (long) chunkZ);
for (WorldModifier modifier : this.worldModifiers)
{

4
src/main/java/com/github/halotroop/litecraft/world/block/BlockRenderer.java
View File

@ -1,7 +1,8 @@
package com.github.halotroop.litecraft.world.block;
import java.util.*;
import java.util.List;
import org.joml.Matrix4f;
import org.lwjgl.opengl.*;
import com.github.halotroop.litecraft.Litecraft;
@ -10,7 +11,6 @@ import com.github.hydos.ginger.engine.api.GingerRegister;
import com.github.hydos.ginger.engine.elements.objects.RenderObject;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.Renderer;
import com.github.hydos.ginger.engine.render.models.*;
import com.github.hydos.ginger.engine.render.shaders.StaticShader;

2
src/main/java/com/github/halotroop/litecraft/world/gen/OverworldChunkGenerator.java
View File

@ -26,7 +26,7 @@ public class OverworldChunkGenerator implements ChunkGenerator, WorldGenConstant
double totalX = x + chunk.chunkStartX;
for (int z = 0; z < CHUNK_SIZE; ++z) {
int height = (int) this.noise.sample(totalX, (double) (chunk.chunkStartZ + z));
int height = (int) this.noise.sample(totalX, chunk.chunkStartZ + z);
for (int y = 0; y < CHUNK_SIZE; ++y) {
int totalY = chunk.chunkStartY + y;

3
src/main/java/com/github/hydos/ginger/engine/api/Ginger.java
View File

@ -1,5 +1,7 @@
package com.github.hydos.ginger.engine.api;
import org.joml.Vector2f;
import com.github.halotroop.litecraft.Litecraft;
import com.github.halotroop.litecraft.logic.Timer;
import com.github.halotroop.litecraft.logic.Timer.TickListener;
@ -8,7 +10,6 @@ import com.github.hydos.ginger.engine.api.game.*;
import com.github.hydos.ginger.engine.elements.buttons.TextureButton;
import com.github.hydos.ginger.engine.font.*;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector2f;
import com.github.hydos.ginger.engine.particle.ParticleMaster;
import com.github.hydos.ginger.engine.postprocessing.*;
import com.github.hydos.ginger.engine.render.MasterRenderer;

2
src/main/java/com/github/hydos/ginger/engine/cameras/Camera.java
View File

@ -1,10 +1,10 @@
package com.github.hydos.ginger.engine.cameras;
import org.joml.Vector3f;
import org.lwjgl.glfw.*;
import com.github.hydos.ginger.engine.elements.objects.Player;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
public class Camera
{

12
src/main/java/com/github/hydos/ginger/engine/cameras/FirstPersonCamera.java
View File

@ -1,8 +1,9 @@
package com.github.hydos.ginger.engine.cameras;
import org.joml.Vector3f;
import com.github.hydos.ginger.engine.elements.objects.Player;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
public class FirstPersonCamera extends Camera
{
@ -16,18 +17,23 @@ public class FirstPersonCamera extends Camera
player.isVisible = false;
}
@Override
public float getPitch()
{ return pitch; }
@Override
public Vector3f getPosition()
{ return position; }
@Override
public float getRoll()
{ return roll; }
@Override
public float getYaw()
{ return yaw; }
@Override
public void move()
{
@ -36,7 +42,7 @@ public class FirstPersonCamera extends Camera
position.y = player.getPosition().y;
roll = player.getRotX();
yaw = -player.getRotY() + 180 + Window.getNormalizedMouseCoordinates().getX() * 70;
pitch = player.getRotZ() + -Window.getNormalizedMouseCoordinates().getY() * 70;
yaw = -player.getRotY() + 180 + Window.getNormalizedMouseCoordinates().x() * 70;
pitch = player.getRotZ() + -Window.getNormalizedMouseCoordinates().y() * 70;
}
}

2
src/main/java/com/github/hydos/ginger/engine/elements/GuiTexture.java
View File

@ -1,6 +1,6 @@
package com.github.hydos.ginger.engine.elements;
import com.github.hydos.ginger.engine.math.vectors.Vector2f;
import org.joml.Vector2f;
public class GuiTexture
{

2
src/main/java/com/github/hydos/ginger/engine/elements/buttons/TextureButton.java
View File

@ -2,11 +2,11 @@ package com.github.hydos.ginger.engine.elements.buttons;
import java.util.List;
import org.joml.Vector2f;
import org.lwjgl.glfw.GLFW;
import com.github.hydos.ginger.engine.elements.GuiTexture;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector2f;
import com.github.hydos.ginger.engine.utils.Loader;
public class TextureButton

2
src/main/java/com/github/hydos/ginger/engine/elements/objects/Light.java
View File

@ -1,6 +1,6 @@
package com.github.hydos.ginger.engine.elements.objects;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import org.joml.Vector3f;
public class Light
{

2
src/main/java/com/github/hydos/ginger/engine/elements/objects/Player.java
View File

@ -1,9 +1,9 @@
package com.github.hydos.ginger.engine.elements.objects;
import org.joml.Vector3f;
import org.lwjgl.glfw.GLFW;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import com.github.hydos.ginger.engine.render.models.TexturedModel;
import com.github.hydos.ginger.main.settings.Constants;

3
src/main/java/com/github/hydos/ginger/engine/elements/objects/RenderObject.java
View File

@ -1,6 +1,7 @@
package com.github.hydos.ginger.engine.elements.objects;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import org.joml.Vector3f;
import com.github.hydos.ginger.engine.render.models.TexturedModel;
public class RenderObject

2
src/main/java/com/github/hydos/ginger/engine/font/GUIText.java
View File

@ -1,6 +1,6 @@
package com.github.hydos.ginger.engine.font;
import com.github.hydos.ginger.engine.math.vectors.*;
import org.joml.*;
/** Represents a piece of text in the game. */
public class GUIText

4
src/main/java/com/github/hydos/ginger/engine/io/Window.java
View File

@ -2,11 +2,11 @@ package com.github.hydos.ginger.engine.io;
import java.nio.*;
import org.joml.*;
import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.*;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.math.vectors.*;
import com.github.hydos.ginger.engine.render.texture.Image;
public class Window
@ -84,7 +84,7 @@ public class Window
public static float getFloatTime()
{
float f = (System.nanoTime() / (long) 1000000000);
float f = (System.nanoTime() / 1000000000);
return f;
}

46
src/main/java/com/github/hydos/ginger/engine/math/Maths.java
View File

@ -1,8 +1,10 @@
package com.github.hydos.ginger.engine.math;
import java.lang.Math;
import org.joml.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.*;
public class Maths
{
@ -18,47 +20,47 @@ public class Maths
public static Matrix4f createTransformationMatrix(Vector2f translation, Vector2f scale)
{
Matrix4f matrix = new Matrix4f();
matrix.setIdentity();
Matrix4f.translate(translation, matrix, matrix);
Matrix4f.scale(new Vector3f(scale.x, scale.y, 1f), matrix, matrix);
matrix.identity();
matrix.translate(new org.joml.Vector3f(translation.x, translation.y, 0), matrix);
matrix.scale(new Vector3f(scale.x, scale.y, 1f), matrix);
return matrix;
}
public static Matrix4f createTransformationMatrix(Vector3f translation, float rx, float ry, float rz, float scale)
{
Matrix4f matrix = new Matrix4f();
matrix.setIdentity();
Matrix4f.translate(translation, matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(rx), new Vector3f(1, 0, 0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(ry), new Vector3f(0, 1, 0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(rz), new Vector3f(0, 0, 1), matrix, matrix);
matrix.identity();
matrix.translate(translation, matrix);
matrix.rotate((float) Math.toRadians(rx), new Vector3f(1, 0, 0), matrix);
matrix.rotate((float) Math.toRadians(ry), new Vector3f(0, 1, 0), matrix);
matrix.rotate((float) Math.toRadians(rz), new Vector3f(0, 0, 1), matrix);
Vector3f newScale = new Vector3f(scale, scale, scale);
Matrix4f.scale(newScale, matrix, matrix);
matrix.scale(newScale, matrix);
return matrix;
}
public static Matrix4f createTransformationMatrix(Vector3f translation, float rx, float ry, float rz, Vector3f scale)
{
Matrix4f matrix = new Matrix4f();
matrix.setIdentity();
Matrix4f.translate(translation, matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(rx), new Vector3f(1, 0, 0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(ry), new Vector3f(0, 1, 0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(rz), new Vector3f(0, 0, 1), matrix, matrix);
Matrix4f.scale(scale, matrix, matrix);
matrix.identity();
matrix.translate(translation, matrix);
matrix.rotate((float) Math.toRadians(rx), new Vector3f(1, 0, 0), matrix);
matrix.rotate((float) Math.toRadians(ry), new Vector3f(0, 1, 0), matrix);
matrix.rotate((float) Math.toRadians(rz), new Vector3f(0, 0, 1), matrix);
matrix.scale(scale, matrix);
return matrix;
}
public static Matrix4f createViewMatrix(Camera camera)
{
Matrix4f viewMatrix = new Matrix4f();
viewMatrix.setIdentity();
Matrix4f.rotate((float) Math.toRadians(camera.getPitch()), new Vector3f(1, 0, 0), viewMatrix, viewMatrix);
Matrix4f.rotate((float) Math.toRadians(camera.getYaw()), new Vector3f(0, 1, 0), viewMatrix, viewMatrix);
Matrix4f.rotate((float) Math.toRadians(camera.getRoll()), new Vector3f(0, 0, 1), viewMatrix, viewMatrix);
viewMatrix.identity();
viewMatrix.rotate((float) Math.toRadians(camera.getPitch()), new Vector3f(1, 0, 0), viewMatrix);
viewMatrix.rotate((float) Math.toRadians(camera.getYaw()), new Vector3f(0, 1, 0), viewMatrix);
viewMatrix.rotate((float) Math.toRadians(camera.getRoll()), new Vector3f(0, 0, 1), viewMatrix);
Vector3f cameraPos = camera.getPosition();
Vector3f negativeCameraPos = new Vector3f(-cameraPos.x, -cameraPos.y, -cameraPos.z);
Matrix4f.translate(negativeCameraPos, viewMatrix, viewMatrix);
viewMatrix.translate(negativeCameraPos, viewMatrix);
return viewMatrix;
}
}

487
src/main/java/com/github/hydos/ginger/engine/math/Quaternion.java
View File

@ -1,487 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math;
/**
*
* Quaternions for LWJGL!
*
* @author fbi
* @version $Revision$
* $Id$
*/
import java.nio.FloatBuffer;
import org.joml.Vector4f;
import com.github.hydos.ginger.engine.math.matrixes.*;
import com.github.hydos.ginger.engine.math.vectors.*;
public class Quaternion extends Vector implements ReadableVector4f
{
private static final long serialVersionUID = 1L;
/** The dot product of two quaternions
*
* @param left
* The LHS quat
* @param right
* The RHS quat
* @return left dot right */
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; }
/** Sets the value of this quaternion to the quaternion product of
* quaternions left and right (this = left * right). Note that this is safe
* for aliasing (e.g. this can be left or right).
*
* @param left
* the first quaternion
* @param right
* the second quaternion */
public static Quaternion mul(Quaternion left, Quaternion right,
Quaternion dest)
{
if (dest == null)
dest = new Quaternion();
dest.set(left.x * right.w + left.w * right.x + left.y * right.z
- left.z * right.y,
left.y * right.w + left.w * right.y
+ left.z * right.x - left.x * right.z,
left.z * right.w
+ left.w * right.z + left.x * right.y - left.y * right.x,
left.w * right.w - left.x * right.x - left.y * right.y
- left.z * right.z);
return dest;
}
/** Multiplies quaternion left by the inverse of quaternion right and places
* the value into this quaternion. The value of both argument quaternions is
* preservered (this = left * right^-1).
*
* @param left
* the left quaternion
* @param right
* the right quaternion */
public static Quaternion mulInverse(Quaternion left, Quaternion right,
Quaternion dest)
{
float n = right.lengthSquared();
// zero-div may occur.
n = (n == 0.0 ? n : 1 / n);
// store on stack once for aliasing-safty
if (dest == null)
dest = new Quaternion();
dest
.set((left.x * right.w - left.w * right.x - left.y
* right.z + left.z * right.y)
* n,
(left.y * right.w - left.w * right.y - left.z
* right.x + left.x * right.z)
* n,
(left.z * right.w - left.w * right.z - left.x
* right.y + left.y * right.x)
* n,
(left.w * right.w + left.x * right.x + left.y
* right.y + left.z * right.z)
* n);
return dest;
}
/** Calculate the conjugate of this quaternion and put it into the given one
*
* @param src
* The source quaternion
* @param dest
* The quaternion which should be set to the conjugate of this
* quaternion */
public static Quaternion negate(Quaternion src, Quaternion dest)
{
if (dest == null)
dest = new Quaternion();
dest.x = -src.x;
dest.y = -src.y;
dest.z = -src.z;
dest.w = src.w;
return dest;
}
/** Normalise the source quaternion and place the result in another quaternion.
*
* @param src
* The source quaternion
* @param dest
* The destination quaternion, or null if a new quaternion is to be
* created
* @return The normalised quaternion */
public static Quaternion normalise(Quaternion src, Quaternion dest)
{
float inv_l = 1f / src.length();
if (dest == null)
dest = new Quaternion();
dest.set(src.x * inv_l, src.y * inv_l, src.z * inv_l, src.w * inv_l);
return dest;
}
/** Scale the source quaternion by scale and put the result in the destination
*
* @param scale The amount to scale by
* @param src The source quaternion
* @param dest The destination quaternion, or null if a new quaternion is to be created
* @return The scaled quaternion */
public static Quaternion scale(float scale, Quaternion src, Quaternion dest)
{
if (dest == null)
dest = new Quaternion();
dest.x = src.x * scale;
dest.y = src.y * scale;
dest.z = src.z * scale;
dest.w = src.w * scale;
return dest;
}
/** Sets the value of the source quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The source matrix
* @param q
* The destination quaternion, or null if a new quaternion is to be created
* @return q */
public static Quaternion setFromMatrix(Matrix3f m, Quaternion q)
{ return q.setFromMat(m.m00, m.m01, m.m02, m.m10, m.m11, m.m12, m.m20,
m.m21, m.m22); }
/** Sets the value of the source quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The source matrix
* @param q
* The destination quaternion, or null if a new quaternion is to be created
* @return q */
public static Quaternion setFromMatrix(Matrix4f m, Quaternion q)
{ return q.setFromMat(m.m00, m.m01, m.m02, m.m10, m.m11, m.m12, m.m20,
m.m21, m.m22); }
/** Set the given quaternion to the multiplication identity.
*
* @param q The quaternion
* @return q */
public static Quaternion setIdentity(Quaternion q)
{
q.x = 0;
q.y = 0;
q.z = 0;
q.w = 1;
return q;
}
public float x, y, z, w;
/** C'tor. The quaternion will be initialized to the identity. */
public Quaternion()
{
super();
setIdentity();
}
/** C'tor */
public Quaternion(float x, float y, float z, float w)
{ set(x, y, z, w); }
/** C'tor
*
* @param src */
public Quaternion(ReadableVector4f src)
{ set(src); }
/*
* (Overrides)
*
* @see org.lwjgl.vector.ReadableVector3f#getW()
*/
@Override
public float getW()
{ return w; }
/** @return x */
@Override
public final float getX()
{ return x; }
/** @return y */
@Override
public final float getY()
{ return y; }
/*
* (Overrides)
*
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
@Override
public float getZ()
{ return z; }
/** @return the length squared of the quaternion */
@Override
public float lengthSquared()
{ return x * x + y * y + z * z + w * w; }
/* (non-Javadoc)
* @see org.lwjgl.util.vector.Vector#load(java.nio.FloatBuffer)
*/
@Override
public Vector load(FloatBuffer buf)
{
x = buf.get();
y = buf.get();
z = buf.get();
w = buf.get();
return this;
}
/** Calculate the conjugate of this quaternion */
@Override
public Vector negate()
{ return negate(this, this); }
/** Calculate the conjugate of this quaternion and put it into the given one
*
* @param dest
* The quaternion which should be set to the conjugate of this
* quaternion */
public Quaternion negate(Quaternion dest)
{ return negate(this, dest); }
/** Normalise this quaternion and place the result in another quaternion.
*
* @param dest
* The destination quaternion, or null if a new quaternion is to be
* created
* @return the normalised quaternion */
public Quaternion normalise(Quaternion dest)
{ return normalise(this, dest); }
/*
* (non-Javadoc)
*
* @see org.lwjgl.vector.Vector#scale(float)
*/
@Override
public Vector scale(float scale)
{ return scale(scale, this, this); }
/*
* (non-Javadoc)
*
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
public void set(float x, float y)
{
this.x = x;
this.y = y;
}
/*
* (non-Javadoc)
*
* @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float)
*/
public void set(float x, float y, float z)
{
this.x = x;
this.y = y;
this.z = z;
}
/*
* (non-Javadoc)
*
* @see org.lwjgl.util.vector.WritableVector4f#set(float, float, float,
* float)
*/
public void set(float x, float y, float z, float w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/** Load from another Vector4f
*
* @param src
* The source vector
* @return this */
public Quaternion set(ReadableVector4f src)
{
x = src.getX();
y = src.getY();
z = src.getZ();
w = src.getW();
return this;
}
/** Sets the value of this quaternion to the equivalent rotation of the
* Axis-Angle argument.
*
* @param a1
* the axis-angle: (x,y,z) is the axis and w is the angle */
public final void setFromAxisAngle(Vector4f a1)
{
x = a1.x;
y = a1.y;
z = a1.z;
float n = (float) Math.sqrt(x * x + y * y + z * z);
// zero-div may occur.
float s = (float) (Math.sin(0.5 * a1.w) / n);
x *= s;
y *= s;
z *= s;
w = (float) Math.cos(0.5 * a1.w);
}
/** Private method to perform the matrix-to-quaternion conversion */
private Quaternion setFromMat(float m00, float m01, float m02, float m10,
float m11, float m12, float m20, float m21, float m22)
{
float s;
float tr = m00 + m11 + m22;
if (tr >= 0.0)
{
s = (float) Math.sqrt(tr + 1.0);
w = s * 0.5f;
s = 0.5f / s;
x = (m21 - m12) * s;
y = (m02 - m20) * s;
z = (m10 - m01) * s;
}
else
{
float max = Math.max(Math.max(m00, m11), m22);
if (max == m00)
{
s = (float) Math.sqrt(m00 - (m11 + m22) + 1.0);
x = s * 0.5f;
s = 0.5f / s;
y = (m01 + m10) * s;
z = (m20 + m02) * s;
w = (m21 - m12) * s;
}
else if (max == m11)
{
s = (float) Math.sqrt(m11 - (m22 + m00) + 1.0);
y = s * 0.5f;
s = 0.5f / s;
z = (m12 + m21) * s;
x = (m01 + m10) * s;
w = (m02 - m20) * s;
}
else
{
s = (float) Math.sqrt(m22 - (m00 + m11) + 1.0);
z = s * 0.5f;
s = 0.5f / s;
x = (m20 + m02) * s;
y = (m12 + m21) * s;
w = (m10 - m01) * s;
}
}
return this;
}
/** Sets the value of this quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The source matrix */
public final Quaternion setFromMatrix(Matrix3f m)
{ return setFromMatrix(m, this); }
/** Sets the value of this quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The matrix
* @return this */
public final Quaternion setFromMatrix(Matrix4f m)
{ return setFromMatrix(m, this); }
/** Set this quaternion to the multiplication identity.
*
* @return this */
public Quaternion setIdentity()
{ return setIdentity(this); }
/** Set W
*
* @param w */
public void setW(float w)
{ this.w = w; }
/** Set X
*
* @param x */
public final void setX(float x)
{ this.x = x; }
/** Set Y
*
* @param y */
public final void setY(float y)
{ this.y = y; }
/** Set Z
*
* @param z */
public void setZ(float z)
{ this.z = z; }
/* (non-Javadoc)
* @see org.lwjgl.util.vector.ReadableVector#store(java.nio.FloatBuffer)
*/
@Override
public Vector store(FloatBuffer buf)
{
buf.put(x);
buf.put(y);
buf.put(z);
buf.put(w);
return this;
}
@Override
public String toString()
{ return "Quaternion: " + x + " " + y + " " + z + " " + w; }
}

107
src/main/java/com/github/hydos/ginger/engine/math/matrixes/Matrix.java
View File

@ -1,107 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.matrixes;
import java.io.Serializable;
import java.nio.FloatBuffer;
/** Base class for matrices. When a matrix is constructed it will be the identity
* matrix unless otherwise stated.
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public abstract class Matrix implements Serializable
{
private static final long serialVersionUID = 1L;
/** Constructor for Matrix. */
protected Matrix()
{ super(); }
/** @return the determinant of the matrix */
public abstract float determinant();
/** Invert this matrix
*
* @return this */
public abstract Matrix invert();
/** Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this */
public abstract Matrix load(FloatBuffer buf);
/** Load from a float buffer. The buffer stores the matrix in row major
* (mathematical) order.
*
* @param buf A float buffer to read from
* @return this */
public abstract Matrix loadTranspose(FloatBuffer buf);
/** Negate this matrix
*
* @return this */
public abstract Matrix negate();
/** Set this matrix to be the identity matrix.
*
* @return this */
public abstract Matrix setIdentity();
/** Set this matrix to 0.
*
* @return this */
public abstract Matrix setZero();
/** Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
*
* @param buf The buffer to store this matrix in
* @return this */
public abstract Matrix store(FloatBuffer buf);
/** Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
*
* @param buf The buffer to store this matrix in
* @return this */
public abstract Matrix storeTranspose(FloatBuffer buf);
/** Transpose this matrix
*
* @return this */
public abstract Matrix transpose();
}

361
src/main/java/com/github/hydos/ginger/engine/math/matrixes/Matrix2f.java
View File

@ -1,361 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.matrixes;
import java.io.Serializable;
import java.nio.FloatBuffer;
import com.github.hydos.ginger.engine.math.vectors.Vector2f;
/** Holds a 2x2 matrix
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public class Matrix2f extends Matrix implements Serializable
{
private static final long serialVersionUID = 1L;
/** Add two matrices together and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix2f add(Matrix2f left, Matrix2f right, Matrix2f dest)
{
if (dest == null)
dest = new Matrix2f();
dest.m00 = left.m00 + right.m00;
dest.m01 = left.m01 + right.m01;
dest.m10 = left.m10 + right.m10;
dest.m11 = left.m11 + right.m11;
return dest;
}
/** Invert the source matrix and place the result in the destination matrix.
*
* @param src The source matrix to be inverted
* @param dest The destination matrix or null if a new matrix is to be created
* @return The inverted matrix, or null if source can't be reverted. */
public static Matrix2f invert(Matrix2f src, Matrix2f dest)
{
/*
*inv(A) = 1/det(A) * adj(A);
*/
float determinant = src.determinant();
if (determinant != 0)
{
if (dest == null)
dest = new Matrix2f();
float determinant_inv = 1f / determinant;
float t00 = src.m11 * determinant_inv;
float t01 = -src.m01 * determinant_inv;
float t11 = src.m00 * determinant_inv;
float t10 = -src.m10 * determinant_inv;
dest.m00 = t00;
dest.m01 = t01;
dest.m10 = t10;
dest.m11 = t11;
return dest;
}
else
return null;
}
/** Copy the source matrix to the destination matrix.
*
* @param src The source matrix
* @param dest The destination matrix, or null if a new one should be created.
* @return The copied matrix */
public static Matrix2f load(Matrix2f src, Matrix2f dest)
{
if (dest == null)
dest = new Matrix2f();
dest.m00 = src.m00;
dest.m01 = src.m01;
dest.m10 = src.m10;
dest.m11 = src.m11;
return dest;
}
/** Multiply the right matrix by the left and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix2f mul(Matrix2f left, Matrix2f right, Matrix2f dest)
{
if (dest == null)
dest = new Matrix2f();
float m00 = left.m00 * right.m00 + left.m10 * right.m01;
float m01 = left.m01 * right.m00 + left.m11 * right.m01;
float m10 = left.m00 * right.m10 + left.m10 * right.m11;
float m11 = left.m01 * right.m10 + left.m11 * right.m11;
dest.m00 = m00;
dest.m01 = m01;
dest.m10 = m10;
dest.m11 = m11;
return dest;
}
/** Negate the source matrix and stash the result in the destination matrix.
*
* @param src The source matrix to be negated
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix */
public static Matrix2f negate(Matrix2f src, Matrix2f dest)
{
if (dest == null)
dest = new Matrix2f();
dest.m00 = -src.m00;
dest.m01 = -src.m01;
dest.m10 = -src.m10;
dest.m11 = -src.m11;
return dest;
}
/** Set the source matrix to be the identity matrix.
*
* @param src The matrix to set to the identity.
* @return The source matrix */
public static Matrix2f setIdentity(Matrix2f src)
{
src.m00 = 1.0f;
src.m01 = 0.0f;
src.m10 = 0.0f;
src.m11 = 1.0f;
return src;
}
public static Matrix2f setZero(Matrix2f src)
{
src.m00 = 0.0f;
src.m01 = 0.0f;
src.m10 = 0.0f;
src.m11 = 0.0f;
return src;
}
/** Subtract the right matrix from the left and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix2f sub(Matrix2f left, Matrix2f right, Matrix2f dest)
{
if (dest == null)
dest = new Matrix2f();
dest.m00 = left.m00 - right.m00;
dest.m01 = left.m01 - right.m01;
dest.m10 = left.m10 - right.m10;
dest.m11 = left.m11 - right.m11;
return dest;
}
/** Transform a Vector by a matrix and return the result in a destination
* vector.
*
* @param left The left matrix
* @param right The right vector
* @param dest The destination vector, or null if a new one is to be created
* @return the destination vector */
public static Vector2f transform(Matrix2f left, Vector2f right, Vector2f dest)
{
if (dest == null)
dest = new Vector2f();
float x = left.m00 * right.x + left.m10 * right.y;
float y = left.m01 * right.x + left.m11 * right.y;
dest.x = x;
dest.y = y;
return dest;
}
/** Transpose the source matrix and place the result in the destination matrix.
*
* @param src The source matrix or null if a new matrix is to be created
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix */
public static Matrix2f transpose(Matrix2f src, Matrix2f dest)
{
if (dest == null)
dest = new Matrix2f();
float m01 = src.m10;
float m10 = src.m01;
dest.m01 = m01;
dest.m10 = m10;
return dest;
}
public float m00, m01, m10, m11;
/** Constructor for Matrix2f. The matrix is initialised to the identity. */
public Matrix2f()
{ setIdentity(); }
/** Constructor */
public Matrix2f(Matrix2f src)
{ load(src); }
/* (non-Javadoc)
* @see org.lwjgl.vector.Matrix#determinant()
*/
@Override
public float determinant()
{ return m00 * m11 - m01 * m10; }
/** Invert this matrix
*
* @return this if successful, null otherwise */
@Override
public Matrix invert()
{ return invert(this, this); }
/** Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this */
@Override
public Matrix load(FloatBuffer buf)
{
m00 = buf.get();
m01 = buf.get();
m10 = buf.get();
m11 = buf.get();
return this;
}
/** Load from another matrix
*
* @param src The source matrix
* @return this */
public Matrix2f load(Matrix2f src)
{ return load(src, this); }
/** Load from a float buffer. The buffer stores the matrix in row major
* (mathematical) order.
*
* @param buf A float buffer to read from
* @return this */
@Override
public Matrix loadTranspose(FloatBuffer buf)
{
m00 = buf.get();
m10 = buf.get();
m01 = buf.get();
m11 = buf.get();
return this;
}
/** Negate this matrix
*
* @return this */
@Override
public Matrix negate()
{ return negate(this); }
/** Negate this matrix and stash the result in another matrix.
*
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix */
public Matrix2f negate(Matrix2f dest)
{ return negate(this, dest); }
/** Set this matrix to be the identity matrix.
*
* @return this */
@Override
public Matrix setIdentity()
{ return setIdentity(this); }
/** Set this matrix to 0.
*
* @return this */
@Override
public Matrix setZero()
{ return setZero(this); }
/** Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
*
* @param buf The buffer to store this matrix in */
@Override
public Matrix store(FloatBuffer buf)
{
buf.put(m00);
buf.put(m01);
buf.put(m10);
buf.put(m11);
return this;
}
/** Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
*
* @param buf The buffer to store this matrix in */
@Override
public Matrix storeTranspose(FloatBuffer buf)
{
buf.put(m00);
buf.put(m10);
buf.put(m01);
buf.put(m11);
return this;
}
/** Returns a string representation of this matrix */
@Override
public String toString()
{
StringBuilder buf = new StringBuilder();
buf.append(m00).append(' ').append(m10).append(' ').append('\n');
buf.append(m01).append(' ').append(m11).append(' ').append('\n');
return buf.toString();
}
/** Transpose this matrix
*
* @return this */
@Override
public Matrix transpose()
{ return transpose(this); }
/** Transpose this matrix and place the result in another matrix.
*
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix */
public Matrix2f transpose(Matrix2f dest)
{ return transpose(this, dest); }
}

467
src/main/java/com/github/hydos/ginger/engine/math/matrixes/Matrix3f.java
View File

@ -1,467 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.matrixes;
import java.io.Serializable;
import java.nio.FloatBuffer;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
/** Holds a 3x3 matrix.
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public class Matrix3f extends Matrix implements Serializable
{
private static final long serialVersionUID = 1L;
/** Add two matrices together and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix3f add(Matrix3f left, Matrix3f right, Matrix3f dest)
{
if (dest == null)
dest = new Matrix3f();
dest.m00 = left.m00 + right.m00;
dest.m01 = left.m01 + right.m01;
dest.m02 = left.m02 + right.m02;
dest.m10 = left.m10 + right.m10;
dest.m11 = left.m11 + right.m11;
dest.m12 = left.m12 + right.m12;
dest.m20 = left.m20 + right.m20;
dest.m21 = left.m21 + right.m21;
dest.m22 = left.m22 + right.m22;
return dest;
}
/** Invert the source matrix and put the result into the destination matrix
*
* @param src The source matrix to be inverted
* @param dest The destination matrix, or null if a new one is to be created
* @return The inverted matrix if successful, null otherwise */
public static Matrix3f invert(Matrix3f src, Matrix3f dest)
{
float determinant = src.determinant();
if (determinant != 0)
{
if (dest == null)
dest = new Matrix3f();
/* do it the ordinary way
*
* inv(A) = 1/det(A) * adj(T), where adj(T) = transpose(Conjugate Matrix)
*
* m00 m01 m02
* m10 m11 m12
* m20 m21 m22
*/
float determinant_inv = 1f / determinant;
// get the conjugate matrix
float t00 = src.m11 * src.m22 - src.m12 * src.m21;
float t01 = -src.m10 * src.m22 + src.m12 * src.m20;
float t02 = src.m10 * src.m21 - src.m11 * src.m20;
float t10 = -src.m01 * src.m22 + src.m02 * src.m21;
float t11 = src.m00 * src.m22 - src.m02 * src.m20;
float t12 = -src.m00 * src.m21 + src.m01 * src.m20;
float t20 = src.m01 * src.m12 - src.m02 * src.m11;
float t21 = -src.m00 * src.m12 + src.m02 * src.m10;
float t22 = src.m00 * src.m11 - src.m01 * src.m10;
dest.m00 = t00 * determinant_inv;
dest.m11 = t11 * determinant_inv;
dest.m22 = t22 * determinant_inv;
dest.m01 = t10 * determinant_inv;
dest.m10 = t01 * determinant_inv;
dest.m20 = t02 * determinant_inv;
dest.m02 = t20 * determinant_inv;
dest.m12 = t21 * determinant_inv;
dest.m21 = t12 * determinant_inv;
return dest;
}
else
return null;
}
/** Copy source matrix to destination matrix
*
* @param src The source matrix
* @param dest The destination matrix, or null of a new matrix is to be created
* @return The copied matrix */
public static Matrix3f load(Matrix3f src, Matrix3f dest)
{
if (dest == null)
dest = new Matrix3f();
dest.m00 = src.m00;
dest.m10 = src.m10;
dest.m20 = src.m20;
dest.m01 = src.m01;
dest.m11 = src.m11;
dest.m21 = src.m21;
dest.m02 = src.m02;
dest.m12 = src.m12;
dest.m22 = src.m22;
return dest;
}
/** Multiply the right matrix by the left and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix3f mul(Matrix3f left, Matrix3f right, Matrix3f dest)
{
if (dest == null)
dest = new Matrix3f();
float m00 = left.m00 * right.m00 + left.m10 * right.m01 + left.m20 * right.m02;
float m01 = left.m01 * right.m00 + left.m11 * right.m01 + left.m21 * right.m02;
float m02 = left.m02 * right.m00 + left.m12 * right.m01 + left.m22 * right.m02;
float m10 = left.m00 * right.m10 + left.m10 * right.m11 + left.m20 * right.m12;
float m11 = left.m01 * right.m10 + left.m11 * right.m11 + left.m21 * right.m12;
float m12 = left.m02 * right.m10 + left.m12 * right.m11 + left.m22 * right.m12;
float m20 = left.m00 * right.m20 + left.m10 * right.m21 + left.m20 * right.m22;
float m21 = left.m01 * right.m20 + left.m11 * right.m21 + left.m21 * right.m22;
float m22 = left.m02 * right.m20 + left.m12 * right.m21 + left.m22 * right.m22;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
return dest;
}
/** Negate the source matrix and place the result in the destination matrix.
*
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix */
public static Matrix3f negate(Matrix3f src, Matrix3f dest)
{
if (dest == null)
dest = new Matrix3f();
dest.m00 = -src.m00;
dest.m01 = -src.m02;
dest.m02 = -src.m01;
dest.m10 = -src.m10;
dest.m11 = -src.m12;
dest.m12 = -src.m11;
dest.m20 = -src.m20;
dest.m21 = -src.m22;
dest.m22 = -src.m21;
return dest;
}
/** Set the matrix to be the identity matrix.
*
* @param m The matrix to be set to the identity
* @return m */
public static Matrix3f setIdentity(Matrix3f m)
{
m.m00 = 1.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m10 = 0.0f;
m.m11 = 1.0f;
m.m12 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 1.0f;
return m;
}
/** Set the matrix matrix to 0.
*
* @param m The matrix to be set to 0
* @return m */
public static Matrix3f setZero(Matrix3f m)
{
m.m00 = 0.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m10 = 0.0f;
m.m11 = 0.0f;
m.m12 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 0.0f;
return m;
}
/** Subtract the right matrix from the left and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix3f sub(Matrix3f left, Matrix3f right, Matrix3f dest)
{
if (dest == null)
dest = new Matrix3f();
dest.m00 = left.m00 - right.m00;
dest.m01 = left.m01 - right.m01;
dest.m02 = left.m02 - right.m02;
dest.m10 = left.m10 - right.m10;
dest.m11 = left.m11 - right.m11;
dest.m12 = left.m12 - right.m12;
dest.m20 = left.m20 - right.m20;
dest.m21 = left.m21 - right.m21;
dest.m22 = left.m22 - right.m22;
return dest;
}
/** Transform a Vector by a matrix and return the result in a destination
* vector.
*
* @param left The left matrix
* @param right The right vector
* @param dest The destination vector, or null if a new one is to be created
* @return the destination vector */
public static Vector3f transform(Matrix3f left, Vector3f right, Vector3f dest)
{
if (dest == null) dest = new Vector3f();
float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z;
float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z;
float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z;
dest.x = x;
dest.y = y;
dest.z = z;
return dest;
}
/** Transpose the source matrix and place the result into the destination matrix
*
* @param src The source matrix to be transposed
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix */
public static Matrix3f transpose(Matrix3f src, Matrix3f dest)
{
if (dest == null)
dest = new Matrix3f();
float m00 = src.m00;
float m01 = src.m10;
float m02 = src.m20;
float m10 = src.m01;
float m11 = src.m11;
float m12 = src.m21;
float m20 = src.m02;
float m21 = src.m12;
float m22 = src.m22;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
return dest;
}
public float m00,
m01,
m02,
m10,
m11,
m12,
m20,
m21,
m22;
/** Constructor for Matrix3f. Matrix is initialised to the identity. */
public Matrix3f()
{
super();
setIdentity();
}
/** @return the determinant of the matrix */
@Override
public float determinant()
{
float f = m00 * (m11 * m22 - m12 * m21)
+ m01 * (m12 * m20 - m10 * m22)
+ m02 * (m10 * m21 - m11 * m20);
return f;
}
/** Invert this matrix
*
* @return this if successful, null otherwise */
@Override
public Matrix invert()
{ return invert(this, this); }
/** Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this */
@Override
public Matrix load(FloatBuffer buf)
{
m00 = buf.get();
m01 = buf.get();
m02 = buf.get();
m10 = buf.get();
m11 = buf.get();
m12 = buf.get();
m20 = buf.get();
m21 = buf.get();
m22 = buf.get();
return this;
}
/** Load from another matrix
*
* @param src The source matrix
* @return this */
public Matrix3f load(Matrix3f src)
{ return load(src, this); }
/** Load from a float buffer. The buffer stores the matrix in row major
* (maths) order.
*
* @param buf A float buffer to read from
* @return this */
@Override
public Matrix loadTranspose(FloatBuffer buf)
{
m00 = buf.get();
m10 = buf.get();
m20 = buf.get();
m01 = buf.get();
m11 = buf.get();
m21 = buf.get();
m02 = buf.get();
m12 = buf.get();
m22 = buf.get();
return this;
}
/** Negate this matrix
*
* @return this */
@Override
public Matrix negate()
{ return negate(this); }
/** Negate this matrix and place the result in a destination matrix.
*
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix */
public Matrix3f negate(Matrix3f dest)
{ return negate(this, dest); }
/** Set this matrix to be the identity matrix.
*
* @return this */
@Override
public Matrix setIdentity()
{ return setIdentity(this); }
/** Set this matrix to 0.
*
* @return this */
@Override
public Matrix setZero()
{ return setZero(this); }
/** Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
*
* @param buf The buffer to store this matrix in */
@Override
public Matrix store(FloatBuffer buf)
{
buf.put(m00);
buf.put(m01);
buf.put(m02);
buf.put(m10);
buf.put(m11);
buf.put(m12);
buf.put(m20);
buf.put(m21);
buf.put(m22);
return this;
}
/** Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
*
* @param buf The buffer to store this matrix in */
@Override
public Matrix storeTranspose(FloatBuffer buf)
{
buf.put(m00);
buf.put(m10);
buf.put(m20);
buf.put(m01);
buf.put(m11);
buf.put(m21);
buf.put(m02);
buf.put(m12);
buf.put(m22);
return this;
}
/** Returns a string representation of this matrix */
@Override
public String toString()
{
StringBuilder buf = new StringBuilder();
buf.append(m00).append(' ').append(m10).append(' ').append(m20).append(' ').append('\n');
buf.append(m01).append(' ').append(m11).append(' ').append(m21).append(' ').append('\n');
buf.append(m02).append(' ').append(m12).append(' ').append(m22).append(' ').append('\n');
return buf.toString();
}
/** Transpose this matrix
*
* @return this */
@Override
public Matrix transpose()
{ return transpose(this, this); }
/** Transpose this matrix and place the result in another matrix
*
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix */
public Matrix3f transpose(Matrix3f dest)
{ return transpose(this, dest); }
}

799
src/main/java/com/github/hydos/ginger/engine/math/matrixes/Matrix4f.java
View File

@ -1,799 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.matrixes;
import java.io.Serializable;
import java.nio.FloatBuffer;
import org.joml.Vector4f;
import com.github.hydos.ginger.engine.math.vectors.*;
/** Holds a 4x4 float matrix.
*
* @author foo */
@Deprecated
public class Matrix4f extends Matrix implements Serializable
{
private static final long serialVersionUID = 1L;
/** Add two matrices together and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix4f add(Matrix4f left, Matrix4f right, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m00 = left.m00 + right.m00;
dest.m01 = left.m01 + right.m01;
dest.m02 = left.m02 + right.m02;
dest.m03 = left.m03 + right.m03;
dest.m10 = left.m10 + right.m10;
dest.m11 = left.m11 + right.m11;
dest.m12 = left.m12 + right.m12;
dest.m13 = left.m13 + right.m13;
dest.m20 = left.m20 + right.m20;
dest.m21 = left.m21 + right.m21;
dest.m22 = left.m22 + right.m22;
dest.m23 = left.m23 + right.m23;
dest.m30 = left.m30 + right.m30;
dest.m31 = left.m31 + right.m31;
dest.m32 = left.m32 + right.m32;
dest.m33 = left.m33 + right.m33;
return dest;
}
/** Calculate the determinant of a 3x3 matrix
*
* @return result */
private static float determinant3x3(float t00, float t01, float t02,
float t10, float t11, float t12,
float t20, float t21, float t22)
{ return t00 * (t11 * t22 - t12 * t21)
+ t01 * (t12 * t20 - t10 * t22)
+ t02 * (t10 * t21 - t11 * t20); }
/** Invert the source matrix and put the result in the destination
*
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return The inverted matrix if successful, null otherwise */
public static Matrix4f invert(Matrix4f src, Matrix4f dest)
{
float determinant = src.determinant();
if (determinant != 0)
{
/*
* m00 m01 m02 m03
* m10 m11 m12 m13
* m20 m21 m22 m23
* m30 m31 m32 m33
*/
if (dest == null)
dest = new Matrix4f();
float determinant_inv = 1f / determinant;
// first row
float t00 = determinant3x3(src.m11, src.m12, src.m13, src.m21, src.m22, src.m23, src.m31, src.m32, src.m33);
float t01 = -determinant3x3(src.m10, src.m12, src.m13, src.m20, src.m22, src.m23, src.m30, src.m32, src.m33);
float t02 = determinant3x3(src.m10, src.m11, src.m13, src.m20, src.m21, src.m23, src.m30, src.m31, src.m33);
float t03 = -determinant3x3(src.m10, src.m11, src.m12, src.m20, src.m21, src.m22, src.m30, src.m31, src.m32);
// second row
float t10 = -determinant3x3(src.m01, src.m02, src.m03, src.m21, src.m22, src.m23, src.m31, src.m32, src.m33);
float t11 = determinant3x3(src.m00, src.m02, src.m03, src.m20, src.m22, src.m23, src.m30, src.m32, src.m33);
float t12 = -determinant3x3(src.m00, src.m01, src.m03, src.m20, src.m21, src.m23, src.m30, src.m31, src.m33);
float t13 = determinant3x3(src.m00, src.m01, src.m02, src.m20, src.m21, src.m22, src.m30, src.m31, src.m32);
// third row
float t20 = determinant3x3(src.m01, src.m02, src.m03, src.m11, src.m12, src.m13, src.m31, src.m32, src.m33);
float t21 = -determinant3x3(src.m00, src.m02, src.m03, src.m10, src.m12, src.m13, src.m30, src.m32, src.m33);
float t22 = determinant3x3(src.m00, src.m01, src.m03, src.m10, src.m11, src.m13, src.m30, src.m31, src.m33);
float t23 = -determinant3x3(src.m00, src.m01, src.m02, src.m10, src.m11, src.m12, src.m30, src.m31, src.m32);
// fourth row
float t30 = -determinant3x3(src.m01, src.m02, src.m03, src.m11, src.m12, src.m13, src.m21, src.m22, src.m23);
float t31 = determinant3x3(src.m00, src.m02, src.m03, src.m10, src.m12, src.m13, src.m20, src.m22, src.m23);
float t32 = -determinant3x3(src.m00, src.m01, src.m03, src.m10, src.m11, src.m13, src.m20, src.m21, src.m23);
float t33 = determinant3x3(src.m00, src.m01, src.m02, src.m10, src.m11, src.m12, src.m20, src.m21, src.m22);
// transpose and divide by the determinant
dest.m00 = t00 * determinant_inv;
dest.m11 = t11 * determinant_inv;
dest.m22 = t22 * determinant_inv;
dest.m33 = t33 * determinant_inv;
dest.m01 = t10 * determinant_inv;
dest.m10 = t01 * determinant_inv;
dest.m20 = t02 * determinant_inv;
dest.m02 = t20 * determinant_inv;
dest.m12 = t21 * determinant_inv;
dest.m21 = t12 * determinant_inv;
dest.m03 = t30 * determinant_inv;
dest.m30 = t03 * determinant_inv;
dest.m13 = t31 * determinant_inv;
dest.m31 = t13 * determinant_inv;
dest.m32 = t23 * determinant_inv;
dest.m23 = t32 * determinant_inv;
return dest;
}
else
return null;
}
/** Copy the source matrix to the destination matrix
*
* @param src The source matrix
* @param dest The destination matrix, or null of a new one is to be created
* @return The copied matrix */
public static Matrix4f load(Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m00 = src.m00;
dest.m01 = src.m01;
dest.m02 = src.m02;
dest.m03 = src.m03;
dest.m10 = src.m10;
dest.m11 = src.m11;
dest.m12 = src.m12;
dest.m13 = src.m13;
dest.m20 = src.m20;
dest.m21 = src.m21;
dest.m22 = src.m22;
dest.m23 = src.m23;
dest.m30 = src.m30;
dest.m31 = src.m31;
dest.m32 = src.m32;
dest.m33 = src.m33;
return dest;
}
public static Matrix4f mul(Matrix4f left, Matrix4f right, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
float m00 = left.m00 * right.m00 + left.m10 * right.m01 + left.m20 * right.m02 + left.m30 * right.m03;
float m01 = left.m01 * right.m00 + left.m11 * right.m01 + left.m21 * right.m02 + left.m31 * right.m03;
float m02 = left.m02 * right.m00 + left.m12 * right.m01 + left.m22 * right.m02 + left.m32 * right.m03;
float m03 = left.m03 * right.m00 + left.m13 * right.m01 + left.m23 * right.m02 + left.m33 * right.m03;
float m10 = left.m00 * right.m10 + left.m10 * right.m11 + left.m20 * right.m12 + left.m30 * right.m13;
float m11 = left.m01 * right.m10 + left.m11 * right.m11 + left.m21 * right.m12 + left.m31 * right.m13;
float m12 = left.m02 * right.m10 + left.m12 * right.m11 + left.m22 * right.m12 + left.m32 * right.m13;
float m13 = left.m03 * right.m10 + left.m13 * right.m11 + left.m23 * right.m12 + left.m33 * right.m13;
float m20 = left.m00 * right.m20 + left.m10 * right.m21 + left.m20 * right.m22 + left.m30 * right.m23;
float m21 = left.m01 * right.m20 + left.m11 * right.m21 + left.m21 * right.m22 + left.m31 * right.m23;
float m22 = left.m02 * right.m20 + left.m12 * right.m21 + left.m22 * right.m22 + left.m32 * right.m23;
float m23 = left.m03 * right.m20 + left.m13 * right.m21 + left.m23 * right.m22 + left.m33 * right.m23;
float m30 = left.m00 * right.m30 + left.m10 * right.m31 + left.m20 * right.m32 + left.m30 * right.m33;
float m31 = left.m01 * right.m30 + left.m11 * right.m31 + left.m21 * right.m32 + left.m31 * right.m33;
float m32 = left.m02 * right.m30 + left.m12 * right.m31 + left.m22 * right.m32 + left.m32 * right.m33;
float m33 = left.m03 * right.m30 + left.m13 * right.m31 + left.m23 * right.m32 + left.m33 * right.m33;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m03 = m03;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m13 = m13;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
dest.m23 = m23;
dest.m30 = m30;
dest.m31 = m31;
dest.m32 = m32;
dest.m33 = m33;
return dest;
}
/** Negate this matrix and place the result in a destination matrix.
*
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return The negated matrix */
public static Matrix4f negate(Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m00 = -src.m00;
dest.m01 = -src.m01;
dest.m02 = -src.m02;
dest.m03 = -src.m03;
dest.m10 = -src.m10;
dest.m11 = -src.m11;
dest.m12 = -src.m12;
dest.m13 = -src.m13;
dest.m20 = -src.m20;
dest.m21 = -src.m21;
dest.m22 = -src.m22;
dest.m23 = -src.m23;
dest.m30 = -src.m30;
dest.m31 = -src.m31;
dest.m32 = -src.m32;
dest.m33 = -src.m33;
return dest;
}
/** Rotates the source matrix around the given axis the specified angle and
* put the result in the destination matrix.
*
* @param angle the angle, in radians.
* @param axis The vector representing the rotation axis. Must be normalized.
* @param src The matrix to rotate
* @param dest The matrix to put the result, or null if a new matrix is to be created
* @return The rotated matrix */
public static Matrix4f rotate(float angle, Vector3f axis, Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
float c = (float) Math.cos(angle);
float s = (float) Math.sin(angle);
float oneminusc = 1.0f - c;
float xy = axis.x * axis.y;
float yz = axis.y * axis.z;
float xz = axis.x * axis.z;
float xs = axis.x * s;
float ys = axis.y * s;
float zs = axis.z * s;
float f00 = axis.x * axis.x * oneminusc + c;
float f01 = xy * oneminusc + zs;
float f02 = xz * oneminusc - ys;
// n[3] not used
float f10 = xy * oneminusc - zs;
float f11 = axis.y * axis.y * oneminusc + c;
float f12 = yz * oneminusc + xs;
// n[7] not used
float f20 = xz * oneminusc + ys;
float f21 = yz * oneminusc - xs;
float f22 = axis.z * axis.z * oneminusc + c;
float t00 = src.m00 * f00 + src.m10 * f01 + src.m20 * f02;
float t01 = src.m01 * f00 + src.m11 * f01 + src.m21 * f02;
float t02 = src.m02 * f00 + src.m12 * f01 + src.m22 * f02;
float t03 = src.m03 * f00 + src.m13 * f01 + src.m23 * f02;
float t10 = src.m00 * f10 + src.m10 * f11 + src.m20 * f12;
float t11 = src.m01 * f10 + src.m11 * f11 + src.m21 * f12;
float t12 = src.m02 * f10 + src.m12 * f11 + src.m22 * f12;
float t13 = src.m03 * f10 + src.m13 * f11 + src.m23 * f12;
dest.m20 = src.m00 * f20 + src.m10 * f21 + src.m20 * f22;
dest.m21 = src.m01 * f20 + src.m11 * f21 + src.m21 * f22;
dest.m22 = src.m02 * f20 + src.m12 * f21 + src.m22 * f22;
dest.m23 = src.m03 * f20 + src.m13 * f21 + src.m23 * f22;
dest.m00 = t00;
dest.m01 = t01;
dest.m02 = t02;
dest.m03 = t03;
dest.m10 = t10;
dest.m11 = t11;
dest.m12 = t12;
dest.m13 = t13;
return dest;
}
/** Scales the source matrix and put the result in the destination matrix
*
* @param vec The vector to scale by
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return The scaled matrix */
public static Matrix4f scale(Vector3f vec, Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m00 = src.m00 * vec.x;
dest.m01 = src.m01 * vec.x;
dest.m02 = src.m02 * vec.x;
dest.m03 = src.m03 * vec.x;
dest.m10 = src.m10 * vec.y;
dest.m11 = src.m11 * vec.y;
dest.m12 = src.m12 * vec.y;
dest.m13 = src.m13 * vec.y;
dest.m20 = src.m20 * vec.z;
dest.m21 = src.m21 * vec.z;
dest.m22 = src.m22 * vec.z;
dest.m23 = src.m23 * vec.z;
return dest;
}
/** Set the given matrix to be the identity matrix.
*
* @param m The matrix to set to the identity
* @return m */
public static Matrix4f setIdentity(Matrix4f m)
{
m.m00 = 1.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m03 = 0.0f;
m.m10 = 0.0f;
m.m11 = 1.0f;
m.m12 = 0.0f;
m.m13 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 1.0f;
m.m23 = 0.0f;
m.m30 = 0.0f;
m.m31 = 0.0f;
m.m32 = 0.0f;
m.m33 = 1.0f;
return m;
}
/** Set the given matrix to 0.
*
* @param m The matrix to set to 0
* @return m */
public static Matrix4f setZero(Matrix4f m)
{
m.m00 = 0.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m03 = 0.0f;
m.m10 = 0.0f;
m.m11 = 0.0f;
m.m12 = 0.0f;
m.m13 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 0.0f;
m.m23 = 0.0f;
m.m30 = 0.0f;
m.m31 = 0.0f;
m.m32 = 0.0f;
m.m33 = 0.0f;
return m;
}
/** Subtract the right matrix from the left and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public static Matrix4f sub(Matrix4f left, Matrix4f right, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m00 = left.m00 - right.m00;
dest.m01 = left.m01 - right.m01;
dest.m02 = left.m02 - right.m02;
dest.m03 = left.m03 - right.m03;
dest.m10 = left.m10 - right.m10;
dest.m11 = left.m11 - right.m11;
dest.m12 = left.m12 - right.m12;
dest.m13 = left.m13 - right.m13;
dest.m20 = left.m20 - right.m20;
dest.m21 = left.m21 - right.m21;
dest.m22 = left.m22 - right.m22;
dest.m23 = left.m23 - right.m23;
dest.m30 = left.m30 - right.m30;
dest.m31 = left.m31 - right.m31;
dest.m32 = left.m32 - right.m32;
dest.m33 = left.m33 - right.m33;
return dest;
}
/** Transform a Vector by a matrix and return the result in a destination
* vector.
*
* @param left The left matrix
* @param right The right vector
* @param dest The destination vector, or null if a new one is to be created
* @return the destination vector */
public static Vector4f transform(Matrix4f left, Vector4f right, Vector4f dest)
{
if (dest == null)
dest = new Vector4f();
float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z + left.m30 * right.w;
float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z + left.m31 * right.w;
float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z + left.m32 * right.w;
float w = left.m03 * right.x + left.m13 * right.y + left.m23 * right.z + left.m33 * right.w;
dest.x = x;
dest.y = y;
dest.z = z;
dest.w = w;
return dest;
}
/** Translate the source matrix and stash the result in the destination matrix
*
* @param vec The vector to translate by
* @param src The source matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return The translated matrix */
public static Matrix4f translate(Vector2f vec, Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m30 += src.m00 * vec.x + src.m10 * vec.y;
dest.m31 += src.m01 * vec.x + src.m11 * vec.y;
dest.m32 += src.m02 * vec.x + src.m12 * vec.y;
dest.m33 += src.m03 * vec.x + src.m13 * vec.y;
return dest;
}
/** Translate the source matrix and stash the result in the destination matrix
*
* @param vec The vector to translate by
* @param src The source matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return The translated matrix */
public static Matrix4f translate(Vector3f vec, Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
dest.m30 += src.m00 * vec.x + src.m10 * vec.y + src.m20 * vec.z;
dest.m31 += src.m01 * vec.x + src.m11 * vec.y + src.m21 * vec.z;
dest.m32 += src.m02 * vec.x + src.m12 * vec.y + src.m22 * vec.z;
dest.m33 += src.m03 * vec.x + src.m13 * vec.y + src.m23 * vec.z;
return dest;
}
/** Transpose the source matrix and place the result in the destination matrix
*
* @param src The source matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix */
public static Matrix4f transpose(Matrix4f src, Matrix4f dest)
{
if (dest == null)
dest = new Matrix4f();
float m00 = src.m00;
float m01 = src.m10;
float m02 = src.m20;
float m03 = src.m30;
float m10 = src.m01;
float m11 = src.m11;
float m12 = src.m21;
float m13 = src.m31;
float m20 = src.m02;
float m21 = src.m12;
float m22 = src.m22;
float m23 = src.m32;
float m30 = src.m03;
float m31 = src.m13;
float m32 = src.m23;
float m33 = src.m33;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m03 = m03;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m13 = m13;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
dest.m23 = m23;
dest.m30 = m30;
dest.m31 = m31;
dest.m32 = m32;
dest.m33 = m33;
return dest;
}
public float m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33;
/** Construct a new matrix, initialized to the identity. */
public Matrix4f()
{
super();
setIdentity();
}
public Matrix4f(final Matrix4f src)
{
super();
load(src);
}
/** @return the determinant of the matrix */
@Override
public float determinant()
{
float f = m00
* ((m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32)
- m13 * m22 * m31
- m11 * m23 * m32
- m12 * m21 * m33);
f -= m01
* ((m10 * m22 * m33 + m12 * m23 * m30 + m13 * m20 * m32)
- m13 * m22 * m30
- m10 * m23 * m32
- m12 * m20 * m33);
f += m02
* ((m10 * m21 * m33 + m11 * m23 * m30 + m13 * m20 * m31)
- m13 * m21 * m30
- m10 * m23 * m31
- m11 * m20 * m33);
f -= m03
* ((m10 * m21 * m32 + m11 * m22 * m30 + m12 * m20 * m31)
- m12 * m21 * m30
- m10 * m22 * m31
- m11 * m20 * m32);
return f;
}
/** Invert this matrix
*
* @return this if successful, null otherwise */
@Override
public Matrix invert()
{ return invert(this, this); }
/** Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this */
@Override
public Matrix load(FloatBuffer buf)
{
m00 = buf.get();
m01 = buf.get();
m02 = buf.get();
m03 = buf.get();
m10 = buf.get();
m11 = buf.get();
m12 = buf.get();
m13 = buf.get();
m20 = buf.get();
m21 = buf.get();
m22 = buf.get();
m23 = buf.get();
m30 = buf.get();
m31 = buf.get();
m32 = buf.get();
m33 = buf.get();
return this;
}
/** Load from another matrix4f
*
* @param src The source matrix
* @return this */
public Matrix4f load(Matrix4f src)
{ return load(src, this); }
/** Load from a float buffer. The buffer stores the matrix in row major
* (maths) order.
*
* @param buf A float buffer to read from
* @return this */
@Override
public Matrix loadTranspose(FloatBuffer buf)
{
m00 = buf.get();
m10 = buf.get();
m20 = buf.get();
m30 = buf.get();
m01 = buf.get();
m11 = buf.get();
m21 = buf.get();
m31 = buf.get();
m02 = buf.get();
m12 = buf.get();
m22 = buf.get();
m32 = buf.get();
m03 = buf.get();
m13 = buf.get();
m23 = buf.get();
m33 = buf.get();
return this;
}
/** Multiply the right matrix by the left and place the result in a third matrix.
*
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix */
public Matrix4f mul(Matrix4f left)
{ return Matrix4f.mul(left, left, this); }
/** Negate this matrix
*
* @return this */
@Override
public Matrix negate()
{ return negate(this); }
/** Negate this matrix and place the result in a destination matrix.
*
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix */
public Matrix4f negate(Matrix4f dest)
{ return negate(this, dest); }
/** Rotates the matrix around the given axis the specified angle
*
* @param angle the angle, in radians.
* @param axis The vector representing the rotation axis. Must be normalized.
* @return this */
public Matrix4f rotate(float angle, Vector3f axis)
{ return rotate(angle, axis, this); }
/** Rotates the matrix around the given axis the specified angle
*
* @param angle the angle, in radians.
* @param axis The vector representing the rotation axis. Must be normalized.
* @param dest The matrix to put the result, or null if a new matrix is to be created
* @return The rotated matrix */
public Matrix4f rotate(float angle, Vector3f axis, Matrix4f dest)
{ return rotate(angle, axis, this, dest); }
/** Scales this matrix
*
* @param vec The vector to scale by
* @return this */
public Matrix4f scale(Vector3f vec)
{ return scale(vec, this, this); }
/** Set this matrix to be the identity matrix.
*
* @return this */
@Override
public Matrix setIdentity()
{ return setIdentity(this); }
/** Set this matrix to 0.
*
* @return this */
@Override
public Matrix setZero()
{ return setZero(this); }
/** Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
*
* @param buf The buffer to store this matrix in */
@Override
public Matrix store(FloatBuffer buf)
{
buf.put(m00);
buf.put(m01);
buf.put(m02);
buf.put(m03);
buf.put(m10);
buf.put(m11);
buf.put(m12);
buf.put(m13);
buf.put(m20);
buf.put(m21);
buf.put(m22);
buf.put(m23);
buf.put(m30);
buf.put(m31);
buf.put(m32);
buf.put(m33);
return this;
}
/** Store the rotation portion of this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
*
* @param buf The buffer to store this matrix in */
public Matrix store3f(FloatBuffer buf)
{
buf.put(m00);
buf.put(m01);
buf.put(m02);
buf.put(m10);
buf.put(m11);
buf.put(m12);
buf.put(m20);
buf.put(m21);
buf.put(m22);
return this;
}
/** Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
*
* @param buf The buffer to store this matrix in */
@Override
public Matrix storeTranspose(FloatBuffer buf)
{
buf.put(m00);
buf.put(m10);
buf.put(m20);
buf.put(m30);
buf.put(m01);
buf.put(m11);
buf.put(m21);
buf.put(m31);
buf.put(m02);
buf.put(m12);
buf.put(m22);
buf.put(m32);
buf.put(m03);
buf.put(m13);
buf.put(m23);
buf.put(m33);
return this;
}
/** Returns a string representation of this matrix */
@Override
public String toString()
{
StringBuilder buf = new StringBuilder();
buf.append(m00).append(' ').append(m10).append(' ').append(m20).append(' ').append(m30).append('\n');
buf.append(m01).append(' ').append(m11).append(' ').append(m21).append(' ').append(m31).append('\n');
buf.append(m02).append(' ').append(m12).append(' ').append(m22).append(' ').append(m32).append('\n');
buf.append(m03).append(' ').append(m13).append(' ').append(m23).append(' ').append(m33).append('\n');
return buf.toString();
}
/** Translate this matrix
*
* @param vec The vector to translate by
* @return this */
public Matrix4f translate(Vector2f vec)
{ return translate(vec, this); }
/** Translate this matrix and stash the result in another matrix
*
* @param vec The vector to translate by
* @param dest The destination matrix or null if a new matrix is to be created
* @return the translated matrix */
public Matrix4f translate(Vector2f vec, Matrix4f dest)
{ return translate(vec, this, dest); }
/** Translate this matrix
*
* @param vec The vector to translate by
* @return this */
public Matrix4f translate(Vector3f vec)
{ return translate(vec, this); }
/** Translate this matrix and stash the result in another matrix
*
* @param vec The vector to translate by
* @param dest The destination matrix or null if a new matrix is to be created
* @return the translated matrix */
public Matrix4f translate(Vector3f vec, Matrix4f dest)
{ return translate(vec, this, dest); }
/** Transpose this matrix
*
* @return this */
@Override
public Matrix transpose()
{ return transpose(this); }
/** Transpose this matrix and place the result in another matrix
*
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix */
public Matrix4f transpose(Matrix4f dest)
{ return transpose(this, dest); }
}

51
src/main/java/com/github/hydos/ginger/engine/math/vectors/ReadableVector.java
View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
import java.nio.FloatBuffer;
/** @author foo */
@Deprecated
public interface ReadableVector
{
/** @return the length of the vector */
float length();
/** @return the length squared of the vector */
float lengthSquared();
/** Store this vector in a FloatBuffer
*
* @param buf The buffer to store it in, at the current position
* @return this */
Vector store(FloatBuffer buf);
}

43
src/main/java/com/github/hydos/ginger/engine/math/vectors/ReadableVector2f.java
View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
/** @author foo */
@Deprecated
public interface ReadableVector2f extends ReadableVector
{
/** @return x */
float getX();
/** @return y */
float getY();
}

40
src/main/java/com/github/hydos/ginger/engine/math/vectors/ReadableVector3f.java
View File

@ -1,40 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
/** @author foo */
@Deprecated
public interface ReadableVector3f extends ReadableVector2f
{
/** @return z */
float getZ();
}

40
src/main/java/com/github/hydos/ginger/engine/math/vectors/ReadableVector4f.java
View File

@ -1,40 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
/** @author foo */
@Deprecated
public interface ReadableVector4f extends ReadableVector3f
{
/** @return w */
float getW();
}

98
src/main/java/com/github/hydos/ginger/engine/math/vectors/Vector.java
View File

@ -1,98 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
import java.io.Serializable;
import java.nio.FloatBuffer;
/** Base class for vectors.
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public abstract class Vector implements Serializable, ReadableVector
{
private static final long serialVersionUID = 1L;
/** Constructor for Vector. */
protected Vector()
{ super(); }
/** @return the length of the vector */
@Override
public final float length()
{ return (float) Math.sqrt(lengthSquared()); }
/** @return the length squared of the vector */
@Override
public abstract float lengthSquared();
/** Load this vector from a FloatBuffer
*
* @param buf The buffer to load it from, at the current position
* @return this */
public abstract Vector load(FloatBuffer buf);
/** Negate a vector
*
* @return this */
public abstract Vector negate();
/** Normalise this vector
*
* @return this */
public final Vector normalise()
{
float len = length();
if (len != 0.0f)
{
float l = 1.0f / len;
return scale(l);
}
else
throw new IllegalStateException("Zero length vector");
}
/** Scale this vector
*
* @param scale The scale factor
* @return this */
public abstract Vector scale(float scale);
/** Store this vector in a FloatBuffer
*
* @param buf The buffer to store it in, at the current position
* @return this */
@Override
public abstract Vector store(FloatBuffer buf);
}

280
src/main/java/com/github/hydos/ginger/engine/math/vectors/Vector2f.java
View File

@ -1,280 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
import java.io.Serializable;
import java.nio.FloatBuffer;
/** Holds a 2-tuple vector.
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public class Vector2f extends Vector implements Serializable, ReadableVector2f, WritableVector2f
{
private static final long serialVersionUID = 1L;
/** Add a vector to another vector and place the result in a destination
* vector.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return the sum of left and right in dest */
public static Vector2f add(Vector2f left, Vector2f right, Vector2f dest)
{
if (dest == null)
return new Vector2f(left.x + right.x, left.y + right.y);
else
{
dest.set(left.x + right.x, left.y + right.y);
return dest;
}
}
/** Calculate the angle between two vectors, in radians
*
* @param a A vector
* @param b The other vector
* @return the angle between the two vectors, in radians */
public static float angle(Vector2f a, Vector2f b)
{
float dls = dot(a, b) / (a.length() * b.length());
if (dls < -1f)
dls = -1f;
else if (dls > 1.0f)
dls = 1.0f;
return (float) Math.acos(dls);
}
/** The dot product of two vectors is calculated as
* v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
*
* @param left The LHS vector
* @param right The RHS vector
* @return left dot right */
public static float dot(Vector2f left, Vector2f right)
{ return left.x * right.x + left.y * right.y; }
/** Subtract a vector from another vector and place the result in a destination
* vector.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return left minus right in dest */
public static Vector2f sub(Vector2f left, Vector2f right, Vector2f dest)
{
if (dest == null)
return new Vector2f(left.x - right.x, left.y - right.y);
else
{
dest.set(left.x - right.x, left.y - right.y);
return dest;
}
}
public float x, y;
/** Constructor for Vector2f. */
public Vector2f()
{ super(); }
/** Constructor. */
public Vector2f(float x, float y)
{ set(x, y); }
/** Constructor. */
public Vector2f(ReadableVector2f src)
{ set(src); }
@Override
public boolean equals(Object obj)
{
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Vector2f other = (Vector2f) obj;
if (x == other.x && y == other.y) return true;
return false;
}
/** @return x */
@Override
public final float getX()
{ return x; }
/** @return y */
@Override
public final float getY()
{ return y; }
/** @return the length squared of the vector */
@Override
public float lengthSquared()
{ return x * x + y * y; }
/** Load this vector from a FloatBuffer
*
* @param buf The buffer to load it from, at the current position
* @return this */
@Override
public Vector load(FloatBuffer buf)
{
x = buf.get();
y = buf.get();
return this;
}
/** Negate a vector
*
* @return this */
@Override
public Vector negate()
{
x = -x;
y = -y;
return this;
}
/** Negate a vector and place the result in a destination vector.
*
* @param dest The destination vector or null if a new vector is to be created
* @return the negated vector */
public Vector2f negate(Vector2f dest)
{
if (dest == null)
dest = new Vector2f();
dest.x = -x;
dest.y = -y;
return dest;
}
/** Normalise this vector and place the result in another vector.
*
* @param dest The destination vector, or null if a new vector is to be created
* @return the normalised vector */
public Vector2f normalise(Vector2f dest)
{
float l = length();
if (dest == null)
dest = new Vector2f(x / l, y / l);
else
dest.set(x / l, y / l);
return dest;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#scale(float)
*/
@Override
public Vector scale(float scale)
{
x *= scale;
y *= scale;
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
@Override
public void set(float x, float y)
{
this.x = x;
this.y = y;
}
/** Load from another Vector2f
*
* @param src The source vector
* @return this */
public Vector2f set(ReadableVector2f src)
{
x = src.getX();
y = src.getY();
return this;
}
/** Set X
*
* @param x */
@Override
public final void setX(float x)
{ this.x = x; }
/** Set Y
*
* @param y */
@Override
public final void setY(float y)
{ this.y = y; }
/** Store this vector in a FloatBuffer
*
* @param buf The buffer to store it in, at the current position
* @return this */
@Override
public Vector store(FloatBuffer buf)
{
buf.put(x);
buf.put(y);
return this;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString()
{
StringBuilder sb = new StringBuilder(64);
sb.append("Vector2f[");
sb.append(x);
sb.append(", ");
sb.append(y);
sb.append(']');
return sb.toString();
}
/** Translate a vector
*
* @param x The translation in x
* @param y the translation in y
* @return this */
public Vector2f translate(float x, float y)
{
this.x += x;
this.y += y;
return this;
}
}

341
src/main/java/com/github/hydos/ginger/engine/math/vectors/Vector3f.java
View File

@ -1,341 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
import java.io.Serializable;
import java.nio.FloatBuffer;
/** Holds a 3-tuple vector.
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public class Vector3f extends Vector implements Serializable, ReadableVector3f, WritableVector3f
{
private static final long serialVersionUID = 1L;
/** Add a vector to another vector and place the result in a destination
* vector.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return the sum of left and right in dest */
public static Vector3f add(Vector3f left, Vector3f right, Vector3f dest)
{
if (dest == null)
return new Vector3f(left.x + right.x, left.y + right.y, left.z + right.z);
else
{
dest.set(left.x + right.x, left.y + right.y, left.z + right.z);
return dest;
}
}
/** Calculate the angle between two vectors, in radians
*
* @param a A vector
* @param b The other vector
* @return the angle between the two vectors, in radians */
public static float angle(Vector3f a, Vector3f b)
{
float dls = dot(a, b) / (a.length() * b.length());
if (dls < -1f)
dls = -1f;
else if (dls > 1.0f)
dls = 1.0f;
return (float) Math.acos(dls);
}
/** The cross product of two vectors.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination result, or null if a new vector is to be created
* @return left cross right */
public static Vector3f cross(
Vector3f left,
Vector3f right,
Vector3f dest)
{
if (dest == null)
dest = new Vector3f();
dest.set(
left.y * right.z - left.z * right.y,
right.x * left.z - right.z * left.x,
left.x * right.y - left.y * right.x);
return dest;
}
/** The dot product of two vectors is calculated as
* v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
*
* @param left The LHS vector
* @param right The RHS vector
* @return left dot right */
public static float dot(Vector3f left, Vector3f right)
{ return left.x * right.x + left.y * right.y + left.z * right.z; }
/** Subtract a vector from another vector and place the result in a destination
* vector.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return left minus right in dest */
public static Vector3f sub(Vector3f left, Vector3f right, Vector3f dest)
{
if (dest == null)
return new Vector3f(left.x - right.x, left.y - right.y, left.z - right.z);
else
{
dest.set(left.x - right.x, left.y - right.y, left.z - right.z);
return dest;
}
}
public float x, y, z;
/** Constructor for Vector3f. */
public Vector3f()
{ super(); }
/** Constructor */
public Vector3f(float x, float y, float z)
{ set(x, y, z); }
/** Constructor */
public Vector3f(ReadableVector3f src)
{ set(src); }
public Vector3f add(Vector3f vector)
{ return new Vector3f(x + vector.x, y + vector.y, z + vector.z); }
@Override
public boolean equals(Object obj)
{
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Vector3f other = (Vector3f) obj;
if (x == other.x && y == other.y && z == other.z) return true;
return false;
}
/** @return x */
@Override
public final float getX()
{ return x; }
/** @return y */
@Override
public final float getY()
{ return y; }
/* (Overrides)
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
@Override
public float getZ()
{ return z; }
/** @return the length squared of the vector */
@Override
public float lengthSquared()
{ return x * x + y * y + z * z; }
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#load(FloatBuffer)
*/
@Override
public Vector load(FloatBuffer buf)
{
x = buf.get();
y = buf.get();
z = buf.get();
return this;
}
public Vector3f mul(float value)
{ return new Vector3f(x * value, y * value, z * value); }
public Vector3f mul(Vector3f vector)
{ return new Vector3f(x * vector.x, y * vector.y, z * vector.z); }
/** Negate a vector
*
* @return this */
@Override
public Vector negate()
{
x = -x;
y = -y;
z = -z;
return this;
}
/** Negate a vector and place the result in a destination vector.
*
* @param dest The destination vector or null if a new vector is to be created
* @return the negated vector */
public Vector3f negate(Vector3f dest)
{
if (dest == null)
dest = new Vector3f();
dest.x = -x;
dest.y = -y;
dest.z = -z;
return dest;
}
/** Normalise this vector and place the result in another vector.
*
* @param dest The destination vector, or null if a new vector is to be created
* @return the normalised vector */
public Vector3f normalise(Vector3f dest)
{
float l = length();
if (dest == null)
dest = new Vector3f(x / l, y / l, z / l);
else
dest.set(x / l, y / l, z / l);
return dest;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#scale(float)
*/
@Override
public Vector scale(float scale)
{
x *= scale;
y *= scale;
z *= scale;
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
@Override
public void set(float x, float y)
{
this.x = x;
this.y = y;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float)
*/
@Override
public void set(float x, float y, float z)
{
this.x = x;
this.y = y;
this.z = z;
}
/** Load from another Vector3f
*
* @param src The source vector
* @return this */
public Vector3f set(ReadableVector3f src)
{
x = src.getX();
y = src.getY();
z = src.getZ();
return this;
}
/** Set X
*
* @param x */
@Override
public final void setX(float x)
{ this.x = x; }
/** Set Y
*
* @param y */
@Override
public final void setY(float y)
{ this.y = y; }
/** Set Z
*
* @param z */
@Override
public void setZ(float z)
{ this.z = z; }
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#store(FloatBuffer)
*/
@Override
public Vector store(FloatBuffer buf)
{
buf.put(x);
buf.put(y);
buf.put(z);
return this;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString()
{
StringBuilder sb = new StringBuilder(64);
sb.append("Vector3f[");
sb.append(x);
sb.append(", ");
sb.append(y);
sb.append(", ");
sb.append(z);
sb.append(']');
return sb.toString();
}
/** Translate a vector
*
* @param x The translation in x
* @param y the translation in y
* @return this */
public Vector3f translate(float x, float y, float z)
{
this.x += x;
this.y += y;
this.z += z;
return this;
}
}

332
src/main/java/com/github/hydos/ginger/engine/math/vectors/Vector4f.java
View File

@ -1,332 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
import java.io.Serializable;
import java.nio.FloatBuffer;
/** Holds a 4-tuple vector.
*
* @author cix_foo <cix_foo@users.sourceforge.net>
* @version $Revision$
* $Id$ */
@Deprecated
public class Vector4f extends Vector implements Serializable, ReadableVector4f, WritableVector4f
{
private static final long serialVersionUID = 1L;
/** Add a vector to another vector and place the result in a destination
* vector.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return the sum of left and right in dest */
public static Vector4f add(Vector4f left, Vector4f right, Vector4f dest)
{
if (dest == null)
return new Vector4f(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w);
else
{
dest.set(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w);
return dest;
}
}
/** Calculate the angle between two vectors, in radians
*
* @param a A vector
* @param b The other vector
* @return the angle between the two vectors, in radians */
public static float angle(Vector4f a, Vector4f b)
{
float dls = dot(a, b) / (a.length() * b.length());
if (dls < -1f)
dls = -1f;
else if (dls > 1.0f)
dls = 1.0f;
return (float) Math.acos(dls);
}
/** The dot product of two vectors is calculated as
* v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w
*
* @param left The LHS vector
* @param right The RHS vector
* @return left dot right */
public static float dot(Vector4f left, Vector4f right)
{ return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w; }
/** Subtract a vector from another vector and place the result in a destination
* vector.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return left minus right in dest */
public static Vector4f sub(Vector4f left, Vector4f right, Vector4f dest)
{
if (dest == null)
return new Vector4f(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w);
else
{
dest.set(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w);
return dest;
}
}
public float x, y, z, w;
/** Constructor for Vector4f. */
public Vector4f()
{ super(); }
/** Constructor */
public Vector4f(float x, float y, float z, float w)
{ set(x, y, z, w); }
/** Constructor */
public Vector4f(ReadableVector4f src)
{ set(src); }
@Override
public boolean equals(Object obj)
{
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Vector4f other = (Vector4f) obj;
if (x == other.x && y == other.y && z == other.z && w == other.w) return true;
return false;
}
/* (Overrides)
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
@Override
public float getW()
{ return w; }
/** @return x */
@Override
public final float getX()
{ return x; }
/** @return y */
@Override
public final float getY()
{ return y; }
/* (Overrides)
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
@Override
public float getZ()
{ return z; }
/** @return the length squared of the vector */
@Override
public float lengthSquared()
{ return x * x + y * y + z * z + w * w; }
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#load(FloatBuffer)
*/
@Override
public Vector load(FloatBuffer buf)
{
x = buf.get();
y = buf.get();
z = buf.get();
w = buf.get();
return this;
}
/** Negate a vector
*
* @return this */
@Override
public Vector negate()
{
x = -x;
y = -y;
z = -z;
w = -w;
return this;
}
/** Negate a vector and place the result in a destination vector.
*
* @param dest The destination vector or null if a new vector is to be created
* @return the negated vector */
public Vector4f negate(Vector4f dest)
{
if (dest == null)
dest = new Vector4f();
dest.x = -x;
dest.y = -y;
dest.z = -z;
dest.w = -w;
return dest;
}
/** Normalise this vector and place the result in another vector.
*
* @param dest The destination vector, or null if a new vector is to be created
* @return the normalised vector */
public Vector4f normalise(Vector4f dest)
{
float l = length();
if (dest == null)
dest = new Vector4f(x / l, y / l, z / l, w / l);
else
dest.set(x / l, y / l, z / l, w / l);
return dest;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#scale(float)
*/
@Override
public Vector scale(float scale)
{
x *= scale;
y *= scale;
z *= scale;
w *= scale;
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
@Override
public void set(float x, float y)
{
this.x = x;
this.y = y;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float)
*/
@Override
public void set(float x, float y, float z)
{
this.x = x;
this.y = y;
this.z = z;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector4f#set(float, float, float, float)
*/
@Override
public void set(float x, float y, float z, float w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/** Load from another Vector4f
*
* @param src The source vector
* @return this */
public Vector4f set(ReadableVector4f src)
{
x = src.getX();
y = src.getY();
z = src.getZ();
w = src.getW();
return this;
}
/** Set W
*
* @param w */
@Override
public void setW(float w)
{ this.w = w; }
/** Set X
*
* @param x */
@Override
public final void setX(float x)
{ this.x = x; }
/** Set Y
*
* @param y */
@Override
public final void setY(float y)
{ this.y = y; }
/** Set Z
*
* @param z */
@Override
public void setZ(float z)
{ this.z = z; }
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#store(FloatBuffer)
*/
@Override
public Vector store(FloatBuffer buf)
{
buf.put(x);
buf.put(y);
buf.put(z);
buf.put(w);
return this;
}
@Override
public String toString()
{ return "Vector4f: " + x + " " + y + " " + z + " " + w; }
/** Translate a vector
*
* @param x The translation in x
* @param y the translation in y
* @return this */
public Vector4f translate(float x, float y, float z, float w)
{
this.x += x;
this.y += y;
this.z += z;
this.w += w;
return this;
}
}

57
src/main/java/com/github/hydos/ginger/engine/math/vectors/WritableVector2f.java
View File

@ -1,57 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
/** Writable interface to Vector2fs
*
* @author $author$
* @version $revision$
* $Id$ */
@Deprecated
public interface WritableVector2f
{
/** Set the X,Y values
*
* @param x
* @param y */
void set(float x, float y);
/** Set the X value
*
* @param x */
void setX(float x);
/** Set the Y value
*
* @param y */
void setY(float y);
}

53
src/main/java/com/github/hydos/ginger/engine/math/vectors/WritableVector3f.java
View File

@ -1,53 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
/** Writable interface to Vector3fs
*
* @author $author$
* @version $revision$
* $Id$ */
@Deprecated
public interface WritableVector3f extends WritableVector2f
{
/** Set the X,Y,Z values
*
* @param x
* @param y
* @param z */
void set(float x, float y, float z);
/** Set the Z value
*
* @param z */
void setZ(float z);
}

54
src/main/java/com/github/hydos/ginger/engine/math/vectors/WritableVector4f.java
View File

@ -1,54 +0,0 @@
/*
* Copyright (c) 2002-2008 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.github.hydos.ginger.engine.math.vectors;
/** Writable interface to Vector4fs
*
* @author $author$
* @version $revision$
* $Id$ */
@Deprecated
public interface WritableVector4f extends WritableVector3f
{
/** Set the X,Y,Z,W values
*
* @param x
* @param y
* @param z
* @param w */
void set(float x, float y, float z, float w);
/** Set the W value
*
* @param w */
void setW(float w);
}

6
src/main/java/com/github/hydos/ginger/engine/obj/OBJFileLoader.java
View File

@ -1,10 +1,9 @@
package com.github.hydos.ginger.engine.obj;
import org.joml.*;
import org.lwjgl.assimp.*;
import org.lwjgl.assimp.AIVector3D.Buffer;
import com.github.hydos.ginger.engine.math.vectors.*;
public class OBJFileLoader
{
public static String resourceLocation = "~/Desktop/Ginger3D/src/main/resources/models/";
@ -32,8 +31,7 @@ public class OBJFileLoader
if (mesh.mNumUVComponents().get(0) != 0)
{
AIVector3D texture = mesh.mTextureCoords(0).get(i);
meshTextureCoord.setX(texture.x());
meshTextureCoord.setY(texture.y());
meshTextureCoord.set(texture.x(),texture.y());
}
vertexList[i] = new Vertex(meshVertex, meshNormal, meshTextureCoord);
}

2
src/main/java/com/github/hydos/ginger/engine/obj/Vertex.java
View File

@ -1,6 +1,6 @@
package com.github.hydos.ginger.engine.obj;
import com.github.hydos.ginger.engine.math.vectors.*;
import org.joml.*;
public class Vertex
{

19
src/main/java/com/github/hydos/ginger/engine/obj/normals/NormalMappedObjLoader.java
View File

@ -3,7 +3,8 @@ package com.github.hydos.ginger.engine.obj.normals;
import java.io.*;
import java.util.*;
import com.github.hydos.ginger.engine.math.vectors.*;
import org.joml.*;
import com.github.hydos.ginger.engine.render.models.RawModel;
import com.github.hydos.ginger.engine.utils.Loader;
@ -12,18 +13,18 @@ public class NormalMappedObjLoader
private static void calculateTangents(VertexNM v0, VertexNM v1, VertexNM v2,
List<Vector2f> textures)
{
Vector3f delatPos1 = Vector3f.sub(v1.getPosition(), v0.getPosition(), null);
Vector3f delatPos2 = Vector3f.sub(v2.getPosition(), v0.getPosition(), null);
Vector3f delatPos1 = v1.getPosition().sub(v0.getPosition());
Vector3f delatPos2 = v2.getPosition().sub(v0.getPosition());
Vector2f uv0 = textures.get(v0.getTextureIndex());
Vector2f uv1 = textures.get(v1.getTextureIndex());
Vector2f uv2 = textures.get(v2.getTextureIndex());
Vector2f deltaUv1 = Vector2f.sub(uv1, uv0, null);
Vector2f deltaUv2 = Vector2f.sub(uv2, uv0, null);
Vector2f deltaUv1 = uv1.sub(uv0);
Vector2f deltaUv2 = uv2.sub(uv0);
float r = 1.0f / (deltaUv1.x * deltaUv2.y - deltaUv1.y * deltaUv2.x);
delatPos1.scale(deltaUv2.y);
delatPos2.scale(deltaUv1.y);
Vector3f tangent = Vector3f.sub(delatPos1, delatPos2, null);
tangent.scale(r);
delatPos1.mul(deltaUv2.y);
delatPos2.mul(deltaUv1.y);
Vector3f tangent = delatPos1.sub(delatPos2);
tangent.mul(r);
v0.addTangent(tangent);
v1.addTangent(tangent);
v2.addTangent(tangent);

6
src/main/java/com/github/hydos/ginger/engine/obj/normals/VertexNM.java
View File

@ -2,7 +2,7 @@ package com.github.hydos.ginger.engine.obj.normals;
import java.util.*;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import org.joml.Vector3f;
public class VertexNM
{
@ -31,8 +31,8 @@ public class VertexNM
if (tangents.isEmpty())
{ return; }
for (Vector3f tangent : tangents)
{ Vector3f.add(averagedTangent, tangent, averagedTangent); }
averagedTangent.normalise();
{ averagedTangent.add(averagedTangent, tangent); }
averagedTangent.normalize();
}
//NEW

11
src/main/java/com/github/hydos/ginger/engine/particle/Particle.java
View File

@ -1,8 +1,11 @@
package com.github.hydos.ginger.engine.particle;
import java.lang.Math;
import org.joml.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.vectors.*;
import com.github.hydos.ginger.main.settings.Constants;
public class Particle
@ -71,9 +74,9 @@ public class Particle
float time = (float) Window.getTime() / 1000000;
velocity.y += Constants.gravity.y() * gravityEffect * time;
Vector3f change = new Vector3f(velocity);
change.scale(time);
Vector3f.add(change, position, position);
distance = Vector3f.sub(camera.getPosition(), position, null).lengthSquared();
change.mul(time);
position.add(change, position);
distance = camera.getPosition().sub(position).lengthSquared();
elapsedTime += time;
updateTextureCoordInfo();
return elapsedTime < lifeLength;

3
src/main/java/com/github/hydos/ginger/engine/particle/ParticleMaster.java
View File

@ -3,8 +3,9 @@ package com.github.hydos.ginger.engine.particle;
import java.util.*;
import java.util.Map.Entry;
import org.joml.Matrix4f;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.renderers.ParticleRenderer;
public class ParticleMaster

17
src/main/java/com/github/hydos/ginger/engine/particle/ParticleSystem.java
View File

@ -1,12 +1,11 @@
package com.github.hydos.ginger.engine.particle;
import java.lang.Math;
import java.util.Random;
import org.joml.Vector4f;
import org.joml.*;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
public class ParticleSystem
{
@ -22,12 +21,12 @@ public class ParticleSystem
Vector4f direction = new Vector4f(x, y, z, 1);
if (coneDirection.x != 0 || coneDirection.y != 0 || (coneDirection.z != 1 && coneDirection.z != -1))
{
Vector3f rotateAxis = Vector3f.cross(coneDirection, new Vector3f(0, 0, 1), null);
rotateAxis.normalise();
float rotateAngle = (float) Math.acos(Vector3f.dot(coneDirection, new Vector3f(0, 0, 1)));
Vector3f rotateAxis = coneDirection.cross(new Vector3f(0, 0, 1));
rotateAxis.normalize();
float rotateAngle = (float) Math.acos(coneDirection.dot(new Vector3f(0, 0, 1)));
Matrix4f rotationMatrix = new Matrix4f();
rotationMatrix.rotate(-rotateAngle, rotateAxis);
Matrix4f.transform(rotationMatrix, direction, direction);
rotationMatrix.transform(direction);
}
else if (coneDirection.z == -1)
{ direction.z *= -1; }
@ -63,8 +62,8 @@ public class ParticleSystem
{
velocity = generateRandomUnitVector();
}
velocity.normalise();
velocity.scale(generateValue(averageSpeed, speedError));
velocity.normalize();
velocity.mul(generateValue(averageSpeed, speedError));
float scale = generateValue(averageScale, scaleError);
float lifeLength = generateValue(averageLifeLength, lifeError);
new Particle(texture, new Vector3f(center), velocity, gravityComplient, lifeLength, generateRotation(), new Vector3f(scale, scale, scale));

16
src/main/java/com/github/hydos/ginger/engine/render/MasterRenderer.java
View File

@ -1,8 +1,9 @@
package com.github.hydos.ginger.engine.render;
import java.lang.Math;
import java.util.*;
import org.joml.Vector4f;
import org.joml.*;
import org.lwjgl.opengl.*;
import com.github.halotroop.litecraft.world.World;
@ -11,7 +12,6 @@ import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.elements.GuiTexture;
import com.github.hydos.ginger.engine.elements.objects.*;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.models.TexturedModel;
import com.github.hydos.ginger.engine.render.renderers.*;
import com.github.hydos.ginger.engine.render.shaders.*;
@ -73,12 +73,12 @@ public class MasterRenderer
float y_scale = (float) ((1f / Math.tan(Math.toRadians(FOV / 2f))));
float x_scale = y_scale / aspectRatio;
float frustum_length = FAR_PLANE - NEAR_PLANE;
projectionMatrix.m00 = x_scale;
projectionMatrix.m11 = y_scale;
projectionMatrix.m22 = -((FAR_PLANE + NEAR_PLANE) / frustum_length);
projectionMatrix.m23 = -1;
projectionMatrix.m32 = -((2 * NEAR_PLANE * FAR_PLANE) / frustum_length);
projectionMatrix.m33 = 0;
projectionMatrix._m00(x_scale);
projectionMatrix._m11(y_scale);
projectionMatrix._m22 (-((FAR_PLANE + NEAR_PLANE) / frustum_length));
projectionMatrix._m23(-1);
projectionMatrix._m32(-((2 * NEAR_PLANE * FAR_PLANE) / frustum_length));
projectionMatrix._m33(0);
}
public Matrix4f getProjectionMatrix()

2
src/main/java/com/github/hydos/ginger/engine/render/renderers/GuiRenderer.java
View File

@ -2,11 +2,11 @@ package com.github.hydos.ginger.engine.render.renderers;
import java.util.List;
import org.joml.Matrix4f;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.elements.GuiTexture;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.Renderer;
import com.github.hydos.ginger.engine.render.models.RawModel;
import com.github.hydos.ginger.engine.render.shaders.GuiShader;

3
src/main/java/com/github/hydos/ginger/engine/render/renderers/NormalMappingRenderer.java
View File

@ -2,14 +2,13 @@ package com.github.hydos.ginger.engine.render.renderers;
import java.util.*;
import org.joml.Vector4f;
import org.joml.*;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.elements.objects.*;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.*;
import com.github.hydos.ginger.engine.render.models.*;
import com.github.hydos.ginger.engine.render.shaders.NormalMappingShader;

2
src/main/java/com/github/hydos/ginger/engine/render/renderers/ObjectRenderer.java
View File

@ -2,6 +2,7 @@ package com.github.hydos.ginger.engine.render.renderers;
import java.util.*;
import org.joml.Matrix4f;
import org.lwjgl.opengl.*;
import com.github.halotroop.litecraft.types.block.BlockEntity;
@ -9,7 +10,6 @@ import com.github.hydos.ginger.engine.api.GingerRegister;
import com.github.hydos.ginger.engine.elements.objects.RenderObject;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.*;
import com.github.hydos.ginger.engine.render.models.*;
import com.github.hydos.ginger.engine.render.shaders.StaticShader;

62
src/main/java/com/github/hydos/ginger/engine/render/renderers/ParticleRenderer.java
View File

@ -1,15 +1,15 @@
package com.github.hydos.ginger.engine.render.renderers;
import java.lang.Math;
import java.nio.FloatBuffer;
import java.util.*;
import org.joml.*;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import com.github.hydos.ginger.engine.particle.*;
import com.github.hydos.ginger.engine.render.Renderer;
import com.github.hydos.ginger.engine.render.models.RawModel;
@ -108,40 +108,40 @@ public class ParticleRenderer extends Renderer
private void storeMatrixData(Matrix4f matrix, float[] vboData)
{
vboData[pointer++] = matrix.m00;
vboData[pointer++] = matrix.m01;
vboData[pointer++] = matrix.m02;
vboData[pointer++] = matrix.m03;
vboData[pointer++] = matrix.m10;
vboData[pointer++] = matrix.m11;
vboData[pointer++] = matrix.m12;
vboData[pointer++] = matrix.m13;
vboData[pointer++] = matrix.m20;
vboData[pointer++] = matrix.m21;
vboData[pointer++] = matrix.m22;
vboData[pointer++] = matrix.m23;
vboData[pointer++] = matrix.m30;
vboData[pointer++] = matrix.m31;
vboData[pointer++] = matrix.m32;
vboData[pointer++] = matrix.m33;
vboData[pointer++] = matrix.m00();
vboData[pointer++] = matrix.m01();
vboData[pointer++] = matrix.m02();
vboData[pointer++] = matrix.m03();
vboData[pointer++] = matrix.m10();
vboData[pointer++] = matrix.m11();
vboData[pointer++] = matrix.m12();
vboData[pointer++] = matrix.m13();
vboData[pointer++] = matrix.m20();
vboData[pointer++] = matrix.m21();
vboData[pointer++] = matrix.m22();
vboData[pointer++] = matrix.m23();
vboData[pointer++] = matrix.m30();
vboData[pointer++] = matrix.m31();
vboData[pointer++] = matrix.m32();
vboData[pointer++] = matrix.m33();
}
private void updateModelViewMatrix(Vector3f position, float rotation, float scale, Matrix4f viewMatrix, float[] vboData)
{
Matrix4f modelMatrix = new Matrix4f();
Matrix4f.translate(position, modelMatrix, modelMatrix);
modelMatrix.m00 = viewMatrix.m00;
modelMatrix.m01 = viewMatrix.m10;
modelMatrix.m02 = viewMatrix.m20;
modelMatrix.m10 = viewMatrix.m01;
modelMatrix.m11 = viewMatrix.m11;
modelMatrix.m12 = viewMatrix.m21;
modelMatrix.m20 = viewMatrix.m02;
modelMatrix.m21 = viewMatrix.m12;
modelMatrix.m22 = viewMatrix.m22;
Matrix4f.rotate((float) Math.toRadians(rotation), new Vector3f(0, 0, 1), modelMatrix, modelMatrix);
Matrix4f.scale(new Vector3f(scale, scale, scale), modelMatrix, modelMatrix);
Matrix4f modelViewMatrix = Matrix4f.mul(viewMatrix, modelMatrix, null);
modelMatrix.translate(position, modelMatrix);
modelMatrix._m00(viewMatrix.m00());
modelMatrix._m01(viewMatrix.m10());
modelMatrix._m02(viewMatrix.m20());
modelMatrix._m10(viewMatrix.m01());
modelMatrix._m11(viewMatrix.m11());
modelMatrix._m12(viewMatrix.m21());
modelMatrix._m20(viewMatrix.m02());
modelMatrix._m21(viewMatrix.m12());
modelMatrix._m22(viewMatrix.m22());
modelMatrix.rotate((float) Math.toRadians(rotation), new Vector3f(0, 0, 1), modelMatrix);
modelMatrix.scale(new Vector3f(scale, scale, scale), modelMatrix);
Matrix4f modelViewMatrix = viewMatrix.mul(modelMatrix);
storeMatrixData(modelViewMatrix, vboData);
}

2
src/main/java/com/github/hydos/ginger/engine/render/renderers/SkyboxRenderer.java
View File

@ -1,9 +1,9 @@
package com.github.hydos.ginger.engine.render.renderers;
import org.joml.Matrix4f;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.Renderer;
import com.github.hydos.ginger.engine.render.models.RawModel;
import com.github.hydos.ginger.engine.render.shaders.SkyboxShader;

3
src/main/java/com/github/hydos/ginger/engine/render/shaders/FontShader.java
View File

@ -1,7 +1,8 @@
package com.github.hydos.ginger.engine.render.shaders;
import org.joml.*;
import com.github.hydos.ginger.engine.font.GUIText;
import com.github.hydos.ginger.engine.math.vectors.*;
public class FontShader extends ShaderProgram
{

2
src/main/java/com/github/hydos/ginger/engine/render/shaders/GuiShader.java
View File

@ -1,6 +1,6 @@
package com.github.hydos.ginger.engine.render.shaders;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import org.joml.Matrix4f;
public class GuiShader extends ShaderProgram
{

6
src/main/java/com/github/hydos/ginger/engine/render/shaders/NormalMappingShader.java
View File

@ -2,11 +2,9 @@ package com.github.hydos.ginger.engine.render.shaders;
import java.util.List;
import org.joml.Vector4f;
import org.joml.*;
import com.github.hydos.ginger.engine.elements.objects.Light;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.*;
public class NormalMappingShader extends ShaderProgram
{
@ -75,7 +73,7 @@ public class NormalMappingShader extends ShaderProgram
{
Vector3f position = light.getPosition();
Vector4f eyeSpacePos = new Vector4f(position.x, position.y, position.z, 1f);
Matrix4f.transform(viewMatrix, eyeSpacePos, eyeSpacePos);
viewMatrix.transform(eyeSpacePos);
return new Vector3f(eyeSpacePos.x, eyeSpacePos.y, eyeSpacePos.z);
}

2
src/main/java/com/github/hydos/ginger/engine/render/shaders/ParticleShader.java
View File

@ -1,6 +1,6 @@
package com.github.hydos.ginger.engine.render.shaders;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import org.joml.Matrix4f;
public class ParticleShader extends ShaderProgram
{

14
src/main/java/com/github/hydos/ginger/engine/render/shaders/ShaderProgram.java
View File

@ -1,18 +1,12 @@
package com.github.hydos.ginger.engine.render.shaders;
import java.io.*;
import java.nio.FloatBuffer;
import org.joml.Vector4f;
import org.lwjgl.BufferUtils;
import org.joml.*;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.*;
public abstract class ShaderProgram
{
private static FloatBuffer matrixBuffer = BufferUtils.createFloatBuffer(16);
private static int loadShader(String file, int type)
{
StringBuilder shaderSource = new StringBuilder();
@ -97,9 +91,9 @@ public abstract class ShaderProgram
protected void loadMatrix(int location, Matrix4f matrix)
{
matrix.store(matrixBuffer);
matrixBuffer.flip();
GL20.glUniformMatrix4fv(location, false, matrixBuffer);
float[] fm = new float[16];
matrix.get(fm);
GL20.glUniformMatrix4fv(location, false, fm);
}
protected void loadVector(int location, Vector3f vector)

9
src/main/java/com/github/hydos/ginger/engine/render/shaders/SkyboxShader.java
View File

@ -1,8 +1,9 @@
package com.github.hydos.ginger.engine.render.shaders;
import org.joml.Matrix4f;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
public class SkyboxShader extends ShaderProgram
{
@ -29,9 +30,9 @@ public class SkyboxShader extends ShaderProgram
public void loadViewMatrix(Camera camera)
{
Matrix4f matrix = Maths.createViewMatrix(camera);
matrix.m30 = 0;
matrix.m31 = 0;
matrix.m32 = 0;
matrix.m30(0);
matrix.m31(0);
matrix.m32(0);
super.loadMatrix(location_viewMatrix, matrix);
}
}

4
src/main/java/com/github/hydos/ginger/engine/render/shaders/StaticShader.java
View File

@ -2,11 +2,11 @@ package com.github.hydos.ginger.engine.render.shaders;
import java.util.List;
import org.joml.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.elements.objects.Light;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
public class StaticShader extends ShaderProgram
{

4
src/main/java/com/github/hydos/ginger/engine/render/shaders/TerrainShader.java
View File

@ -2,11 +2,11 @@ package com.github.hydos.ginger.engine.render.shaders;
import java.util.List;
import org.joml.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.elements.objects.Light;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
public class TerrainShader extends ShaderProgram
{

17
src/main/java/com/github/hydos/ginger/engine/render/tools/MousePicker.java
View File

@ -1,12 +1,10 @@
package com.github.hydos.ginger.engine.render.tools;
import org.joml.Vector4f;
import org.joml.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.*;
public class MousePicker
{
@ -72,7 +70,7 @@ public class MousePicker
Vector3f camPos = camera.getPosition();
Vector3f start = new Vector3f(camPos.x, camPos.y, camPos.z);
Vector3f scaledRay = new Vector3f(ray.x * distance, ray.y * distance, ray.z * distance);
return Vector3f.add(start, scaledRay, null);
return scaledRay.add(start);
}
private boolean intersectionInRange(float start, float finish, Vector3f ray)
@ -91,23 +89,22 @@ public class MousePicker
private boolean isUnderGround(Vector3f testPoint)
{
float height = 0;
return false;
}
private Vector4f toEyeCoords(Vector4f clipCoords)
{
Matrix4f invertedProjection = Matrix4f.invert(projectionMatrix, null);
Vector4f eyeCoords = Matrix4f.transform(invertedProjection, clipCoords, null);
Matrix4f invertedProjection = projectionMatrix.invert();
Vector4f eyeCoords = invertedProjection.transform(clipCoords);
return new Vector4f(eyeCoords.x, eyeCoords.y, -1f, 0f);
}
private Vector3f toWorldCoords(Vector4f eyeCoords)
{
Matrix4f invertedView = Matrix4f.invert(viewMatrix, null);
Vector4f rayWorld = Matrix4f.transform(invertedView, eyeCoords, null);
Matrix4f invertedView = viewMatrix.invert();
Vector4f rayWorld = invertedView.transform(eyeCoords);
Vector3f mouseRay = new Vector3f(rayWorld.x, rayWorld.y, rayWorld.z);
mouseRay.normalise();
mouseRay.normalize();
return mouseRay;
}

41
src/main/java/com/github/hydos/ginger/engine/shadow/ShadowBox.java
View File

@ -1,11 +1,11 @@
package com.github.hydos.ginger.engine.shadow;
import org.joml.Vector4f;
import java.lang.Math;
import org.joml.*;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.io.Window;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.Vector3f;
import com.github.hydos.ginger.engine.render.MasterRenderer;
/** Represents the 3D cuboidal area of the world in which objects will cast
@ -73,19 +73,15 @@ public class ShadowBox
private Vector4f[] calculateFrustumVertices(Matrix4f rotation, Vector3f forwardVector,
Vector3f centerNear, Vector3f centerFar)
{
Vector4f upVector4F = Matrix4f.transform(rotation, UP, null);
Vector4f upVector4F = rotation.transform(UP);
Vector3f upVector = new Vector3f(upVector4F.x, upVector4F.y, upVector4F.z);
Vector3f rightVector = Vector3f.cross(forwardVector, upVector, null);
Vector3f rightVector = forwardVector.cross(upVector);
Vector3f downVector = new Vector3f(-upVector.x, -upVector.y, -upVector.z);
Vector3f leftVector = new Vector3f(-rightVector.x, -rightVector.y, -rightVector.z);
Vector3f farTop = Vector3f.add(centerFar, new Vector3f(upVector.x * farHeight,
upVector.y * farHeight, upVector.z * farHeight), null);
Vector3f farBottom = Vector3f.add(centerFar, new Vector3f(downVector.x * farHeight,
downVector.y * farHeight, downVector.z * farHeight), null);
Vector3f nearTop = Vector3f.add(centerNear, new Vector3f(upVector.x * nearHeight,
upVector.y * nearHeight, upVector.z * nearHeight), null);
Vector3f nearBottom = Vector3f.add(centerNear, new Vector3f(downVector.x * nearHeight,
downVector.y * nearHeight, downVector.z * nearHeight), null);
Vector3f farTop = centerFar.add(new Vector3f(upVector.x * farHeight, upVector.y * farHeight, upVector.z * farHeight));
Vector3f farBottom = centerFar.add(new Vector3f(downVector.x * farHeight, downVector.y * farHeight, downVector.z * farHeight));
Vector3f nearTop = centerNear.add(new Vector3f(upVector.x * nearHeight, upVector.y * nearHeight, upVector.z * nearHeight));
Vector3f nearBottom = centerNear.add(new Vector3f(downVector.x * nearHeight, downVector.y * nearHeight, downVector.z * nearHeight));
Vector4f[] points = new Vector4f[8];
points[0] = calculateLightSpaceFrustumCorner(farTop, rightVector, farWidth);
points[1] = calculateLightSpaceFrustumCorner(farTop, leftVector, farWidth);
@ -111,10 +107,9 @@ public class ShadowBox
private Vector4f calculateLightSpaceFrustumCorner(Vector3f startPoint, Vector3f direction,
float width)
{
Vector3f point = Vector3f.add(startPoint,
new Vector3f(direction.x * width, direction.y * width, direction.z * width), null);
Vector3f point = startPoint.add(new Vector3f(direction.x * width, direction.y * width, direction.z * width));
Vector4f point4f = new Vector4f(point.x, point.y, point.z, 1f);
Matrix4f.transform(lightViewMatrix, point4f, point4f);
lightViewMatrix.transform(point4f);
return point4f;
}
@ -147,8 +142,8 @@ public class ShadowBox
float z = (minZ + maxZ) / 2f;
Vector4f cen = new Vector4f(x, y, z, 1);
Matrix4f invertedLight = new Matrix4f();
Matrix4f.invert(lightViewMatrix, invertedLight);
Vector4f processedCenter = Matrix4f.transform(invertedLight, cen, null);
lightViewMatrix.invert(invertedLight);
Vector4f processedCenter = invertedLight.transform(cen);
return new Vector3f(processedCenter.x, processedCenter.y, processedCenter.z);
}
@ -171,14 +166,14 @@ public class ShadowBox
protected void update()
{
Matrix4f rotation = calculateCameraRotationMatrix();
Vector4f forwardVector4F = Matrix4f.transform(rotation, FORWARD, null);
Vector4f forwardVector4F = rotation.transform(FORWARD);
Vector3f forwardVector = new Vector3f(forwardVector4F.x, forwardVector4F.y, forwardVector4F.z);
Vector3f toFar = new Vector3f(forwardVector);
toFar.scale(SHADOW_DISTANCE);
toFar.mul(SHADOW_DISTANCE);
Vector3f toNear = new Vector3f(forwardVector);
toNear.scale(MasterRenderer.NEAR_PLANE);
Vector3f centerNear = Vector3f.add(toNear, cam.getPosition(), null);
Vector3f centerFar = Vector3f.add(toFar, cam.getPosition(), null);
toNear.mul(MasterRenderer.NEAR_PLANE);
Vector3f centerNear = toNear.add(cam.getPosition());
Vector3f centerFar = toFar.add(cam.getPosition());
Vector4f[] points = calculateFrustumVertices(rotation, forwardVector, centerNear,
centerFar);
boolean first = true;

4
src/main/java/com/github/hydos/ginger/engine/shadow/ShadowMapEntityRenderer.java
View File

@ -2,11 +2,11 @@ package com.github.hydos.ginger.engine.shadow;
import java.util.*;
import org.joml.Matrix4f;
import org.lwjgl.opengl.*;
import com.github.hydos.ginger.engine.elements.objects.RenderObject;
import com.github.hydos.ginger.engine.math.Maths;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.render.MasterRenderer;
import com.github.hydos.ginger.engine.render.models.*;
@ -51,7 +51,7 @@ public class ShadowMapEntityRenderer
{
Matrix4f modelMatrix = Maths.createTransformationMatrix(entity.getPosition(),
entity.getRotX(), entity.getRotY(), entity.getRotZ(), entity.getScale());
Matrix4f mvpMatrix = Matrix4f.mul(projectionViewMatrix, modelMatrix, null);
Matrix4f mvpMatrix = projectionViewMatrix.mul(modelMatrix);
shader.loadMvpMatrix(mvpMatrix);
}

29
src/main/java/com/github/hydos/ginger/engine/shadow/ShadowMapMasterRenderer.java
View File

@ -1,13 +1,13 @@
package com.github.hydos.ginger.engine.shadow;
import java.lang.Math;
import java.util.*;
import org.joml.*;
import org.lwjgl.opengl.GL11;
import com.github.hydos.ginger.engine.cameras.Camera;
import com.github.hydos.ginger.engine.elements.objects.*;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import com.github.hydos.ginger.engine.math.vectors.*;
import com.github.hydos.ginger.engine.render.models.TexturedModel;
/** This class is in charge of using all of the classes in the shadows package to
@ -89,7 +89,7 @@ public class ShadowMapMasterRenderer
*
* @return The to-shadow-map-space matrix. */
public Matrix4f getToShadowMapSpaceMatrix()
{ return Matrix4f.mul(offset, projectionViewMatrix, null); }
{ return projectionViewMatrix.mul(offset); }
/** Prepare for the shadow render pass. This first updates the dimensions of
* the orthographic "view cuboid" based on the information that was
@ -113,7 +113,7 @@ public class ShadowMapMasterRenderer
{
updateOrthoProjectionMatrix(box.getWidth(), box.getHeight(), box.getLength());
updateLightViewMatrix(lightDirection, box.getCenter());
Matrix4f.mul(projectionMatrix, lightViewMatrix, projectionViewMatrix);
projectionViewMatrix.mul(projectionMatrix, lightViewMatrix);
shadowFbo.bindFrameBuffer();
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
@ -157,16 +157,15 @@ public class ShadowMapMasterRenderer
* - the center of the "view cuboid" in world space. */
private void updateLightViewMatrix(Vector3f direction, Vector3f center)
{
direction.normalise();
direction.normalize();
center.negate();
lightViewMatrix.setIdentity();
lightViewMatrix.identity();
float pitch = (float) Math.acos(new Vector2f(direction.x, direction.z).length());
Matrix4f.rotate(pitch, new Vector3f(1, 0, 0), lightViewMatrix, lightViewMatrix);
lightViewMatrix.rotate(pitch, new Vector3f(1, 0, 0), lightViewMatrix);
float yaw = (float) Math.toDegrees(((float) Math.atan(direction.x / direction.z)));
yaw = direction.z > 0 ? yaw - 180 : yaw;
Matrix4f.rotate((float) -Math.toRadians(yaw), new Vector3f(0, 1, 0), lightViewMatrix,
lightViewMatrix);
Matrix4f.translate(center, lightViewMatrix, lightViewMatrix);
lightViewMatrix.rotate((float) -Math.toRadians(yaw), new Vector3f(0, 1, 0), lightViewMatrix);
lightViewMatrix.translate(center, lightViewMatrix);
}
/** Creates the orthographic projection matrix. This projection matrix
@ -181,10 +180,10 @@ public class ShadowMapMasterRenderer
* - shadow box length. */
private void updateOrthoProjectionMatrix(float width, float height, float length)
{
projectionMatrix.setIdentity();
projectionMatrix.m00 = 2f / width;
projectionMatrix.m11 = 2f / height;
projectionMatrix.m22 = -2f / length;
projectionMatrix.m33 = 1;
projectionMatrix.identity();
projectionMatrix._m00(2f / width);
projectionMatrix._m11(2f / height);
projectionMatrix._m22(-2f / length);
projectionMatrix._m33(1);
}
}

3
src/main/java/com/github/hydos/ginger/engine/shadow/ShadowShader.java
View File

@ -1,6 +1,7 @@
package com.github.hydos.ginger.engine.shadow;
import com.github.hydos.ginger.engine.math.matrixes.Matrix4f;
import org.joml.Matrix4f;
import com.github.hydos.ginger.engine.render.shaders.ShaderProgram;
public class ShadowShader extends ShaderProgram