InventorX/C3D
1
1
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

added a bunch of features, preparing to read from obj files for display

Browse source
This commit is contained in:
InventorXtreme 2024-03-10 01:58:05 -05:00
parent 6b04973314
commit 34e70de2f9
11 changed files with 567 additions and 377 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.clang-format
View file

@ -1 +1,2 @@
IndentWidth: 4
ColumnLimit: 80

16
Makefile
View file

@ -1,12 +1,12 @@
CC = gcc
CFLAGS = -pg -g -Wall
LDFLAGS = -pg -g
LDLIBS = -lraylib -lm
objects = c3d.o
CC = clang #Set compiler
CFLAGS = -pg -g -Wall -O2 -pg #set compiler flags
LDFLAGS = -pg -g #set linker flags
LDLIBS = -lraylib -lm #set libraries to use
objects = c3d.o reader.o arrayfuncs.o vecfunc.c #list all object files
c3d: $(objects)
c3d: $(objects) #State that to make the c3d executeable, we need all objects
$(objects): %.o: %.c
$(objects): %.o: %.c #State that to make each object, we use its respective c file
clean:
clean: #to clean remove all object files and the executable
rm -f *.o c3d

11
arrayfuncs.c Normal file
View file

@ -0,0 +1,11 @@
#include "c3dtypes.h"
void TriArrayAppend(TriArray *tarr, Tri t) {
tarr->arr[tarr->length] = t;
tarr->length = tarr->length + 1;
}
void Tri2DArrayAppend(Tri2DArray *tarr, Tri2D t) {
tarr->arr[tarr->length] = t;
tarr->length = tarr->length + 1;
}

8
arrayfuncs.h Normal file
View file

@ -0,0 +1,8 @@
#ifndef ARRAYFUNCS_HEADER
#define ARRAYFUNCS_HEADER
void TriArrayAppend(TriArray *tarr, Tri t);
void Tri2DArrayAppend(Tri2DArray *tarr, Tri2D t);
#endif

655
c3d.c
View file

