From f705b5fe3d2bd16148b264fa7d8c79e8b6fbcab7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicolas=20Hord=C3=A9?= Date: Fri, 19 Oct 2018 10:13:29 +0200 Subject: [PATCH] =?UTF-8?q?fix:=20correction=20affichage=20video=20et=20aj?= =?UTF-8?q?out=20des=20fonctions=20matricielles,=20trigonom=C3=A9triques?= =?UTF-8?q?=20et=20math=C3=A9matiques=20diverses?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/asm.h | 4 +- include/math.h | 20 +- include/matrix.h | 76 +++++++ include/video.h | 6 + lib/math.c | 85 ++++++++ lib/matrix.c | 508 +++++++++++++++++++++++++++++++++++++++++++++++ lib/shell.c | 19 +- lib/vga.c | 7 +- lib/video.c | 2 +- 9 files changed, 713 insertions(+), 14 deletions(-) create mode 100644 include/matrix.h create mode 100644 lib/matrix.c diff --git a/include/asm.h b/include/asm.h index 12d00ad..dafa9a9 100755 --- a/include/asm.h +++ b/include/asm.h @@ -133,10 +133,10 @@ asm volatile ("cld;rep stosb"::"c" (count), "D" (dst), "a" (pattern)); #define stosw(pattern,dst,count) \ - asm volatile ("cld;rep stosw"::"a" (pattern), "c" (count), "D" (dst)); + asm volatile ("cld;rep stosw"::"c" (count), "D" (dst), "a" (pattern)); #define stosd(pattern,dst,count) \ - asm volatile ("cld;rep stosl"::"a" (pattern), "c" (count), "D" (dst)); + asm volatile ("cld;rep stosl"::"c" (count), "D" (dst), "a" (pattern)); #define rol(addr) \ asm volatile ("rolb $0x1,%0":"=m" (addr):); diff --git a/include/math.h b/include/math.h index 34ce72b..d33cd63 100755 --- a/include/math.h +++ b/include/math.h @@ -2,13 +2,25 @@ /* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */ /* */ #define sgn(x) ((x<0)?-1:((x>0)?1:0)); - +#define M_PI 3.14159265358979323846 //Pi +#define M_2_PI 0.636619772367581343076 //2 fois la réciproque de Pi +#define M_PI_2 1.57079632679489661923 //Pi divisé par two +#define EPSILON 1E-40 +#define degtorad(deg) (deg * PI / 180.0) +#define radtodeg(rad) (rad * 180.0 / PI) + +float fabsf(float n); +double fabs(double n); +float sqrtf(float n); +float rsqrtf(float n); +double sqrt(double n); +double rsqrt(double n); u32 abs(int x); -random(u32 lower, u32 upper); +u32 random(u32 lower, u32 upper); u32 rand(void); void randomize(void); -u8 log2(u32 n); -u8 log10(u32 n); +u8 log2(u64 n); +u8 log10(u64 n); unsigned long long __udivdi3 (unsigned long long num, unsigned long long den); unsigned long long __umoddi3 (unsigned long long n, unsigned long long d); u32 pow(u32 a, u8 n); diff --git a/include/matrix.h b/include/matrix.h new file mode 100644 index 0000000..d81dc67 --- /dev/null +++ b/include/matrix.h @@ -0,0 +1,76 @@ +/*******************************************************************************/ +/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */ +/* */ + +typedef struct vector4 +{ + float x, y, z, w; +} vector4; + +typedef struct vector3 +{ + float x, y, z; +} vector3; + +typedef struct vector2 +{ + float x, y; +} vector2; + + +typedef struct matrix44 +{ + vector4 V[4]; +} matrix44; + +void vector4_show(vector4 src); +void vector4_create(float x, float y, float z, float w, vector4 *dst); +void vector4_copy(vector4 src, vector4 *dst); +void vector4_add(vector4 v1, vector4 v2, vector4 *dst); +void vector4_sub(vector4 v1, vector4 v2, vector4 *dst); +void vector4_scale(vector4 *dst, float factor); +void vector4_crossproduct(vector4 v1, vector4 v2, vector4 *dst); +void vector4_normalize(vector4 *dst); +void vector4_divide(vector4 *v1, vector4 v2, vector4 *dst); +void vector4_perpendicular(vector4 v1, vector4 v2, vector4 *dst); +void vector4_rotate_x(vector4 *dst, float angle); +void vector4_rotate_y(vector4 *dst, float angle); +void vector4_rotate_z(vector4 *dst, float angle); +float vector4_len(vector4 src); +float vector4_dotproduct(vector4 v1, vector4 v2); +float vector4_norm(vector4 src); +float vector4_distance(vector4 v1, vector4 v2); +int vector4_isequals(vector4 v1, vector4 v2); +void vector4_planenormal(vector4 v1, vector4 v2, vector4 v3, vector4 *dst); + +void matrix44_homogen(matrix44 *matrix); +void matrix44_empty(matrix44 *matrix); +void matrix44_scaling(vector4 v, matrix44 *dst); +void matrix44_translation(vector4 v, matrix44 *dst); +void matrix44_scale(matrix44 *dst, float factor); +void matrix44_scale_translation(vector4 scale, vector4 translation, matrix44 *dst); +void matrix44_rotation_x(float angle, matrix44 *dst); +void matrix44_rotation_y(float angle, matrix44 *dst); +void matrix44_rotation_z(float angle, matrix44 *dst); +void matrix44_rotation(vector4 axis, float angle, matrix44 *dst); +void matrix44_multiply(matrix44 *m1, matrix44 *m2, matrix44 *dst); +void matrix44_transform(matrix44 *matrix, vector4 *dst); +float matrix44_determinant(matrix44 *matrix); +float todeterminant(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3); +void matrix44_adjoint(matrix44 *matrix); +void matrix44_show(matrix44 *matrix); +void matrix44_invert(matrix44 *matrix); +void matrix44_transpose(matrix44 *matrix); +void matrix44_lookat(vector4 eye, vector4 dst, vector4 up, matrix44 *matrix); +int matrix44_isequals(matrix44 *m1, matrix44 *m2); +void toarray(matrix44 *m, float *array); + + + + + + + + + + diff --git a/include/video.h b/include/video.h index 25d6a6e..5449d03 100755 --- a/include/video.h +++ b/include/video.h @@ -10,6 +10,12 @@ #define MAXDRIVERS 10 #define MAXFONTS 10 +typedef struct rgbcolor { + u8 R; + u8 G; + u8 B; +} rgbcolor __attribute__ ((packed)); + typedef struct videoinfos { u8 currentmode; u16 currentwidth; diff --git a/lib/math.c b/lib/math.c index 1ecef4c..e2183f9 100755 --- a/lib/math.c +++ b/lib/math.c @@ -3,6 +3,7 @@ /* */ #include "types.h" #include "timer.h" +#include "math.h" /*******************************************************************************/ /* Arithmétique 64 bits */ @@ -46,6 +47,90 @@ unsigned long long __umoddi3 (unsigned long long n, unsigned long long d) return n - d * __udivdi3 (n, d); } +/******************************************************************************/ +/* Fonctions qui retournent le sinus et cosinus */ + +double cos(double x){ + if( x < 0.0 ) + x = -x; + while( M_PI < x ) + x -= M_2_PI; + return 1.0 - (x*x/2.0)*( 1.0 - (x*x/12.0) * ( 1.0 - (x*x/30.0) * (1.0 - x*x/56.0 ))); +} + +double sin(double x){ + return cos(x-M_PI_2); +} + +float cosf(float x){ + if( x < 0.0f ) + x = -x; + while( M_PI < x ) + x -= M_2_PI; + return 1.0f - (x*x/2.0f)*( 1.0f - (x*x/12.0f) * ( 1.0f - (x*x/30.0f) * (1.0f - x*x/56.0f ))); +} + +float sinf(float x){ + return cos(x-M_PI_2); +} + +/******************************************************************************/ +/* Fonction qui retourne la valeur absolue */ + +float fabsf(float n) +{ + return (*((int *) &n) &= 0x7fffffff); +} + +double fabs(double n) +{ + return (*(((int *) &n) + 1) &= 0x7fffffff); +} + +/******************************************************************************/ +/* Fonction qui retourne la racine */ + +float sqrtf(float n) +{ + + float x = n; + float y = 1; + double e = 0.000001; + while(x - y > e) + { + x = (x + y)/2; + y = n/x; + } + return x; +} + +double sqrt(double n) +{ + + double x = n; + double y = 1; + double e = 0.000001; + while(x - y > e) + { + x = (x + y)/2; + y = n/x; + } + return x; +} + +/******************************************************************************/ +/* Fonction qui retourne l'inverse de la racine */ + +float rsqrtf(float n) +{ + return 1 / sqrt(n); +} + +double rsqrt(double n) +{ + return 1 / sqrt(n); +} + /******************************************************************************/ /* Fonction qui retourne la puissance n de a */ diff --git a/lib/matrix.c b/lib/matrix.c new file mode 100644 index 0000000..5f4df5a --- /dev/null +++ b/lib/matrix.c @@ -0,0 +1,508 @@ +/*******************************************************************************/ +/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */ +/* */ +#include "matrix.h" +#include "types.h" +#include "math.h" + +void vector4_show(vector4 src) +{ + printf("vecteur: X=%f Y=%f Z=%f W=%f \r\n", src.x, src.y, src.z, src.w); +} + +void vector4_create(float x, float y, float z, float w, vector4 *dst) +{ + dst->x = x; + dst->y = y; + dst->z = z; + dst->w = w; +} + +void vector4_copy(vector4 src, vector4 *dst) +{ + vector4_create(src.x, src.y, src.z, src.w, dst); +} + +void vector4_add(vector4 v1, vector4 v2, vector4 *dst) +{ + dst->x = v1.x + v2.x; + dst->y = v1.y + v2.y; + dst->z = v1.z + v2.z; +} + +void vector4_sub(vector4 v1, vector4 v2, vector4 *dst) +{ + dst->x = v1.x - v2.x; + dst->y = v1.y - v2.y; + dst->z = v1.z - v2.z; +} + +void vector4_scale(vector4 *dst, float factor) +{ + dst->x *= factor; + dst->y *= factor; + dst->z *= factor; + dst->w *= factor; +} + +void vector4_crossproduct(vector4 v1, vector4 v2, vector4 *dst) +{ + dst->x = v1.y * v2.z - v1.z * v2.y; + dst->y = v1.z * v2.x - v1.x * v2.z; + dst->z = v1.x * v2.y - v1.y * v2.x; +} + +void vector4_normalize(vector4 *dst) +{ + float len; + float norm; + norm = vector4_norm(*dst); + if (norm != 0) + { + len = 1 / norm; + dst->x = dst->x * len; + dst->y = dst->y * len; + dst->z = dst->z * len; + dst->w = 0; + } +} + +void vector4_divide(vector4 *v1, vector4 v2, vector4 *dst) +{ + dst->x = v1->x / v2.x; + dst->y = v1->y / v2.y; + dst->z = v1->z / v2.z; +} + +void vector4_perpendicular(vector4 v1, vector4 v2, vector4 *dst) +{ + float dot = vector4_dotproduct(v1, v2); + dst->x = v1.x - dot * v2.x; + dst->y = v1.y - dot * v2.y; + dst->z = v1.z - dot * v2.z; +} + +void vector4_rotate_x(vector4 *dst, float angle) +{ + vector4 origin; + float sinus, cosinus; + sinus = sin(angle); + cosinus = cos(angle); + origin.x = dst->x; + origin.y = dst->y; + origin.z = dst->z; + dst->y = cosinus * origin.y + sinus * origin.z; + dst->z = cosinus * origin.z - sinus * origin.y; +} + +void vector4_rotate_y(vector4 *dst, float angle) +{ + vector4 origin; + float sinus, cosinus; + sinus = sin(angle); + cosinus = cos(angle); + origin.x = dst->x; + origin.y = dst->y; + origin.z = dst->z; + dst->x = cosinus * origin.x + sinus * origin.z; + dst->z = cosinus * origin.z - sinus * origin.x; +} + +void vector4_rotate_z(vector4 *dst, float angle) +{ + vector4 origin; + float sinus, cosinus; + sinus = sin(angle); + cosinus = cos(angle); + origin.x = dst->x; + origin.y = dst->y; + origin.z = dst->z; + dst->x = cosinus * origin.x + sinus * origin.y; + dst->y = cosinus * origin.y - sinus * origin.x; +} + +float vector4_len(vector4 src) +{ + return sqrtf((src.x * src.x) + + (src.y * src.y) + + (src.z * src.z)); +} + +float vector4_dotproduct(vector4 v1, vector4 v2) +{ + return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z); +} + +float vector4_norm(vector4 src) +{ + return sqrtf((src.x * src.x) + + (src.y * src.y) + + (src.z * src.z)); +} + +float vector4_distance(vector4 v1, vector4 v2) +{ + return sqrt(pow(v2.x - v1.x, 2) + + pow(v2.y - v1.y, 2) + + pow(v2.z - v1.z, 2)); +} + +int vector4_isequals(vector4 v1, vector4 v2) +{ + float x, y, z; + x = fabsf(v1.x - v2.x); + y = fabsf(v1.y - v2.y); + z = fabsf(v1.z - v2.z); + return (x < 0.000001 && y < 0.000001 && z < 0.000001); +} + +void vector4_planenormal(vector4 v1, vector4 v2, vector4 v3, vector4 *dst) +{ + vector4 temp1, temp2; + vector4_sub(v2, v1, &temp1); + vector4_sub(v3, v1, &temp2); + vector4_crossproduct(temp1, temp2, dst); + vector4_normalize(dst); +} + +void matrix44_homogen(matrix44 *matrix) +{ + vector4_create(1, 0, 0, 0, &matrix->V[0]); + vector4_create(0, 1, 0, 0, &matrix->V[1]); + vector4_create(0, 0, 1, 0, &matrix->V[2]); + vector4_create(0, 0, 0, 1, &matrix->V[3]); +} + +void matrix44_empty(matrix44 *matrix) +{ + vector4_create(0, 0, 0, 0, &matrix->V[0]); + vector4_create(0, 0, 0, 0, &matrix->V[1]); + vector4_create(0, 0, 0, 0, &matrix->V[2]); + vector4_create(0, 0, 0, 0, &matrix->V[3]); +} + +void matrix44_scaling(vector4 v, matrix44 *dst) +{ + matrix44_homogen(dst); + dst->V[0].x = v.x; + dst->V[1].y = v.y; + dst->V[2].z = v.z; +} + +void matrix44_translation(vector4 v, matrix44 *dst) +{ + matrix44_homogen(dst); + dst->V[0].x = v.x; + dst->V[1].y = v.y; + dst->V[2].z = v.z; +} + +void matrix44_scale(matrix44 *dst, float factor) +{ + vector4_scale(&dst->V[0], factor); + vector4_scale(&dst->V[1], factor); + vector4_scale(&dst->V[2], factor); + vector4_scale(&dst->V[3], factor); +} + +void matrix44_scale_translation(vector4 scale, vector4 translation, matrix44 *dst) +{ + matrix44_homogen(dst); + dst->V[0].x = scale.x; + dst->V[1].y = scale.y; + dst->V[2].z = scale.z; + dst->V[3].x = translation.x; + dst->V[3].y = translation.y; + dst->V[3].z = translation.z; +} + +void matrix44_rotation_x(float angle, matrix44 *dst) +{ + float sinus,cosinus; + cosinus = cos(angle); + sinus = sin(angle); + matrix44_empty(dst); + dst->V[0].x = 1; + dst->V[1].y = cosinus; + dst->V[1].z = sinus; + dst->V[2].y = -1 * sinus; + dst->V[2].z = cosinus; + dst->V[3].w = 1; +} + +void matrix44_rotation_y(float angle, matrix44 *dst) +{ + float sinus,cosinus; + cosinus = cos(angle); + sinus = sin(angle); + matrix44_empty(dst); + dst->V[0].x = cosinus; + dst->V[0].z = -1 * sinus; + dst->V[1].y = 1; + dst->V[2].x = sinus; + dst->V[2].z = cosinus; + dst->V[3].w = 1; +} + +void matrix44_rotation_z(float angle, matrix44 *dst) +{ + float sinus,cosinus; + cosinus = cos(angle); + sinus = sin(angle); + matrix44_empty(dst); + dst->V[0].x = cosinus; + dst->V[0].y = sinus; + dst->V[1].x = -1 * sinus; + dst->V[1].y = cosinus; + dst->V[2].z = 1; + dst->V[3].w = 1; +} + +void matrix44_rotation(vector4 axis, float angle, matrix44 *dst) +{ + float cosinus, sinus, minuscos; + sinus = sinf(angle); + cosinus = cosf(angle); + vector4_normalize(&axis); + minuscos = 1 - cosinus; + + dst->V[0].x = (minuscos * axis.x * axis.x) + cosinus; + dst->V[0].y = (minuscos * axis.x * axis.y) - (axis.z * sinus); + dst->V[0].z = (minuscos * axis.z * axis.x) + (axis.y * sinus); + dst->V[0].w = 0; + + dst->V[1].x = (minuscos * axis.x * axis.y) + (axis.z * sinus); + dst->V[1].y = (minuscos * axis.y * axis.y) + cosinus; + dst->V[1].z = (minuscos * axis.y * axis.z) - (axis.x * sinus); + dst->V[1].w = 0; + + dst->V[2].x = (minuscos * axis.z * axis.x) - (axis.y * sinus); + dst->V[2].y = (minuscos * axis.y * axis.z) + (axis.x * sinus); + dst->V[2].z = (minuscos * axis.z * axis.z) + cosinus; + dst->V[2].w = 0; + + dst->V[3].x = 0; + dst->V[3].y = 0; + dst->V[3].z = 0; + dst->V[3].w = 1; +} + +void matrix44_multiply(matrix44 *m1, matrix44 *m2, matrix44 *dst) +{ + dst->V[0].x = (m1->V[0].x * m2->V[0].x + m1->V[0].y * m2->V[1].x + + m1->V[0].z * m2->V[2].x + m1->V[0].w * m2->V[3].x); + dst->V[0].y = (m1->V[0].x * m2->V[0].y + m1->V[0].y * m2->V[1].y + + m1->V[0].z * m2->V[2].y + m1->V[0].w * m2->V[3].y); + dst->V[0].z = (m1->V[0].x * m2->V[0].z + m1->V[0].y * m2->V[1].z + + m1->V[0].z * m2->V[2].z + m1->V[0].w * m2->V[3].z); + dst->V[0].w = (m1->V[0].x * m2->V[0].w + m1->V[0].y * m2->V[1].w + + m1->V[0].z * m2->V[2].w + m1->V[0].w * m2->V[3].w); + dst->V[1].x = (m1->V[1].x * m2->V[0].x + m1->V[1].y * m2->V[1].x + + m1->V[1].z * m2->V[2].x + m1->V[1].w * m2->V[3].x); + dst->V[1].y = (m1->V[1].x * m2->V[0].y + m1->V[1].y * m2->V[1].y + + m1->V[1].z * m2->V[2].y + m1->V[1].w * m2->V[3].y); + dst->V[1].z = (m1->V[1].x * m2->V[0].z + m1->V[1].y * m2->V[1].z + + m1->V[1].z * m2->V[2].z + m1->V[1].w * m2->V[3].z); + dst->V[1].w = (m1->V[1].x * m2->V[0].w + m1->V[1].y * m2->V[1].w + + m1->V[1].z * m2->V[2].w + m1->V[1].w * m2->V[3].w); + dst->V[2].x = (m1->V[2].x * m2->V[0].x + m1->V[2].y * m2->V[1].x + + m1->V[2].z * m2->V[2].x + m1->V[2].w * m2->V[3].x); + dst->V[2].y = (m1->V[2].x * m2->V[0].y + m1->V[2].y * m2->V[1].y + + m1->V[2].z * m2->V[2].y + m1->V[2].w * m2->V[3].y); + dst->V[2].z = (m1->V[2].x * m2->V[0].z + m1->V[2].y * m2->V[1].z + + m1->V[2].z * m2->V[2].z + m1->V[2].w * m2->V[3].z); + dst->V[2].w = (m1->V[2].x * m2->V[0].w + m1->V[2].y * m2->V[1].w + + m1->V[2].z * m2->V[2].w + m1->V[2].w * m2->V[3].w); + dst->V[3].x = (m1->V[3].x * m2->V[0].x + m1->V[3].y * m2->V[1].x + + m1->V[3].z * m2->V[2].x + m1->V[3].w * m2->V[3].x); + dst->V[3].y = (m1->V[3].x * m2->V[0].y + m1->V[3].y * m2->V[1].y + + m1->V[3].z * m2->V[2].y + m1->V[3].w * m2->V[3].y); + dst->V[3].z = (m1->V[3].x * m2->V[0].z + m1->V[3].y * m2->V[1].z + + m1->V[3].z * m2->V[2].z + m1->V[3].w * m2->V[3].z); + dst->V[3].w = (m1->V[3].x * m2->V[0].w + m1->V[3].y * m2->V[1].w + + m1->V[3].z * m2->V[2].w + m1->V[3].w * m2->V[3].w); +} + +void matrix44_transform(matrix44 *matrix, vector4 *dst) +{ + vector4 origin; + origin.x = dst->x; + origin.y = dst->y; + origin.z = dst->z; + origin.w = dst->w; + dst->x = origin.x * matrix->V[0].x + origin.y * matrix->V[1].x + origin.z * matrix->V[2].x + origin.w * matrix->V[3].x; + dst->y = origin.x * matrix->V[0].y + origin.y * matrix->V[1].y + origin.z * matrix->V[2].y + origin.w * matrix->V[3].y; + dst->z = origin.x * matrix->V[0].z + origin.y * matrix->V[1].z + origin.z * matrix->V[2].z + origin.w * matrix->V[3].z; + dst->w = origin.x * matrix->V[0].w + origin.y * matrix->V[1].w + origin.z * matrix->V[2].w + origin.w * matrix->V[3].w; +} + +float matrix44_determinant(matrix44 *matrix) +{ + float a, b, c, d; + a = matrix->V[0].x * todeterminant(matrix->V[1].y, matrix->V[2].y, matrix->V[3].y, + matrix->V[1].z, matrix->V[2].z, matrix->V[3].z, + matrix->V[1].w, matrix->V[2].w, matrix->V[3].w); + b = matrix->V[0].y * todeterminant(matrix->V[1].x, matrix->V[2].x, matrix->V[3].x, + matrix->V[1].z, matrix->V[2].z, matrix->V[3].z, + matrix->V[1].w, matrix->V[2].w, matrix->V[3].w); + c = matrix->V[0].z * todeterminant(matrix->V[1].x, matrix->V[2].x, matrix->V[3].x, + matrix->V[1].y, matrix->V[2].y, matrix->V[3].y, + matrix->V[1].w, matrix->V[2].w, matrix->V[3].w); + d = matrix->V[0].w * todeterminant(matrix->V[1].x, matrix->V[2].x, matrix->V[3].x, + matrix->V[1].y, matrix->V[2].y, matrix->V[3].y, + matrix->V[1].z, matrix->V[2].z, matrix->V[3].z); + return a - b + c - d; +} + +float todeterminant(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) +{ + return (a1 * ((b2 * c3) - (b3 * c2))) - (b1 * ((a2 * c3) - (a3 * c2))) + (c1 * ((a2 * b3) - (a3 * b2))); +} + +void matrix44_adjoint(matrix44 *matrix) +{ + float a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4; + a1 = matrix->V[0].x; + b1 = matrix->V[0].y; + c1 = matrix->V[0].z; + d1 = matrix->V[0].w; + + a2 = matrix->V[1].x; + b2 = matrix->V[1].y; + c2 = matrix->V[1].z; + d2 = matrix->V[1].w; + + a3 = matrix->V[2].x; + b3 = matrix->V[2].y; + c3 = matrix->V[2].z; + d3 = matrix->V[2].w; + + a4 = matrix->V[3].x; + b4 = matrix->V[3].y; + c4 = matrix->V[3].z; + d4 = matrix->V[3].w; + + matrix->V[0].x = todeterminant(b2, b3, b4, c2, c3, c4, d2, d3, d4); + matrix->V[1].x = -todeterminant(a2, a3, a4, c2, c3, c4, d2, d3, d4); + matrix->V[2].x = todeterminant(a2, a3, a4, b2, b3, b4, d2, d3, d4); + matrix->V[3].x = -todeterminant(a2, a3, a4, b2, b3, b4, c2, c3, c4); + + matrix->V[0].y = -todeterminant(b1, b3, b4, c1, c3, c4, d1, d3, d4); + matrix->V[1].y = todeterminant(a1, a3, a4, c1, c3, c4, d1, d3, d4); + matrix->V[2].y = -todeterminant(a1, a3, a4, b1, b3, b4, d1, d3, d4); + matrix->V[3].y = todeterminant(a1, a3, a4, b1, b3, b4, c1, c3, c4); + + matrix->V[0].z = todeterminant(b1, b2, b4, c1, c2, c4, d1, d2, d4); + matrix->V[1].z = -todeterminant(a1, a2, a4, c1, c2, c4, d1, d2, d4); + matrix->V[2].z = todeterminant(a1, a2, a4, b1, b2, b4, d1, d2, d4); + matrix->V[3].z = -todeterminant(a1, a2, a4, b1, b2, b4, c1, c2, c4); + + matrix->V[0].w = -todeterminant(b1, b2, b3, c1, c2, c3, d1, d2, d3); + matrix->V[1].w = todeterminant(a1, a2, a3, c1, c2, c3, d1, d2, d3); + matrix->V[2].w = -todeterminant(a1, a2, a3, b1, b2, b3, d1, d2, d3); + matrix->V[3].w = todeterminant(a1, a2, a3, b1, b2, b3, c1, c2, c3); +} + +void matrix44_show(matrix44 *matrix) +{ + printf("Matrice: X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x, matrix->V[1].y, matrix->V[2].z, matrix->V[3].w); + printf(" X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x, matrix->V[1].y, matrix->V[2].z, matrix->V[3].w); + printf(" X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x, matrix->V[1].y, matrix->V[2].z, matrix->V[3].w); +} + +void matrix44_invert(matrix44 *matrix) +{ + float det; + det = matrix44_determinant(matrix); + if (fabs(det) < EPSILON) + { + matrix44_homogen(matrix); + } + else + { + matrix44_adjoint(matrix); + matrix44_scale(matrix, 1.0 / det); + } +} + +void matrix44_transpose(matrix44 *matrix) +{ + float f; + f = matrix->V[0].y; + matrix->V[0].y = matrix->V[1].x; + matrix->V[1].x = f; + + f = matrix->V[0].z; + matrix->V[0].z = matrix->V[2].x; + matrix->V[2].x = f; + + f = matrix->V[0].w; + matrix->V[0].w = matrix->V[3].x; + matrix->V[3].x = f; + + f = matrix->V[1].z; + matrix->V[1].z = matrix->V[2].y; + matrix->V[2].y = f; + + f = matrix->V[1].w; + matrix->V[1].w = matrix->V[3].y; + matrix->V[3].y = f; + + f = matrix->V[2].w; + matrix->V[2].w = matrix->V[3].z; + matrix->V[3].z = f; +} + +void matrix44_lookat(vector4 eye, vector4 dst, vector4 up, matrix44 *matrix) +{ + vector4 xaxis, yaxis, zaxis, negeye; + vector4_sub(dst, eye, &zaxis); + vector4_normalize(&zaxis); + + vector4_crossproduct(zaxis, up, &xaxis); + vector4_normalize(&xaxis); + + vector4_crossproduct(xaxis, zaxis, &yaxis); + + vector4_copy(xaxis, &matrix->V[0]); + vector4_copy(yaxis, &matrix->V[1]); + vector4_copy(zaxis, &matrix->V[2]); + + matrix->V[2].x = -matrix->V[2].x; + matrix->V[2].y = -matrix->V[2].y; + matrix->V[2].z = -matrix->V[2].z; + + vector4_create(0, 0, 0, 1, &matrix->V[3]); + + matrix44_transpose(matrix); + vector4_create(-eye.x, -eye.y, -eye.z, 1, &negeye); + + matrix44_transform(matrix, &negeye); + vector4_copy(negeye, &matrix->V[3]); +} + +int matrix44_isequals(matrix44 *m1, matrix44 *m2) +{ + return vector4_isequals(m1->V[0], m2->V[0]) && vector4_isequals(m1->V[1], m2->V[1]) && + vector4_isequals(m1->V[2], m2->V[2]) && vector4_isequals(m1->V[3], m2->V[3]); +} + +void toarray(matrix44 *m, float *array) +{ + array[0] = m->V[0].x; + array[1] = m->V[0].y; + array[2] = m->V[0].z; + array[3] = m->V[0].w; + array[4] = m->V[1].x; + array[5] = m->V[1].y; + array[6] = m->V[1].z; + array[7] = m->V[1].w; + array[8] = m->V[2].x; + array[9] = m->V[2].y; + array[10] = m->V[2].z; + array[11] = m->V[2].w; + array[12] = m->V[3].x; + array[13] = m->V[3].y; + array[14] = m->V[3].z; + array[15] = m->V[3].w; +} diff --git a/lib/shell.c b/lib/shell.c index 68513f8..98f24c9 100644 --- a/lib/shell.c +++ b/lib/shell.c @@ -428,7 +428,21 @@ int test2d() struct vertex2d a, b, c; randomize(); u32 color; - for (int i = 0; i < 3000; i++) { + for (int i = 0; i < 2000; i++) { + a.x = random(0, vinfo->currentwidth); + a.y = random(0, vinfo->currentheight); + b.x = random(0, vinfo->currentwidth); + b.y = random(0, vinfo->currentheight); + if (vinfo->currentdepth>24) + color=egatorgb(random(0,16)); + else if (vinfo->currentdepth==8) + color=random(0,63); + else + color=random(0,16); + linev(&a,&b,color); + } + waitascii(); + for (int i = 0; i < 2000; i++) { a.x = random(0, vinfo->currentwidth); a.y = random(0, vinfo->currentheight); b.x = random(0, vinfo->currentwidth); @@ -438,11 +452,10 @@ int test2d() if (vinfo->currentdepth>24) color=egatorgb(random(0,16)); else if (vinfo->currentdepth==8) - color=random(0,256); + color=random(0,63); else color=random(0,16); trianglefilled(&a, &b, &c, color); - waitascii(); triangle(&a, &b, &c, egatorgb(4)); } return 0; diff --git a/lib/vga.c b/lib/vga.c index 0a1865c..655859a 100755 --- a/lib/vga.c +++ b/lib/vga.c @@ -22,9 +22,8 @@ u8 *VGA_detect_hardware(void) { u32 getbase(void) { u32 base; - /*outb(GRAPHICS, 6); - base = inb(GRAPHICS + 1);*/ - base = modes[infos.currentmode].graphic.Miscellaneous_Graphics_Register; + outb(GRAPHICS, 6); + base = inb(GRAPHICS + 1); base >>= 2; base &= 3; switch (base) { @@ -185,7 +184,7 @@ u32 VGA_mem_to_video (void *src,u32 dst, u32 size, bool increment_src) { case 8: if (!increment_src) { - u8 tmp=(u8) src; + u8 tmp=(u8) (src); if (size%4 == 0) { u32 pattern = tmp + (tmp<<8) + (tmp<<16) + (tmp<<24); diff --git a/lib/video.c b/lib/video.c index f0f2b60..01fadb7 100755 --- a/lib/video.c +++ b/lib/video.c @@ -1175,7 +1175,7 @@ void loadfont(u8 *name,font* pointer,u8 width, u8 height) if (fonts[i].nom[0]=='B' && fonts[i].nom[1]=='I' && fonts[i].nom[2]=='O' && fonts[i].nom[3]=='S') { u8 number=(fonts[i].nom[4]-'0'); - font_load(pointer, number, height); + font_load(pointer, height, number); } }