AstralTransRocketries/ClassiCube
1
0
Fork 0
mirror of https://github.com/ClassiCube/ClassiCube.git synced 2025-09-17 11:35:08 -04:00
Code Issues Packages Projects Releases Wiki Activity

Combine some headers, part 1

Browse Source
This commit is contained in:
UnknownShadow200 2018-03-27 13:02:11 +11:00
parent e0433935e6
commit 880cbbd0a6
16 changed files with 182 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ClassicalSharp/Entities/Components/PhysicsComponent.cs
View File

@ -300,7 +300,8 @@ namespace ClassicalSharp.Entities {
if (dist < 0.002f || dist > 1f) continue; // TODO: range needs to be lower?
Vector3 dir = Vector3.Normalize(dX, 0, dZ);
entity.Velocity -= dir * (1 - dist) / 32f; // TODO: should be 24/25
float pushStrength = (1 - dist) / 32f; // TODO: should be 24/25
entity.Velocity -= dir * pushStrength;
}
}
}

2
src/Client/Client.vcxproj
View File

@ -240,7 +240,6 @@
<ClInclude Include="GraphicsAPI.h" />
<ClInclude Include="GraphicsCommon.h" />
<ClInclude Include="GraphicsEnums.h" />
<ClInclude Include="Matrix.h" />
<ClInclude Include="Noise.h" />
<ClInclude Include="Platform.h" />
<ClInclude Include="Random.h" />
@ -298,7 +297,6 @@
<ClCompile Include="Options.c" />
<ClCompile Include="PackedCol.c" />
<ClCompile Include="GraphicsCommon.c" />
<ClCompile Include="Matrix.c" />
<ClCompile Include="Noise.c" />
<ClCompile Include="Particle.c" />
<ClCompile Include="Physics.c" />

6
src/Client/Client.vcxproj.filters
View File

@ -171,9 +171,6 @@
<ClInclude Include="Block.h">
<Filter>Header Files\Blocks</Filter>
</ClInclude>
<ClInclude Include="Matrix.h">
<Filter>Header Files\Math</Filter>
</ClInclude>
<ClInclude Include="Bitmap.h">
<Filter>Header Files\2D\Utils</Filter>
</ClInclude>
@ -395,9 +392,6 @@
<ClCompile Include="Block.c">
<Filter>Source Files\Blocks</Filter>
</ClCompile>
<ClCompile Include="Matrix.c">
<Filter>Source Files\Math</Filter>
</ClCompile>
<ClCompile Include="Bitmap.c">
<Filter>Source Files\2D\Utils</Filter>
</ClCompile>

1
src/Client/Entity.h
View File