@ -1,8 +1,13 @@
#include "raylib.h"
#include "reader.h"
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "raylib.h"
#include <string.h>
#include "c3dtypes.h"
#include "arrayfuncs.h"
#include "vecfunc.h"
const int RENDERWIDTH = 1920;
@ -11,206 +16,170 @@ const int RENDERHEIGHT = 1080;
const int HALFWIDTH = RENDERWIDTH / 2;
const int HALFHEIGHT = RENDERHEIGHT / 2;
const int SCREENWIDTH = 1280;
const int SCREENHEIGHT = 720;
const float WIDTHSCALE = (float)RENDERWIDTH / SCREENWIDTH;
const float HEIGHTSCALE = (float) RENDERHEIGHT / SCREENHEIGHT;
const float HEIGHTSCALE = (float)RENDERHEIGHT / SCREENHEIGHT;
const float fov = 70.0 / 180.0 * 3.14159265369;
const float half_fov = fov / 2;
float proj; //HALFWIDTH / tan(half_fov) Inited later
float proj; // HALFWIDTH / tan(half_fov) Inited later
struct LocalCam {
Vector3 position;
Vector3 velocity;
Vector3 acceleration;
Vector3 angles;
Vector3 angleVelocity;
Vector3 angleAcceleration;
};
typedef struct LocalCam LocalCam;
struct Tri {
Vector3 a;
Vector3 b;
Vector3 c;
Color color;
};
typedef struct Tri Tri;
struct Tri2D{
Vector2 a;
Vector2 b;
Vector2 c;
Color color;
};
typedef struct Tri2D Tri2D;
struct Zee {
int depth;
Tri2D * triangle;
};
typedef struct Zee Zee;
struct TriArray {
int length;
Tri* arr;
};
typedef struct TriArray TriArray;
struct Tri2DArray {
int length;
Tri2D* arr;
};
typedef struct Tri2DArray Tri2DArray;
double Min(double a, double b){
if (a>b) {
return b;
double Min(double a, double b) {
if (a > b) {
return b;
}
return a;
}
double Max(double a, double b){
if (a<b){
return b;
double Max(double a, double b) {
if (a < b) {
return b;
}
return a;
}
static inline int IndexOfZBuff(int row, int col) {
return row + RENDERWIDTH*col;
return row + RENDERWIDTH * col;
}
//sort triangle verts so that point A is the "highest" point (lowest y val) and point C is the "lowest" pont (highest y val)
void Tri2DSortByY(Tri2D * t){
// sort triangle verts so that point A is the "highest" point (lowest y val) and
// point C is the "lowest" pont (highest y val)
void Tri2DSortByY(Tri2D *t) {
Vector2 temp;
if (t->a.y > t->b.y) {
temp = t->a;
t->a = t->b;
t->b = temp;
temp = t->a;
t->a = t->b;
t->b = temp;
}
if (t->b.y > t->c.y){
temp = t->b;
t->b = t->c;
t->c = temp;
if (t->b.y > t->c.y) {
temp = t->b;
t->b = t->c;
t->c = temp;
}
if (t->a.y > t->b.y) {
temp = t->a;
t->a = t->b;
t->b = temp;
temp = t->a;
t->a = t->b;
t->b = temp;
}
}
//Draws triangle with a flat top. Note A and B must be the top points with C being the bottom "spike"
void FillTopFlatZbuffer(Zee * zee , Tri2D* t, Tri2D * tp) {
// Draws triangle with a flat top. Note A and B must be the top points with C
// being the bottom "spike"
void FillTopFlatZbuffer(Zee *zee, Tri2D *t, Tri2D *tp) {
if (t->b.x < t->a.x) {
Vector2 e = t->b;
t->b = t->a;
t->a = e;
Vector2 e = t->b;
t->b = t->a;
t->a = e;
}
//Becasue we are trying to get the x values in terms of the y values, we need inverse slope
float atocslopeinv = (t->c.x - t->a.x) / (t->c.y - t->a.y); //dif in x from start to end with a and c
float btocslopinv = (t->c.x - t->b.x) / (t->c.y - t->b.y); //dif in x from start to end with b and c
// Becasue we are trying to get the x values in terms of the y values, we
// need inverse slope
float atocslopeinv =
(t->c.x - t->a.x) /
(t->c.y - t->a.y); // dif in x from start to end with a and c
float btocslopinv =
(t->c.x - t->b.x) /
(t->c.y - t->b.y); // dif in x from start to end with b and c
//start at bottom of triangle (point c) so that we do not need to determine which vertex is on which side and increment it with its proper slope
// start at bottom of triangle (point c) so that we do not need to determine
// which vertex is on which side and increment it with its proper slope
double curx1 = t->c.x;
double curx2 = t->c.x;
for(int scanline=t->c.y; scanline >= t->a.y; scanline--){
if (0 <= scanline && scanline < RENDERHEIGHT){
for (int i = Max(curx1,0); i < Min(curx2,RENDERWIDTH); i++) {
zee[IndexOfZBuff(i,scanline) ].triangle = tp;
}
}
curx1 -= atocslopeinv; //subtract because we are working backwards (reason why we start with point c in slope equtn)
curx2 -= btocslopinv;
for (int scanline = t->c.y; scanline >= t->a.y; scanline--) {
if (0 <= scanline && scanline < RENDERHEIGHT) {
for (int i = Max(curx1, 0); i < Min(curx2, RENDERWIDTH); i++) {
zee[IndexOfZBuff(i, scanline)].triangle = tp;
}
}
curx1 -=
atocslopeinv; // subtract because we are working backwards (reason
// why we start with point c in slope equtn)
curx2 -= btocslopinv;
}
}
void PrintTri2D(Tri2D t) {
printf("{(TRI2D) A: (%f, %f), B: (%f, %f), C:(%f,%f) }\n ",t.a.x,t.a.y,t.b.x, t.b.y, t.c.x, t.c.y);
printf("{(TRI2D) A: (%f, %f), B: (%f, %f), C:(%f,%f) }\n ", t.a.x, t.a.y,
t.b.x, t.b.y, t.c.x, t.c.y);
}
//Draws triangle with a flat bottomp. Note B and C must be the bottom points with A being the top "spike"
void FillBottomFlatZbuffer(Zee * zee, Tri2D* t, Tri2D * tp) {
// Draws triangle with a flat bottomp. Note B and C must be the bottom points
// with A being the top "spike"
void FillBottomFlatZbuffer(Zee *zee, Tri2D *t, Tri2D *tp) {
if (t->c.x < t->b.x) {
Vector2 e = t->c;
t->c = t->b;
t->b = e;
Vector2 e = t->c;
t->c = t->b;
t->b = e;
}
//Becasue we are trying to get the x values in terms of the y values, we need inverse slope
float atobslopeinv = (t->b.x - t->a.x) / (t->b.y - t->a.y); //dif in x from start to end with a and c
float atocslopeinv = (t->c.x - t->a.x) / (t->c.y - t->a.y); //dif in x from start to end with b and c
// Becasue we are trying to get the x values in terms of the y values, we
// need inverse slope
float atobslopeinv =
(t->b.x - t->a.x) /
(t->b.y - t->a.y); // dif in x from start to end with a and c
float atocslopeinv =
(t->c.x - t->a.x) /
(t->c.y - t->a.y); // dif in x from start to end with b and c
//start at top of triangle (point c) so that we do not need to determine which vertex is on which side and increment it with its proper slope
// start at top of triangle (point c) so that we do not need to determine
// which vertex is on which side and increment it with its proper slope
double curx1 = t->a.x;
double curx2 = t->a.x;
for(int scanline=t->a.y; scanline < t->c.y; scanline++){
if (0 <= scanline && scanline < RENDERHEIGHT){
for (int i = Max(curx1,0); i < Min(curx2,RENDERWIDTH); i++) {
zee[ IndexOfZBuff(i,scanline) ].triangle = tp;
}
}
curx1 += atobslopeinv;
curx2 += atocslopeinv;
for (int scanline = t->a.y; scanline < t->c.y; scanline++) {
if (0 <= scanline && scanline < RENDERHEIGHT) {
for (int i = Max(curx1, 0); i < Min(curx2, RENDERWIDTH); i++) {
zee[IndexOfZBuff(i, scanline)].triangle = tp;
}
}
curx1 += atobslopeinv;
curx2 += atocslopeinv;
}
}
void DrawTriZuff(Zee * zbuf, Tri2D * t){
void DrawTriZuff(Zee *zbuf, Tri2D *t) {
Tri2DSortByY(t);
if (t->b.y == t->c.y) { // if bottom of triangle is flat
FillBottomFlatZbuffer(zbuf,t,t);
FillBottomFlatZbuffer(zbuf, t, t);
} else if (t->a.y == t->b.y) { // if top of triangle is flat
FillTopFlatZbuffer(zbuf, t, t);
} else { // funny split tri
Vector2 v4; // v4 is the vertex on the line between a and c. It is used
// to split the triangle into a top and bottom
v4.y = t->b.y;
float slope = (float)((t->c.x) - (t->a.x)) /
((float)(t->c.y - t->a.y)); // get slope in run over rise
// becasue we need to find x
float changeiny = (float)(t->b.y - t->a.y);
float officalxpos = t->a.x + (slope * changeiny);
v4.x = officalxpos;
Tri2D bottomflattrires;
bottomflattrires.a = t->a;
bottomflattrires.b = t->b;
bottomflattrires.c = v4;
bottomflattrires.color = t->color;
Tri2D topflattrires;
topflattrires.a = t->b;
topflattrires.b = v4;
topflattrires.c = t->c;
topflattrires.color = t->color;
FillBottomFlatZbuffer(zbuf, &bottomflattrires, t);
FillTopFlatZbuffer(zbuf, &topflattrires, t);
}
else if (t->a.y == t->b.y) { //if top of triangle is flat
FillTopFlatZbuffer(zbuf,t,t);
} else{ //funny split tri
Vector2 v4; //v4 is the vertex on the line between a and c. It is used to split the triangle into a top and bottom
v4.y = t->b.y;
float slope = (float)((t->c.x) - (t->a.x)) /((float)(t->c.y - t->a.y)); //get slope in run over rise becasue we need to find x
float changeiny = (float) (t->b.y - t->a.y);
float officalxpos = t->a.x + (slope*changeiny);
v4.x = officalxpos;
Tri2D bottomflattrires;
bottomflattrires.a = t->a;
bottomflattrires.b = t->b;
bottomflattrires.c = v4;
bottomflattrires.color = t->color;
Tri2D topflattrires;
topflattrires.a = t->b;
topflattrires.b = v4;
topflattrires.c = t->c;
topflattrires.color = t->color;
FillBottomFlatZbuffer(zbuf, &bottomflattrires, t);
FillTopFlatZbuffer(zbuf, &topflattrires, t);
}
}
float Sign(Vector2* v1, Vector2* v2, Vector2* v3) {
return (v1->x - v3->x) * (v2->y - v3->y) - (v2->x - v3->x) * (v1->y - v3->y);
float Sign(Vector2 *v1, Vector2 *v2, Vector2 *v3) {
return (v1->x - v3->x) * (v2->y - v3->y) -
(v2->x - v3->x) * (v1->y - v3->y);
}
bool IsInTri(Tri2D tri, Vector2 p) {
static inline bool IsInTri(Tri2D tri, Vector2 p) {
float d1, d2, d3;
bool has_neg, has_pos;
@ -224,58 +193,7 @@ bool IsInTri(Tri2D tri, Vector2 p) {
return !(has_neg && has_pos);
}
void TriArrayAppend(TriArray * tarr, Tri t) {
tarr->arr[tarr->length] = t;
tarr->length = tarr->length + 1;
}
void Tri2DArrayAppend(Tri2DArray * tarr, Tri2D t) {
tarr->arr[tarr->length] = t;
tarr->length = tarr->length + 1;
}
Vector3 Vector3Sum(Vector3 v1, Vector3 v2) {
Vector3 retvec;
retvec.x = v1.x + v2.x;
retvec.y = v1.y + v2.y;
retvec.z = v1.z + v2.z;
return retvec;
}
void Vector3Print(Vector3 v) {
printf("VX: %f, VY: %f, FZ: %f\n",v.x,v.y,v.z);
}
Vector3 Vector3Scale(Vector3 v1, float scale) {
Vector3 retvec;
retvec.x = v1.x * scale;
retvec.y = v1.y * scale;
retvec.z = v1.z * scale;
return retvec;
}
Vector3 RotateAboutX(Vector3 v, double radians){
Vector3 rotatedvector;
rotatedvector.x = 1*v.x + (0) + (0);
rotatedvector.y = (0) + cos(radians)*v.y + (-sin(radians)*v.z);
rotatedvector.z = 0 + sin(radians)*v.y + cos(radians)*v.z;
return rotatedvector;
}
Vector3 RotateAboutY(Vector3 v, double radians){
Vector3 rotatedvector;
rotatedvector.x = cos(radians)*v.x + (0) + sin(radians)*v.z;
rotatedvector.y = (0) + 1*v.y + (0);
rotatedvector.z = -sin(radians)*v.x + 0 + cos(radians)*v.z;
return rotatedvector;
}
Vector3 RotateAboutZ(Vector3 v, double radians){
Vector3 rotatedvector;
rotatedvector.x = cos(radians)*v.x + (-sin(radians)*v.y) + (0);
rotatedvector.y = sin(radians)*v.x + cos(radians)*v.y + (0);
rotatedvector.z = 0 + 0 + 1*v.z;
return rotatedvector;
}
void CtrlLocalCam(LocalCam *cam, float time) {
cam->velocity.x = 0;
@ -286,63 +204,65 @@ void CtrlLocalCam(LocalCam *cam, float time) {
cam->angleVelocity.z = 0;
if (IsKeyDown(KEY_W)) {
Vector3 forceForward = (Vector3){0,0,-500};
Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
printf("%f", cam->angles.y);
Vector3Print(rotatedforce);
cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
Vector3 forceForward = (Vector3){0, 0, -500};
Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
// printf("%f", cam->angles.y);
// Vector3Print(rotatedforce);
cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
// cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
// cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
}
if (IsKeyDown(KEY_S)) {
Vector3 forceForward = (Vector3){0,0,500};
Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
Vector3 forceForward = (Vector3){0, 0, 500};
Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
// cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
// cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
}
if (IsKeyDown(KEY_A)) {
Vector3 forceForward = (Vector3){-500,0,0};
Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
Vector3 forceForward = (Vector3){-500, 0, 0};
Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
// cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
// cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
}
if (IsKeyDown(KEY_D)) {
Vector3 forceForward = (Vector3){500,0,0};
Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
Vector3 forceForward = (Vector3){500, 0, 0};
Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
// cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
// cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
}
if(IsKeyDown(KEY_SPACE)) {
cam->velocity.y = cam->velocity.y - 50;
if (IsKeyDown(KEY_SPACE)) {
cam->velocity.y = cam->velocity.y - 50;
}
if(IsKeyDown(KEY_LEFT_SHIFT)) {
cam->velocity.y = cam->velocity.y + 50;
if (IsKeyDown(KEY_LEFT_SHIFT)) {
cam->velocity.y = cam->velocity.y + 50;
}
if (IsKeyDown(KEY_Q)){
cam->angleVelocity.y = cam->angleVelocity.y + time*10;
if (IsKeyDown(KEY_Q)) {
cam->angleVelocity.y = cam->angleVelocity.y + time * 10;
}
if (IsKeyDown(KEY_E)){
cam->angleVelocity.y = cam->angleVelocity.y - time*10;
if (IsKeyDown(KEY_E)) {
cam->angleVelocity.y = cam->angleVelocity.y - time * 10;
}
if (IsKeyDown(KEY_G)) {
printf("PosX: %f PosY: %f PosZ: %f\n",cam->position.x,cam->position.y,cam->position.z);
printf("RotX; %f RotY: %f RotZ: %f\n",cam->angles.x,cam->angles.y,cam->angles.z);
printf("PosX: %f PosY: %f PosZ: %f\n", cam->position.x, cam->position.y,
cam->position.z);
printf("RotX; %f RotY: %f RotZ: %f\n", cam->angles.x, cam->angles.y,
cam->angles.z);
}
}
void LocalCamApplyVelo(LocalCam *cam,float time){
void LocalCamApplyVelo(LocalCam *cam, float time) {
cam->position.x = cam->position.x + cam->velocity.x * time;
cam->position.y = cam->position.y + cam->velocity.y * time;
cam->position.z = cam->position.z + cam->velocity.z * time;
@ -350,13 +270,9 @@ void LocalCamApplyVelo(LocalCam *cam,float time){
cam->angles.x = cam->angles.x + cam->angleVelocity.x * time;
cam->angles.y = cam->angles.y + cam->angleVelocity.y * time;
cam->angles.z = cam->angles.z + cam->angleVelocity.z * time;
//printf("%f %f %f\n",cam->angles.x, cam->angles.y, cam->angles.z);
// printf("%f %f %f\n",cam->angles.x, cam->angles.y, cam->angles.z);
}
Vector2 Conv3Dto2D(Vector3 v) {
Vector2 returnvector;
returnvector.x = proj * v.x / (-v.z);
@ -371,31 +287,33 @@ Vector2 Conv2DCenteredToScreen(Vector2 v) {
return returnvector;
}
Vector3 TransformWithCam(Vector3 v, LocalCam * cam) {
static inline Vector3 TransformWithCam(Vector3 v, LocalCam *cam) {
Vector3 returnvector;
returnvector.x = v.x - cam->position.x;
returnvector.y = v.y - cam->position.y;
returnvector.z = v.z - cam->position.z;
returnvector = RotateAboutZ(returnvector,cam->angles.z);
returnvector = RotateAboutY(returnvector,-cam->angles.y);
returnvector = RotateAboutX(returnvector,-cam->angles.x);
returnvector = RotateAboutZ(returnvector, cam->angles.z);
returnvector = RotateAboutY(returnvector, -cam->angles.y);
returnvector = RotateAboutX(returnvector, -cam->angles.x);
//printf("Before: %f %f %f, After: %f %f %f\n", v.x, v.y, v.z, returnvector.x, returnvector.y, returnvector.z);
// printf("Before: %f %f %f, After: %f %f %f\n", v.x, v.y, v.z,
// returnvector.x, returnvector.y, returnvector.z);
return returnvector;
}
Tri TriTransformWithCam(Tri *t, LocalCam * cam) {
Tri TriTransformWithCam(Tri *t, LocalCam *cam) {
Tri rettri;
rettri.a = TransformWithCam(t->a,cam);
rettri.b = TransformWithCam(t->b,cam);
rettri.c = TransformWithCam(t->c,cam);
rettri.a = TransformWithCam(t->a, cam);
rettri.b = TransformWithCam(t->b, cam);
rettri.c = TransformWithCam(t->c, cam);
rettri.color = t->color;
return rettri;
}
Tri2D ConvertTriToTri2D(Tri* t){
Tri2D ConvertTriToTri2D(Tri *t) {
Tri2D rettri2d;
rettri2d.a = Conv3Dto2D(t->a);
rettri2d.b = Conv3Dto2D(t->b);
@ -409,14 +327,13 @@ Tri2D ConvertTriToTri2D(Tri* t){
return rettri2d;
}
int main() {
printf("%d\n", TestFunc(5));
proj = HALFWIDTH / tan(half_fov);
SetConfigFlags(FLAG_WINDOW_UNDECORATED);
InitWindow(SCREENWIDTH, SCREENHEIGHT, "raylib [core] example - basic window");
InitWindow(SCREENWIDTH, SCREENHEIGHT,
"raylib [core] example - basic window");
// SetWindowPosition(0,1080);
Vector2 a = GetMonitorPosition(0);
@ -427,32 +344,34 @@ int main() {
printf("mh:%d mw:%d w:%d h:%d\n", mh, mw, w, h);
SetWindowPosition(a.x + (0.5 * mw) - (w / 2), a.y + (0.5 * mh) - (0.5 * h));
RenderTexture2D uiraylibtexture = LoadRenderTexture(RENDERWIDTH,RENDERHEIGHT);
RenderTexture2D render3dtexture = LoadRenderTexture(RENDERWIDTH,RENDERHEIGHT);
RenderTexture2D uiraylibtexture =
LoadRenderTexture(RENDERWIDTH, RENDERHEIGHT);
RenderTexture2D render3dtexture =
LoadRenderTexture(RENDERWIDTH, RENDERHEIGHT);
Texture2D directaccesstex;
// Init cube model
// TODO: Load from obj
LocalCam camera;
camera.position = (Vector3){0,0,0};
camera.acceleration = (Vector3){0,0,0};
camera.angleAcceleration = (Vector3){0,0,0};
camera.angles = (Vector3){0,0,0};
camera.velocity = (Vector3){0,0,0};
camera.angleVelocity = (Vector3){0,0,0};
camera.position = (Vector3){0, 0, 0};
camera.acceleration = (Vector3){0, 0, 0};
camera.angleAcceleration = (Vector3){0, 0, 0};
camera.angles = (Vector3){0, 0, 0};
camera.velocity = (Vector3){0, 0, 0};
camera.angleVelocity = (Vector3){0, 0, 0};
Vector3 point = (Vector3){0,0,-10};
Vector3 point = (Vector3){0, 0, -10};
Tri internaltriarray[50];
TriArray tarr;
tarr.arr = internaltriarray;
tarr.length = 0;
TriArrayAppend(&tarr,(Tri){(Vector3){0,0,-1000},(Vector3){0,800,-1000},(Vector3){800,800,-1000},WHITE});
TriArrayAppend(&tarr,
(Tri){(Vector3){0, 0, -1000}, (Vector3){0, 800, -1000},
(Vector3){800, 800, -1000}, WHITE});
Tri internaltransformedtriarray[50];
TriArray TransformedTris;
@ -461,135 +380,149 @@ int main() {
Tri2D internaltri2darray[50];
Tri2DArray Tri2Darr;
Tri2Darr.length=0;
Tri2Darr.length = 0;
Tri2Darr.arr = internaltri2darray;
//static Zee ZBuff[1920][1080] = {{(Zee){10000,NULL}}}; //FIXME: Stupid static makes the file 32 Megs because pog
Zee * ZBuff = malloc(RENDERHEIGHT*RENDERWIDTH*sizeof(Zee));
static Color display[1920*1080*4];
memset(display,0,sizeof(display));
// static Zee ZBuff[1920][1080] = {{(Zee){10000,NULL}}}; //FIXME: Stupid
// static makes the file 32 Megs because pog
Zee *ZBuff = malloc(RENDERHEIGHT * RENDERWIDTH * sizeof(Zee));
static Color display[1920 * 1080 * 4];
memset(display, 0, sizeof(display));
Tri2D funners = (Tri2D){ (Vector2){50,50},(Vector2){500,50},(Vector2){500,500},GREEN};
Tri2D funners2 = (Tri2D){ (Vector2){600,0},(Vector2){600,500},(Vector2){1000,500},RED};
Tri2D funners = (Tri2D){(Vector2){50, 50}, (Vector2){500, 50},
(Vector2){500, 500}, GREEN};
Tri2D funners2 = (Tri2D){(Vector2){600, 0}, (Vector2){600, 500},
(Vector2){1000, 500}, RED};
Tri2D fullscreentritop = (Tri2D){ (Vector2){0,0}, (Vector2){1920,0}, (Vector2){1920,1080}, BLUE};
Tri2D fullscreentribottom = (Tri2D){ (Vector2){0,0}, (Vector2){0,1080}, (Vector2){1920,1080}, RED};
Tri2D fullscreentritop = (Tri2D){(Vector2){0, 0}, (Vector2){1920, 0},
(Vector2){1920, 1080}, BLUE};
Tri2D fullscreentribottom = (Tri2D){(Vector2){0, 0}, (Vector2){0, 1080},
(Vector2){1920, 1080}, RED};
Tri2D blank =
(Tri2D){(Vector2){-10, -10}, (Vector2){-10, -10}, (Vector2){-10, -10}};
Tri2D norm = (Tri2D){(Vector2){500, 50}, (Vector2){0, 0},
(Vector2){250, 500}, GREEN};
Tri2D blank = (Tri2D) { (Vector2){-10,-10},(Vector2){-10,-10}, (Vector2){-10,-10}};
Tri2D norm = (Tri2D){ (Vector2){500,50},(Vector2){0,0},(Vector2){250,500},GREEN};
while (!WindowShouldClose()) {
float frametime = GetFrameTime();
CtrlLocalCam(&camera,frametime);
LocalCamApplyVelo(&camera,frametime);
//ClearBackground(BLACK);
bool run3d = false;
while (!WindowShouldClose() && run3d) {
float frametime = GetFrameTime();
CtrlLocalCam(&camera, frametime);
LocalCamApplyVelo(&camera, frametime);
// ClearBackground(BLACK);
/* Vector3 TransVector = TransformWithCam(point,&camera); */
/* if (TransVector.z < 0) { */
/* Vector2 MPos = Conv3Dto2D(TransVector); */
/* Vector2 FinPos = Conv2DCenteredToScreen(MPos); */
/* DrawCircleV(FinPos,100,BLACK); */
/* } */
/* Vector3 TransVector = TransformWithCam(point,&camera); */
/* if (TransVector.z < 0) { */
/* Vector2 MPos = Conv3Dto2D(TransVector); */
/* Vector2 FinPos = Conv2DCenteredToScreen(MPos); */
/* DrawCircleV(FinPos,100,BLACK); */
/* } */
/* EndTextureMode(); */
TransformedTris.length = 0;
Tri2Darr.length = 0;
TransformedTris.length = 0;
Tri2Darr.length = 0;
for (int i = 0; i < tarr.length; i++) {
TriArrayAppend(&TransformedTris,TriTransformWithCam(&tarr.arr[i],&camera));
}
for (int i = 0; i < tarr.length; i++) {
TriArrayAppend(&TransformedTris,
TriTransformWithCam(&tarr.arr[i], &camera));
}
for(int i = 0; i < TransformedTris.length; i++) {
Tri2DArrayAppend(&Tri2Darr,ConvertTriToTri2D(&TransformedTris.arr[i]));
}
for (int i = 0; i < TransformedTris.length; i++) {
if ((TransformedTris.arr[i].a.z < 0) &&
(TransformedTris.arr[i].b.z < 0) &&
(TransformedTris.arr[i].c.z < 0)) {
Tri2DArrayAppend(&Tri2Darr,
ConvertTriToTri2D(&TransformedTris.arr[i]));
}
}
//memset(ZBuff,NULL ,sizeof(Zee) * RENDERHEIGHT*RENDERWIDTH );
// for (int i = 0; i < RENDERHEIGHT*RENDERWIDTH; i ++) {
// ZBuff[i] = (Zee){10000,NULL};
// }
memset(display,0,sizeof(display));
/* for (int i = 0; i < RENDERHEIGHT*RENDERWIDTH; i ++) { */
/* ZBuff[i] = (Zee){10000,NULL}; */
/* } */
memset(display, 0, sizeof(display));
memset(ZBuff, 0, sizeof(Zee) * 1920 * 1080);
/* for (int y = 0; y < RENDERHEIGHT; y++){ */
/* for (int x = 0; x<RENDERWIDTH; x++){ */
/* ZBuff[x][y].triangle = &blank; */
/* } */
/* } */
for (int i = 0; i < Tri2Darr.length; i++) {
for (int y = 0; y < RENDERHEIGHT; y++) {
for (int x = 0; x < RENDERWIDTH; x++) {
if (IsInTri(Tri2Darr.arr[i], (Vector2){x, y})) {
ZBuff[IndexOfZBuff(x, y)].triangle = &Tri2Darr.arr[i];
}
}
}
}
// FillTopFlatZbuffer(ZBuff, &funners);
// FillBottomFlatZbuffer(ZBuff,&funners2);
/* for (int y = 0; y < RENDERHEIGHT; y++){ */
/* for (int x = 0; x<RENDERWIDTH; x++){ */
/* ZBuff[x][y].triangle = &blank; */
/* } */
/* } */
// FillTopFlatZbuffer(ZBuff, &fullscreentritop);
// FillBottomFlatZbuffer(ZBuff, &fullscreentribottom);
/* for(int i = 0; i < Tri2Darr.length; i++) { */
/* for(int y = 0; y < RENDERHEIGHT; y++){ */
/* for(int x = 0; x< RENDERWIDTH; x++) { */
/* if (IsInTri(Tri2Darr.arr[i],(Vector2){x,y})) { */
/* ZBuff[x][y].triangle = &Tri2Darr.arr[i]; */
/* } */
/* } */
/* } */
/* } */
// DrawTriZuff(ZBuff, &norm);
// DrawTriZuff(ZBuff, TriTransformWithCam(&norm, &camera));
int index = 0;
for (int y = 0; y < RENDERHEIGHT; y++) {
for (int x = 0; x < RENDERWIDTH; x++) {
// int index = (x+y*RENDERWIDTH);
/* Color * c = &ZBuff[x][y].triangle->color;
display[index] = c->r;
display[index+1] = c->g;
display[index+2] = c->b;
display[index+3] = c->a;
*/
if (ZBuff[IndexOfZBuff(x, y)].triangle !=
0) { // memset sets this to 0
// DrawPixel(x,y,ZBuff[x][y].triangle->color);
//FillTopFlatZbuffer(ZBuff, &funners);
//FillBottomFlatZbuffer(ZBuff,&funners2);
display[index] = ZBuff[IndexOfZBuff(x, y)].triangle->color;
// Zee test = ZBuff[IndexOfZBuff(x,y)];
// display[index] = test.triangle->color;
}
index = index + 1;
}
}
//FillTopFlatZbuffer(ZBuff, &fullscreentritop);
//FillBottomFlatZbuffer(ZBuff, &fullscreentribottom);
BeginTextureMode(uiraylibtexture);
// gui stuff
EndTextureMode();
DrawTriZuff(ZBuff, &norm);
// Copytexture to main display :0
BeginDrawing();
ClearBackground(BLACK);
UpdateTexture(render3dtexture.texture, display);
// Copies render3dtexture to screen
DrawTexturePro(render3dtexture.texture,
(Rectangle){0, 0, render3dtexture.texture.width,
render3dtexture.texture.height},
(Rectangle){0, 0, SCREENWIDTH, SCREENHEIGHT},
(Vector2){0, 0}, 0, WHITE);
int index = 0;
for(int y = 0; y < RENDERHEIGHT; y++) {
for(int x = 0; x < RENDERWIDTH; x++) {
//int index = (x+y*RENDERWIDTH);
/* Color * c = &ZBuff[x][y].triangle->color;
display[index] = c->r;
display[index+1] = c->g;
display[index+2] = c->b;
display[index+3] = c->a;
*/
// Copies uiraylibtexture to screen (not this is not the texture used
// for 3d stuff
DrawTexturePro(uiraylibtexture.texture,
(Rectangle){0, 0, uiraylibtexture.texture.width,
-uiraylibtexture.texture.height},
(Rectangle){0, 0, SCREENWIDTH, SCREENHEIGHT},
(Vector2){0, 0}, 0, WHITE);
char fpstext[40];
sprintf(fpstext, "%d", GetFPS());
DrawText(fpstext, 0, 0, 20, WHITE);
if (ZBuff[IndexOfZBuff(x,y)].triangle != NULL) {
//DrawPixel(x,y,ZBuff[x][y].triangle->color);
display[index] = ZBuff[IndexOfZBuff(x,y)].triangle->color;
// Zee test = ZBuff[IndexOfZBuff(x,y)];
// display[index] = test.triangle->color;
}
index = index+1;
}
}
BeginTextureMode(uiraylibtexture);
//gui stuff
EndTextureMode();
//Copytexture to main display :0
BeginDrawing();
ClearBackground(BLACK);
UpdateTexture(render3dtexture.texture, display);
//Copies render3dtexture to screen
DrawTexturePro(render3dtexture.texture, (Rectangle){0,0,render3dtexture.texture.width, render3dtexture.texture.height}, (Rectangle){0,0,SCREENWIDTH,SCREENHEIGHT},(Vector2){0,0},0,WHITE);
//Copies uiraylibtexture to screen (not this is not the texture used for 3d stuff
DrawTexturePro(uiraylibtexture.texture, (Rectangle){0,0,uiraylibtexture.texture.width,-uiraylibtexture.texture.height},(Rectangle){0,0,SCREENWIDTH,SCREENHEIGHT},(Vector2){0,0},0,WHITE);
char fpstext[40];
sprintf(fpstext,"%d",GetFPS());
DrawText( fpstext ,0,0,20,WHITE);
EndDrawing();
EndDrawing();
}
CloseWindow();

64
c3dtypes.h Normal file
View file

@ -0,0 +1,64 @@
#include "raylib.h"
#ifndef C3DTYPES_HEADER
#define C3DTYPES_HEADER
struct LocalCam {
Vector3 position;
Vector3 velocity;
Vector3 acceleration;
Vector3 angles;
Vector3 angleVelocity;
Vector3 angleAcceleration;
};
typedef struct LocalCam LocalCam;
struct Tri {
Vector3 a;
Vector3 b;
Vector3 c;
Color color;
};
typedef struct Tri Tri;
struct Tri2D {
Vector2 a;
Vector2 b;
Vector2 c;
Color color;
};
typedef struct Tri2D Tri2D;
struct Zee {
int depth;
Tri2D *triangle;
};
typedef struct Zee Zee;
struct TriArray {
int length;
Tri *arr;
};
typedef struct TriArray TriArray;
struct Tri2DArray {
int length;
Tri2D *arr;
};
typedef struct Tri2DArray Tri2DArray;
struct Object {
char name[100];
Vector3 *VertexArray;
int VertexArrayLength;
TriArray * triangles;
};
typedef struct Object Object;
#endif

46
cube.obj Normal file
View file

@ -0,0 +1,46 @@
# Blender v2.76 (sub 0) OBJ File: ''
# www.blender.org
mtllib cube.mtl
o Cube
v 1.000000 -1.000000 -1.000000
v 1.000000 -1.000000 1.000000
v -1.000000 -1.000000 1.000000
v -1.000000 -1.000000 -1.000000
v 1.000000 1.000000 -0.999999
v 0.999999 1.000000 1.000001
v -1.000000 1.000000 1.000000
v -1.000000 1.000000 -1.000000
vt 1.000000 0.333333
vt 1.000000 0.666667
vt 0.666667 0.666667
vt 0.666667 0.333333
vt 0.666667 0.000000
vt 0.000000 0.333333
vt 0.000000 0.000000
vt 0.333333 0.000000
vt 0.333333 1.000000
vt 0.000000 1.000000
vt 0.000000 0.666667
vt 0.333333 0.333333
vt 0.333333 0.666667
vt 1.000000 0.000000
vn 0.000000 -1.000000 0.000000
vn 0.000000 1.000000 0.000000
vn 1.000000 0.000000 0.000000
vn -0.000000 0.000000 1.000000
vn -1.000000 -0.000000 -0.000000
vn 0.000000 0.000000 -1.000000
usemtl Material
s off
f 2/1/1 3/2/1 4/3/1
f 8/1/2 7/4/2 6/5/2
f 5/6/3 6/7/3 2/8/3
f 6/8/4 7/5/4 3/4/4
f 3/9/5 7/10/5 8/11/5
f 1/12/6 4/13/6 8/11/6
f 1/4/1 2/1/1 4/3/1
f 5/14/2 8/1/2 6/5/2
f 1/12/3 5/6/3 2/8/3
f 2/12/4 6/8/4 3/4/4
f 4/13/5 3/9/5 8/11/5
f 5/6/6 1/12/6 8/11/6

60
reader.c Normal file
View file

@ -0,0 +1,60 @@
#include "c3dtypes.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int TestFunc(int x) {
x = x + 1;
return x;
}
Object ReadObjectFromFile() {
Object out;
out.VertexArray = malloc(10000*sizeof(Vector3));
out.VertexArrayLength = 0;
TriArray tarr;
tarr.arr = malloc(10000*sizeof(Tri));
tarr.length = 0;
out.triangles = &tarr;
strncpy(out.name, "cube.obj", 100);
FILE * f = fopen("cube.obj", "r");
while (true) {
char t[500];
char * fgetres = fgets(t, 500, f);
if (fgetres == NULL) {
break;
}
char objtype[10];
double v1;
double v2;
double v3;
sscanf(t, "%s %lf %lf %lf", objtype, &v1,&v2,&v3);
if ( strcmp(t, "v")) {
out.VertexArray[out.VertexArrayLength].x = v1;
out.VertexArray[out.VertexArrayLength].x = v2;
out.VertexArray[out.VertexArrayLength].x = v3;
out.VertexArrayLength = out.VertexArrayLength + 1;
}
if ( strcmp(t, "f")) {
//TODO: append face to triarry
}
//need to bring in triarray functions into their own file
}
//TODO: use file object and read each line
// add verticies to the vertex list, +1 ing the length value each time
// just fucking parse the obj file its not that hard
}

6
reader.h Normal file
View file

@ -0,0 +1,6 @@
#ifndef READER_HEADER
#define READER_HEADER
int TestFunc(int x);
#endif

46
vecfunc.c Normal file
View file

@ -0,0 +1,46 @@
#include "raylib.h"
#include <stdio.h>
#include <math.h>
Vector3 Vector3Sum(Vector3 v1, Vector3 v2) {
Vector3 retvec;
retvec.x = v1.x + v2.x;
retvec.y = v1.y + v2.y;
retvec.z = v1.z + v2.z;
return retvec;
}
void Vector3Print(Vector3 v) {
printf("VX: %f, VY: %f, FZ: %f\n", v.x, v.y, v.z);
}
Vector3 Vector3Scale(Vector3 v1, float scale) {
Vector3 retvec;
retvec.x = v1.x * scale;
retvec.y = v1.y * scale;
retvec.z = v1.z * scale;
return retvec;
}
Vector3 RotateAboutX(Vector3 v, double radians) {
Vector3 rotatedvector;
rotatedvector.x = 1 * v.x + (0) + (0);
rotatedvector.y = (0) + cos(radians) * v.y + (-sin(radians) * v.z);
rotatedvector.z = 0 + sin(radians) * v.y + cos(radians) * v.z;
return rotatedvector;
}
Vector3 RotateAboutY(Vector3 v, double radians) {
Vector3 rotatedvector;
rotatedvector.x = cos(radians) * v.x + (0) + sin(radians) * v.z;
rotatedvector.y = (0) + 1 * v.y + (0);
rotatedvector.z = -sin(radians) * v.x + 0 + cos(radians) * v.z;
return rotatedvector;
}
Vector3 RotateAboutZ(Vector3 v, double radians) {
Vector3 rotatedvector;
rotatedvector.x = cos(radians) * v.x + (-sin(radians) * v.y) + (0);
rotatedvector.y = sin(radians) * v.x + cos(radians) * v.y + (0);
rotatedvector.z = 0 + 0 + 1 * v.z;
return rotatedvector;
}

15
vecfunc.h Normal file
View file

@ -0,0 +1,15 @@
#ifndef VECFUNC_HEADER
#define VECFUNC_HEADER
Vector3 Vector3Sum(Vector3 v1, Vector3 v2);
void Vector3Print(Vector3 v);
Vector3 Vector3Scale(Vector3 v1, float scale);
Vector3 RotateAboutX(Vector3 V, double radians);
Vector3 RotateAboutY(Vector3 V, double radians);
Vector3 RotateAboutZ(Vector3 V, double radians);
#endif