Skip to content

Commit e3ebd0a

Browse files
betajippitybetajippity
committed
Added Embree 2.4 (OSX)
1 parent af1c597 commit e3ebd0a

27 files changed

+1789
-2
lines changed

‎README.md‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
Nuparu
22
======
33

4-
v0.1.14.45
4+
v0.1.15.01
55

66
Third Party dependencies and foundation libraries for Karl's graphics projects
77

@@ -21,6 +21,7 @@ Nuparu currently consists of:
2121
* [TBB](https://www.threadingbuildingblocks.org/) 4.3 Initial Release (OSX/Win)
2222
* [Zlib](http://www.zlib.net/) 1.2.8 (Win)
2323
* [Boost](www.boost.org) 1.55.0 (OSX/Linux/Win)
24+
* [Embree](https://embree.github.io) 2.4 (OSX)
2425

2526
Notes:
2627

@@ -30,7 +31,7 @@ Notes:
3031
* Nuparu does not contain the entirety of Boost; instead, only a subset of Boost required for OpenVDB is included. The components of Boost included are header-only.
3132
* OpenVDB has a slight modification in Coord.h for Windows support
3233
* RMSD has minor modifications for C++ support
33-
* All binary OSX libraries are built with OSX 10.9's default Clang (Apple LLVM 5.1). Both libc++ and libstd++ versions are provided.
34+
* All binary OSX libraries are built with OSX's Clang variant (Apple LLVM 5.1 or greater). Both libc++ and libstd++ versions are provided.
3435
* All binary Windows libraries are built using /MT with Visual Studio 2012
3536
* All binary libraries on all platforms are built for x86-64
3637
* Licenses for each library are included in each library's include/ directory

‎include/boost/random/uniform_real_distribution.hpp‎

Lines changed: 239 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,239 @@
1+
/* boost random/uniform_real_distribution.hpp header file
2+
*
3+
* Copyright Jens Maurer 2000-2001
4+
* Copyright Steven Watanabe 2011
5+
* Distributed under the Boost Software License, Version 1.0. (See
6+
* accompanying file LICENSE_1_0.txt or copy at
7+
* http://www.boost.org/LICENSE_1_0.txt)
8+
*
9+
* See http://www.boost.org for most recent version including documentation.
10+
*
11+
* $Id: uniform_real_distribution.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $
12+
*
13+
*/
14+
15+
#ifndef BOOST_RANDOM_UNIFORM_REAL_DISTRIBUTION_HPP
16+
#define BOOST_RANDOM_UNIFORM_REAL_DISTRIBUTION_HPP
17+
18+
#include <iosfwd>
19+
#include <ios>
20+
#include <istream>
21+
#include <boost/assert.hpp>
22+
#include <boost/config.hpp>
23+
#include <boost/random/detail/config.hpp>
24+
#include <boost/random/detail/operators.hpp>
25+
#include <boost/random/detail/signed_unsigned_tools.hpp>
26+
#include <boost/type_traits/is_integral.hpp>
27+
28+
namespace boost {
29+
namespace random {
30+
namespace detail {
31+
32+
template<class Engine, class T>
33+
T generate_uniform_real(
34+
Engine& eng, T min_value, T max_value,
35+
boost::mpl::false_ /** is_integral<Engine::result_type> */)
36+
{
37+
for(;;) {
38+
typedef T result_type;
39+
typedef typename Engine::result_type base_result;
40+
result_type numerator = static_cast<T>(eng() - (eng.min)());
41+
result_type divisor = static_cast<T>((eng.max)() - (eng.min)());
42+
BOOST_ASSERT(divisor > 0);
43+
BOOST_ASSERT(numerator >= 0 && numerator <= divisor);
44+
T result = numerator / divisor * (max_value - min_value) + min_value;
45+
if(result < max_value) return result;
46+
}
47+
}
48+
49+
template<class Engine, class T>
50+
T generate_uniform_real(
51+
Engine& eng, T min_value, T max_value,
52+
boost::mpl::true_ /** is_integral<Engine::result_type> */)
53+
{
54+
for(;;) {
55+
typedef T result_type;
56+
typedef typename Engine::result_type base_result;
57+
result_type numerator = static_cast<T>(subtract<base_result>()(eng(), (eng.min)()));
58+
result_type divisor = static_cast<T>(subtract<base_result>()((eng.max)(), (eng.min)())) + 1;
59+
BOOST_ASSERT(divisor > 0);
60+
BOOST_ASSERT(numerator >= 0 && numerator <= divisor);
61+
T result = numerator / divisor * (max_value - min_value) + min_value;
62+
if(result < max_value) return result;
63+
}
64+
}
65+
66+
template<class Engine, class T>
67+
inline T generate_uniform_real(Engine& eng, T min_value, T max_value)
68+
{
69+
typedef typename Engine::result_type base_result;
70+
return generate_uniform_real(eng, min_value, max_value,
71+
boost::is_integral<base_result>());
72+
}
73+
74+
}
75+
76+
/**
77+
* The class template uniform_real_distribution models a \random_distribution.
78+
* On each invocation, it returns a random floating-point value uniformly
79+
* distributed in the range [min..max).
80+
*/
81+
template<class RealType = double>
82+
class uniform_real_distribution
83+
{
84+
public:
85+
typedef RealType input_type;
86+
typedef RealType result_type;
87+
88+
class param_type
89+
{
90+
public:
91+
92+
typedef uniform_real_distribution distribution_type;
93+
94+
/**
95+
* Constructs the parameters of a uniform_real_distribution.
96+
*
97+
* Requires min <= max
98+
*/
99+
explicit param_type(RealType min_arg = RealType(0.0),
100+
RealType max_arg = RealType(1.0))
101+
: _min(min_arg), _max(max_arg)
102+
{
103+
BOOST_ASSERT(_min <= _max);
104+
}
105+
106+
/** Returns the minimum value of the distribution. */
107+
RealType a() const { return _min; }
108+
/** Returns the maximum value of the distribution. */
109+
RealType b() const { return _max; }
110+
111+
/** Writes the parameters to a @c std::ostream. */
112+
BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
113+
{
114+
os << parm._min << " " << parm._max;
115+
return os;
116+
}
117+
118+
/** Reads the parameters from a @c std::istream. */
119+
BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
120+
{
121+
RealType min_in, max_in;
122+
if(is >> min_in >> std::ws >> max_in) {
123+
if(min_in <= max_in) {
124+
parm._min = min_in;
125+
parm._max = max_in;
126+
} else {
127+
is.setstate(std::ios_base::failbit);
128+
}
129+
}
130+
return is;
131+
}
132+
133+
/** Returns true if the two sets of parameters are equal. */
134+
BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
135+
{ return lhs._min == rhs._min && lhs._max == rhs._max; }
136+
137+
/** Returns true if the two sets of parameters are different. */
138+
BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
139+
140+
private:
141+
142+
RealType _min;
143+
RealType _max;
144+
};
145+
146+
/**
147+
* Constructs a uniform_real_distribution. @c min and @c max are
148+
* the parameters of the distribution.
149+
*
150+
* Requires: min <= max
151+
*/
152+
explicit uniform_real_distribution(
153+
RealType min_arg = RealType(0.0),
154+
RealType max_arg = RealType(1.0))
155+
: _min(min_arg), _max(max_arg)
156+
{
157+
BOOST_ASSERT(min_arg <= max_arg);
158+
}
159+
/** Constructs a uniform_real_distribution from its parameters. */
160+
explicit uniform_real_distribution(const param_type& parm)
161+
: _min(parm.a()), _max(parm.b()) {}
162+
163+
/** Returns the minimum value of the distribution */
164+
RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
165+
/** Returns the maximum value of the distribution */
166+
RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
167+
168+
/** Returns the minimum value of the distribution */
169+
RealType a() const { return _min; }
170+
/** Returns the maximum value of the distribution */
171+
RealType b() const { return _max; }
172+
173+
/** Returns the parameters of the distribution. */
174+
param_type param() const { return param_type(_min, _max); }
175+
/** Sets the parameters of the distribution. */
176+
void param(const param_type& parm)
177+
{
178+
_min = parm.a();
179+
_max = parm.b();
180+
}
181+
182+
/**
183+
* Effects: Subsequent uses of the distribution do not depend
184+
* on values produced by any engine prior to invoking reset.
185+
*/
186+
void reset() { }
187+
188+
/** Returns a value uniformly distributed in the range [min, max). */
189+
template<class Engine>
190+
result_type operator()(Engine& eng) const
191+
{ return detail::generate_uniform_real(eng, _min, _max); }
192+
193+
/**
194+
* Returns a value uniformly distributed in the range
195+
* [param.a(), param.b()).
196+
*/
197+
template<class Engine>
198+
result_type operator()(Engine& eng, const param_type& parm) const
199+
{ return detail::generate_uniform_real(eng, parm.a(), parm.b()); }
200+
201+
/** Writes the distribution to a @c std::ostream. */
202+
BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, uniform_real_distribution, ud)
203+
{
204+
os << ud.param();
205+
return os;
206+
}
207+
208+
/** Reads the distribution from a @c std::istream. */
209+
BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, uniform_real_distribution, ud)
210+
{
211+
param_type parm;
212+
if(is >> parm) {
213+
ud.param(parm);
214+
}
215+
return is;
216+
}
217+
218+
/**
219+
* Returns true if the two distributions will produce identical sequences
220+
* of values given equal generators.
221+
*/
222+
BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(uniform_real_distribution, lhs, rhs)
223+
{ return lhs._min == rhs._min && lhs._max == rhs._max; }
224+
225+
/**
226+
* Returns true if the two distributions may produce different sequences
227+
* of values given equal generators.
228+
*/
229+
BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(uniform_real_distribution)
230+
231+
private:
232+
RealType _min;
233+
RealType _max;
234+
};
235+
236+
} // namespace random
237+
} // namespace boost
238+
239+
#endif // BOOST_RANDOM_UNIFORM_INT_HPP

‎include/embree2/config.h‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
/* #undef BUILD_EMBREE_SHARED_LIB */
2+
/* #undef RTCORE_RAY_MASK */
3+
/* #undef RTCORE_STAT_COUNTERS */
4+
/* #undef RTCORE_BACKFACE_CULLING */
5+
#define RTCORE_INTERSECTION_FILTER
6+
#define RTCORE_BUFFER_STRIDE
7+
/* #undef RTCORE_SPINLOCKS */
8+
/* #undef RTCORE_TASKLOGGER */
9+
/* #undef RTCORE_EXPORT_ALL_SYMBOLS */
10+
/* #undef RTCORE_ENABLE_RAYSTREAM_LOGGER */
11+
/* #undef RTCORE_RETURN_SUBDIV_NORMAL */
12+

0 commit comments

Comments
 (0)