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
|
/******************************************************************/
/* This file is part of the homework assignments for CSCI-427/527 */
/* at The College of William & Mary and authored by Pieter Peers. */
/* No part of this file, whether altered or in original form, can */
/* be distributed or used outside the context of CSCI-427/527 */
/* without consent of either the College of William & Mary or */
/* Pieter Peers. */
/******************************************************************/
#include <cassert>
#include "errorMessage.h"
#include "sceneIO_core.h"
#include "sceneIO_basis.h"
#include "sceneIO_cache.h"
#include "sceneIO_texture.h"
#include "sceneIO_transformation3d.h"
#include "raycasting.h"
#include "pathtracing.h"
#include "recursiveRaytracing.h"
#include "bvh_intersector.h"
#include "linear_intersector.h"
#include "environmentMap.h"
bool importCamera(const XMLNode& node, camera& cam)
{
// sanity check
assert(node.name() == "camera");
// import camera
cam = camera( getVec3d(node, "eye", vec3d(0.0f, 0.0f, 0.0f)),
getVec3d(node, "view", vec3d(0.0f, 0.0f, -1.0f)),
getVec3d(node, "up", vec3d(0.0f, 1.0f, 0.0f)),
getFloat(node, "fov", 60),
getInteger(node, "width", 256),
getInteger(node, "height", 256) );
// Done.
return( getString(node, "auto", "false") == "true");
}
void importRenderEngine(const XMLNode& node, std::unique_ptr<const render_base>& renderer)
{
// sanity check
assert(node.name() == "renderer");
// get render engine type
std::string type = getString(node, "type", "raycasting");
// create render type
if(type == "raycasting") renderer = std::unique_ptr<const render_base>( new raycasting() );
else if(type == "recursiveRaytracing") renderer = std::unique_ptr<const render_base>( new recursiveRaytracing( getInteger(node, "maxDepth", 1), getInteger(node, "samplesPerPixel", 1) ) );
else if(type == "pathtracing") renderer = std::unique_ptr<const render_base>( new pathtracing( getInteger(node, "samplesPerPixel", 1), getString(node, "directOnly", "false") == "true") );
else errorMessage("Unknown render engine type (%s)", type.c_str());
// Done.
}
void importIntersector(const XMLNode& node, std::unique_ptr<const intersector_factory_base>& intersector)
{
// sanity check
assert(node.name() == "intersector");
// get intersector type
std::string type = getString(node, "type", "linear");
// create intersector
if(type == "linear") intersector = std::unique_ptr<const intersector_factory_base>( new linear_intersector_factory());
else if(type == "bvh") intersector = std::unique_ptr<const intersector_factory_base>( new bvh_intersector_factory());
else errorMessage("Unknown intersector type (%s)", type.c_str());
// Done.
}
void importEnvironmentMap(const XMLNode& node, nodeCache<texture_base>& texture_cache, const std::string& rootDir, std::unique_ptr<const environmentMap>& map)
{
// sanity check
assert(node.name() == "environmentMap");
// node properties
transformation3d transform;
std::shared_ptr<const texture_base> texture;
// check child nodes
for(XMLNode child=node.firstChild(); child.isValid(); child++)
{
std::string name = child.name();
if(name == "transformation") importTransformation(child, transform);
else if(name == "texture") texture = importTexture(child, texture_cache, rootDir);
else errorMessage("Unknown node (%s) in environmentMap.", name.c_str());
}
// Done.
map = std::unique_ptr<const environmentMap>(new environmentMap(texture, transform));
}
|