@ -6,7 +6,6 @@
#include "Vectors.h"
#include "AABB.h"
#include "GraphicsEnums.h"
#include "Matrix.h"
#include "GameStructs.h"
/* Represents an in-game entity.
Copyright 2014-2017 ClassicalSharp | Licensed under BSD-3

23
src/Client/EntityComponents.c
View File

@ -12,6 +12,7 @@
#include "GraphicsAPI.h"
#include "GraphicsCommon.h"
#include "ModelCache.h"
#include "Searcher.h"
#define ANIM_MAX_ANGLE (110 * MATH_DEG2RAD)
#define ANIM_ARM_MAX (60.0f * MATH_DEG2RAD)
@ -577,23 +578,23 @@ bool ShadowComponent_GetBlocks(Entity* entity, Vector3I* coords, Real32 x, Real3
return true;
}
#define size 128
#define half (size / 2)
#define sh_size 128
#define sh_half (sh_size / 2)
void ShadowComponent_MakeTex(void) {
UInt8 pixels[Bitmap_DataSize(size, size)];
Bitmap bmp; Bitmap_Create(&bmp, size, size, pixels);
UInt8 pixels[Bitmap_DataSize(sh_size, sh_size)];
Bitmap bmp; Bitmap_Create(&bmp, sh_size, sh_size, pixels);
UInt32 inPix = PackedCol_ARGB(0, 0, 0, 200);
UInt32 inPix = PackedCol_ARGB(0, 0, 0, 200);
UInt32 outPix = PackedCol_ARGB(0, 0, 0, 0);
UInt32 x, y;
for (y = 0; y < size; y++) {
for (y = 0; y < sh_size; y++) {
UInt32* row = Bitmap_GetRow(&bmp, y);
for (x = 0; x < size; x++) {
for (x = 0; x < sh_size; x++) {
Real64 dist =
(half - (x + 0.5)) * (half - (x + 0.5)) +
(half - (y + 0.5)) * (half - (y + 0.5));
row[x] = dist < half * half ? inPix : outPix;
(sh_half - (x + 0.5)) * (sh_half - (x + 0.5)) +
(sh_half - (y + 0.5)) * (sh_half - (y + 0.5));
row[x] = dist < sh_half * sh_half ? inPix : outPix;
}
}
ShadowComponent_ShadowTex = Gfx_CreateTexture(&bmp, false, false);
@ -660,4 +661,4 @@ void ShadowComponent_Draw(Entity* entity) {
UInt32 vCount = (UInt32)(ptr - vertices) / VertexP3fT2fC4b_Size;
GfxCommon_UpdateDynamicVb_IndexedTris(vb, vertices, vCount);
}
}

2
src/Client/EnvRenderer.c
View File

@ -4,7 +4,7 @@
#include "GraphicsEnums.h"
#include "Funcs.h"
#include "GraphicsAPI.h"
#include "Matrix.h"
#include "Vectors.h"
#include "AABB.h"
#include "Block.h"
#include "Platform.h"

8
src/Client/ExtMath.h
View File

@ -30,25 +30,17 @@
#define Math_Sqrt(x) sqrtf(x)
#define Math_Mod(x, y) fmodf(x, y)
/* Integer floor of a floating-point value. */
Int32 Math_Floor(Real32 value);
/* Integer ceiling of a floating-point value. */
Int32 Math_Ceil(Real32 value);
/* Log base 2 of given value. */
Int32 Math_Log2(Int32 value);
/* Performs rounding upwards integer division.*/
Int32 Math_CeilDiv(Int32 a, Int32 b);
/* Returns sign of the given value. */
Int32 Math_Sign(Real32 value);
/* Performs linear interpolation between two values. */
Real32 Math_Lerp(Real32 a, Real32 b, Real32 t);
/* Linearly interpolates between a given angle range, adjusting if necessary. */
Real32 Math_LerpAngle(Real32 leftAngle, Real32 rightAngle, Real32 t);
/* Returns the next highest power of 2 that is greater or equal to the given value. */
Int32 Math_NextPowOf2(Int32 value);
/* Returns whether the given value is a power of 2. */
bool Math_IsPowOf2(Int32 value);
/* Returns the number of vertices needed to subdivide a quad. */

2
src/Client/FrustumCulling.h
View File

