refactor: removed cpp code
This commit is contained in:
411
fastmath.hpp
411
fastmath.hpp
@@ -1,411 +0,0 @@
|
||||
#ifndef FASTMATH_H
|
||||
#define FASTMATH_H
|
||||
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
#define SHIFT_AMOUNT 16
|
||||
#define HALF_SHIFT (SHIFT_AMOUNT / 2)
|
||||
|
||||
#define SHIFT_MASK ((1 << SHIFT_AMOUNT) - 1)
|
||||
#define TO_FLOAT(x) \
|
||||
(((float)(x >> SHIFT_AMOUNT)) + \
|
||||
((double)(x & SHIFT_MASK) / (1 << SHIFT_AMOUNT)))
|
||||
#define TO_INT(x) ((int32_t)(x * (1 << SHIFT_AMOUNT)))
|
||||
#define MUL_F(a, b) (((a) >> HALF_SHIFT) * ((b) >> HALF_SHIFT))
|
||||
#define DIV_F(a, b) ((((a) << HALF_SHIFT) / (b)) << HALF_SHIFT)
|
||||
|
||||
struct decimal {
|
||||
|
||||
int32_t i;
|
||||
constexpr decimal() = default;
|
||||
// constexpr decimal() : i(0) {}
|
||||
constexpr decimal(float i) : i(TO_INT(i)) {}
|
||||
constexpr decimal(double i) : i(TO_INT(i)) {}
|
||||
constexpr decimal(int32_t i) : i(i) {}
|
||||
|
||||
inline friend std::ostream &operator<<(std::ostream &os, const decimal &d) {
|
||||
return (os << TO_FLOAT(d.i));
|
||||
}
|
||||
|
||||
inline friend decimal operator+(const decimal &d1, const decimal &d2) {
|
||||
return {d1.i + d2.i};
|
||||
}
|
||||
inline decimal &operator+=(const decimal &d) { return (*this) = {i + d.i}; }
|
||||
|
||||
inline friend decimal operator-(const decimal &d1, const decimal &d2) {
|
||||
return {d1.i - d2.i};
|
||||
}
|
||||
inline friend decimal operator-(const decimal &d) { return {-d.i}; }
|
||||
|
||||
inline friend decimal operator*(const decimal &d1, const decimal &d2) {
|
||||
return {MUL_F(d1.i, d2.i)};
|
||||
}
|
||||
|
||||
inline decimal &operator*=(const decimal &d) {
|
||||
return (*this) = {MUL_F(i, d.i)};
|
||||
}
|
||||
|
||||
inline friend decimal operator/(const decimal &d1, const decimal &d2) {
|
||||
return {DIV_F(d1.i, d2.i)};
|
||||
}
|
||||
|
||||
inline friend bool operator<(const decimal &d1, const decimal &d2) {
|
||||
return d1.i < d2.i;
|
||||
}
|
||||
|
||||
inline friend bool operator>(const decimal &d1, const decimal &d2) {
|
||||
return d1.i > d2.i;
|
||||
}
|
||||
inline friend bool operator<=(const decimal &d1, const decimal &d2) {
|
||||
return d1.i <= d2.i;
|
||||
}
|
||||
inline friend bool operator>=(const decimal &d1, const decimal &d2) {
|
||||
return d1.i >= d2.i;
|
||||
}
|
||||
|
||||
inline friend bool operator==(const decimal &d1, const decimal &d2) {
|
||||
return d1.i == d2.i;
|
||||
}
|
||||
inline friend bool operator!=(const decimal &d1, const decimal &d2) {
|
||||
return d1.i != d2.i;
|
||||
}
|
||||
|
||||
inline decimal sqrt() { return {((int32_t)sqrtf(i)) << HALF_SHIFT}; }
|
||||
|
||||
inline float to_float() { return TO_FLOAT(i); }
|
||||
inline bool isSmall() { return (abs(i) < (1 << (HALF_SHIFT - 1))); }
|
||||
};
|
||||
|
||||
template <int n, class Dev> struct vec {
|
||||
|
||||
decimal v[n];
|
||||
|
||||
constexpr vec() noexcept = default;
|
||||
|
||||
template <class... Args>
|
||||
constexpr vec(Args... args) noexcept : v{static_cast<decimal>(args)...} {
|
||||
static_assert(sizeof...(Args) == n, "Wrong number of elements for vec");
|
||||
}
|
||||
|
||||
friend Dev operator+(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
Dev newV = {};
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = v1.v[i] + v2.v[i];
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
friend Dev operator+=(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
Dev newV = {};
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = v1.v[i] + v2.v[i];
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
|
||||
friend Dev operator-(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
Dev newV = {};
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = v1.v[i] - v2.v[i];
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
|
||||
friend std::ostream &operator<<(std::ostream &os, const vec<n, Dev> &v) {
|
||||
os << "(" << v.v[0];
|
||||
for (int i = 1; i < n; i++) {
|
||||
os << ", " << v.v[i];
|
||||
}
|
||||
return (os << ")" << std::endl);
|
||||
}
|
||||
|
||||
Dev operator-() {
|
||||
Dev newV = {};
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = -v[i];
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
|
||||
friend Dev operator*(const vec<n, Dev> &v, const decimal &d) {
|
||||
int32_t f = d.i >> HALF_SHIFT;
|
||||
|
||||
Dev newV = {};
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = (v.v[i].i >> HALF_SHIFT) * f;
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
static Dev max(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
Dev newV = {};
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = std::max(v1.v[i], v2.v[i]);
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
static Dev min(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
Dev newV = {};
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV.v[i] = std::min(v1.v[i], v2.v[i]);
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
|
||||
friend Dev operator*(const decimal &d, const vec<n, Dev> &v) {
|
||||
return v * d;
|
||||
}
|
||||
|
||||
friend decimal operator*(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
decimal res = decimal(0.0f);
|
||||
for (int i = 0; i < n; i++) {
|
||||
res += v1.v[i] * v2.v[i];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
friend bool operator==(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
|
||||
bool res = true;
|
||||
for (int i = 0; i < n; i++) {
|
||||
res &= v1.v[i] == v2.v[i];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
bool isSmall() {
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (!v[i].isSmall())
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
decimal &operator[](const int &i) { return v[i]; }
|
||||
|
||||
decimal len_sq() { return *this * *this; }
|
||||
|
||||
decimal len() { return this->len_sq().sqrt(); }
|
||||
|
||||
Dev normalize() {
|
||||
decimal f = decimal(1.0) / this->len();
|
||||
return (*this * f);
|
||||
}
|
||||
|
||||
constexpr static Dev zero() {
|
||||
Dev newV = {};
|
||||
for (int i = 0; i < n; i++) {
|
||||
newV[i] = decimal(0);
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
};
|
||||
struct vec2 : public vec<2, vec2> {
|
||||
|
||||
vec2(float x, float y) : vec<2, vec2>(decimal(x), decimal(y)) {}
|
||||
|
||||
vec2(double x, double y) : vec<2, vec2>(decimal(x), decimal(y)) {}
|
||||
|
||||
vec2(int32_t x, int32_t y) : vec<2, vec2>(decimal(x), decimal(y)) {}
|
||||
|
||||
vec2(decimal x, decimal y) : vec<2, vec2>(x, y) {}
|
||||
|
||||
decimal &x() { return v[0]; }
|
||||
decimal &y() { return v[1]; }
|
||||
};
|
||||
struct vec3 : public vec<3, vec3> {
|
||||
|
||||
constexpr vec3() : vec<3, vec3>() {}
|
||||
|
||||
constexpr vec3(float x, float y, float z)
|
||||
: vec<3, vec3>(decimal(x), decimal(y), decimal(z)) {}
|
||||
|
||||
constexpr vec3(double x, double y, double z)
|
||||
: vec<3, vec3>(decimal(x), decimal(y), decimal(z)) {}
|
||||
|
||||
constexpr vec3(int32_t x, int32_t y, int32_t z)
|
||||
: vec<3, vec3>(decimal(x), decimal(y), decimal(z)) {}
|
||||
|
||||
constexpr vec3(decimal x, decimal y, decimal z) : vec<3, vec3>(x, y, z) {}
|
||||
|
||||
inline decimal &x() { return v[0]; }
|
||||
inline decimal &y() { return v[1]; }
|
||||
inline decimal &z() { return v[2]; }
|
||||
|
||||
inline vec3 cross(vec3 &v) {
|
||||
return vec3((y() * v.z()) - (z() * v.y()),
|
||||
(z() * v.x()) - (x() * v.z()),
|
||||
(x() * v.y()) - (y() * v.x()));
|
||||
}
|
||||
};
|
||||
struct vec4 : public vec<4, vec4> {
|
||||
|
||||
constexpr vec4() : vec<4, vec4>() {}
|
||||
|
||||
vec4(float x, float y, float z, float w)
|
||||
: vec<4, vec4>(decimal(x), decimal(y), decimal(z), decimal(w)) {}
|
||||
|
||||
vec4(double x, double y, double z, double w)
|
||||
: vec<4, vec4>(decimal(x), decimal(y), decimal(z), decimal(w)) {}
|
||||
|
||||
vec4(int32_t x, int32_t y, int32_t z, int32_t w)
|
||||
: vec<4, vec4>(decimal(x), decimal(y), decimal(z), decimal(w)) {}
|
||||
|
||||
vec4(vec3 v, decimal w) : vec<4, vec4>(v.x(), v.y(), v.z(), w) {}
|
||||
|
||||
decimal &x() { return v[0]; }
|
||||
decimal &y() { return v[1]; }
|
||||
decimal &z() { return v[2]; }
|
||||
decimal &w() { return v[3]; }
|
||||
};
|
||||
|
||||
template <int n, class Dev> struct mat {
|
||||
decimal m[n * n];
|
||||
|
||||
static const int size = n;
|
||||
friend Dev operator+(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
|
||||
Dev newM = {};
|
||||
|
||||
for (int i = 0; i < n * n; i++) {
|
||||
newM.v[i] = m1.m[i] + m2.m[i];
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
friend Dev operator+=(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
|
||||
Dev newM = {};
|
||||
|
||||
for (int i = 0; i < n * n; i++) {
|
||||
newM.m[i] = m1.m[i] + m2.m[i];
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
|
||||
friend Dev operator-(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
|
||||
Dev newM = {};
|
||||
|
||||
for (int i = 0; i < n * n; i++) {
|
||||
newM.m[i] = m1.m[i] - m2.m[i];
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
|
||||
friend std::ostream &operator<<(std::ostream &os, const mat<n, Dev> &m) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
os << "|" << m.m[i * n];
|
||||
for (int j = 1; j < n; j++) {
|
||||
os << ", " << m.m[i * n + j];
|
||||
}
|
||||
os << "|" << "\n";
|
||||
}
|
||||
return (os << std::endl);
|
||||
}
|
||||
|
||||
template <class Dev1>
|
||||
friend Dev1 operator*(const mat<n, Dev> &mat, const vec<n, Dev1> &v) {
|
||||
Dev1 newV = vec<n, Dev1>::zero();
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
newV[i] += mat.m[i * n + j] * v.v[j];
|
||||
}
|
||||
}
|
||||
return newV;
|
||||
}
|
||||
|
||||
decimal &operator[](const int &i) { return m[i]; }
|
||||
|
||||
friend Dev operator*(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
|
||||
Dev newM = mat<n, Dev>::zero();
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
for (int k = 0; k < n; k++) {
|
||||
newM[i * n + j] += m1.m[i * n + k] * m2.m[k * n + j];
|
||||
}
|
||||
}
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
|
||||
constexpr static Dev identity() {
|
||||
Dev newM = {};
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (i == j)
|
||||
newM.m[i * n + i] = decimal(1.0f);
|
||||
else
|
||||
newM.m[i * n + j] = decimal(0.0f);
|
||||
}
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
constexpr static Dev zero() {
|
||||
Dev newM = {};
|
||||
for (int i = 0; i < n * n; i++) {
|
||||
newM[i] = decimal(0);
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
|
||||
inline void set(int x, int y, decimal v) { m[y * n + x] = v; }
|
||||
inline decimal get(int x, int y) { return m[y * n + x]; }
|
||||
|
||||
friend bool operator==(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
|
||||
bool res = true;
|
||||
for (int i = 0; i < n * n; i++) {
|
||||
res &= m1.m[i] == m2.m[i];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
bool isSmall() {
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (!m[i].isSmall())
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class Dev1> Dev1 cutTo() const {
|
||||
static_assert(Dev1::size < n, "Can only convert to smaller matrix");
|
||||
Dev1 newM = mat<Dev1::size, Dev1>::zero();
|
||||
for (int i = 0; i < Dev1::size; i++) {
|
||||
for (int j = 0; j < Dev1::size; j++) {
|
||||
newM.m[Dev1::size * i + j] = m[n * i + j];
|
||||
}
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
};
|
||||
|
||||
template <int n> struct matN : public mat<n, matN<n>> {};
|
||||
|
||||
struct mat3 : public mat<3, mat3> {};
|
||||
|
||||
struct mat4 : public mat<4, mat4> {
|
||||
static mat4 translation(const vec3 &v) {
|
||||
mat4 newM = mat4::identity();
|
||||
for (int i = 0; i < 3; i++) {
|
||||
newM[4 * i + 3] = v.v[i];
|
||||
}
|
||||
return newM;
|
||||
}
|
||||
static mat4 rotateOnX(float a) {
|
||||
mat4 newM = mat4::identity();
|
||||
newM.m[1 * 4 + 1] = cos(a), newM.m[2 * 4 + 2] = cos(a);
|
||||
newM.m[1 * 4 + 2] = -sin(a), newM.m[2 * 4 + 1] = sin(a);
|
||||
return newM;
|
||||
}
|
||||
static mat4 rotateOnY(float a) {
|
||||
mat4 newM = mat4::identity();
|
||||
newM.m[0 * 4 + 0] = cos(a), newM.m[2 * 4 + 2] = cos(a);
|
||||
newM.m[0 * 4 + 2] = sin(a), newM.m[2 * 4 + 0] = -sin(a);
|
||||
return newM;
|
||||
}
|
||||
static mat4 rotateOnZ(float a) {
|
||||
mat4 newM = mat4::identity();
|
||||
newM.m[0 * 4 + 0] = cos(a), newM.m[1 * 4 + 1] = cos(a);
|
||||
newM.m[1 * 4 + 0] = sin(a), newM.m[0 * 4 + 1] = -sin(a);
|
||||
return newM;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
156
main.cpp
156
main.cpp
@@ -1,156 +0,0 @@
|
||||
#include "fastmath.hpp"
|
||||
#include "polygon.hpp"
|
||||
#include "renderer.hpp"
|
||||
#include "rendertarget.hpp"
|
||||
#include "testModel.hpp"
|
||||
#include <QApplication>
|
||||
#include <QImage>
|
||||
#include <QLabel>
|
||||
#include <QObject>
|
||||
#include <QPixmap>
|
||||
#include <QTimer>
|
||||
#include <chrono>
|
||||
#include <functional>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#define HIGHT 64
|
||||
#define WIDTH 64
|
||||
|
||||
#define FAA_FAC 2
|
||||
#define RHIGHT ((int)(HIGHT * FAA_FAC))
|
||||
#define RWIDTH ((int)(WIDTH * FAA_FAC))
|
||||
|
||||
char *drawToString(unsigned short *img) {
|
||||
char *textImg = (char *)malloc(200000 * sizeof(char));
|
||||
// strcat(textImg,"\e[1;1H\e[2J"); --clear
|
||||
for (int y = 0; y < HIGHT; y++) {
|
||||
for (int x = 0; x < WIDTH; x++) {
|
||||
// printf("%d,%d\n",x,y);
|
||||
char buff[20];
|
||||
unsigned short val = 0;
|
||||
int my = y * FAA_FAC;
|
||||
int mx = x * FAA_FAC;
|
||||
val += img[my * RWIDTH + mx];
|
||||
val += img[my * RWIDTH + mx + 1];
|
||||
val += img[(my + 1) * RWIDTH + mx];
|
||||
val += img[(my + 1) * RWIDTH + mx + 1];
|
||||
sprintf(buff, "\033[38;5;%dm██\033[0m", 232 + val / 4);
|
||||
strcat(textImg, buff);
|
||||
}
|
||||
strcat(textImg, "\n");
|
||||
}
|
||||
return textImg;
|
||||
}
|
||||
|
||||
void drawImage(unsigned short *img) {
|
||||
decimal heightPerPix = decimal(1.0) / decimal((float)(HIGHT * FAA_FAC));
|
||||
decimal widthPerPix = decimal(1.0) / decimal((float)(WIDTH * FAA_FAC));
|
||||
|
||||
polygon poly = polygon(vec3(0.9, 0.9, 0.0) * decimal(128.0),
|
||||
vec3(0.5, 0.1, 0.0) * decimal(128.0),
|
||||
vec3(0.1, 0.9, 0.0) * decimal(128.0));
|
||||
|
||||
// printf("\n hpp: %f, wpp: %f
|
||||
// \n",TO_FLOAT(heightPerPix),TO_FLOAT(widthPerPix)); calcViewPos(t);
|
||||
for (decimal y = 0; y < decimal((float)(RHIGHT)); y += decimal(1.0)) {
|
||||
for (decimal x = 0; x < decimal((float)(RWIDTH)); x += decimal(1.0)) {
|
||||
|
||||
vec3 p = vec3(x, y, 0.0);
|
||||
|
||||
if (poly.contains(p)) {
|
||||
|
||||
img[(y.i >> SHIFT_AMOUNT) * RWIDTH + (x.i >> SHIFT_AMOUNT)] =
|
||||
(unsigned short)23; // (((-normal[1]+(1 <<
|
||||
// SHIFT_AMOUNT))*14)>>SHIFT_AMOUNT);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("done writing %d \n", *(img + sizeof(unsigned short) * 32 * 32));
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
Rendertarget target(128, 128);
|
||||
Renderer renderer;
|
||||
renderer.target = ⌖
|
||||
|
||||
polygon poly =
|
||||
polygon(vec3(0.9, 0.9, 1.0), vec3(0.5, 0.1, 1.0), vec3(0.1, 0.9, 1.0));
|
||||
|
||||
std::chrono::steady_clock::time_point begin =
|
||||
std::chrono::steady_clock::now();
|
||||
renderer.render(&testModel, mat4::translation(vec3(0.0f, -1.0f, 5.0f)) *
|
||||
mat4::rotateOnY(-1.5707963267948966f));
|
||||
std::chrono::steady_clock::time_point end =
|
||||
std::chrono::steady_clock::now();
|
||||
|
||||
std::cout << "Time difference = "
|
||||
<< std::chrono::duration_cast<std::chrono::milliseconds>(end -
|
||||
begin)
|
||||
.count()
|
||||
<< "[ms]" << std::endl;
|
||||
|
||||
uint8_t *pixel = new uint8_t[64 * 64 * 3];
|
||||
/*for (int i = 0; i < 64 * 64 * 3; i++) {
|
||||
pixel[i] = target.pixels[i].i >> SHIFT_AMOUNT;
|
||||
}*/
|
||||
std::function<void(int, uint32_t *)> addTo = [&target](int start,
|
||||
uint32_t *arr) {
|
||||
for (int c = 0; c < 3; c++) {
|
||||
arr[c] += target.pixels[start + c];
|
||||
}
|
||||
};
|
||||
|
||||
QApplication a(argc, argv);
|
||||
QWidget widget;
|
||||
widget.setAutoFillBackground(true);
|
||||
widget.setGeometry(0, 0, 500, 500);
|
||||
QLabel display(&widget);
|
||||
QImage img((unsigned char *)pixel, 64, 64, QImage::Format_RGB888);
|
||||
|
||||
// display.setPixmap(QPixmap::fromImage(img).scaled(widget.size()));
|
||||
|
||||
float rot = 0.f;
|
||||
std::function<void()> renderLoop = [&addTo, &target, &pixel, &renderer,
|
||||
&display, &widget, &img, &rot]() {
|
||||
std::chrono::steady_clock::time_point begin =
|
||||
std::chrono::steady_clock::now();
|
||||
renderer.render(&testModel, mat4::translation(vec3(0.0f, -1.0f, 5.0f)) *
|
||||
mat4::rotateOnY(rot));
|
||||
std::chrono::steady_clock::time_point end =
|
||||
std::chrono::steady_clock::now();
|
||||
|
||||
std::cout << "Time difference = "
|
||||
<< std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||
end - begin)
|
||||
.count()
|
||||
<< "[ms]" << std::endl;
|
||||
|
||||
for (int x = 0; x < 64; x++) {
|
||||
for (int y = 0; y < 64; y++) {
|
||||
uint32_t result[3] = {};
|
||||
addTo((target.width * y * 2 + x * 2) * 3, result);
|
||||
addTo((target.width * (y * 2 + 1) + x * 2) * 3, result);
|
||||
addTo((target.width * y * 2 + (x * 2 + 1)) * 3, result);
|
||||
addTo((target.width * (y * 2 + 1) + (x * 2 + 1)) * 3, result);
|
||||
for (int c = 0; c < 3; c++) {
|
||||
pixel[(WIDTH * (WIDTH - y - 1) + WIDTH - x - 1) * 3 + c] =
|
||||
result[c] >> 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
// QImage img((unsigned char *)pixel, 64, 64, QImage::Format_RGB888);
|
||||
display.setPixmap(QPixmap::fromImage(img).scaled(widget.size() * 1));
|
||||
rot += 0.1f;
|
||||
};
|
||||
renderLoop();
|
||||
widget.show();
|
||||
QTimer timer;
|
||||
timer.setInterval(20);
|
||||
timer.start();
|
||||
QObject::connect(&timer, &QTimer::timeout, &widget, renderLoop);
|
||||
return a.exec();
|
||||
}
|
||||
16
model.hpp
16
model.hpp
@@ -1,16 +0,0 @@
|
||||
|
||||
#ifndef MODEL_H
|
||||
#define MODEL_H
|
||||
|
||||
#include "fastmath.hpp"
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
struct model {
|
||||
std::vector<vec3> verts;
|
||||
// At 0 vertecie index, at 1 normal index
|
||||
std::vector<std::tuple<uint16_t, uint16_t>> faces;
|
||||
std::vector<vec3> normals;
|
||||
std::vector<vec3> colors;
|
||||
};
|
||||
|
||||
#endif
|
||||
134
polygon.hpp
134
polygon.hpp
@@ -1,134 +0,0 @@
|
||||
#ifndef POLYGON_H
|
||||
#define POLYGON_H
|
||||
|
||||
#include "fastmath.hpp"
|
||||
#include <iostream>
|
||||
struct polygon {
|
||||
|
||||
vec3 points[3];
|
||||
decimal delta[9];
|
||||
bool small = false;
|
||||
decimal baryFactor;
|
||||
|
||||
decimal bounding[4]; // min x, max x, min y, max y
|
||||
vec3 normals[3];
|
||||
vec3 colors[3];
|
||||
vec3 barycentrics;
|
||||
vec3 boundingBarycentrics;
|
||||
|
||||
polygon(const vec3 &v1, const vec3 &v2, const vec3 &v3)
|
||||
: points{v1, v2, v3}, delta{} {}
|
||||
polygon() : points{}, delta{} {}
|
||||
|
||||
void calcDelta() {
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
int n = (i + 1) % 3;
|
||||
|
||||
delta[i * 3] = points[i].y() - points[n].y();
|
||||
delta[i * 3 + 1] = points[n].x() - points[i].x();
|
||||
delta[i * 3 + 2] =
|
||||
points[i].x() * points[n].y() - points[i].y() * points[n].x();
|
||||
if (delta[i * 3].i == 0 && delta[i * 3 + 1].i == 0)
|
||||
small = true;
|
||||
}
|
||||
bounding[0] = points[0].x();
|
||||
bounding[1] = points[0].x();
|
||||
bounding[2] = points[0].y();
|
||||
bounding[3] = points[0].y();
|
||||
for (int i = 1; i < 3; i++) {
|
||||
if (bounding[0] > points[i].x())
|
||||
bounding[0] = points[i].x();
|
||||
if (bounding[1] < points[i].x())
|
||||
bounding[1] = points[i].x();
|
||||
if (bounding[2] > points[i].y())
|
||||
bounding[2] = points[i].y();
|
||||
if (bounding[3] < points[i].y())
|
||||
bounding[3] = points[i].y();
|
||||
}
|
||||
|
||||
baryFactor =
|
||||
(points[1].x() - points[0].x()) * (points[2].y() - points[1].y()) -
|
||||
(points[1].y() - points[0].y()) * (points[2].x() - points[1].x());
|
||||
|
||||
if (baryFactor.isSmall()) {
|
||||
small = true;
|
||||
} else
|
||||
baryFactor = decimal(1.0) / baryFactor;
|
||||
// std::cout << baryFactor << std::endl;
|
||||
/*if ((bounding[1].i - bounding[0].i < 1 << HALF_SHIFT) &&
|
||||
(bounding[3].i - bounding[2].i < 1 << HALF_SHIFT))
|
||||
small = true;*/
|
||||
}
|
||||
|
||||
vec3 avgNormal() {
|
||||
vec3 result;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
result += normals[i];
|
||||
}
|
||||
return result * decimal(0.3333);
|
||||
}
|
||||
|
||||
const bool depContains(const vec3 &p) {
|
||||
// if (skip)
|
||||
// return false;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
if (small)
|
||||
return true;
|
||||
vec3 d = p;
|
||||
if ((d.x() * delta[i * 3] + d.y() * delta[i * 3 + 1] +
|
||||
delta[i * 3 + 2]) > decimal(0.2))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
const bool contains(const vec3 &p) {
|
||||
if (small)
|
||||
return true;
|
||||
else
|
||||
return (barycentrics[0] >= decimal(-0.01)) &&
|
||||
(barycentrics[1] >= decimal(-0.01)) &&
|
||||
(barycentrics[2] >= decimal(-0.01));
|
||||
}
|
||||
friend std::ostream &operator<<(std::ostream &os, const polygon &p) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
os << p.points[i];
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
vec3 calcNormal() {
|
||||
return normals[0] * boundingBarycentrics[0] +
|
||||
normals[1] * boundingBarycentrics[1] +
|
||||
normals[2] * boundingBarycentrics[2];
|
||||
}
|
||||
|
||||
vec3 calcColor() {
|
||||
return colors[0] * boundingBarycentrics[0] +
|
||||
colors[1] * boundingBarycentrics[1] +
|
||||
colors[2] * boundingBarycentrics[2];
|
||||
}
|
||||
|
||||
decimal calcDepth() {
|
||||
return points[0].z() * boundingBarycentrics[0] +
|
||||
points[1].z() * boundingBarycentrics[1] +
|
||||
points[2].z() * boundingBarycentrics[2];
|
||||
}
|
||||
|
||||
void calcBarycentric(vec3 s) {
|
||||
// if (small)
|
||||
// return vec3(decimal(0.333), decimal(0.333), decimal(0.333));
|
||||
|
||||
barycentrics[0] = (points[1].x() - s.x()) * (points[2].y() - s.y()) -
|
||||
(points[2].x() - s.x()) * (points[1].y() - s.y());
|
||||
barycentrics[1] = (points[2].x() - s.x()) * (points[0].y() - s.y()) -
|
||||
(points[0].x() - s.x()) * (points[2].y() - s.y());
|
||||
barycentrics = barycentrics * baryFactor;
|
||||
barycentrics[2] = decimal(1.0) - barycentrics[1] - barycentrics[0];
|
||||
// return result;
|
||||
boundingBarycentrics = vec3::max(
|
||||
vec3::min(barycentrics, vec3(1.0, 1.0, 1.0)), vec3(0.0, 0.0, 0.0));
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
136
renderer.hpp
136
renderer.hpp
@@ -1,136 +0,0 @@
|
||||
|
||||
#ifndef RENDERER_H
|
||||
#define RENDERER_H
|
||||
|
||||
#include "fastmath.hpp"
|
||||
#include "model.hpp"
|
||||
#include "polygon.hpp"
|
||||
#include "rendertarget.hpp"
|
||||
#include <bits/stdc++.h>
|
||||
#include <cstring>
|
||||
#include <memory.h>
|
||||
|
||||
#define SCREEN_SPACE_SIZE 8.0
|
||||
|
||||
class Renderer {
|
||||
|
||||
public:
|
||||
Rendertarget *target;
|
||||
|
||||
bool clearTarget = true;
|
||||
vec3 sunDir = vec3(1.0, -1.0, 1.0).normalize();
|
||||
|
||||
void toScreenSpace(vec3 *np, mat4 matrix) {
|
||||
vec4 tp = (matrix * vec4(*np, decimal(1.0f)));
|
||||
tp.x() = tp.x() / tp.z() * decimal(2.0) * decimal(SCREEN_SPACE_SIZE) +
|
||||
decimal(SCREEN_SPACE_SIZE);
|
||||
tp.y() = tp.y() / tp.z() * decimal(2.0) * decimal(SCREEN_SPACE_SIZE) +
|
||||
decimal(SCREEN_SPACE_SIZE);
|
||||
*np = vec3(tp.x(), tp.y(), tp.z());
|
||||
}
|
||||
|
||||
void render(const model *model, const mat4 matrix) {
|
||||
decimal widthScale =
|
||||
decimal(SCREEN_SPACE_SIZE * 2) / decimal((float)target->width);
|
||||
decimal heightScale =
|
||||
decimal(SCREEN_SPACE_SIZE * 2) / decimal((float)target->height);
|
||||
|
||||
decimal invWidthScale =
|
||||
decimal((float)(target->width / SCREEN_SPACE_SIZE / 2));
|
||||
decimal invHeightScale =
|
||||
decimal((float)(target->height / SCREEN_SPACE_SIZE / 2));
|
||||
|
||||
// TODO clear target with memset
|
||||
if (clearTarget) {
|
||||
// memset((wchar_t *)target->pixels, 0,
|
||||
// target->height * target->width * sizeof(target[0]));
|
||||
target->clearDepth();
|
||||
target->clearTarget();
|
||||
}
|
||||
|
||||
vec3 verts[model->verts.size()] = {};
|
||||
|
||||
std::copy(model->verts.begin(), model->verts.end(), verts);
|
||||
|
||||
for (int i = 0; i < model->verts.size(); i++) {
|
||||
toScreenSpace(verts + i, matrix);
|
||||
}
|
||||
|
||||
vec3 normals[model->normals.size()] = {};
|
||||
mat3 normalMatrix = matrix.cutTo<mat3>();
|
||||
for (int i = 0; i < model->normals.size(); i++) {
|
||||
normals[i] = normalMatrix * model->normals[i];
|
||||
}
|
||||
|
||||
polygon testP;
|
||||
|
||||
for (int f = 0; f < model->faces.size(); f += 3) {
|
||||
testP.small = false;
|
||||
for (int p = 0; p < 3; p++) {
|
||||
testP.points[p] = verts[std::get<0>(model->faces[f + p])];
|
||||
testP.colors[p] =
|
||||
model->colors[std::get<0>(model->faces[f + p])];
|
||||
testP.normals[p] = normals[std::get<1>(model->faces[f + p])];
|
||||
}
|
||||
if ((testP.avgNormal() * vec3(0.0, 0.0, 1.0)) > decimal(0.))
|
||||
continue;
|
||||
|
||||
testP.calcDelta();
|
||||
|
||||
int startX = std::max<int>(
|
||||
(testP.bounding[0] * invWidthScale).i >> SHIFT_AMOUNT, 0);
|
||||
int endX = std::min<int>((testP.bounding[1] * invWidthScale).i >>
|
||||
SHIFT_AMOUNT,
|
||||
(uint32_t)target->width - 1);
|
||||
int startY = std::max<int>(
|
||||
(testP.bounding[2] * invHeightScale).i >> SHIFT_AMOUNT, 0);
|
||||
int endY = std::min<int>((testP.bounding[3] * invHeightScale).i >>
|
||||
SHIFT_AMOUNT,
|
||||
target->height - 1);
|
||||
|
||||
vec3 pos = vec3(testP.bounding[0], testP.bounding[2], 0.0);
|
||||
for (int x = startX; x < endX; x++) {
|
||||
for (int y = startY; y < endY; y++) {
|
||||
|
||||
if (testP.depContains(pos)) {
|
||||
|
||||
testP.calcBarycentric(pos);
|
||||
decimal depth = testP.calcDepth();
|
||||
if (depth < target->getDepth(x, y)) {
|
||||
// std::cout << factors << std::endl;
|
||||
vec3 normal = testP.calcNormal();
|
||||
vec3 color = testP.calcColor();
|
||||
decimal lightFac =
|
||||
std::max(normal * (-sunDir), decimal(0.0)) +
|
||||
decimal(0.5);
|
||||
;
|
||||
target->setDepth(x, y, depth);
|
||||
target->set(x, y,
|
||||
(color * decimal(120.0)) * lightFac);
|
||||
|
||||
// target->set(x, y,
|
||||
// vec3(lightFac * decimal(200.0), 0, 0));
|
||||
// target->set(x, y,
|
||||
// (normal + vec3(1.0, 1.0, 1.0)) *
|
||||
// decimal(120.0));
|
||||
// target->set(
|
||||
// x, y,
|
||||
// (testP.avgNormal() + vec3(1.0, 1.0, 1.0)) *
|
||||
// decimal(120.0));
|
||||
// target->set(x, y,
|
||||
// testP.barycentrics * decimal(200.0));
|
||||
// if (!factors.isSmall())
|
||||
// target->set(x, y, vec3(0., 255.0, 0.));
|
||||
}
|
||||
// target->set(x, y, vec3(0.0, 255.0, 0.0));
|
||||
}
|
||||
pos.y() += heightScale;
|
||||
}
|
||||
pos.y() = decimal(testP.bounding[2]);
|
||||
pos.x() += widthScale;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,45 +0,0 @@
|
||||
|
||||
#ifndef RENDERTARGET_H
|
||||
#define RENDERTARGET_H
|
||||
|
||||
#include "fastmath.hpp"
|
||||
class Rendertarget {
|
||||
|
||||
public:
|
||||
const int width;
|
||||
const int height;
|
||||
|
||||
Rendertarget(int width, int height) : width(width), height(height) {
|
||||
pixels = new uint8_t[width * height * 3];
|
||||
depth = new decimal[width * height];
|
||||
for (int i = 0; i < width * height * 3; i++) {
|
||||
pixels[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void set(int x, int y, vec3 val) {
|
||||
int start = (width * y + x) * 3;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
pixels[start + i] = (uint8_t)(val[i].i >> SHIFT_AMOUNT);
|
||||
}
|
||||
}
|
||||
|
||||
decimal getDepth(int x, int y) { return depth[width * y + x]; }
|
||||
void setDepth(int x, int y, decimal val) { depth[width * y + x] = val; }
|
||||
|
||||
void clearDepth() {
|
||||
for (int i = 0; i < width * height; i++) {
|
||||
depth[i].i = std::numeric_limits<int32_t>::max();
|
||||
}
|
||||
}
|
||||
void clearTarget() {
|
||||
for (int i = 0; i < width * height * 3; i++) {
|
||||
pixels[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t *pixels;
|
||||
decimal *depth;
|
||||
};
|
||||
|
||||
#endif
|
||||
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user