blob: 4c9dbff7e164254f9b940f49f3c7e256d632b1fb (
plain)
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
124
125
126
127
128
129
130
131
132
133
|
/*************************************************************************
* Copyright (C) 2009 Tavian Barnes <tavianator@gmail.com> *
* *
* This file is part of The Dimension Library. *
* *
* The Dimension Library is free software; you can redistribute it and/ *
* or modify it under the terms of the GNU Lesser General Public License *
* as published by the Free Software Foundation; either version 3 of the *
* License, or (at your option) any later version. *
* *
* The Dimension Library is distributed in the hope that it will be *
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty *
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this program. If not, see *
* <http://www.gnu.org/licenses/>. *
*************************************************************************/
// dmnsn_object* wrapper.
#ifndef DIMENSIONXX_OBJECT_HPP
#define DIMENSIONXX_OBJECT_HPP
namespace Dimension
{
// Type to represent a ray-object intersection
class Intersection
{
public:
Intersection(const Line& ray, double t, const Texture& texture);
explicit Intersection(dmnsn_intersection *intersection);
// Intersection(const Intersection& intersection);
~Intersection();
Line& ray() { return m_ray; }
const Line& ray() const { return m_ray; }
double t() const { return dmnsn()->t; }
void t(double t) { dmnsn()->t = t; }
const Texture& texture() const { return m_texture; }
dmnsn_intersection* dmnsn();
const dmnsn_intersection* dmnsn() const;
dmnsn_intersection* release();
private:
// Copy-assignment prohibited
Intersection& operator=(const Intersection& intersection);
std::tr1::shared_ptr<dmnsn_intersection*> m_intersection;
Line m_ray;
const Texture m_texture;
};
// Base object class. Wraps a dmnsn_object*.
class Object
{
public:
// Wrap an existing object.
explicit Object(dmnsn_object* object);
// Delete the object
virtual ~Object();
// Get/set the transformation matrix
Matrix trans();
void trans(const Matrix& trans);
// Object callbacks
virtual Intersection intersection(const Line& l);
virtual bool inside(const Vector& point);
// Shallow-copy a derived object
virtual Object* copy() const;
// Access the wrapped C object
dmnsn_object* dmnsn();
const dmnsn_object* dmnsn() const;
protected:
// No-op
Object();
// Shallow copy
Object(const Object& object);
// Is m_object unique?
bool unique() const;
// Set the wrapped object
void dmnsn(dmnsn_object* object);
private:
// Copy-assignment prohibited
Object& operator=(const Object&);
std::tr1::shared_ptr<dmnsn_object*> m_object;
};
// A custom object abstract base class, for creating your own object types
class Custom_Object : public Object
{
public:
Custom_Object();
virtual ~Custom_Object();
virtual Intersection intersection(const Line& l) = 0;
virtual bool inside(const Vector& point) = 0;
};
// Array_Element specialization
template <>
class Array_Element<Object>
: public Polymorphic_Array_Element<Object, dmnsn_object*>
{
public:
typedef dmnsn_object* C_Type;
Array_Element() { }
Array_Element(Object& object)
: Polymorphic_Array_Element<Object, dmnsn_object*>(object) { }
Array_Element(C_Type c)
: Polymorphic_Array_Element<Object, dmnsn_object*>(c) { }
// Array_Element(const Array_Element& ae);
// ~Array_Element();
// Array_Element& operator=(const Array_Element& ae);
};
}
#endif /* DIMENSIONXX_OBJECT_HPP */
|