@ -1,6 +1,6 @@
#ifndef CC_FRUSTUMCULLING_H
#define CC_FRUSTUMCULLING_H
#include "Matrix.h"
#include "Vectors.h"
#include "Typedefs.h"
/* Implements frustum culling of bounding spheres.
Copyright 2014-2017 ClassicalSharp | Licensed under BSD-3

2
src/Client/GraphicsAPI.h
View File

@ -4,7 +4,7 @@
#include "Bitmap.h"
#include "PackedCol.h"
#include "String.h"
#include "Matrix.h"
#include "Vectors.h"
#include "Game.h"
#include "GraphicsEnums.h"
#include "GameStructs.h"

1
src/Client/HeldBlockRenderer.c
View File

@ -1,6 +1,5 @@
#include "HeldBlockRenderer.h"
#include "Block.h"
#include "Matrix.h"
#include "Game.h"
#include "Inventory.h"
#include "GraphicsAPI.h"

1
src/Client/IsometricDrawer.c
View File

@ -2,7 +2,6 @@
#include "Drawer.h"
#include "GraphicsCommon.h"
#include "GraphicsAPI.h"
#include "Matrix.h"
#include "PackedCol.h"
#include "ExtMath.h"
#include "Block.h"

137
src/Client/Matrix.c
View File

@ -1,137 +0,0 @@
#include "Matrix.h"
#include "ExtMath.h"
#include "Vectors.h"
Matrix Matrix_Identity = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
/* Transposed, copied from https://open.gl/transformations */
void Matrix_RotateX(Matrix* result, Real32 angle) {
Real32 cosA = Math_Cos(angle), sinA = Math_Sin(angle);
*result = Matrix_Identity;
result->Row1.Y = cosA; result->Row1.Z = sinA;
result->Row2.Y = -sinA; result->Row2.Z = cosA;
}
void Matrix_RotateY(Matrix* result, Real32 angle) {
Real32 cosA = Math_Cos(angle), sinA = Math_Sin(angle);
*result = Matrix_Identity;
result->Row1.X = cosA; result->Row1.Z = -sinA;
result->Row2.X = sinA; result->Row2.Z = cosA;
}
void Matrix_RotateZ(Matrix* result, Real32 angle) {
Real32 cosA = Math_Cos(angle), sinA = Math_Sin(angle);
*result = Matrix_Identity;
result->Row1.X = cosA; result->Row1.Y = sinA;
result->Row2.X = -sinA; result->Row2.Y = cosA;
}
void Matrix_Translate(Matrix* result, Real32 x, Real32 y, Real32 z) {
*result = Matrix_Identity;
result->Row3.X = x;
result->Row3.Y = y;
result->Row3.Z = z;
}
void Matrix_Scale(Matrix* result, Real32 x, Real32 y, Real32 z) {
*result = Matrix_Identity;
result->Row0.X = x;
result->Row1.Y = y;
result->Row2.Z = z;
}
void Matrix_Mul(Matrix* result, Matrix* left, Matrix* right) {
/* Originally from http://www.edais.co.uk/blog/?p=27 */
Real32
lM11 = left->Row0.X, lM12 = left->Row0.Y, lM13 = left->Row0.Z, lM14 = left->Row0.W,
lM21 = left->Row1.X, lM22 = left->Row1.Y, lM23 = left->Row1.Z, lM24 = left->Row1.W,
lM31 = left->Row2.X, lM32 = left->Row2.Y, lM33 = left->Row2.Z, lM34 = left->Row2.W,
lM41 = left->Row3.X, lM42 = left->Row3.Y, lM43 = left->Row3.Z, lM44 = left->Row3.W,
rM11 = right->Row0.X, rM12 = right->Row0.Y, rM13 = right->Row0.Z, rM14 = right->Row0.W,
rM21 = right->Row1.X, rM22 = right->Row1.Y, rM23 = right->Row1.Z, rM24 = right->Row1.W,
rM31 = right->Row2.X, rM32 = right->Row2.Y, rM33 = right->Row2.Z, rM34 = right->Row2.W,
rM41 = right->Row3.X, rM42 = right->Row3.Y, rM43 = right->Row3.Z, rM44 = right->Row3.W;
result->Row0.X = (((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31)) + (lM14 * rM41);
result->Row0.Y = (((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rM32)) + (lM14 * rM42);
result->Row0.Z = (((lM11 * rM13) + (lM12 * rM23)) + (lM13 * rM33)) + (lM14 * rM43);
result->Row0.W = (((lM11 * rM14) + (lM12 * rM24)) + (lM13 * rM34)) + (lM14 * rM44);
result->Row1.X = (((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31)) + (lM24 * rM41);
result->Row1.Y = (((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rM32)) + (lM24 * rM42);
result->Row1.Z = (((lM21 * rM13) + (lM22 * rM23)) + (lM23 * rM33)) + (lM24 * rM43);
result->Row1.W = (((lM21 * rM14) + (lM22 * rM24)) + (lM23 * rM34)) + (lM24 * rM44);
result->Row2.X = (((lM31 * rM11) + (lM32 * rM21)) + (lM33 * rM31)) + (lM34 * rM41);
result->Row2.Y = (((lM31 * rM12) + (lM32 * rM22)) + (lM33 * rM32)) + (lM34 * rM42);
result->Row2.Z = (((lM31 * rM13) + (lM32 * rM23)) + (lM33 * rM33)) + (lM34 * rM43);
result->Row2.W = (((lM31 * rM14) + (lM32 * rM24)) + (lM33 * rM34)) + (lM34 * rM44);
result->Row3.X = (((lM41 * rM11) + (lM42 * rM21)) + (lM43 * rM31)) + (lM44 * rM41);
result->Row3.Y = (((lM41 * rM12) + (lM42 * rM22)) + (lM43 * rM32)) + (lM44 * rM42);
result->Row3.Z = (((lM41 * rM13) + (lM42 * rM23)) + (lM43 * rM33)) + (lM44 * rM43);
result->Row3.W = (((lM41 * rM14) + (lM42 * rM24)) + (lM43 * rM34)) + (lM44 * rM44);
}
void Matrix_Orthographic(Matrix* result, Real32 width, Real32 height, Real32 zNear, Real32 zFar) {
Matrix_OrthographicOffCenter(result, -width * 0.5f, width * 0.5f, -height * 0.5f, height * 0.5f, zNear, zFar);
}
void Matrix_OrthographicOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar) {
/* Transposed, sourced from https://msdn.microsoft.com/en-us/library/dd373965(v=vs.85).aspx */
*result = Matrix_Identity;
result->Row0.X = 2.0f / (right - left);
result->Row1.Y = 2.0f / (top - bottom);
result->Row2.Z = -2.0f / (zFar - zNear);
result->Row3.X = -(right + left) / (right - left);
result->Row3.Y = -(top + bottom) / (top - bottom);
result->Row3.Z = -(zFar + zNear) / (zFar - zNear);
}
void Matrix_PerspectiveFieldOfView(Matrix* result, Real32 fovy, Real32 aspect, Real32 zNear, Real32 zFar) {
Real32 c = zNear * Math_Tan(0.5f * fovy);
Matrix_PerspectiveOffCenter(result, -c * aspect, c * aspect, -c, c, zNear, zFar);
}
void Matrix_PerspectiveOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar) {
/* Transposed, sourced from https://msdn.microsoft.com/en-us/library/dd373537(v=vs.85).aspx */
*result = Matrix_Identity;
result->Row0.X = (2.0f * zNear) / (right - left);
result->Row1.Y = (2.0f * zNear) / (top - bottom);
result->Row3.Z = -(2.0f * zFar * zNear) / (zFar - zNear);
result->Row2.X = (right + left) / (right - left);
result->Row2.Y = (top + bottom) / (top - bottom);
result->Row2.Z = -(zFar + zNear) / (zFar - zNear);
result->Row2.W = -1.0f;
}
void Matrix_LookAt(Matrix* result, Vector3 eye, Vector3 target, Vector3 up) {
/* Transposed, sourced from https://msdn.microsoft.com/en-us/library/windows/desktop/bb281711(v=vs.85).aspx */
Vector3 x, y, z;
Vector3_Subtract(&z, &eye, &target); Vector3_Normalize(&z, &z);
Vector3_Cross(&x, &up, &z); Vector3_Normalize(&x, &x);
Vector3_Cross(&y, &z, &x); Vector3_Normalize(&y, &y);
result->Row0.X = x.X; result->Row0.Y = y.X; result->Row0.Z = z.X; result->Row0.W = 0.0f;
result->Row1.X = x.Y; result->Row1.Y = y.Y; result->Row1.Z = z.Y; result->Row1.W = 0.0f;
result->Row2.X = x.Z; result->Row2.Y = y.Z; result->Row2.Z = z.Z; result->Row2.W = 0.0f;
result->Row3.X = -Vector3_Dot(&x, &eye);
result->Row3.Y = -Vector3_Dot(&y, &eye);
result->Row3.Z = -Vector3_Dot(&z, &eye);
result->Row3.W = 1.0f;
}

29
src/Client/Matrix.h
View File

@ -1,29 +0,0 @@
#ifndef CC_MATRIX_H
#define CC_MATRIX_H
#include "Typedefs.h"
/* Represents a 4 by 4 matrix.
Copyright 2017 ClassicalSharp | Licensed under BSD-3
*/
/* forward declaration */
typedef struct Vector3_ Vector3;
typedef struct Vector4_ { Real32 X, Y, Z, W; } Vector4;
typedef struct Matrix_ { Vector4 Row0, Row1, Row2, Row3; } Matrix;
extern Matrix Matrix_Identity;
void Matrix_RotateX(Matrix* result, Real32 angle);
void Matrix_RotateY(Matrix* result, Real32 angle);
void Matrix_RotateZ(Matrix* result, Real32 angle);
void Matrix_Translate(Matrix* result, Real32 x, Real32 y, Real32 z);
void Matrix_Scale(Matrix* result, Real32 x, Real32 y, Real32 z);
#define Matrix_MulBy(dst, right) Matrix_Mul(dst, dst, right)
void Matrix_Mul(Matrix* result, Matrix* left, Matrix* right);
void Matrix_Orthographic(Matrix* result, Real32 width, Real32 height, Real32 zNear, Real32 zFar);
void Matrix_OrthographicOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar);
void Matrix_PerspectiveFieldOfView(Matrix* result, Real32 fovy, Real32 aspect, Real32 zNear, Real32 zFar);
void Matrix_PerspectiveOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar);
void Matrix_LookAt(Matrix* result, Vector3 eye, Vector3 target, Vector3 up);
#endif

