miro/Scene.cpp at master · zanton/miro · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include "Miro.h"
#include "Scene.h"
#include "Camera.h"
#include "Image.h"
#include "Console.h"

Scene * g_scene = 0;

void
Scene::openGL(Camera *cam)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	cam->drawGL();

	// draw objects
	for (size_t i = 0; i < m_objects.size(); ++i)
	{
		m_objects[i]->renderGL();
	}

	glutSwapBuffers();
}

void
Scene::preCalc()
{
	Objects::iterator it;
	for (it = m_objects.begin(); it != m_objects.end(); it++)
	{
		Object* pObject = *it;
		pObject->preCalc();
	}
	Lights::iterator lit;
	for (lit = m_lights.begin(); lit != m_lights.end(); lit++)
	{
		PointLight* pLight = *lit;
		pLight->preCalc();
	}

  g_profile.n_nodes = 0;
  g_profile.n_leaves = 0;
  g_profile.build_t = get_cur_time();
  g_profile.build_clock = get_cur_clock();
	m_accel.build(&m_objects);
  g_profile.build_clock = get_cur_clock() - g_profile.build_clock;
  g_profile.build_t = get_cur_time() - g_profile.build_t;
  printf("Build time: %lfs (%llu clocks)\n", g_profile.build_t, g_profile.build_clock);
  printf("n_nodes = %ld\n"
         "n_leaves = %ld\n",
         g_profile.n_nodes,
         g_profile.n_leaves);
}

void
Scene::raytraceImage(Camera *cam, Image *img)
{
	Ray ray;
	HitInfo hitInfo;
	Vector3 shadeResult;

  g_profile.n_rays = 0;
  g_profile.n_traversals = 0;
  g_profile.n_raytri_intersect = 0;
  g_profile.n_raytri_intersected = 0;

  g_profile.render_t = get_cur_time();
  g_profile.render_clock = get_cur_clock();
	// loop over all pixels in the image
	for (int j = 0; j < img->height(); ++j)
	{
		for (int i = 0; i < img->width(); ++i)
		{
      g_profile.n_rays++;
			ray = cam->eyeRay(i, j, img->width(), img->height());
			if (trace(hitInfo, ray))
			{
        //printf("0\n");
				shadeResult = hitInfo.material->shade(ray, hitInfo, *this);
        //printf("1\n");
				img->setPixel(i, j, shadeResult);
        //printf("2\n");
			}
		}
		img->drawScanline(j);
		glFinish();
		printf("Rendering Progress: %.3f%%\r", j/float(img->height())*100.0f);
		fflush(stdout);
	}
  g_profile.render_clock = get_cur_clock() - g_profile.render_clock;
  g_profile.render_t = get_cur_time() - g_profile.render_t;

	printf("Rendering Progress: 100.000%%\n");
	debug("done Raytracing!\n");

  printf("Render time: %lfs (%llu clocks)\n", g_profile.render_t, g_profile.render_clock);

  printf("n_rays = %ld\n"
         "n_traversals = %ld\n"
         "n_raytri_intersect = %ld\n"
         "n_raytri_intersected = %ld\n",
         g_profile.n_rays,
         g_profile.n_traversals,
         g_profile.n_raytri_intersect,
         g_profile.n_raytri_intersected);
  printf("%ld & %ld & %lfs (%llu clocks) & %ld & %ld & %ld & %lfs (%llu clocks)\n",
         g_profile.n_nodes,
         g_profile.n_leaves,
         g_profile.build_t, g_profile.build_clock,
         g_profile.n_rays,
         g_profile.n_traversals,
         g_profile.n_raytri_intersect,
         g_profile.render_t, g_profile.render_clock);
}

bool
Scene::trace(HitInfo& minHit, const Ray& ray, float tMin, float tMax) const
{
  //bool hit = m_accel.intersect_naive(minHit, ray, tMin, tMax);
  bool hit = m_accel.intersect(minHit, ray, tMin, tMax);
  //printf("returned from m_accel.intersect()\n");
	return hit;
}