krzosa/software_rasterizer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Testing a generator to output different draw triangle versions, more gamma correct blending

Browse Source
This commit is contained in:
Krzosa Karol
2022-02-20 17:28:46 +01:00
parent e0b2182d11
commit 8cfd52ed81
10 changed files with 1092 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
graphics3.rdbg Normal file
View File

Binary file not shown.

168
main.cpp
View File

@@ -5,22 +5,30 @@ OK Y up coordinate system, left handed
OK Drawing a cube with perspective OK Drawing a cube with perspective
OK Culling triangles facing away from camera OK Culling triangles facing away from camera
OK Texture mapping OK Texture mapping
? Basic math operations on Vec4 Mat4 - Muls, Dot, Cross etc. ? Basic math operations on Vec4 Mat4 - Muls, dot, cross etc.
OK Basic linear transformations - rotation, translation, scaling OK Basic linear transformations - rotation, translation, scaling
OK Bilinear filtering of textures / subpixel precison OK Bilinear filtering of textures / subpixel precison
OK Fix the gaps between triangles (it also improved look of triangle edges) OK Fix the gaps between triangles (it also improved look of triangle edges)
* Perspective matrix vs simple perspective * Perspective matrix vs simple perspective
* Perspective correct interpolation OK Perspective correct interpolation
* Depth buffer OK Depth buffer
KINDA_OK Gamma correct blending
* Alpha blending??
* Premultiplied alpha???
* Lightning
* LookAt Camera
* FPS Camera * FPS Camera
* Reading OBJ files OK Reading OBJ files
* Loading a model from PMX? * Reading PMX files
* Rendering multiple objects, queue renderer * Rendering multiple objects, queue renderer
* Clipping * Clipping
* Optimizations * Optimizations
* SIMD * SIMD
* Multithreading * Multithreading
* *
* Text rendering
* Basic UI
* Gamma correct and alpha blending
*/ */
/* What a codebase needs: /* What a codebase needs:
@@ -34,6 +42,7 @@ OK Fix the gaps between triangles (it also improved look of triangle edges)
#define BILINEAR_BLEND 1 #define BILINEAR_BLEND 1
#define PERSPECTIVE_CORRECT_INTERPOLATION 1 #define PERSPECTIVE_CORRECT_INTERPOLATION 1
#define _CRT_SECURE_NO_WARNINGS
#include "main.h" #include "main.h"
#include "platform.h" #include "platform.h"
#include "math.h" #include "math.h"
@@ -41,8 +50,10 @@ OK Fix the gaps between triangles (it also improved look of triangle edges)
#include "objparser.h" #include "objparser.h"
#include <float.h> #include <float.h>
GLOBAL OS os = {};
GLOBAL bool draw_rects = 0; GLOBAL bool draw_rects = 0;
GLOBAL bool draw_wireframe = 0; GLOBAL bool draw_wireframe = 0;
#include "rasterization_feature_selection.cpp"
struct Face { struct Face {
int p[3]; int p[3];
@@ -76,7 +87,7 @@ GLOBAL Face cube_faces[] = {
}; };
FUNCTION FUNCTION
void DrawRect(Image* dst, float X, float Y, float w, float h, U32 color) { void draw_rect(Image* dst, float X, float Y, float w, float h, U32 color) {
int max_x = (int)(MIN(X + w, dst->x) + 0.5f); int max_x = (int)(MIN(X + w, dst->x) + 0.5f);
int max_y = (int)(MIN(Y + h, dst->y) + 0.5f); int max_y = (int)(MIN(Y + h, dst->y) + 0.5f);
int min_x = (int)(MAX(0, X) + 0.5f); int min_x = (int)(MAX(0, X) + 0.5f);
@@ -90,7 +101,7 @@ void DrawRect(Image* dst, float X, float Y, float w, float h, U32 color) {
} }
FUNCTION FUNCTION
void DrawBitmap(Image* dst, Image* src, Vec2 pos) { void draw_bitmap(Image* dst, Image* src, Vec2 pos) {
I64 minx = (I64)(pos.x + 0.5); I64 minx = (I64)(pos.x + 0.5);
I64 miny = (I64)(pos.y + 0.5); I64 miny = (I64)(pos.y + 0.5);
I64 maxx = minx + src->x; I64 maxx = minx + src->x;
@@ -124,48 +135,61 @@ void DrawBitmap(Image* dst, Image* src, Vec2 pos) {
} }
FUNCTION FUNCTION
float EdgeFunction(Vec4 vecp0, Vec4 vecp1, Vec4 p) { float edge_function(Vec4 vecp0, Vec4 vecp1, Vec4 p) {
float result = (vecp1.y - vecp0.y) * (p.x - vecp0.x) - (vecp1.x - vecp0.x) * (p.y - vecp0.y); float result = (vecp1.y - vecp0.y) * (p.x - vecp0.x) - (vecp1.x - vecp0.x) * (p.y - vecp0.y);
return result; return result;
} }
FUNCTION
Vec4 srgb_to_almost_linear(Vec4 a) {
Vec4 result = {a.r*a.r, a.g*a.g, a.b*a.b, a.a};
return result; // @Note: Linear would be to power of 2.2
}
FUNCTION
Vec4 almost_linear_to_srgb(Vec4 a) {
Vec4 result = { sqrt(a.r), sqrt(a.g), sqrt(a.b), a.a };
return result;
}
FUNCTION FUNCTION
void DrawTriangle(Image* dst, float *depth_buffer, Image *src, Vec4 p0, Vec4 p1, Vec4 p2, void draw_triangle(Image* dst, float *depth_buffer, Image *src,
Vec4 p0, Vec4 p1, Vec4 p2,
Vec2 tex0, Vec2 tex1, Vec2 tex2) { Vec2 tex0, Vec2 tex1, Vec2 tex2) {
float min_x1 = (float)(MIN(p0.x, MIN(p1.x, p2.x))); float min_x1 = (float)(MIN(p0.x, MIN(p1.x, p2.x)));
float min_y1 = (float)(MIN(p0.y, MIN(p1.y, p2.y))); float min_y1 = (float)(MIN(p0.y, MIN(p1.y, p2.y)));
float max_x1 = (float)(MAX(p0.x, MAX(p1.x, p2.x))); float max_x1 = (float)(MAX(p0.x, MAX(p1.x, p2.x)));
float max_y1 = (float)(MAX(p0.y, MAX(p1.y, p2.y))); float max_y1 = (float)(MAX(p0.y, MAX(p1.y, p2.y)));
I64 min_x = (I64)MAX(0, Floor(min_x1)); I64 min_x = (I64)MAX(0, floor(min_x1));
I64 min_y = (I64)MAX(0, Floor(min_y1)); I64 min_y = (I64)MAX(0, floor(min_y1));
I64 max_x = (I64)MIN(dst->x, Ceil(max_x1)); I64 max_x = (I64)MIN(dst->x, ceil(max_x1));
I64 max_y = (I64)MIN(dst->y, Ceil(max_y1)); I64 max_y = (I64)MIN(dst->y, ceil(max_y1));
float area = EdgeFunction(p0, p1, p2); float area = edge_function(p0, p1, p2);
for (I64 y = min_y; y < max_y; y++) { for (I64 y = min_y; y < max_y; y++) {
for (I64 x = min_x; x < max_x; x++) { for (I64 x = min_x; x < max_x; x++) {
float edge1 = EdgeFunction(p0, p1, { (float)x,(float)y }); float edge1 = edge_function(p0, p1, { (float)x,(float)y });
float edge2 = EdgeFunction(p1, p2, { (float)x,(float)y }); float edge2 = edge_function(p1, p2, { (float)x,(float)y });
float edge3 = EdgeFunction(p2, p0, { (float)x,(float)y }); float edge3 = edge_function(p2, p0, { (float)x,(float)y });
if (edge1 >= 0 && edge2 >= 0 && edge3 >= 0) { if (edge1 >= 0 && edge2 >= 0 && edge3 >= 0) {
float w1 = edge2 / area; float w1 = edge2 / area;
float w2 = edge3 / area; float w2 = edge3 / area;
float w3 = edge1 / area; float w3 = edge1 / area;
float interpolated_z = (1.f / p0.w) * w1 + (1.f / p1.w) * w2 + (1.f / p2.w) * w3;
#if PERSPECTIVE_CORRECT_INTERPOLATION #if PERSPECTIVE_CORRECT_INTERPOLATION
float u = tex0.x * (w1 / p0.w) + tex1.x * (w2 / p1.w) + tex2.x * (w3 / p2.w); float u = tex0.x * (w1 / p0.w) + tex1.x * (w2 / p1.w) + tex2.x * (w3 / p2.w);
float v = tex0.y * (w1 / p0.w) + tex1.y * (w2 / p1.w) + tex2.y * (w3 / p2.w); float v = tex0.y * (w1 / p0.w) + tex1.y * (w2 / p1.w) + tex2.y * (w3 / p2.w);
float interpolated_z = (1.f / p0.w) * w1 + (1.f / p1.w) * w2 + (1.f / p2.w) * w3;
u /= interpolated_z; u /= interpolated_z;
v /= interpolated_z; v /= interpolated_z;
interpolated_z = 1.f / interpolated_z;
#else #else
float u = tex0.x * w1 + tex1.x * w2 + tex2.x * w3; float u = tex0.x * w1 + tex1.x * w2 + tex2.x * w3;
float v = tex0.y * w1 + tex1.y * w2 + tex2.y * w3; float v = tex0.y * w1 + tex1.y * w2 + tex2.y * w3;
#endif #endif
// @Note: We could do: interpolated_z = 1.f / interpolated_z to get proper depth
// but why waste an instruction, the smaller the depth value the farther the object
float* depth = depth_buffer + (x + y * dst->x); float* depth = depth_buffer + (x + y * dst->x);
if (*depth > interpolated_z) { if (*depth < interpolated_z) {
*depth = interpolated_z; *depth = interpolated_z;
u = u * (src->x - 2); u = u * (src->x - 2);
v = v * (src->y - 2); v = v * (src->y - 2);
@@ -175,16 +199,20 @@ void DrawTriangle(Image* dst, float *depth_buffer, Image *src, Vec4 p0, Vec4 p1,
float vdiff = v - (float)vi; float vdiff = v - (float)vi;
// Origin UV (0,0) is in bottom left // Origin UV (0,0) is in bottom left
U32* pixel = src->pixels + (ui + (src->y - 1ll - vi) * src->x); U32* pixel = src->pixels + (ui + (src->y - 1ll - vi) * src->x);
#if BILINEAR_BLEND
Vec4 pixelx1y1 = V4ABGR(*pixel);
Vec4 pixelx2y1 = V4ABGR(*(pixel + 1));
Vec4 pixelx1y2 = V4ABGR(*(pixel - src->x));
Vec4 pixelx2y2 = V4ABGR(*(pixel + 1 - src->x));
Vec4 blendx1 = Lerp(pixelx1y1, pixelx2y1, udiff); #if BILINEAR_BLEND
Vec4 blendx2 = Lerp(pixelx1y2, pixelx2y2, udiff); Vec4 pixelx1y1 = srgb_to_almost_linear(v4abgr(*pixel));
Vec4 result_color = Lerp(blendx1, blendx2, vdiff); Vec4 pixelx2y1 = srgb_to_almost_linear(v4abgr(*(pixel + 1)));
U32 color32 = ColorToU32ABGR(result_color); Vec4 pixelx1y2 = srgb_to_almost_linear(v4abgr(*(pixel - src->x)));
Vec4 pixelx2y2 = srgb_to_almost_linear(v4abgr(*(pixel + 1 - src->x)));
Vec4 blendx1 = lerp(pixelx1y1, pixelx2y1, udiff);
Vec4 blendx2 = lerp(pixelx1y2, pixelx2y2, udiff);
Vec4 result_color = lerp(blendx1, blendx2, vdiff);
result_color = almost_linear_to_srgb(result_color);
ASSERT(result_color.r <= 1 && result_color.g <= 1 && result_color.b <= 1);
U32 color32 = color_to_u32abgr(result_color);
#else #else
U32 color32 = *pixel; U32 color32 = *pixel;
#endif #endif
@@ -195,14 +223,15 @@ void DrawTriangle(Image* dst, float *depth_buffer, Image *src, Vec4 p0, Vec4 p1,
} }
} }
if (draw_rects) { if (draw_rects) {
DrawRect(dst, p0.x-4, p0.y-4, 8,8, 0x00ff0000); draw_rect(dst, p0.x-4, p0.y-4, 8,8, 0x00ff0000);
DrawRect(dst, p1.x-4, p1.y-4, 8,8, 0x0000ff00); draw_rect(dst, p1.x-4, p1.y-4, 8,8, 0x0000ff00);
DrawRect(dst, p2.x-4, p2.y-4, 8,8, 0x000000ff); draw_rect(dst, p2.x-4, p2.y-4, 8,8, 0x000000ff);
} }
} }
#include "raster_functions.cpp"
FUNCTION FUNCTION
void DrawLine(Image *dst, float x0, float y0, float x1, float y1) { void draw_line(Image *dst, float x0, float y0, float x1, float y1) {
float delta_x = (x1 - x0); float delta_x = (x1 - x0);
float delta_y = (y1 - y0); float delta_y = (y1 - y0);
float longest_side_length = (ABS(delta_x) >= ABS(delta_y)) ? ABS(delta_x) : ABS(delta_y); float longest_side_length = (ABS(delta_x) >= ABS(delta_y)) ? ABS(delta_x) : ABS(delta_y);
@@ -226,16 +255,16 @@ struct FaceA {
}; };
FUNCTION FUNCTION
Obj LoadObj(const char* file) { Obj load_obj(const char* file) {
char* data = OS_ReadFile(file); char* data = os.read_file(file);
char* memory = (char*)malloc(100000); char* memory = (char*)malloc(100000);
Obj result = Obj_Parse(memory, 100000, data); Obj result = obj::parse(memory, 100000, data);
free(data); free(data);
return result; return result;
} }
FUNCTION FUNCTION
Image LoadImage(const char* path) { Image load_image(const char* path) {
int x, y, n; int x, y, n;
unsigned char* data = stbi_load(path, &x, &y, &n, 4); unsigned char* data = stbi_load(path, &x, &y, &n, 4);
Image result = { (U32*)data, x, y }; Image result = { (U32*)data, x, y };
@@ -243,23 +272,25 @@ Image LoadImage(const char* path) {
} }
int main() { int main() {
Obj_Test(); obj::test();
OS_Init({ 1280,720 }); os.init({ 1280,720 });
generate_stuff();
float rotation = 0; float rotation = 0;
Vec3 camera_pos = {0,0,-5}; Vec3 camera_pos = {0,0,-5};
Obj obj = LoadObj("assets/f22.obj"); Obj obj = load_obj("assets/f22.obj");
Vec3* vertices = (Vec3 *)obj.vertices; Vec3* vertices = (Vec3 *)obj.vertices;
Vec2* tex_coords = (Vec2*)obj.texture; Vec2* tex_coords = (Vec2*)obj.texture;
FaceA* faces = (FaceA*)obj.indices; FaceA* faces = (FaceA*)obj.indices;
I64 face_count = obj.indices_count; I64 face_count = obj.indices_count;
Image img = LoadImage("assets/bricksx64.png"); Image img = load_image("assets/bricksx64.png");
Image screen320 = {(U32 *)malloc(320*180*sizeof(U32)), 320, 180}; Image screen320 = {(U32 *)malloc(320*180*sizeof(U32)), 320, 180};
float* depth320 = (float *)malloc(sizeof(float) * 320 * 180); float* depth320 = (float *)malloc(sizeof(float) * 320 * 180);
while (OS_GameLoop()) { while (os.game_loop()) {
Mat4 perspective = Mat4Perspective(60.f, (float)screen.x, (float)screen.y, 0.1f, 100.f); Mat4 perspective = make_matrix_perspective(60.f, (float)os.screen.x, (float)os.screen.y, 0.1f, 100.f);
U32* p = screen320.pixels; U32* p = screen320.pixels;
for (int y = 0; y < screen320.y; y++) { for (int y = 0; y < screen320.y; y++) {
for (int x = 0; x < screen320.x; x++) { for (int x = 0; x < screen320.x; x++) {
@@ -269,16 +300,16 @@ int main() {
float* dp = depth320; float* dp = depth320;
for (int y = 0; y < screen320.y; y++) { for (int y = 0; y < screen320.y; y++) {
for (int x = 0; x < screen320.x; x++) { for (int x = 0; x < screen320.x; x++) {
*dp++ = FLT_MAX; *dp++ = -FLT_MAX;
} }
} }
DrawBitmap(&screen320, &img, {0,0}); draw_bitmap(&screen320, &img, {0,0});
Mat4 transform = Mat4RotationZ(rotation); Mat4 transform = make_matrix_rotation_z(rotation);
transform = transform * Mat4RotationX(rotation); transform = transform * make_matrix_rotation_x(rotation);
if (keydown_a) rotation += 0.05f; if (os.keydown_a) rotation += 0.05f;
if (keydown_b) rotation -= 0.05f; if (os.keydown_b) rotation -= 0.05f;
if (keydown_f1) draw_rects = !draw_rects; if (os.keydown_f1) draw_rects = !draw_rects;
if (keydown_f2) draw_wireframe = !draw_wireframe; if (os.keydown_f2) draw_wireframe = !draw_wireframe;
for (int i = 0; i < face_count; i++) { for (int i = 0; i < face_count; i++) {
FaceA* face = faces + i; FaceA* face = faces + i;
Vec4 pos[3] = { Vec4 pos[3] = {
@@ -300,8 +331,8 @@ int main() {
Vec3 p0_to_camera = camera_pos - pos[0].xyz; Vec3 p0_to_camera = camera_pos - pos[0].xyz;
Vec3 p0_to_p1 = pos[1].xyz - pos[0].xyz; Vec3 p0_to_p1 = pos[1].xyz - pos[0].xyz;
Vec3 p0_to_p2 = pos[2].xyz - pos[0].xyz; Vec3 p0_to_p2 = pos[2].xyz - pos[0].xyz;
Vec3 normal = Cross(p0_to_p1, p0_to_p2); Vec3 normal = cross(p0_to_p1, p0_to_p2);
if (Dot(normal, p0_to_camera) > 0) { if (dot(normal, p0_to_camera) > 0) {
for (int j = 0; j < 3; j++) { for (int j = 0; j < 3; j++) {
//@Note: Camera //@Note: Camera
pos[j].xyz = pos[j].xyz - camera_pos; pos[j].xyz = pos[j].xyz - camera_pos;
@@ -313,25 +344,32 @@ int main() {
//@Note: To pixel space //@Note: To pixel space
pos[j].x *= screen320.x / 2; pos[j].x *= screen320.x / 2;
pos[j].y *= screen320.y / 2; pos[j].y *= screen320.y / 2;
pos[j].x += screen320.x / 2; //pos[j].x += screen320.x / 2;
pos[j].y += screen320.y / 2; //pos[j].y += screen320.y / 2;
pos[j].x += screen320.x / 4;
pos[j].y += screen320.y / 4;
} }
DrawTriangle(&screen320, depth320, &img, pos[0], pos[1], pos[2], tex[0], tex[1], tex[2]); draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_on_BILINEAR_BLEND_off(&screen320, depth320, &img, pos[0], pos[1], pos[2], tex[0], tex[1], tex[2]);
for (int j = 0; j < 3; j++) {
pos[j].x += screen320.x / 3;
pos[j].y += screen320.y / 3;
}
draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_on_BILINEAR_BLEND_on(&screen320, depth320, &img, pos[0], pos[1], pos[2], tex[0], tex[1], tex[2]);
if (draw_wireframe) { if (draw_wireframe) {
DrawLine(&screen320, pos[0].x, pos[0].y, pos[1].x, pos[1].y); draw_line(&screen320, pos[0].x, pos[0].y, pos[1].x, pos[1].y);
DrawLine(&screen320, pos[1].x, pos[1].y, pos[2].x, pos[2].y); draw_line(&screen320, pos[1].x, pos[1].y, pos[2].x, pos[2].y);
DrawLine(&screen320, pos[2].x, pos[2].y, pos[0].x, pos[0].y); draw_line(&screen320, pos[2].x, pos[2].y, pos[0].x, pos[0].y);
} }
} }
} }
// @Note: Draw 320screen to OS screen // @Note: Draw 320screen to OS screen
U32* ptr = screen.pixels; U32* ptr = os.screen.pixels;
for (int y = 0; y < screen.y; y++) { for (int y = 0; y < os.screen.y; y++) {
for (int x = 0; x < screen.x; x++) { for (int x = 0; x < os.screen.x; x++) {
float u = (float)x / (float)screen.x; float u = (float)x / (float)os.screen.x;
float v = (float)y / (float)screen.y; float v = (float)y / (float)os.screen.y;
int tx = (int)(u * screen320.x + 0.5f); int tx = (int)(u * screen320.x + 0.5f);
int ty = (int)(v * screen320.y + 0.5f); int ty = (int)(v * screen320.y + 0.5f);
*ptr++ = screen320.pixels[tx + ty * (screen320.x)]; *ptr++ = screen320.pixels[tx + ty * (screen320.x)];

81
math.h
View File

@@ -1,6 +1,8 @@
#include "main.h" #include "main.h"
#include <intrin.h> #include <intrin.h>
constexpr float PI32 = 3.14159265359f;
struct Mat4 { struct Mat4 {
float p[4][4]; float p[4][4];
}; };
@@ -20,8 +22,6 @@ union Vec4 {
struct { Vec3 xyz; }; struct { Vec3 xyz; };
}; };
constexpr float PI32 = 3.14159265359f;
FUNCTION FUNCTION
Vec4 vec4(Vec3 a, float b) { Vec4 vec4(Vec3 a, float b) {
Vec4 result = { a.x,a.y,a.z,b }; Vec4 result = { a.x,a.y,a.z,b };
@@ -29,7 +29,7 @@ Vec4 vec4(Vec3 a, float b) {
} }
FUNCTION FUNCTION
Mat4 Mat4Identity() { Mat4 make_matrix_identity() {
Mat4 result = { Mat4 result = {
1,0,0,0, 1,0,0,0,
0,1,0,0, 0,1,0,0,
@@ -40,7 +40,7 @@ Mat4 Mat4Identity() {
} }
FUNCTION FUNCTION
float Sin(float value) { float sin(float value) {
__m128 result128 = _mm_set_ps1(value); __m128 result128 = _mm_set_ps1(value);
result128 = _mm_sin_ps(result128); result128 = _mm_sin_ps(result128);
float result = *(float *)&result128; float result = *(float *)&result128;
@@ -48,7 +48,7 @@ float Sin(float value) {
} }
FUNCTION FUNCTION
float Cos(float value) { float cos(float value) {
__m128 result128 = _mm_set_ps1(value); __m128 result128 = _mm_set_ps1(value);
result128 = _mm_cos_ps(result128); result128 = _mm_cos_ps(result128);
float result = *(float*)&result128; float result = *(float*)&result128;
@@ -56,7 +56,7 @@ float Cos(float value) {
} }
FUNCTION FUNCTION
float Tan(float value) { float tan(float value) {
__m128 result128 = _mm_set_ps1(value); __m128 result128 = _mm_set_ps1(value);
result128 = _mm_tan_ps(result128); result128 = _mm_tan_ps(result128);
float result = *(float*)&result128; float result = *(float*)&result128;
@@ -64,7 +64,7 @@ float Tan(float value) {
} }
FUNCTION FUNCTION
float Floor(float value) { float floor(float value) {
__m128 result128 = _mm_set_ps1(value); __m128 result128 = _mm_set_ps1(value);
result128 = _mm_floor_ps(result128); result128 = _mm_floor_ps(result128);
float result = *(float*)&result128; float result = *(float*)&result128;
@@ -72,7 +72,7 @@ float Floor(float value) {
} }
FUNCTION FUNCTION
float Ceil(float value) { float ceil(float value) {
__m128 result128 = _mm_set_ps1(value); __m128 result128 = _mm_set_ps1(value);
result128 = _mm_ceil_ps(result128); result128 = _mm_ceil_ps(result128);
float result = *(float*)&result128; float result = *(float*)&result128;
@@ -80,7 +80,7 @@ float Ceil(float value) {
} }
FUNCTION FUNCTION
float Round(float value) { float round(float value) {
__m128 result128 = _mm_set_ps1(value); __m128 result128 = _mm_set_ps1(value);
result128 = _mm_round_ps(result128, _MM_FROUND_TO_NEAREST_INT| _MM_FROUND_NO_EXC); result128 = _mm_round_ps(result128, _MM_FROUND_TO_NEAREST_INT| _MM_FROUND_NO_EXC);
float result = *(float*)&result128; float result = *(float*)&result128;
@@ -88,9 +88,17 @@ float Round(float value) {
} }
FUNCTION FUNCTION
Mat4 Mat4RotationZ(float rotation) { float sqrt(float value) {
float s = Sin(rotation); __m128 result128 = _mm_set_ps1(value);
float c = Cos(rotation); result128 = _mm_sqrt_ps(result128);
float result = *(float*)&result128;
return result;
}
FUNCTION
Mat4 make_matrix_rotation_x(float rotation) {
float s = sin(rotation);
float c = cos(rotation);
Mat4 result = { Mat4 result = {
c, s, 0, 0, c, s, 0, 0,
-s, c, 0, 0, -s, c, 0, 0,
@@ -101,9 +109,9 @@ Mat4 Mat4RotationZ(float rotation) {
} }
FUNCTION FUNCTION
Mat4 Mat4RotationY(float rotation) { Mat4 make_matrix_rotation_y(float rotation) {
float s = Sin(rotation); float s = sin(rotation);
float c = Cos(rotation); float c = cos(rotation);
Mat4 result = { Mat4 result = {
c, 0, -s, 0, c, 0, -s, 0,
0, 1, 0, 0, 0, 1, 0, 0,
@@ -114,9 +122,9 @@ Mat4 Mat4RotationY(float rotation) {
} }
FUNCTION FUNCTION
Mat4 Mat4RotationX(float rotation) { Mat4 make_matrix_rotation_z(float rotation) {
float s = Sin(rotation); float s = sin(rotation);
float c = Cos(rotation); float c = cos(rotation);
Mat4 result = { Mat4 result = {
1, 0, 0, 0, 1, 0, 0, 0,
0, c, s, 0, 0, c, s, 0,
@@ -127,9 +135,9 @@ Mat4 Mat4RotationX(float rotation) {
} }
FUNCTION FUNCTION
Mat4 Mat4Perspective(float fov, float window_x, float window_y, float znear, float zfar) { Mat4 make_matrix_perspective(float fov, float window_x, float window_y, float znear, float zfar) {
float aspect_ratio = window_y / window_x; float aspect_ratio = window_y / window_x;
float f = (1.f / Tan((fov/2.f)*(180.f/PI32))); float f = (1.f / tan((fov/2.f)*(180.f/PI32)));
Mat4 result = { Mat4 result = {
aspect_ratio*f, 0, 0, 0, aspect_ratio*f, 0, 0, 0,
0, f, 0, 0, 0, f, 0, 0,
@@ -140,7 +148,19 @@ Mat4 Mat4Perspective(float fov, float window_x, float window_y, float znear, flo
} }
FUNCTION FUNCTION
Mat4 Mat4Translate(Mat4 a, Vec3 translation) { Mat4 transpose(Mat4 a) {
Mat4 result = a;
result.p[0][1] = result.p[1][0];
result.p[0][2] = result.p[2][0];
result.p[0][3] = result.p[3][0];
result.p[2][1] = result.p[1][2];
result.p[3][1] = result.p[1][3];
result.p[3][2] = result.p[2][3];
return result;
}
FUNCTION
Mat4 translate(Mat4 a, Vec3 translation) {
a.p[0][0] += translation.x; a.p[0][0] += translation.x;
a.p[0][1] += translation.y; a.p[0][1] += translation.y;
a.p[0][2] += translation.z; a.p[0][2] += translation.z;
@@ -189,7 +209,6 @@ Vec3 operator+(Vec3 a, Vec3 b) {
return result; return result;
} }
FUNCTION FUNCTION
Vec4 operator*(Mat4 a, Vec4 b) { Vec4 operator*(Mat4 a, Vec4 b) {
Vec4 result = { Vec4 result = {
@@ -225,13 +244,13 @@ Mat4 operator*(Mat4 a, Mat4 b) {
} }
FUNCTION FUNCTION
float Dot(Vec3 a, Vec3 b) { float dot(Vec3 a, Vec3 b) {
float result = a.x * b.x + a.y * b.y + a.z * b.z; float result = a.x * b.x + a.y * b.y + a.z * b.z;
return result; return result;
} }
FUNCTION FUNCTION
Vec3 Cross(Vec3 a, Vec3 b) { Vec3 cross(Vec3 a, Vec3 b) {
Vec3 result = { Vec3 result = {
a.y * b.z - a.z * b.y, a.y * b.z - a.z * b.y,
a.z * b.x - a.x * b.z, a.z * b.x - a.x * b.z,
@@ -241,7 +260,7 @@ Vec3 Cross(Vec3 a, Vec3 b) {
} }
FUNCTION FUNCTION
U32 ColorToU32ARGB(Vec4 a) { U32 color_to_u32argb(Vec4 a) {
uint8_t r8 = (uint8_t)(a.r * 255.f); uint8_t r8 = (uint8_t)(a.r * 255.f);
uint8_t g8 = (uint8_t)(a.g * 255.f); uint8_t g8 = (uint8_t)(a.g * 255.f);
uint8_t b8 = (uint8_t)(a.b * 255.f); uint8_t b8 = (uint8_t)(a.b * 255.f);
@@ -251,7 +270,7 @@ U32 ColorToU32ARGB(Vec4 a) {
} }
FUNCTION FUNCTION
U32 ColorToU32ABGR(Vec4 a) { U32 color_to_u32abgr(Vec4 a) {
uint8_t r8 = (uint8_t)(a.r * 255.f); uint8_t r8 = (uint8_t)(a.r * 255.f);
uint8_t g8 = (uint8_t)(a.g * 255.f); uint8_t g8 = (uint8_t)(a.g * 255.f);
uint8_t b8 = (uint8_t)(a.b * 255.f); uint8_t b8 = (uint8_t)(a.b * 255.f);
@@ -261,7 +280,7 @@ U32 ColorToU32ABGR(Vec4 a) {
} }
FUNCTION FUNCTION
Vec4 V4ARGB(U32 c) { Vec4 v4argb(U32 c) {
float a = ((c & 0xff000000) >> 24) / 255.f; float a = ((c & 0xff000000) >> 24) / 255.f;
float r = ((c & 0x00ff0000) >> 16) / 255.f; float r = ((c & 0x00ff0000) >> 16) / 255.f;
float g = ((c & 0x0000ff00) >> 8) / 255.f; float g = ((c & 0x0000ff00) >> 8) / 255.f;
@@ -271,7 +290,7 @@ Vec4 V4ARGB(U32 c) {
} }
FUNCTION FUNCTION
Vec4 V4ABGR(U32 c) { Vec4 v4abgr(U32 c) {
float a = ((c & 0xff000000) >> 24) / 255.f; float a = ((c & 0xff000000) >> 24) / 255.f;
float b = ((c & 0x00ff0000) >> 16) / 255.f; float b = ((c & 0x00ff0000) >> 16) / 255.f;
float g = ((c & 0x0000ff00) >> 8) / 255.f; float g = ((c & 0x0000ff00) >> 8) / 255.f;
@@ -281,13 +300,13 @@ Vec4 V4ABGR(U32 c) {
} }
FUNCTION FUNCTION
float Lerp(float a, float b, float t) { float lerp(float a, float b, float t) {
float result = (1.0f - t) * a + t * b; float result = (1.0f - t) * a + t * b;
return result; return result;
} }
FUNCTION FUNCTION
Vec4 Lerp(Vec4 a, Vec4 b, float t) { Vec4 lerp(Vec4 a, Vec4 b, float t) {
Vec4 result = {Lerp(a.x,b.x,t), Lerp(a.y,b.y,t), Lerp(a.z,b.z,t), Lerp(a.w,b.w,t) }; Vec4 result = {lerp(a.x,b.x,t), lerp(a.y,b.y,t), lerp(a.z,b.z,t), lerp(a.w,b.w,t) };
return result; return result;
} }

387
objparser.cpp
View File

@@ -2,6 +2,7 @@
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#define FUNCTION static
enum class TokenType { enum class TokenType {
none, word, number, whitespace, end none, word, number, whitespace, end
@@ -18,223 +19,213 @@ struct Token {
}; };
}; };
static
bool Obj_IsAlphabetic(char w) {
bool result = (w >= 'a' && w <= 'z') || (w >= 'A' && w <= 'Z');
return result;
}
static
bool Obj_IsNumber(char w) {
bool result = w >= '0' && w <= '9';
return result;
}
static
bool Obj_IsWhitespace(char w) {
bool result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
return result;
}
static
int Obj_StringLen(char* a) {
int result = 0;
while (*a++ != 0) result++;
return result;
}
static
bool Obj_Equals(Token a, const char* b) {
int len = Obj_StringLen((char*)b);
if (a.type != TokenType::word) return false;
if (a.len != len) return false;
for (int i = 0; i < len; i++) {
if (a.s[i] != b[i]) return false;
}
return true;
}
static
Token Obj_NextTokenRaw(char** data) {
Token result = {};
result.s = *data;
*data += 1;
if (Obj_IsAlphabetic(*result.s)) {
result.type = TokenType::word;
while (!Obj_IsWhitespace(**data)) {
*data+=1;
}
result.len = (int)(*data - result.s);
}
else if (Obj_IsNumber(*result.s) || *result.s == '-') {
result.type = TokenType::number;
while (Obj_IsNumber(**data) || **data == '.') {
*data += 1;
}
result.number = atof(result.s);
}
else if (*result.s == '#') {
while (**data != '\n') *data += 1;
result = Obj_NextTokenRaw(data);
}
else if (Obj_IsWhitespace(*result.s)) {
result.type = TokenType::whitespace;
while (Obj_IsWhitespace(**data)) *data += 1;
result.len = (int)(*data - result.s);
}
else if (*result.s == 0) {
result.type = TokenType::end;
}
else if(*result.s >= '!') {
result.type = (TokenType)*result.s;
}
return result;
}
static
Token Obj_NextToken(char** data) {
Token result;
do {
result = Obj_NextTokenRaw(data);
} while (result.type == TokenType::whitespace);
return result;
}
static
double Obj_ExpectNumber(char** data) {
Token t = Obj_NextToken(data);
assert(t.type == TokenType::number); // @Todo: Error handling, error flag
return t.number;
}
static
void Obj_ExpectToken(char** data, char token) {
Token t = Obj_NextToken(data);
assert(t.type == (TokenType)token); // @Todo: Error handling, error flag
}
static
void Obj_Debug_ExpectRaw(char** data, TokenType type) {
char* data_temp = *data;
assert(Obj_NextTokenRaw(&data_temp).type == type);
}
struct Obj_Arena { struct Obj_Arena {
char* base; char* base;
size_t size; size_t size;
size_t p; size_t p;
}; };
static namespace obj {
char* Obj_Push(Obj_Arena *a, size_t size) { FUNCTION bool is_alphabetic(char w) {
char* ptr = a->base; bool result = (w >= 'a' && w <= 'z') || (w >= 'A' && w <= 'Z');
if (a->p + size < a->size) { return result;
ptr += a->p;
a->p += size;
} }
else {
assert(!"Buffer is too small to hold the data!"); FUNCTION bool is_number(char w) {
bool result = w >= '0' && w <= '9';
return result;
} }
return ptr;
}
Obj Obj_Parse(char* memory, size_t memory_size, char* data) { FUNCTION bool is_whitespace(char w) {
Obj_Arena arena = { memory, memory_size }; bool result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
Obj result = {}; return result;
int parsing_vertices = 0; }
int parsing_normals = 0;
int parsing_textures = 0;
for (;;) { FUNCTION int string_len(char* a) {
Token token = Obj_NextToken(&data); int result = 0;
if (token.type == TokenType::end) break; while (*a++ != 0) result++;
else if (token.type == TokenType::word) { return result;
if (Obj_Equals(token, "v")) { }
assert(parsing_vertices != 2);
parsing_vertices = 1; FUNCTION bool equals(Token a, const char* b) {
float* ptr = (float*)Obj_Push(&arena, sizeof(float) * 3); int len = string_len((char*)b);
ptr[0] = (float)Obj_ExpectNumber(&data); if (a.type != TokenType::word) return false;
ptr[1] = (float)Obj_ExpectNumber(&data); if (a.len != len) return false;
ptr[2] = (float)Obj_ExpectNumber(&data); for (int i = 0; i < len; i++) {
if (result.vertices == 0) result.vertices = ptr; if (a.s[i] != b[i]) return false;
result.vertices_count++; }
Obj_Debug_ExpectRaw(&data, TokenType::whitespace); return true;
}
FUNCTION Token next_token_raw(char** data) {
Token result = {};
result.s = *data;
*data += 1;
if (is_alphabetic(*result.s)) {
result.type = TokenType::word;
while (!is_whitespace(**data)) {
*data += 1;
} }
else if (Obj_Equals(token, "vt")) { result.len = (int)(*data - result.s);
assert(parsing_textures != 2); }
parsing_textures = 1; else if (is_number(*result.s) || *result.s == '-') {
parsing_vertices = 2; result.type = TokenType::number;
while (is_number(**data) || **data == '.') {
float* ptr = (float*)Obj_Push(&arena, sizeof(float) * 2); *data += 1;
ptr[0] = (float)Obj_ExpectNumber(&data);
ptr[1] = (float)Obj_ExpectNumber(&data);
if (result.texture == 0) result.texture = ptr;
Obj_Debug_ExpectRaw(&data, TokenType::whitespace);
} }
else if (Obj_Equals(token, "vn")) { result.number = atof(result.s);
assert((parsing_textures == 1 || parsing_textures == 2) && parsing_vertices == 2); }
parsing_textures = 2; else if (*result.s == '#') {
parsing_normals = 1; while (**data != '\n') *data += 1;
result = next_token_raw(data);
}
else if (is_whitespace(*result.s)) {
result.type = TokenType::whitespace;
while (is_whitespace(**data)) *data += 1;
result.len = (int)(*data - result.s);
}
else if (*result.s == 0) {
result.type = TokenType::end;
}
else if (*result.s >= '!') {
result.type = (TokenType)*result.s;
}
float* ptr = (float*)Obj_Push(&arena, sizeof(float) * 3); return result;
ptr[0] = (float)Obj_ExpectNumber(&data); }
ptr[1] = (float)Obj_ExpectNumber(&data);
ptr[2] = (float)Obj_ExpectNumber(&data);
if (result.normals == 0) result.normals = ptr;
Obj_Debug_ExpectRaw(&data, TokenType::whitespace);
}
else if (Obj_Equals(token, "f")) {
assert(parsing_normals == 1 && parsing_textures == 2 && parsing_vertices == 2);
int* ptr = (int*)Obj_Push(&arena, sizeof(int) * 9);
ptr[0] = (int)Obj_ExpectNumber(&data);
Obj_ExpectToken(&data, '/');
ptr[3] = (int)Obj_ExpectNumber(&data);
Obj_ExpectToken(&data, '/');
ptr[6] = (int)Obj_ExpectNumber(&data);
ptr[1] = (int)Obj_ExpectNumber(&data); FUNCTION Token next_token(char** data) {
Obj_ExpectToken(&data, '/'); Token result;
ptr[4] = (int)Obj_ExpectNumber(&data); do {
Obj_ExpectToken(&data, '/'); result = next_token_raw(data);
ptr[7] = (int)Obj_ExpectNumber(&data); } while (result.type == TokenType::whitespace);
return result;
}
ptr[2] = (int)Obj_ExpectNumber(&data); FUNCTION double expect_number(char** data) {
Obj_ExpectToken(&data, '/'); Token t = next_token(data);
ptr[5] = (int)Obj_ExpectNumber(&data); assert(t.type == TokenType::number); // @Todo: Error handling, error flag
Obj_ExpectToken(&data, '/'); return t.number;
ptr[8] = (int)Obj_ExpectNumber(&data); }
if (result.indices == 0) result.indices = ptr;
result.indices_count += 1;
Obj_Debug_ExpectRaw(&data, TokenType::whitespace); FUNCTION void expect_token(char** data, char token) {
Token t = next_token(data);
assert(t.type == (TokenType)token); // @Todo: Error handling, error flag
}
FUNCTION void debug_expect_raw(char** data, TokenType type) {
char* data_temp = *data;
assert(next_token_raw(&data_temp).type == type);
}
FUNCTION char* push(Obj_Arena *a, size_t size) {
char* ptr = a->base;
if (a->p + size < a->size) {
ptr += a->p;
a->p += size;
}
else {
assert(!"Buffer is too small to hold the data!");
}
return ptr;
}
Obj parse(char* memory, size_t memory_size, char* data) {
Obj_Arena arena = { memory, memory_size };
Obj result = {};
int parsing_vertices = 0;
int parsing_normals = 0;
int parsing_textures = 0;
for (; ; ) {
Token token = next_token(&data);
if (token.type == TokenType::end) break;
else if (token.type == TokenType::word) {
if (equals(token, "v")) {
assert(parsing_vertices != 2);
parsing_vertices = 1;
float* ptr = (float*)push(&arena, sizeof(float) * 3);
ptr[0] = (float)expect_number(&data);
ptr[1] = (float)expect_number(&data);
ptr[2] = (float)expect_number(&data);
if (result.vertices == 0) result.vertices = ptr;
result.vertices_count++;
debug_expect_raw(&data, TokenType::whitespace);
}
else if (equals(token, "vt")) {
assert(parsing_textures != 2);
parsing_textures = 1;
parsing_vertices = 2;
float* ptr = (float*)push(&arena, sizeof(float) * 2);
ptr[0] = (float)expect_number(&data);
ptr[1] = (float)expect_number(&data);
if (result.texture == 0) result.texture = ptr;
debug_expect_raw(&data, TokenType::whitespace);
}
else if (equals(token, "vn")) {
assert((parsing_textures == 1 || parsing_textures == 2) && parsing_vertices == 2);
parsing_textures = 2;
parsing_normals = 1;
float* ptr = (float*)push(&arena, sizeof(float) * 3);
ptr[0] = (float)expect_number(&data);
ptr[1] = (float)expect_number(&data);
ptr[2] = (float)expect_number(&data);
if (result.normals == 0) result.normals = ptr;
debug_expect_raw(&data, TokenType::whitespace);
}
else if (equals(token, "f")) {
assert(parsing_normals == 1 && parsing_textures == 2 && parsing_vertices == 2);
int* ptr = (int*)push(&arena, sizeof(int) * 9);
ptr[0] = (int)expect_number(&data);
expect_token(&data, '/');
ptr[3] = (int)expect_number(&data);
expect_token(&data, '/');
ptr[6] = (int)expect_number(&data);
ptr[1] = (int)expect_number(&data);
expect_token(&data, '/');
ptr[4] = (int)expect_number(&data);
expect_token(&data, '/');
ptr[7] = (int)expect_number(&data);
ptr[2] = (int)expect_number(&data);
expect_token(&data, '/');
ptr[5] = (int)expect_number(&data);
expect_token(&data, '/');
ptr[8] = (int)expect_number(&data);
if (result.indices == 0) result.indices = ptr;
result.indices_count += 1;
debug_expect_raw(&data, TokenType::whitespace);
}
} }
} }
result.memory_taken = arena.p;
return result;
} }
result.memory_taken = arena.p;
return result;
}
static FUNCTION void test_lex() {
void Obj_TestLex() { const char* d = "v 0.885739 0.001910 -0.380334";
const char* d = "v 0.885739 0.001910 -0.380334"; char* dd = (char *)d;
char* dd = (char *)d; assert(next_token(&dd).type == TokenType::word);
assert(Obj_NextToken(&dd).type == TokenType::word); Token t = next_token(&dd); assert(t.type == TokenType::number && t.number > 0.8857);
Token t = Obj_NextToken(&dd); assert(t.type == TokenType::number && t.number > 0.8857); t = next_token(&dd); assert(t.type == TokenType::number && t.number > 0.0019);
t = Obj_NextToken(&dd); assert(t.type == TokenType::number && t.number > 0.0019); t = next_token(&dd); assert(t.type == TokenType::number && t.number < -0.38);
t = Obj_NextToken(&dd); assert(t.type == TokenType::number && t.number < -0.38); d = "# Blender v2.79 (sub 0) OBJ File: 'fighters_0.blend'\n"
d = "# Blender v2.79 (sub 0) OBJ File: 'fighters_0.blend'\n" "# www.blender.org\n"
"# www.blender.org\n" "mtllib f-22.mtl\n"
"mtllib f-22.mtl\n" "o F-22\n";
"o F-22\n"; dd = (char *)d;
dd = (char *)d; t = next_token(&dd); assert(t.type == TokenType::word && equals(t, (char*)"mtllib"));
t = Obj_NextToken(&dd); assert(t.type == TokenType::word && Obj_Equals(t, (char*)"mtllib")); t = next_token(&dd); assert(t.type == TokenType::word && equals(t, (char*)"f-22.mtl"));
t = Obj_NextToken(&dd); assert(t.type == TokenType::word && Obj_Equals(t, (char*)"f-22.mtl")); t = next_token(&dd); assert(t.type == TokenType::word && equals(t, (char*)"o"));
t = Obj_NextToken(&dd); assert(t.type == TokenType::word && Obj_Equals(t, (char*)"o")); t = next_token(&dd); assert(t.type == TokenType::word && equals(t, (char*)"F-22"));
t = Obj_NextToken(&dd); assert(t.type == TokenType::word && Obj_Equals(t, (char*)"F-22")); }
}
void Obj_Test() { void test() {
Obj_TestLex(); test_lex();
}
} }

6
objparser.h
View File

@@ -10,5 +10,7 @@ struct Obj {
size_t memory_taken; size_t memory_taken;
}; };
Obj Obj_Parse(char* memory, size_t memory_size, char* data); namespace obj {
void Obj_Test(); Obj parse(char* memory, size_t memory_size, char* data);
void test();
}

118
platform.cpp
View File

@@ -7,50 +7,41 @@
#include <windows.h> #include <windows.h>
#include <shellscalingapi.h> #include <shellscalingapi.h>
struct OSWin32 {
HBITMAP screen_dib;
HDC screen_dc;
HDC window_dc;
HWND hwnd;
HINSTANCE hinstance;
};
typedef HRESULT tSetProcessDpiAwareness(PROCESS_DPI_AWARENESS); typedef HRESULT tSetProcessDpiAwareness(PROCESS_DPI_AWARENESS);
GLOBAL OS *wnd_proc_os = 0;
Image screen;
bool keydown_a;
bool keydown_b;
bool keydown_f1;
bool keydown_f2;
bool keydown_f3;
GLOBAL bool g_app_is_running = true;
GLOBAL HBITMAP g_screen_dib;
GLOBAL HDC g_screen_dc;
GLOBAL HDC g_window_dc;
GLOBAL HWND g_hwnd;
GLOBAL HINSTANCE g_hinstance;
GLOBAL int g_cmdshow;
FUNCTION
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
LRESULT result = 0; LRESULT result = 0;
switch (uMsg) { switch (uMsg) {
case WM_CLOSE: DestroyWindow(hwnd); g_app_is_running = false; break; case WM_CLOSE: DestroyWindow(hwnd); wnd_proc_os->app_is_running = false; break;
case WM_DESTROY: PostQuitMessage(0); g_app_is_running = false; break; case WM_DESTROY: PostQuitMessage(0); wnd_proc_os->app_is_running = false; break;
case WM_SYSKEYDOWN: case WM_SYSKEYDOWN:
case WM_KEYDOWN: { case WM_KEYDOWN: {
switch (wParam) { switch (wParam) {
case VK_ESCAPE: g_app_is_running = false; break; case VK_ESCAPE: wnd_proc_os->app_is_running = false; break;
case 0x4F: keydown_a = true; break; case 0x4F: wnd_proc_os->keydown_a = true; break;
case 0x50: keydown_b = true; break; case 0x50: wnd_proc_os->keydown_b = true; break;
case VK_F1: keydown_f1 = true; break; case VK_F1: wnd_proc_os->keydown_f1 = true; break;
case VK_F2: keydown_f2 = true; break; case VK_F2: wnd_proc_os->keydown_f2 = true; break;
case VK_F3: keydown_f3 = true; break; case VK_F3: wnd_proc_os->keydown_f3 = true; break;
} }
} break; } break;
case WM_SYSKEYUP: case WM_SYSKEYUP:
case WM_KEYUP: { case WM_KEYUP: {
switch (wParam) { switch (wParam) {
case 0x4F: keydown_a = false; break; case 0x4F: wnd_proc_os->keydown_a = false; break;
case 0x50: keydown_b = false; break; case 0x50: wnd_proc_os->keydown_b = false; break;
case VK_F1: keydown_f1 = false; break; case VK_F1: wnd_proc_os->keydown_f1 = false; break;
case VK_F2: keydown_f2 = false; break; case VK_F2: wnd_proc_os->keydown_f2 = false; break;
case VK_F3: keydown_f3 = false; break; case VK_F3: wnd_proc_os->keydown_f3 = false; break;
} }
} break; } break;
default: result = DefWindowProc(hwnd, uMsg, wParam, lParam); default: result = DefWindowProc(hwnd, uMsg, wParam, lParam);
@@ -59,7 +50,8 @@ LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
} }
FUNCTION FUNCTION
void Win32_ScreenInit(int window_x, int window_y) { void win32_screen_init(OS *os, int window_x, int window_y) {
OSWin32 *w32 = (OSWin32 *)os->os_internal_data;
BITMAPINFO bminfo = {}; BITMAPINFO bminfo = {};
bminfo.bmiHeader.biSize = sizeof(bminfo.bmiHeader); bminfo.bmiHeader.biSize = sizeof(bminfo.bmiHeader);
bminfo.bmiHeader.biWidth = window_x; bminfo.bmiHeader.biWidth = window_x;
@@ -71,14 +63,16 @@ void Win32_ScreenInit(int window_x, int window_y) {
bminfo.bmiHeader.biYPelsPerMeter = 1; bminfo.bmiHeader.biYPelsPerMeter = 1;
void* mem = 0; void* mem = 0;
g_screen_dib = CreateDIBSection(g_window_dc, &bminfo, DIB_RGB_COLORS, (void**)&mem, 0, 0); w32->screen_dib = CreateDIBSection(w32->window_dc, &bminfo, DIB_RGB_COLORS, (void**)&mem, 0, 0);
g_screen_dc = CreateCompatibleDC(g_window_dc); w32->screen_dc = CreateCompatibleDC(w32->window_dc);
screen.pixels = (U32*)mem; os->screen.pixels = (U32*)mem;
screen.x = window_x; os->screen.x = window_x;
screen.y = window_y; os->screen.y = window_y;
} }
void OS_Init(OSInitArgs i) { void OS::init(OSInitArgs i) {
OSWin32 *w32 = (OSWin32 *)os_internal_data;
w32->hinstance = (HINSTANCE)GetModuleHandle(NULL);
HMODULE shcore = LoadLibraryA("Shcore.dll"); HMODULE shcore = LoadLibraryA("Shcore.dll");
if (shcore) { if (shcore) {
tSetProcessDpiAwareness* set_dpi_awr = (tSetProcessDpiAwareness*)GetProcAddress(shcore, "SetProcessDpiAwareness"); tSetProcessDpiAwareness* set_dpi_awr = (tSetProcessDpiAwareness*)GetProcAddress(shcore, "SetProcessDpiAwareness");
@@ -91,11 +85,11 @@ void OS_Init(OSInitArgs i) {
const wchar_t CLASS_NAME[] = L"Hello!"; const wchar_t CLASS_NAME[] = L"Hello!";
WNDCLASS wc = { }; WNDCLASS wc = { };
wc.lpfnWndProc = WindowProc; wc.lpfnWndProc = WindowProc;
wc.hInstance = g_hinstance; wc.hInstance = w32->hinstance;
wc.lpszClassName = CLASS_NAME; wc.lpszClassName = CLASS_NAME;
ASSERT(RegisterClass(&wc)); ASSERT(RegisterClass(&wc));
g_hwnd = CreateWindowEx( w32->hwnd = CreateWindowEx(
0, // Optional window styles. 0, // Optional window styles.
CLASS_NAME, // Window class CLASS_NAME, // Window class
L"Have a wonderful day!", // Window text L"Have a wonderful day!", // Window text
@@ -103,24 +97,28 @@ void OS_Init(OSInitArgs i) {
CW_USEDEFAULT, CW_USEDEFAULT, i.window_x, i.window_y, // Size and position CW_USEDEFAULT, CW_USEDEFAULT, i.window_x, i.window_y, // Size and position
NULL, // Parent window NULL, // Parent window
NULL, // Menu NULL, // Menu
g_hinstance, // Instance handle w32->hinstance, // Instance handle
NULL // Additional application data NULL // Additional application data
); );
if (g_hwnd == 0) { if (w32->hwnd == 0) {
ASSERT(!"Failed to create window"); ASSERT(!"Failed to create window");
return; return;
} }
ShowWindow(g_hwnd, SW_SHOW); ShowWindow(w32->hwnd, SW_SHOW);
RECT rect; RECT rect;
GetWindowRect(g_hwnd, &rect); GetWindowRect(w32->hwnd, &rect);
g_window_dc = GetWindowDC(g_hwnd); w32->window_dc = GetWindowDC(w32->hwnd);
Win32_ScreenInit(rect.right - rect.left, rect.bottom - rect.top); win32_screen_init(this, rect.right - rect.left, rect.bottom - rect.top);
app_is_running = true;
} }
bool OS_GameLoop() { bool OS::game_loop() {
OSWin32 *w32 = (OSWin32 *)os_internal_data;
MSG msg = { }; MSG msg = { };
wnd_proc_os = this;
while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE) > 0) { while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE) > 0) {
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
@@ -128,7 +126,7 @@ bool OS_GameLoop() {
// @Note: Free the screen on window resize // @Note: Free the screen on window resize
RECT rect; RECT rect;
GetWindowRect(g_hwnd, &rect); GetWindowRect(w32->hwnd, &rect);
int new_width = rect.right - rect.left; int new_width = rect.right - rect.left;
int new_height = rect.bottom - rect.top; int new_height = rect.bottom - rect.top;
if (new_width != screen.x || new_height != screen.y) { if (new_width != screen.x || new_height != screen.y) {
@@ -136,14 +134,14 @@ bool OS_GameLoop() {
screen.y = new_height; screen.y = new_height;
if (screen.pixels) { if (screen.pixels) {
screen.pixels = 0; screen.pixels = 0;
DeleteDC(g_screen_dc); DeleteDC(w32->screen_dc);
DeleteObject(g_screen_dib); DeleteObject(w32->screen_dib);
} }
} }
// @Note: Create drawable screen // @Note: Create drawable screen
if (!screen.pixels) { if (!screen.pixels) {
Win32_ScreenInit((LONG)screen.x, (LONG)screen.y); win32_screen_init(this, (LONG)screen.x, (LONG)screen.y);
} }
// @Note: Draw screen to window // @Note: Draw screen to window
@@ -157,33 +155,35 @@ bool OS_GameLoop() {
} }
} }
SelectObject(g_screen_dc, g_screen_dib); SelectObject(w32->screen_dc, w32->screen_dib);
BitBlt(g_window_dc, 0, 0, (int)screen.x, (int)screen.y, g_screen_dc, 0, 0, SRCCOPY); BitBlt(w32->window_dc, 0, 0, (int)screen.x, (int)screen.y, w32->screen_dc, 0, 0, SRCCOPY);
} }
Sleep(16); Sleep(16);
return g_app_is_running; return app_is_running;
} }
int main(); int main();
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow) { int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow) {
g_hinstance = hInstance;
g_cmdshow = nCmdShow;
return main(); return main();
} }
#include <stdio.h> #include <stdio.h>
void OS_Message(const char* format, ...) { void OS::message(int debug, const char* format, ...) {
char buffer[1024]; char buffer[1024];
va_list args; va_list args;
va_start(args, format); va_start(args, format);
vsnprintf(buffer, 1024, format, args); vsnprintf(buffer, 1024, format, args);
va_end(args); va_end(args);
if (debug) {
MessageBoxA(0, buffer, "Error!", 0); OutputDebugStringA(buffer);
}
else {
MessageBoxA(0, buffer, "Error!", 0);
}
} }
char* OS_ReadFile(const char* path) { char* OS::read_file(const char* path) {
char* result = 0; char* result = 0;
FILE* f = fopen(path, "rb"); FILE* f = fopen(path, "rb");
if (f) { if (f) {

27
platform.h
View File

@@ -11,13 +11,22 @@ struct OSInitArgs {
int window_y; int window_y;
}; };
extern Image screen; struct OS {
extern bool keydown_a; Image screen;
extern bool keydown_b; bool keydown_a;
extern bool keydown_f1; bool keydown_b;
extern bool keydown_f2; bool keydown_f1;
extern bool keydown_f3; bool keydown_f2;
bool keydown_f3;
bool app_is_running;
bool OS_GameLoop(); void init(OSInitArgs args);
void OS_Init(OSInitArgs); bool game_loop();
char* OS_ReadFile(const char* path);
void message(int debug, const char *msg, ...);
char *read_file(const char *path);
OS() = default;
OS(OSInitArgs args) { init(args); }
char os_internal_data[1024];
};

255
raster_functions.cpp Normal file
View File

@@ -0,0 +1,255 @@
FUNCTION void draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_off_BILINEAR_BLEND_off (Image* dst, float *depth_buffer, Image *src,
Vec4 p0, Vec4 p1, Vec4 p2,
Vec2 tex0, Vec2 tex1, Vec2 tex2) {
float min_x1 = (float)(MIN(p0.x, MIN(p1.x, p2.x)));
float min_y1 = (float)(MIN(p0.y, MIN(p1.y, p2.y)));
float max_x1 = (float)(MAX(p0.x, MAX(p1.x, p2.x)));
float max_y1 = (float)(MAX(p0.y, MAX(p1.y, p2.y)));
I64 min_x = (I64)MAX(0, floor(min_x1));
I64 min_y = (I64)MAX(0, floor(min_y1));
I64 max_x = (I64)MIN(dst->x, ceil(max_x1));
I64 max_y = (I64)MIN(dst->y, ceil(max_y1));
float area = edge_function(p0, p1, p2);
for (I64 y = min_y; y < max_y; y++) {
for (I64 x = min_x; x < max_x; x++) {
float edge1 = edge_function(p0, p1, { (float)x,(float)y });
float edge2 = edge_function(p1, p2, { (float)x,(float)y });
float edge3 = edge_function(p2, p0, { (float)x,(float)y });
if (edge1 >= 0 && edge2 >= 0 && edge3 >= 0) {
float w1 = edge2 / area;
float w2 = edge3 / area;
float w3 = edge1 / area;
float interpolated_z = (1.f / p0.w) * w1 + (1.f / p1.w) * w2 + (1.f / p2.w) * w3;
// PERSPECTIVE_CORRECT_INTERPOLATION
float u = tex0.x * w1 + tex1.x * w2 + tex2.x * w3;
float v = tex0.y * w1 + tex1.y * w2 + tex2.y * w3;
// @Note: We could do: interpolated_z = 1.f / interpolated_z to get proper depth
// but why waste an instruction, the smaller the depth value the farther the object
float* depth = depth_buffer + (x + y * dst->x);
if (*depth < interpolated_z) {
*depth = interpolated_z;
u = u * (src->x - 2);
v = v * (src->y - 2);
I64 ui = (I64)(u);
I64 vi = (I64)(v);
float udiff = u - (float)ui;
float vdiff = v - (float)vi;
// Origin UV (0,0) is in bottom left
U32* pixel = src->pixels + (ui + (src->y - 1ll - vi) * src->x);
// BILINEAR_BLEND
U32 color32 = *pixel;
dst->pixels[x + y * dst->x] = color32;
}
}
}
}
if (draw_rects) {
draw_rect(dst, p0.x-4, p0.y-4, 8,8, 0x00ff0000);
draw_rect(dst, p1.x-4, p1.y-4, 8,8, 0x0000ff00);
draw_rect(dst, p2.x-4, p2.y-4, 8,8, 0x000000ff);
}
}
FUNCTION void draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_on_BILINEAR_BLEND_on (Image* dst, float *depth_buffer, Image *src,
Vec4 p0, Vec4 p1, Vec4 p2,
Vec2 tex0, Vec2 tex1, Vec2 tex2) {
float min_x1 = (float)(MIN(p0.x, MIN(p1.x, p2.x)));
float min_y1 = (float)(MIN(p0.y, MIN(p1.y, p2.y)));
float max_x1 = (float)(MAX(p0.x, MAX(p1.x, p2.x)));
float max_y1 = (float)(MAX(p0.y, MAX(p1.y, p2.y)));
I64 min_x = (I64)MAX(0, floor(min_x1));
I64 min_y = (I64)MAX(0, floor(min_y1));
I64 max_x = (I64)MIN(dst->x, ceil(max_x1));
I64 max_y = (I64)MIN(dst->y, ceil(max_y1));
float area = edge_function(p0, p1, p2);
for (I64 y = min_y; y < max_y; y++) {
for (I64 x = min_x; x < max_x; x++) {
float edge1 = edge_function(p0, p1, { (float)x,(float)y });
float edge2 = edge_function(p1, p2, { (float)x,(float)y });
float edge3 = edge_function(p2, p0, { (float)x,(float)y });
if (edge1 >= 0 && edge2 >= 0 && edge3 >= 0) {
float w1 = edge2 / area;
float w2 = edge3 / area;
float w3 = edge1 / area;
float interpolated_z = (1.f / p0.w) * w1 + (1.f / p1.w) * w2 + (1.f / p2.w) * w3;
// PERSPECTIVE_CORRECT_INTERPOLATION
float u = tex0.x * (w1 / p0.w) + tex1.x * (w2 / p1.w) + tex2.x * (w3 / p2.w);
float v = tex0.y * (w1 / p0.w) + tex1.y * (w2 / p1.w) + tex2.y * (w3 / p2.w);
u /= interpolated_z;
v /= interpolated_z;
// @Note: We could do: interpolated_z = 1.f / interpolated_z to get proper depth
// but why waste an instruction, the smaller the depth value the farther the object
float* depth = depth_buffer + (x + y * dst->x);
if (*depth < interpolated_z) {
*depth = interpolated_z;
u = u * (src->x - 2);
v = v * (src->y - 2);
I64 ui = (I64)(u);
I64 vi = (I64)(v);
float udiff = u - (float)ui;
float vdiff = v - (float)vi;
// Origin UV (0,0) is in bottom left
U32* pixel = src->pixels + (ui + (src->y - 1ll - vi) * src->x);
// BILINEAR_BLEND
Vec4 pixelx1y1 = srgb_to_almost_linear(v4abgr(*pixel));
Vec4 pixelx2y1 = srgb_to_almost_linear(v4abgr(*(pixel + 1)));
Vec4 pixelx1y2 = srgb_to_almost_linear(v4abgr(*(pixel - src->x)));
Vec4 pixelx2y2 = srgb_to_almost_linear(v4abgr(*(pixel + 1 - src->x)));
Vec4 blendx1 = lerp(pixelx1y1, pixelx2y1, udiff);
Vec4 blendx2 = lerp(pixelx1y2, pixelx2y2, udiff);
Vec4 result_color = lerp(blendx1, blendx2, vdiff);
result_color = almost_linear_to_srgb(result_color);
ASSERT(result_color.r <= 1 && result_color.g <= 1 && result_color.b <= 1);
U32 color32 = color_to_u32abgr(result_color);
dst->pixels[x + y * dst->x] = color32;
}
}
}
}
if (draw_rects) {
draw_rect(dst, p0.x-4, p0.y-4, 8,8, 0x00ff0000);
draw_rect(dst, p1.x-4, p1.y-4, 8,8, 0x0000ff00);
draw_rect(dst, p2.x-4, p2.y-4, 8,8, 0x000000ff);
}
}
FUNCTION void draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_off_BILINEAR_BLEND_on (Image* dst, float *depth_buffer, Image *src,

165
rasterization_feature_selection.cpp Normal file
View File

@@ -0,0 +1,165 @@
struct Token {
char* s;
int len;
};
FUNCTION bool is_alphabetic(char w) {
bool result = (w >= 'a' && w <= 'z') || (w >= 'A' && w <= 'Z');
return result;
}
FUNCTION bool is_number(char w) {
bool result = w >= '0' && w <= '9';
return result;
}
FUNCTION bool is_whitespace(char w) {
bool result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
return result;
}
FUNCTION int string_len(char* a) {
int result = 0;
while (*a++ != 0) result++;
return result;
}
FUNCTION bool equals(Token a, const char* b) {
int len = string_len((char*)b);
if (a.len != len) return false;
for (int i = 0; i < len; i++) {
if (a.s[i] != b[i]) return false;
}
return true;
}
bool combinations[64][8] = { { 0, 0 }, { 1, 1 }, { 0, 1 }, { 1, 0 } };
int combinations_to_make = 4;
struct Lexer {
char* stream;
char* data;
char output[10000];
Token next() {
while (is_whitespace(*stream)) stream++;
Token result = {};
result.s = stream++;
if (is_alphabetic(*result.s)) {
while (is_alphabetic(*stream) || *stream == '_') stream++;
}
result.len = (int)(stream - result.s);
return result;
}
bool match(const char* str, Token* out = 0) {
Lexer l = *this;
Token token = next();
if (out) *out = token;
if (equals(token, str)) {
return true;
}
*this = l;
return false;
}
};
struct Section {
char* begin, * end;
char* name, * name_end;
int if_clause_i;
bool is_else;
};
FUNCTION void generate_stuff() {
char* data = os.read_file("main.cpp");
FILE* f = fopen("raster_functions.cpp", "w");
ASSERT(f);
Section sections[100] = {};
int sections_count = 0;
int if_clause_count = 0;
Lexer lexer = { data, data };
for (;;) {
Token token = lexer.next();
if (*token.s == 0) break;
if (equals(token, "FUNCTION") &&
lexer.match("void") &&
lexer.match("draw_triangle", &token)) {
Section* section = sections + sections_count++;
section->begin = token.s + token.len;
int indent = 1;
while (lexer.next().s[0] != '{');
for (; ; ) {
token = lexer.next();
if (token.s[0] == '{') indent++;
else if (token.s[0] == '}') indent--;
else if (token.s[0] == '#') {
if (lexer.match("if")) {
section->end = token.s;
if_clause_count++;
token = lexer.next();
section = sections + sections_count++;
section->if_clause_i = if_clause_count;
section->is_else = false;
section->name = token.s;
section->name_end = token.s + token.len;
section->begin = section->name_end;
}
else if (lexer.match("else")) {
section->end = token.s;
char* name = section->name;
char* name_end = section->name_end;
section = sections + sections_count++;
section->is_else = true;
section->if_clause_i = if_clause_count;
section->name = name;
section->name_end = name_end;
section->begin = token.s + 5;
}
else if (lexer.match("endif")) {
section->end = token.s;
section = sections + sections_count++;
section->begin = token.s + 6;
}
}
if (indent == 0) {
section->end = token.s + 1;
break;
}
}
for (int ci = 0; ci < combinations_to_make; ci++) {
// @Note: Figure out function name
fprintf(f, "\nFUNCTION void draw_triangle");
for (int i = 0; i < sections_count; i++) {
section = sections + i;
if (section->name && section->is_else == !combinations[ci][section->if_clause_i - 1]) {
fprintf(f, "_%.*s_", (int)(section->name_end - section->name), section->name);
fprintf(f, "%s", section->is_else ? "off" : "on");
}
}
// @Note: Figure out function content
for (int i = 0; i < sections_count; i++) {
section = sections + i;
if (!section->name) {
fprintf(f, "%.*s %.*s", (int)(section->name_end - section->name), section->name, (int)(section->end - section->begin), section->begin);
}
else {
if (section->is_else == !combinations[ci][section->if_clause_i - 1]) {
fprintf(f, "// %.*s %.*s", (int)(section->name_end - section->name), section->name, (int)(section->end - section->begin), section->begin);
}
}
}
}
fclose(f);
}
}
}

249
test.txt Normal file
View File

@@ -0,0 +1,249 @@
FUNCTION void draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_off_BILINEAR_BLEND_off (Image* dst, float *depth_buffer, Image *src,
Vec4 p0, Vec4 p1, Vec4 p2,
Vec2 tex0, Vec2 tex1, Vec2 tex2) {
float min_x1 = (float)(MIN(p0.x, MIN(p1.x, p2.x)));
float min_y1 = (float)(MIN(p0.y, MIN(p1.y, p2.y)));
float max_x1 = (float)(MAX(p0.x, MAX(p1.x, p2.x)));
float max_y1 = (float)(MAX(p0.y, MAX(p1.y, p2.y)));
I64 min_x = (I64)MAX(0, floor(min_x1));
I64 min_y = (I64)MAX(0, floor(min_y1));
I64 max_x = (I64)MIN(dst->x, ceil(max_x1));
I64 max_y = (I64)MIN(dst->y, ceil(max_y1));
float area = edge_function(p0, p1, p2);
for (I64 y = min_y; y < max_y; y++) {
for (I64 x = min_x; x < max_x; x++) {
float edge1 = edge_function(p0, p1, { (float)x,(float)y });
float edge2 = edge_function(p1, p2, { (float)x,(float)y });
float edge3 = edge_function(p2, p0, { (float)x,(float)y });
if (edge1 >= 0 && edge2 >= 0 && edge3 >= 0) {
float w1 = edge2 / area;
float w2 = edge3 / area;
float w3 = edge1 / area;
float interpolated_z = (1.f / p0.w) * w1 + (1.f / p1.w) * w2 + (1.f / p2.w) * w3;
// PERSPECTIVE_CORRECT_INTERPOLATION
float u = tex0.x * w1 + tex1.x * w2 + tex2.x * w3;
float v = tex0.y * w1 + tex1.y * w2 + tex2.y * w3;
// @Note: We could do: interpolated_z = 1.f / interpolated_z to get proper depth
// but why waste an instruction, the smaller the depth value the farther the object
float* depth = depth_buffer + (x + y * dst->x);
if (*depth < interpolated_z) {
*depth = interpolated_z;
u = u * (src->x - 2);
v = v * (src->y - 2);
I64 ui = (I64)(u);
I64 vi = (I64)(v);
float udiff = u - (float)ui;
float vdiff = v - (float)vi;
// Origin UV (0,0) is in bottom left
U32* pixel = src->pixels + (ui + (src->y - 1ll - vi) * src->x);
// BILINEAR_BLEND
U32 color32 = *pixel;
dst->pixels[x + y * dst->x] = color32;
}
}
}
}
if (draw_rects) {
draw_rect(dst, p0.x-4, p0.y-4, 8,8, 0x00ff0000);
draw_rect(dst, p1.x-4, p1.y-4, 8,8, 0x0000ff00);
draw_rect(dst, p2.x-4, p2.y-4, 8,8, 0x000000ff);
}
}
FUNCTION void draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_on_BILINEAR_BLEND_on (Image* dst, float *depth_buffer, Image *src,
Vec4 p0, Vec4 p1, Vec4 p2,
Vec2 tex0, Vec2 tex1, Vec2 tex2) {
float min_x1 = (float)(MIN(p0.x, MIN(p1.x, p2.x)));
float min_y1 = (float)(MIN(p0.y, MIN(p1.y, p2.y)));
float max_x1 = (float)(MAX(p0.x, MAX(p1.x, p2.x)));
float max_y1 = (float)(MAX(p0.y, MAX(p1.y, p2.y)));
I64 min_x = (I64)MAX(0, floor(min_x1));
I64 min_y = (I64)MAX(0, floor(min_y1));
I64 max_x = (I64)MIN(dst->x, ceil(max_x1));
I64 max_y = (I64)MIN(dst->y, ceil(max_y1));
float area = edge_function(p0, p1, p2);
for (I64 y = min_y; y < max_y; y++) {
for (I64 x = min_x; x < max_x; x++) {
float edge1 = edge_function(p0, p1, { (float)x,(float)y });
float edge2 = edge_function(p1, p2, { (float)x,(float)y });
float edge3 = edge_function(p2, p0, { (float)x,(float)y });
if (edge1 >= 0 && edge2 >= 0 && edge3 >= 0) {
float w1 = edge2 / area;
float w2 = edge3 / area;
float w3 = edge1 / area;
float interpolated_z = (1.f / p0.w) * w1 + (1.f / p1.w) * w2 + (1.f / p2.w) * w3;
// PERSPECTIVE_CORRECT_INTERPOLATION
float u = tex0.x * (w1 / p0.w) + tex1.x * (w2 / p1.w) + tex2.x * (w3 / p2.w);
float v = tex0.y * (w1 / p0.w) + tex1.y * (w2 / p1.w) + tex2.y * (w3 / p2.w);
u /= interpolated_z;
v /= interpolated_z;
// @Note: We could do: interpolated_z = 1.f / interpolated_z to get proper depth
// but why waste an instruction, the smaller the depth value the farther the object
float* depth = depth_buffer + (x + y * dst->x);
if (*depth < interpolated_z) {
*depth = interpolated_z;
u = u * (src->x - 2);
v = v * (src->y - 2);
I64 ui = (I64)(u);
I64 vi = (I64)(v);
float udiff = u - (float)ui;
float vdiff = v - (float)vi;
// Origin UV (0,0) is in bottom left
U32* pixel = src->pixels + (ui + (src->y - 1ll - vi) * src->x);
// BILINEAR_BLEND
Vec4 pixelx1y1 = v4abgr(*pixel);
Vec4 pixelx2y1 = v4abgr(*(pixel + 1));
Vec4 pixelx1y2 = v4abgr(*(pixel - src->x));
Vec4 pixelx2y2 = v4abgr(*(pixel + 1 - src->x));
Vec4 blendx1 = lerp(pixelx1y1, pixelx2y1, udiff);
Vec4 blendx2 = lerp(pixelx1y2, pixelx2y2, udiff);
Vec4 result_color = lerp(blendx1, blendx2, vdiff);
U32 color32 = color_to_u32abgr(result_color);
dst->pixels[x + y * dst->x] = color32;
}
}
}
}
if (draw_rects) {
draw_rect(dst, p0.x-4, p0.y-4, 8,8, 0x00ff0000);
draw_rect(dst, p1.x-4, p1.y-4, 8,8, 0x0000ff00);
draw_rect(dst, p2.x-4, p2.y-4, 8,8, 0x000000ff);
}
}
FUNCTION void draw_triangle_PERSPECTIVE_CORRECT_INTERPOLATION_off_BILINEAR_BLEND_on (Image* dst, float *depth_buffer, Image *src,