1
src/Client/Particle.c
View File

@ -3,7 +3,6 @@
#include "World.h"
#include "ExtMath.h"
#include "Lighting.h"
#include "Matrix.h"
#include "Entity.h"
#include "Random.h"
#include "TerrainAtlas.h"

199
src/Client/Vectors.c
View File

@ -31,59 +31,30 @@ Real32 Vector3_LengthSquared(Vector3* v) {
return v->X * v->X + v->Y * v->Y + v->Z * v->Z;
}
#define Vec3_Add(result, a, b)\
result->X = a->X + b->X;\
result->Y = a->Y + b->Y;\
result->Z = a->Z + b->Z;
void Vector3_Add(Vector3* result, Vector3* a, Vector3* b) {
result->X = a->X + b->X; result->Y = a->Y + b->Y; result->Z = a->Z + b->Z;
}
void Vector3_Add(Vector3* result, Vector3* a, Vector3* b) { Vec3_Add(result, a, b); }
void Vector3I_Add(Vector3I* result, Vector3I* a, Vector3I* b) { Vec3_Add(result, a, b); }
void Vector3_Add1(Vector3* result, Vector3* a, Real32 b) {
result->X = a->X + b;
result->Y = a->Y + b;
result->Z = a->Z + b;
result->X = a->X + b; result->Y = a->Y + b; result->Z = a->Z + b;
}
#define Vec3_Sub(result, a, b)\
result->X = a->X - b->X;\
result->Y = a->Y - b->Y;\
result->Z = a->Z - b->Z;
void Vector3_Subtract(Vector3* result, Vector3* a, Vector3* b) {
result->X = a->X - b->X; result->Y = a->Y - b->Y; result->Z = a->Z - b->Z;
}
void Vector3_Subtract(Vector3* result, Vector3* a, Vector3* b) { Vec3_Sub(result, a, b); }
void Vector3I_Subtract(Vector3I* result, Vector3I* a, Vector3I* b) { Vec3_Sub(result, a, b); }
void Vector3_Multiply1(Vector3* result, Vector3* a, Real32 scale) {
result->X = a->X * scale; result->Y = a->Y * scale; result->Z = a->Z * scale;
}
#define Vec3_Mul1(result, a, scale)\
result->X = a->X * scale;\
result->Y = a->Y * scale;\
result->Z = a->Z * scale;
void Vector3_Multiply1(Vector3* result, Vector3* a, Real32 scale) { Vec3_Mul1(result, a, scale); }
void Vector3I_Multiply1(Vector3I* result, Vector3I* a, Int32 scale) { Vec3_Mul1(result, a, scale); }
void Vector3_Multiply3(Vector3* result, Vector3* a, Vector3* scale) {
result->X = a->X * scale->X;
result->Y = a->Y * scale->Y;
result->Z = a->Z * scale->Z;
result->X = a->X * scale->X; result->Y = a->Y * scale->Y; result->Z = a->Z * scale->Z;
}
void Vector3_Divide1(Vector3* result, Vector3* a, Real32 scale) {
Vector3_Multiply1(result, a, 1.0f / scale);
void Vector3_Negate(Vector3* result, Vector3* a) {
result->X = -a->X; result->Y = -a->Y; result->Z = -a->Z;
}
void Vector3_Divide3(Vector3* result, Vector3* a, Vector3* scale) {
result->X = a->X / scale->X;
result->Y = a->Y / scale->Y;
result->Z = a->Z / scale->Z;
}
#define Vec3_Negate(result, a)\
result->X = -a->X;\
result->Y = -a->Y;\
result->Z = -a->Z;
void Vector3_Negate(Vector3* result, Vector3* a) { Vec3_Negate(result, a); }
void Vector3I_Negate(Vector3I* result, Vector3I* a) { Vec3_Negate(result, a); }
void Vector3_Lerp(Vector3* result, Vector3* a, Vector3* b, Real32 blend) {
result->X = blend * (b->X - a->X) + a->X;
result->Y = blend * (b->Y - a->Y) + a->Y;
@ -166,27 +137,19 @@ bool Vector3I_NotEquals(Vector3I* a, Vector3I* b) { return Vec3_NE(a, b); }
void Vector3I_Floor(Vector3I* result, Vector3* a) {
result->X = Math_Floor(a->X);
result->Y = Math_Floor(a->Y);
result->Z = Math_Floor(a->Z);
result->X = Math_Floor(a->X); result->Y = Math_Floor(a->Y); result->Z = Math_Floor(a->Z);
}
void Vector3I_ToVector3(Vector3* result, Vector3I* a) {
result->X = (Real32)a->X;
result->Y = (Real32)a->Y;
result->Z = (Real32)a->Z;
result->X = (Real32)a->X; result->Y = (Real32)a->Y; result->Z = (Real32)a->Z;
}
void Vector3I_Min(Vector3I* result, Vector3I* a, Vector3I* b) {
result->X = min(a->X, b->X);
result->Y = min(a->Y, b->Y);
result->Z = min(a->Z, b->Z);
result->X = min(a->X, b->X); result->Y = min(a->Y, b->Y); result->Z = min(a->Z, b->Z);
}
void Vector3I_Max(Vector3I* result, Vector3I* a, Vector3I* b) {
result->X = max(a->X, b->X);
result->Y = max(a->Y, b->Y);
result->Z = max(a->Z, b->Z);
result->X = max(a->X, b->X); result->Y = max(a->Y, b->Y); result->Z = max(a->Z, b->Z);
}
@ -200,4 +163,132 @@ Vector3 Vector3_GetDirVector(Real32 yawRad, Real32 pitchRad) {
void Vector3_GetHeading(Vector3 dir, Real32* yaw, Real32* pitch) {
*pitch = Math_Asin(-dir.Y);
*yaw = Math_Atan2(dir.X, -dir.Z);
}
Matrix Matrix_Identity = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
/* Transposed, source https://open.gl/transformations */
void Matrix_RotateX(Matrix* result, Real32 angle) {
Real32 cosA = Math_Cos(angle), sinA = Math_Sin(angle);
*result = Matrix_Identity;
result->Row1.Y = cosA; result->Row1.Z = sinA;
result->Row2.Y = -sinA; result->Row2.Z = cosA;
}
void Matrix_RotateY(Matrix* result, Real32 angle) {
Real32 cosA = Math_Cos(angle), sinA = Math_Sin(angle);
*result = Matrix_Identity;
result->Row1.X = cosA; result->Row1.Z = -sinA;
result->Row2.X = sinA; result->Row2.Z = cosA;
}
void Matrix_RotateZ(Matrix* result, Real32 angle) {
Real32 cosA = Math_Cos(angle), sinA = Math_Sin(angle);
*result = Matrix_Identity;
result->Row1.X = cosA; result->Row1.Y = sinA;
result->Row2.X = -sinA; result->Row2.Y = cosA;
}
void Matrix_Translate(Matrix* result, Real32 x, Real32 y, Real32 z) {
*result = Matrix_Identity;
result->Row3.X = x; result->Row3.Y = y; result->Row3.Z = z;
}
void Matrix_Scale(Matrix* result, Real32 x, Real32 y, Real32 z) {
*result = Matrix_Identity;
result->Row0.X = x; result->Row1.Y = y; result->Row2.Z = z;
}
void Matrix_Mul(Matrix* result, Matrix* left, Matrix* right) {
/* Originally from http://www.edais.co.uk/blog/?p=27 */
Real32
lM11 = left->Row0.X, lM12 = left->Row0.Y, lM13 = left->Row0.Z, lM14 = left->Row0.W,
lM21 = left->Row1.X, lM22 = left->Row1.Y, lM23 = left->Row1.Z, lM24 = left->Row1.W,
lM31 = left->Row2.X, lM32 = left->Row2.Y, lM33 = left->Row2.Z, lM34 = left->Row2.W,
lM41 = left->Row3.X, lM42 = left->Row3.Y, lM43 = left->Row3.Z, lM44 = left->Row3.W,
rM11 = right->Row0.X, rM12 = right->Row0.Y, rM13 = right->Row0.Z, rM14 = right->Row0.W,
rM21 = right->Row1.X, rM22 = right->Row1.Y, rM23 = right->Row1.Z, rM24 = right->Row1.W,
rM31 = right->Row2.X, rM32 = right->Row2.Y, rM33 = right->Row2.Z, rM34 = right->Row2.W,
rM41 = right->Row3.X, rM42 = right->Row3.Y, rM43 = right->Row3.Z, rM44 = right->Row3.W;
result->Row0.X = (((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31)) + (lM14 * rM41);
result->Row0.Y = (((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rM32)) + (lM14 * rM42);
result->Row0.Z = (((lM11 * rM13) + (lM12 * rM23)) + (lM13 * rM33)) + (lM14 * rM43);
result->Row0.W = (((lM11 * rM14) + (lM12 * rM24)) + (lM13 * rM34)) + (lM14 * rM44);
result->Row1.X = (((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31)) + (lM24 * rM41);
result->Row1.Y = (((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rM32)) + (lM24 * rM42);
result->Row1.Z = (((lM21 * rM13) + (lM22 * rM23)) + (lM23 * rM33)) + (lM24 * rM43);
result->Row1.W = (((lM21 * rM14) + (lM22 * rM24)) + (lM23 * rM34)) + (lM24 * rM44);
result->Row2.X = (((lM31 * rM11) + (lM32 * rM21)) + (lM33 * rM31)) + (lM34 * rM41);
result->Row2.Y = (((lM31 * rM12) + (lM32 * rM22)) + (lM33 * rM32)) + (lM34 * rM42);
result->Row2.Z = (((lM31 * rM13) + (lM32 * rM23)) + (lM33 * rM33)) + (lM34 * rM43);
result->Row2.W = (((lM31 * rM14) + (lM32 * rM24)) + (lM33 * rM34)) + (lM34 * rM44);
result->Row3.X = (((lM41 * rM11) + (lM42 * rM21)) + (lM43 * rM31)) + (lM44 * rM41);
result->Row3.Y = (((lM41 * rM12) + (lM42 * rM22)) + (lM43 * rM32)) + (lM44 * rM42);
result->Row3.Z = (((lM41 * rM13) + (lM42 * rM23)) + (lM43 * rM33)) + (lM44 * rM43);
result->Row3.W = (((lM41 * rM14) + (lM42 * rM24)) + (lM43 * rM34)) + (lM44 * rM44);
}
void Matrix_Orthographic(Matrix* result, Real32 width, Real32 height, Real32 zNear, Real32 zFar) {
Matrix_OrthographicOffCenter(result, -width * 0.5f, width * 0.5f, -height * 0.5f, height * 0.5f, zNear, zFar);
}
void Matrix_OrthographicOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar) {
/* Transposed, source https://msdn.microsoft.com/en-us/library/dd373965(v=vs.85).aspx */
*result = Matrix_Identity;
result->Row0.X = 2.0f / (right - left);
result->Row1.Y = 2.0f / (top - bottom);
result->Row2.Z = -2.0f / (zFar - zNear);
result->Row3.X = -(right + left) / (right - left);
result->Row3.Y = -(top + bottom) / (top - bottom);
result->Row3.Z = -(zFar + zNear) / (zFar - zNear);
}
void Matrix_PerspectiveFieldOfView(Matrix* result, Real32 fovy, Real32 aspect, Real32 zNear, Real32 zFar) {
Real32 c = zNear * Math_Tan(0.5f * fovy);
Matrix_PerspectiveOffCenter(result, -c * aspect, c * aspect, -c, c, zNear, zFar);
}
void Matrix_PerspectiveOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar) {
/* Transposed, source https://msdn.microsoft.com/en-us/library/dd373537(v=vs.85).aspx */
*result = Matrix_Identity;
result->Row0.X = (2.0f * zNear) / (right - left);
result->Row1.Y = (2.0f * zNear) / (top - bottom);
result->Row3.Z = -(2.0f * zFar * zNear) / (zFar - zNear);
result->Row2.X = (right + left) / (right - left);
result->Row2.Y = (top + bottom) / (top - bottom);
result->Row2.Z = -(zFar + zNear) / (zFar - zNear);
result->Row2.W = -1.0f;
}
void Matrix_LookAt(Matrix* result, Vector3 eye, Vector3 target, Vector3 up) {
/* Transposed, source https://msdn.microsoft.com/en-us/library/windows/desktop/bb281711(v=vs.85).aspx */
Vector3 x, y, z;
Vector3_Subtract(&z, &eye, &target); Vector3_Normalize(&z, &z);
Vector3_Cross(&x, &up, &z); Vector3_Normalize(&x, &x);
Vector3_Cross(&y, &z, &x); Vector3_Normalize(&y, &y);
result->Row0.X = x.X; result->Row0.Y = y.X; result->Row0.Z = z.X; result->Row0.W = 0.0f;
result->Row1.X = x.Y; result->Row1.Y = y.Y; result->Row1.Z = z.Y; result->Row1.W = 0.0f;
result->Row2.X = x.Z; result->Row2.Y = y.Z; result->Row2.Z = z.Z; result->Row2.W = 0.0f;
result->Row3.X = -Vector3_Dot(&x, &eye);
result->Row3.Y = -Vector3_Dot(&y, &eye);
result->Row3.Z = -Vector3_Dot(&z, &eye);
result->Row3.W = 1.0f;
}

40
src/Client/Vectors.h
View File

@ -1,15 +1,16 @@
#ifndef CC_VECTORS_H
#define CC_VECTORS_H
#include "Typedefs.h"
#include "Matrix.h"
#include "Compiler.h"
/* Represents 2, 3 dimensional vectors.
/* Represents 2, 3 dimensional vectors, and 4 x 4 matrix.
Copyright 2017 ClassicalSharp | Licensed under BSD-3
*/
typedef struct Vector2_ { Real32 X, Y; } Vector2;
typedef struct Vector3_ { Real32 X, Y, Z; } Vector3;
typedef struct Vector3I_ { Int32 X, Y, Z; } Vector3I;
typedef struct Vector4_ { Real32 X, Y, Z, W; } Vector4;
typedef struct Matrix_ { Vector4 Row0, Row1, Row2, Row3; } Matrix;
extern Matrix Matrix_Identity;
Vector2 Vector2_Create2(Real32 x, Real32 y);
Vector3 Vector3_Create1(Real32 value);
@ -28,39 +29,25 @@ Real32 Vector3_LengthSquared(Vector3* v);
#define Vector3_One VECTOR3_CONST(1.0f, 1.0f, 1.0f)
void Vector3_Add(Vector3* result, Vector3* a, Vector3* b);
void Vector3I_Add(Vector3I* result, Vector3I* a, Vector3I* b);
void Vector3_Add1(Vector3* result, Vector3* a, Real32 b);
void Vector3_Subtract(Vector3* result, Vector3* a, Vector3* b);
void Vector3I_Subtract(Vector3I* result, Vector3I* a, Vector3I* b);
void Vector3_Multiply1(Vector3* result, Vector3* a, Real32 scale);
void Vector3I_Multiply1(Vector3I* result, Vector3I* a, Int32 scale);
void Vector3_Multiply3(Vector3* result, Vector3* a, Vector3* scale);
void Vector3_Divide1(Vector3* result, Vector3* a, Real32 scale);
void Vector3_Divide3(Vector3* result, Vector3* a, Vector3* scale);
void Vector3_Negate(Vector3* result, Vector3* a);
void Vector3I_Negate(Vector3I* result, Vector3I* a);
void Vector3_Lerp(Vector3* result, Vector3* a, Vector3* b, Real32 blend);
Real32 Vector3_Dot(Vector3* left, Vector3* right);
void Vector3_Cross(Vector3* result, Vector3* a, Vector3* b);
void Vector3_Normalize(Vector3* result, Vector3* a);
/* Transforms a vector by the given matrix. */
void Vector3_Transform(Vector3* result, Vector3* a, Matrix* mat);
/* Transforms a vector consisting of only a X component by the given matrix. */
void Vector3_TransformX(Vector3* result, Real32 x, Matrix* mat);
/* Transforms a vector consisting of only a Y component by the given matrix. */
void Vector3_TransformY(Vector3* result, Real32 y, Matrix* mat);
/* Transforms a vector consisting of only a Z component by the given matrix. */
void Vector3_TransformZ(Vector3* result, Real32 z, Matrix* mat);
/* Rotates the given 3D coordinates around the x axis. */
Vector3 Vector3_RotateX(Vector3 v, Real32 angle);
/* Rotates the given 3D coordinates around the y axis. */
Vector3 Vector3_RotateY(Vector3 v, Real32 angle);
/* Rotates the given 3D coordinates around the y axis. */
Vector3 Vector3_RotateY3(Real32 x, Real32 y, Real32 z, Real32 angle);
/* Rotates the given 3D coordinates around the z axis. */
Vector3 Vector3_RotateZ(Vector3 v, Real32 angle);
bool Vector3_Equals(Vector3* a, Vector3* b);
@ -68,11 +55,8 @@ bool Vector3_NotEquals(Vector3* a, Vector3* b);
bool Vector3I_Equals(Vector3I* a, Vector3I* b);
bool Vector3I_NotEquals(Vector3I* a, Vector3I* b);
/* Returns a vector such that each component is floor of input floating-point component.*/
void Vector3I_Floor(Vector3I* result, Vector3* a);
/* Returns a vector with the integer components converted to floating-point components.*/
void Vector3I_ToVector3(Vector3* result, Vector3I* a);
void Vector3I_Min(Vector3I* result, Vector3I* a, Vector3I* b);
void Vector3I_Max(Vector3I* result, Vector3I* a, Vector3I* b);
@ -81,4 +65,20 @@ Vector3 Vector3_GetDirVector(Real32 yawRad, Real32 pitchRad);
/* Returns the yaw and pitch of the given direction vector.
NOTE: This is not an identity function. Returned pitch is always within [-90, 90] degrees.*/
void Vector3_GetHeading(Vector3 dir, Real32* yawRad, Real32* pitchRad);
void Matrix_RotateX(Matrix* result, Real32 angle);
void Matrix_RotateY(Matrix* result, Real32 angle);
void Matrix_RotateZ(Matrix* result, Real32 angle);
void Matrix_Translate(Matrix* result, Real32 x, Real32 y, Real32 z);
void Matrix_Scale(Matrix* result, Real32 x, Real32 y, Real32 z);
#define Matrix_MulBy(dst, right) Matrix_Mul(dst, dst, right)
void Matrix_Mul(Matrix* result, Matrix* left, Matrix* right);
void Matrix_Orthographic(Matrix* result, Real32 width, Real32 height, Real32 zNear, Real32 zFar);
void Matrix_OrthographicOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar);
void Matrix_PerspectiveFieldOfView(Matrix* result, Real32 fovy, Real32 aspect, Real32 zNear, Real32 zFar);
void Matrix_PerspectiveOffCenter(Matrix* result, Real32 left, Real32 right, Real32 bottom, Real32 top, Real32 zNear, Real32 zFar);
void Matrix_LookAt(Matrix* result, Vector3 eye, Vector3 target, Vector3 up);
#endif