darkroom/objects/aa_plane.hpp 追加

darkroom/tracers/raytracer.hpp で、uv座標への変換で上下が反転していた問題を修正。

sprout/darkroom/objects.hpp

@@ -4,5 +4,6 @@
 #include <sprout/config.hpp>
 #include <sprout/darkroom/objects/intersect.hpp>
 #include <sprout/darkroom/objects/sphere.hpp>
+#include <sprout/darkroom/objects/aa_plane.hpp>
 
 #endif	// #ifndef SPROUT_DARKROOM_OBJECTS_HPP

sprout/darkroom/objects/aa_plane.hpp

@@ -0,0 +1,211 @@
+#ifndef SPROUT_DARKROOM_OBJECTS_AA_PLANE_HPP
+#define SPROUT_DARKROOM_OBJECTS_AA_PLANE_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/tuple/tuple.hpp>
+#include <sprout/tuple/functions.hpp>
+#include <sprout/darkroom/access/access.hpp>
+#include <sprout/darkroom/coords/vector.hpp>
+#include <sprout/darkroom/rays/ray.hpp>
+#include <sprout/darkroom/materials/material.hpp>
+
+namespace sprout {
+	namespace darkroom {
+		namespace objects {
+			//
+			// aa_plane_direction
+			//
+			struct aa_plane_direction {
+			public:
+				enum values {
+					x,
+					y,
+					z
+				};
+			};
+			//
+			// basic_aa_plane
+			//
+			template<typename Material, typename Position = sprout::darkroom::coords::vector3d>
+			class basic_aa_plane {
+			public:
+				typedef Material material_type;
+				typedef Position position_type;
+				typedef typename sprout::darkroom::access::unit<position_type>::type unit_type;
+				typedef sprout::darkroom::objects::aa_plane_direction aa_plane_direction;
+			public:
+				template<typename Ray>
+				struct intersection {
+					typedef sprout::tuples::tuple<
+						bool,
+						unit_type,
+						position_type,
+						position_type,
+						decltype(sprout::darkroom::materials::calc_material(
+							std::declval<material_type const&>(),
+							std::declval<position_type const&>(),
+							std::declval<position_type const&>()
+							))
+					> type;
+				};
+			private:
+				aa_plane_direction::values direction_value_;
+				unit_type val_;
+				material_type mat_;
+			private:
+				SPROUT_CONSTEXPR bool is_x() const {
+					return direction_value_ == aa_plane_direction::x;
+				}
+				SPROUT_CONSTEXPR bool is_y() const {
+					return direction_value_ == aa_plane_direction::y;
+				}
+				SPROUT_CONSTEXPR bool is_z() const {
+					return direction_value_ == aa_plane_direction::z;
+				}
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect_6(
+					bool does_intersect,
+					unit_type distance,
+					position_type const& point_of_intersection,
+					position_type const& normal
+					) const
+				{
+					return typename intersection<Ray>::type(
+						does_intersect,
+						distance,
+						point_of_intersection,
+						normal,
+						sprout::darkroom::materials::calc_material(
+							mat_,
+							point_of_intersection,
+							normal
+							)
+						);
+				}
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect_5(
+					int hit_side,
+					bool does_intersect,
+					unit_type distance,
+					position_type const& point_of_intersection
+					) const
+				{
+					return intersect_6<Ray>(
+						does_intersect,
+						distance,
+						point_of_intersection,
+						(is_x() ? position_type(hit_side > 0 ? 1 : -1, 0, 0)
+							: is_y() ? position_type(0, hit_side > 0 ? 1 : -1, 0)
+							: position_type(0, 0, hit_side > 0 ? 1 : -1)
+							)
+						);
+				}
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect_4(
+					Ray const& ray,
+					int hit_side,
+					bool does_intersect,
+					unit_type distance
+					) const
+				{
+					return intersect_5<Ray>(
+						hit_side,
+						does_intersect,
+						distance,
+						does_intersect
+							? sprout::darkroom::rays::point_of_intersection(ray, distance)
+							: position_type(0, 0, 0)
+						);
+				}
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect_3(
+					Ray const& ray,
+					unit_type pos_v,
+					unit_type dir_v,
+					int hit_side,
+					bool does_intersect
+					) const
+				{
+					return intersect_4(
+						ray,
+						hit_side,
+						does_intersect,
+						does_intersect
+							? (pos_v - val_) / -dir_v
+							: unit_type(-1)
+						);
+				}
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect_2(
+					Ray const& ray,
+					unit_type pos_v,
+					unit_type dir_v,
+					int hit_side
+					) const
+				{
+					return intersect_3(
+						ray,
+						pos_v,
+						dir_v,
+						hit_side,
+						(hit_side > 0 && dir_v < 0) || (hit_side < 0 && dir_v > 0)
+						);
+				}
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect_1(
+					Ray const& ray,
+					unit_type pos_v,
+					unit_type dir_v
+					) const
+				{
+					return intersect_2(
+						ray,
+						pos_v,
+						dir_v,
+						pos_v > val_ ? 1 : -1
+						);
+				}
+			public:
+				SPROUT_CONSTEXPR basic_aa_plane(
+					aa_plane_direction::values direction_value,
+					unit_type val,
+					material_type const& mat
+					)
+					: direction_value_(direction_value)
+					, val_(val)
+					, mat_(mat)
+				{};
+				template<typename Ray>
+				SPROUT_CONSTEXPR typename intersection<Ray>::type intersect(Ray const& ray) const {
+					return intersect_1(
+						ray,
+						(is_x() ? sprout::darkroom::coords::x(sprout::darkroom::rays::position(ray))
+							: is_y() ? sprout::darkroom::coords::y(sprout::darkroom::rays::position(ray))
+							: sprout::darkroom::coords::z(sprout::darkroom::rays::position(ray))
+							),
+						(is_x() ? sprout::darkroom::coords::x(sprout::darkroom::rays::direction(ray))
+							: is_y() ? sprout::darkroom::coords::y(sprout::darkroom::rays::direction(ray))
+							: sprout::darkroom::coords::z(sprout::darkroom::rays::direction(ray))
+							)
+						);
+				}
+			};
+			//
+			// make_aa_plane
+			//
+			template<typename Material, typename Unit>
+			SPROUT_CONSTEXPR inline sprout::darkroom::objects::basic_aa_plane<Material>
+			make_aa_plane(
+				sprout::darkroom::objects::aa_plane_direction::values dir_val,
+				Unit const& val,
+				Material const& mat
+				)
+			{
+				return sprout::darkroom::objects::basic_aa_plane<Material>(dir_val, val, mat);
+			}
+		}	// namespace objects
+	}	// namespace darkroom
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_DARKROOM_OBJECTS_AA_PLANE_HPP

sprout/darkroom/rays/ray.hpp

@@ -56,7 +56,7 @@ namespace sprout {
 					sprout::darkroom::coords::scale(sprout::darkroom::rays::direction(ray), dist)
 					);
 			}
-		}	// namespace ray
+		}	// namespace rays
 	}	// namespace darkroom
 }	// namespace sprout
 

sprout/darkroom/tracers/raytracer.hpp

@@ -41,7 +41,7 @@ namespace sprout {
 						lights,
 						camera.template operator()(
 							static_cast<typename Camera::unit_type>(x) / width - 0.5,
-							static_cast<typename Camera::unit_type>(y) / height - 0.5
+							-(static_cast<typename Camera::unit_type>(y) / height - 0.5)
 							),
 						depth_max
 						);