#include "svpng.inc"

#include <math.h> // fabsf(), fminf(), fmaxf(), sinf(), cosf(), sqrt()

#include <stdlib.h> // rand(), RAND_MAX

#include <initializer_list>

#include <vector>

#include <iostream>

#include "Shape.h"

using namespace std;

using std::vector;

#define SAFE_DELETE(p) do {delete (p); (p) = NULL;} while (false)

#define TWO_PI 6.28318530718f

#define W 512

#define H 512

#define N 256

#define BIAS 1e-4f

#define MAX_DEPTH 3

#define IS_DEBUG false

unsigned char img[W * H * 3];

void drawLine(int x0, int y0, int x1, int y1) {

int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;

int dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;

int err = (dx > dy ? dx : -dy) / 2;

while (*(img + (y0 * W + x0) * 3) = 255, x0 != x1 || y0 != y1) {

int e2 = err;

if (e2 > -dx) { err -= dy; x0 += sx; }

if (e2 < dy) { err += dx; y0 += sy; }

}

}

class Entity

{

private:

Shape* m_shape;

Color m_emissive;

float m_reflectivity;

public:

Entity(Shape* s, Color e, float r = 0.0) :m_shape(s), m_emissive(e), m_reflectivity(r) {}

Shape* GetShape() { return m_shape; }

Color GetEmissive() { return m_emissive; }

float GetReflectivity() { return m_reflectivity; }

};

class Scene

{

protected:

vector<Entity*> m_entities;

public:

Scene(vector<Entity*> entities) :m_entities(entities) {}

vector<Entity*> GetEntities() { return m_entities; }

Color Reflect(Entity* ent, Point inter, Vector d, int depth)

{

if (depth > MAX_DEPTH || ent->GetReflectivity() == 0.f) return{ 0.f, 0.f,0.f };

Vector normal = ent->GetShape()->GetNormal(inter);

if (normal * d > 0.f) return{ 0.f, 0.f,0.f };

Vector reflect = d.reflect(normal);

return GetColor(inter + reflect * BIAS, reflect, depth);

}

Color GetColor(Point p, Vector d, int depth = 0) //获取p点从d方向收到的emissive

{

Color trace_emissive{ 0.0f, 0.0f, 0.0f };

float distance = 10.0f;

int ent_index = -1;

Point inter;

for (int j = 0; j < m_entities.size(); j++)

{

Point tmp_inter;

if (m_entities[j]->GetShape()->Intersect(p, d, tmp_inter))

{

float new_dist = (tmp_inter - p).len();

if (distance > new_dist)

{

ent_index = j;

distance = new_dist;

inter = tmp_inter;

}

}

}

if (ent_index >= 0)

{

if (IS_DEBUG)

drawLine(p.x * 512, p.y * 512, inter.x * 512, inter.y * 512);

Color reflect = Reflect(m_entities[ent_index], inter, d, depth + 1);

return m_entities[ent_index]->GetEmissive() + reflect * m_entities[ent_index]->GetReflectivity();

}

else

return{ 0.0f, 0.0f, 0.0f };

}

Color sample(Point p)

{

Color sum{ 0.0f, 0.0f, 0.0f };

for (int i = 0; i < N; i++)

{

float a = TWO_PI * (i + (float)rand() / RAND_MAX) / N;

sum = sum + GetColor(p, { cosf(a), sinf(a) });

}

return sum / N;

}

};

Shape* GeneratePolygon(std::initializer_list<Point> points)

{

Point sum = { 0.f, 0.f };

for (auto p : points)

{

sum.x += p.x;

sum.y += p.y;

}

Point center = { sum.x / points.size(), sum.y / points.size() };

Shape* si = NULL;

for (auto i = points.begin(); i + 1 != points.end(); i++)

{

Point p1 = *i;

Point p2 = *(i + 1);

Line* l = new Line(p1, p2, center);

if (si)

si = new ShapeIntersect(si, l);

else

si = l;

}

si = new ShapeIntersect(si, new Line(*(points.begin()), *(points.end() - 1), center));

return si;

}

Scene* GenerateScene2()

{

Circle* c1 = new Circle({ 0.5f, 0.6f }, 0.1f);

Circle* c2 = new Circle({ 0.5f, 0.7f }, 0.12f);

Shape* su1 = new ShapeUnion(c1, c2); //两个圆的并

Shape* triangle = GeneratePolygon({ { 0.9f,0.5f },{ 0.7f, 0.5f },{ 0.8f, 0.4f } });

Shape* quad1 = GeneratePolygon({ { 0.3f, 0.4f },{ 0.4f, 0.4f },{ 0.4f, 0.3f },{ 0.3f, 0.3f } });

Shape* quad2 = GeneratePolygon({ { 0.2f, 0.5f },{ 0.3f, 0.5f },{ 0.3f, 0.6f },{ 0.2f, 0.6f } });

Entity* e1 = new Entity(su1, { 1.8f, 0.9f, 0.7f }, 0.0f); //葫芦形的黄光

Entity* e2 = new Entity(triangle, { 0.2f, 0.9f, 1.1f }); //三角形的蓝光

Entity* e3 = new Entity(quad1, { 0.05f, 0.05f, 0.2f }, 0.8f);

Entity* e4 = new Entity(quad2, { 0.05f, 0.05f, 0.2f }, 0.8f);

//Entity* e3 = new Entity(quad, { 0.05f, 0.05f, 0.2f }, 1.0f); //正方形的深蓝色

Shape* s = GeneratePolygon({ { 1.f, 2.f },{ 3.f, 4.f } });

return new Scene({ e1,e2, e3, e4 });

}

Scene* GenerateScene()

{

Circle* c1 = new Circle({ 0.5f, 0.3f }, 0.1f);

Line* l1 = new Line(0.0f, 1.0f, -0.7f);

Entity* e1 = new Entity(c1, { 1.8f, 0.9f, 0.7f }); //葫芦形的黄光

Entity* e2 = new Entity(l1, { 0.0f, 0.0f, 0.0f }, 0.8f); //三角形的蓝光

return new Scene({ e1,e2 });

}

int main() {

Scene* s = GenerateScene2();

unsigned char* p = img;

if (!IS_DEBUG)

for (int y = 0; y < H; y++)

for (int x = 0; x < W; x++, p += 3)

{

Color color = s->sample({ (float)x / W, (float)y / H });

p[0] = (int)fminf(color.r *255.0f, 255.0f);

p[1] = (int)fminf(color.g *255.0f, 255.0f);

p[2] = (int)fminf(color.b *255.0f, 255.0f);

}

else

s->sample({ 0.41f, 0.35f }); //debug

svpng(fopen("reflect.png", "wb"), W, H, img, 0);

}