├── BasicTypes.h
├── BmpWriter.h
├── Buffer.h
├── Light.h
├── Main.cpp
├── Material.h
├── Op.h
├── Plane.h
├── README
├── Raytrace.py
├── Scene.h
├── Sphere.h
├── TestScene.h
├── Tile.h
└── Util.h


/BasicTypes.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include <stdint.h>
24 | 
25 | ///////////////////////////////////////////////////////////////////////////////
26 | struct Null {};
27 | 
28 | static const int64_t fixed_shift = (1 << 16);
29 | static const int64_t fixed_root = (1 << 8);
30 | 
31 | template<int64_t VAL>
32 | struct Fixed
33 | {
34 | 	static const int64_t Value = VAL;
35 | 
36 | 	static float ToFloat()
37 | 	{
38 | 		return Value / (float)fixed_shift;
39 | 	}
40 | };
41 | 
42 | typedef Fixed<fixed_shift> One;
43 | typedef Fixed<0> Zero;
44 | typedef Fixed<0x7fffffffffffffffLL> MaxFixed;
45 | typedef Fixed<0x8000000000000000LL> MinFixed;
46 | ///////////////////////////////////////////////////////////////////////////////
47 | template<class X_, class Y_, class Z_>
48 | struct Vec3
49 | {
50 | 	typedef X_ X;
51 | 	typedef Y_ Y;
52 | 	typedef Z_ Z;
53 | };
54 | 
55 | typedef Vec3<Fixed<0>, Fixed<0>, Fixed<0> > Vec3Zero;
56 | ///////////////////////////////////////////////////////////////////////////////
57 | template<class O, class D> struct Ray;
58 | 
59 | template<class Ox, class Oy, class Oz,
60 | 		 class Dx, class Dy, class Dz>
61 | struct Ray<Vec3<Ox,Oy,Oz>, Vec3<Dx,Dy,Dz> >
62 | {
63 | 	typedef Vec3<Ox,Oy,Oz> Origin;
64 | 	typedef Vec3<Dx,Dy,Dz> Dir;
65 | };
66 | ///////////////////////////////////////////////////////////////////////////////
67 | enum HitType
68 | {
69 | 	Missed,
70 | 	Hit
71 | };
72 | 
73 | template<HitType TYPE, class DIST>
74 | struct HitResult : public DIST
75 | {
76 | 	static const HitType Type = TYPE;
77 | };
78 | ///////////////////////////////////////////////////////////////////////////////
79 | 


--------------------------------------------------------------------------------
/BmpWriter.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include <stdio.h>
24 | #include <string.h>
25 | 
26 | struct BMPHEAD
27 | {
28 | 	int filesize;
29 | 	short reserved[2];
30 | 	int headersize;
31 | 	int infoSize;
32 | 	int width;
33 | 	int height;
34 | 	short biPlanes;
35 | 	short bits;
36 | 	int biCompression;
37 | 	int biSizeImage;
38 | 	int biXPelsPerMeter;
39 | 	int biYPelsPerMeter;
40 | 	int biClrUsed;
41 | 	int biClrImportant;
42 | };
43 | 
44 | void WriteBitmap(const char * filename, int width, int height, void * pbuffer)
45 | {
46 | 	unsigned char * buf = (unsigned char *) pbuffer;
47 | 	int pitch = ((width * 3) + 3) & (-4);	
48 | 
49 | 	BMPHEAD bh;
50 | 	memset((char *)&bh,0,sizeof(BMPHEAD));
51 | 	bh.headersize = 54L;
52 | 	bh.infoSize = 0x28L;
53 | 	bh.width = width;
54 | 	bh.height = height;
55 | 	bh.biPlanes =  1;
56 | 	bh.bits = 24;
57 | 	bh.biCompression = 0L;
58 | 	bh.biSizeImage = 54 + (pitch * height);
59 | 	int pad = pitch - (width * 3);
60 | 	unsigned char padbuf[] = {0,0,0};
61 | 
62 | 	FILE * file = fopen(filename, "wb");
63 | 	fwrite("BM", 1, 2, file);
64 | 	fwrite(&bh, 1, sizeof(bh), file);
65 | 	for (int i=(height-1); i>=0; i--)
66 | 	{
67 | 		fwrite(buf + (i * width * 3), 1, width * 3, file);
68 | 		if (pad > 0)
69 | 			fwrite(padbuf,1,pad,file);
70 | 	}
71 | 	fclose(file);
72 | }
73 | 


--------------------------------------------------------------------------------
/Buffer.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | 
24 | #include "Tile.h"
25 | 
26 | // General Case
27 | template<int x, int y, int width, int height,
28 | 	template<int,int> class Function, int tilew=16, int tileh=16>
29 | struct Buffer
30 | {
31 | 	typedef Tile<x,y,tilew,tileh,Function> Data;
32 | 	typedef Buffer<x+tilew,y,width,height,Function,tilew,tileh> Next;
33 | 
34 | 	template<class Visitor>
35 | 	static void Visit(Visitor v)
36 | 	{
37 | 		Data::Visit(v);
38 | 		Next::Visit(v);
39 | 	}
40 | };
41 | 
42 | // First column
43 | template<int y, int width, int height,
44 | 	template<int,int> class Function, int tilew, int tileh>
45 | struct Buffer<0,y,width,height,Function,tilew,tileh>
46 | {
47 | 	typedef Tile<0,y,tilew,tileh,Function> Data;
48 | 	typedef Buffer<tilew,y,width,height,Function,tilew,tileh> Next;
49 | 	typedef Buffer<0,y+tileh,width,height,Function,tilew,tileh> NextRow;
50 | 
51 | 	template<class Visitor>
52 | 	static void Visit(Visitor v)
53 | 	{
54 | 		Data::Visit(v);
55 | 		Next::Visit(v);
56 | 		NextRow::Visit(v);
57 | 	}
58 | };
59 | 
60 | // Terminal
61 | template<int width, int height,
62 | 	template<int,int> class Function, int tilew, int tileh>
63 | struct Buffer<0,height,width,height,Function,tilew,tileh>
64 | {
65 | 	template<class Visitor>
66 | 	static void Visit(Visitor v) {}
67 | };
68 | 
69 | template<int y, int width, int height,
70 | 	template<int,int> class Function, int tilew, int tileh>
71 | struct Buffer<width,y,width,height,Function,tilew,tileh>
72 | {
73 | 	template<class Visitor>
74 | 	static void Visit(Visitor v) {}
75 | };
76 | 


--------------------------------------------------------------------------------
/Light.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2011 Chris Lentini
  3 | http://divergentcoder.com
  4 | 
  5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
  6 | this software and associated documentation files (the "Software"), to deal in 
  7 | the Software without restriction, including without limitation the rights to use, 
  8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
  9 | Software, and to permit persons to whom the Software is furnished to do so, 
 10 | subject to the following conditions:
 11 | 
 12 | The above copyright notice and this permission notice shall be included in all 
 13 | copies or substantial portions of the Software.
 14 | 
 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21 | */
 22 | #pragma once
 23 | 
 24 | template<class Position_, class Color_, class Next_>
 25 | struct PointLight
 26 | {
 27 | 	typedef Position_ Position;
 28 | 	typedef Color_ Color;
 29 | 	typedef Next_ Next;
 30 | 
 31 | 	template<class Pixel, class Scene>
 32 | 	struct CalcLight
 33 | 	{
 34 | 		// Light distance
 35 | 		typedef typename Length<typename Sub<Position, 
 36 | 			typename Pixel::Position>::Result>::Result Dist;
 37 | 
 38 | 		// Pixel -> Light direction
 39 | 		typedef typename Div<typename Sub<Position, 
 40 | 			typename Pixel::Position>::Result, Dist>::Result Dir;
 41 | 
 42 | 		// Shadow test
 43 | 		typedef typename Scene::template IntersectScene<Ray<
 44 | 			typename Pixel::Position, Dir> >::Result ShadowHit;
 45 | 		typedef typename If<ShadowHit::One::Type == Hit, Zero, One>::Result shadow;
 46 | 
 47 | 		// NDL
 48 | 		typedef typename Max<typename Dot<Dir, typename Pixel::Normal>::Result, Zero>::Result NDL;
 49 | 		
 50 | 		// attenuation 1 / D^2
 51 | 		typedef typename Div<One, typename Add<Fixed<1>, 
 52 | 			typename Mul<Dist,Dist>::Result>::Result>::Result atten;
 53 | 
 54 | 		// Combine
 55 | 		typedef typename Mul<Color, NDL>::Result diff0;
 56 | 		typedef typename Mul<diff0, atten>::Result diff1;
 57 | 		typedef typename Mul<diff1, shadow>::Result Result;
 58 | 	};
 59 | };
 60 | 
 61 | template<class Direction, class Color, class _Next>
 62 | struct DirectionalLight 
 63 | {
 64 | 	typedef _Next Next;
 65 | 
 66 | 	typedef typename Sub<Vec3Zero,Direction>::Result NegDir;
 67 | 
 68 | 	template<class Pixel, class Scene>
 69 | 	struct CalcLight
 70 | 	{
 71 | 		// NDL
 72 | 		typedef typename Max<Zero, typename Dot<NegDir, typename Pixel::Normal>::Result>::Result NDL;
 73 | 
 74 | 		// Shadowing
 75 | 		typedef typename Scene::template IntersectScene<Ray<
 76 | 			typename Pixel::Position, NegDir> >::Result ShadowHit;
 77 | 		typedef typename If<ShadowHit::One::Type == Hit, Zero, One>::Result shadow;
 78 | 
 79 | 		// Combine
 80 | 		typedef typename Mul<Color, typename Mul<NDL,shadow>::Result>::Result Result;
 81 | 	};
 82 | };
 83 | 
 84 | template<class Color, class _Next>
 85 | struct AmbientLight 
 86 | {
 87 | 	typedef _Next Next;
 88 | 
 89 | 	template<class Pixel, class Scene>
 90 | 	struct CalcLight
 91 | 	{
 92 | 		typedef Color Result;
 93 | 	};
 94 | };
 95 | 
 96 | template<class Pixel, class Scene, class Lights, class Total>
 97 | struct SumLighting
 98 | {
 99 | 	typedef typename Add<Total, typename Lights::template CalcLight<Pixel,Scene>::Result>::Result Current;
100 | 	typedef typename SumLighting<Pixel,Scene,typename Lights::Next,Current>::Result Result;
101 | };
102 | 
103 | template<class Pixel, class Scene, class Total>
104 | struct SumLighting<Pixel,Scene,Null,Total>
105 | {
106 | 	typedef Total Result;
107 | };
108 | 


--------------------------------------------------------------------------------
/Main.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | 
23 | #include <algorithm>
24 | #include <stdlib.h>
25 | #include "BmpWriter.h"
26 | #include "TestScene.h"
27 | #include "Tile.h"
28 | #include "Buffer.h"
29 | 
30 | #ifndef OUTW
31 | #define OUTW 4
32 | #define OUTH 4
33 | #define UX 0
34 | #define UY 0
35 | #define TILEW 2
36 | #define WRITE_BMP
37 | #endif
38 | 
39 | struct BGR
40 | {
41 | 	unsigned char b;
42 | 	unsigned char g;
43 | 	unsigned char r;
44 | };
45 | 
46 | struct PixelWriter
47 | {
48 | 	BGR *		buffer;
49 | 	
50 | 	template<class RES> 
51 | 	void Call(int _x, int _y)
52 | 	{
53 | 		int x = _x - UX;
54 | 		int y = _y - UY;
55 | 		buffer[(y * TILEW) + x].r = (unsigned char)(255 * std::min(RES::X::ToFloat(),1.f));
56 | 		buffer[(y * TILEW) + x].g = (unsigned char)(255 * std::min(RES::Y::ToFloat(),1.f));
57 | 		buffer[(y * TILEW) + x].b = (unsigned char)(255 * std::min(RES::Z::ToFloat(),1.f));
58 | 	}
59 | };
60 | 
61 | int main()
62 | {
63 | #if defined(WRITE_BMP)
64 | 	BGR buf[OUTW*OUTH];
65 | #else
66 | 	BGR buf[TILEW];
67 | #endif
68 | 
69 | 	memset(buf, 0, sizeof(buf));
70 | 
71 | 	PixelWriter pix;
72 | 	pix.buffer = &buf[0];
73 | 
74 | #if defined(WRITE_BMP)
75 | 	Buffer<0,0,OUTW,OUTH,SceneTracer<TestScene,TestLights,OUTW,OUTH>::Tracer,
76 | 		TILEW,1>::Visit(pix);
77 | 	WriteBitmap("output.bmp", OUTW, OUTH, &buf[0]);
78 | #else
79 | 	Tile<UX,UY,TILEW,1,SceneTracer<TestScene,TestLights,OUTW,OUTH>::Tracer>::Visit(pix);
80 | 	fwrite(&buf[0], 1, sizeof(buf), stdout);
81 | #endif
82 | 
83 | 	return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/Material.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include "Light.h"
24 | 
25 | // Material evaluation
26 | template<bool valid, class Material, class Pixel, class Scene, class Lights, int Depth>
27 | struct EvalMaterial
28 | {
29 | 	typedef typename Material::template Evaluate<Scene, Lights, 
30 | 		Pixel, Depth>::Result Result;
31 | };
32 | 
33 | // Terminal cases
34 | template<class Material, class Pixel, class Scene, class Lights, int Depth>
35 | struct EvalMaterial<false,Material,Pixel,Scene,Lights,Depth>
36 | {
37 | 	typedef Vec3Zero Result;
38 | };
39 | 
40 | template<class Material, class Pixel, class Scene, class Lights>
41 | struct EvalMaterial<true,Material,Pixel,Scene,Lights,0>
42 | {
43 | 	typedef Vec3Zero Result;
44 | };
45 | 
46 | // A simple lit material
47 | template<class R, class G, class B>
48 | struct FlatColor
49 | {
50 | 	typedef Vec3<R,G,B> Color;
51 | 
52 | 	template<class Scene, class Lights, class Pixel, int Depth>
53 | 	struct Evaluate
54 | 	{
55 | 		typedef typename SumLighting<Pixel, Scene, Lights, Vec3Zero>::Result Lighting;
56 | 		typedef typename Mul<Color, Lighting>::Result Result;
57 | 	};
58 | };
59 | 
60 | // A simple reflective material
61 | template<class R, class G, class B, class Strength>
62 | struct Reflective
63 | {
64 | 	typedef Vec3<R,G,B> Color;
65 | 
66 | 	template<class Scene, class Lights, class Pixel, int Depth>
67 | 	struct Evaluate
68 | 	{
69 | 		// Calculate reflection ray
70 | 		typedef typename Dot<typename Pixel::View, typename Pixel::Normal>::Result VDN;
71 | 		typedef typename Sub<typename Pixel::View, typename Mul<typename Pixel::Normal,
72 | 			typename Mul<ToFixed<2,0,1>, VDN>::Result>::Result>::Result ReflDir;
73 | 		typedef Ray<typename Pixel::Position, ReflDir> ReflRay;
74 | 
75 | 		// Get reflection hit and shading
76 | 		typedef typename Scene::template IntersectScene<ReflRay>::Result ReflectionHit;
77 | 		static const bool is_hit = ReflectionHit::One::Type == Hit;
78 | 		typedef typename EvalMaterial<is_hit, typename ReflectionHit::Two,
79 | 			typename ReflectionHit::One, Scene, Lights, Depth-1>::Result ReflectionColor;
80 | 
81 | 		// Sum lighting
82 | 		typedef typename SumLighting<Pixel,Scene,Lights,Vec3Zero>::Result Lighting;
83 | 
84 | 		// Add reflection and lighting * color
85 | 		typedef typename Add<typename Mul<Color,Lighting>::Result, 
86 | 			typename Mul<Strength, ReflectionColor>::Result>::Result Result;
87 | 	};
88 | };
89 | 


--------------------------------------------------------------------------------
/Op.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2011 Chris Lentini
  3 | http://divergentcoder.com
  4 | 
  5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
  6 | this software and associated documentation files (the "Software"), to deal in 
  7 | the Software without restriction, including without limitation the rights to use, 
  8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
  9 | Software, and to permit persons to whom the Software is furnished to do so, 
 10 | subject to the following conditions:
 11 | 
 12 | The above copyright notice and this permission notice shall be included in all 
 13 | copies or substantial portions of the Software.
 14 | 
 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21 | */
 22 | #pragma once
 23 | #include "BasicTypes.h"
 24 | 
 25 | ///////////////////////////////////////////////////////////////////////////////
 26 | template<class L, class R> 
 27 | struct Add
 28 | {
 29 | 	typedef Fixed<L::Value + R::Value> Result;
 30 | };
 31 | 
 32 | template<class x0, class y0, class z0, class x1, class y1, class z1>
 33 | struct Add<Vec3<x0,y0,z0>, Vec3<x1,y1,z1> >
 34 | {
 35 | 	typedef Vec3<typename Add<x0,x1>::Result, typename Add<y0,y1>::Result, 
 36 | 		typename Add<z0,z1>::Result> Result;
 37 | };
 38 | ///////////////////////////////////////////////////////////////////////////////
 39 | template<class L, class R> 
 40 | struct Sub
 41 | {
 42 | 	typedef Fixed<L::Value - R::Value> Result;
 43 | };
 44 | 
 45 | template<class x0, class y0, class z0, class x1, class y1, class z1>
 46 | struct Sub<Vec3<x0,y0,z0>, Vec3<x1,y1,z1> >
 47 | {
 48 | 	typedef Vec3<typename Sub<x0,x1>::Result, typename Sub<y0,y1>::Result,
 49 | 		typename Sub<z0,z1>::Result> Result;
 50 | };
 51 | ///////////////////////////////////////////////////////////////////////////////
 52 | template<class L, class R> 
 53 | struct Mul
 54 | {
 55 | 	typedef Fixed<(L::Value * R::Value) / fixed_shift> Result;
 56 | };
 57 | 
 58 | template<class x0, class y0, class z0,
 59 | 		 class x1, class y1, class z1>
 60 | struct Mul<Vec3<x0,y0,z0>, Vec3<x1,y1,z1> >
 61 | {
 62 | 	typedef Vec3<typename Mul<x0,x1>::Result, typename Mul<y0,y1>::Result,
 63 | 		typename Mul<z0,z1>::Result> Result;
 64 | };
 65 | 
 66 | template<class x, class y, class z, class Scalar>
 67 | struct Mul<Vec3<x,y,z>, Scalar>
 68 | {
 69 | 	typedef Vec3<typename Mul<x,Scalar>::Result, typename Mul<y,Scalar>::Result,
 70 | 		typename Mul<z,Scalar>::Result> Result;
 71 | };
 72 | 
 73 | template<class x, class y, class z, class Scalar>
 74 | struct Mul<Scalar, Vec3<x,y,z> >
 75 | {
 76 | 	typedef Vec3<typename Mul<x,Scalar>::Result, typename Mul<y,Scalar>::Result,
 77 | 		typename Mul<z,Scalar>::Result> Result;
 78 | };
 79 | ///////////////////////////////////////////////////////////////////////////////
 80 | template<class L, class R> 
 81 | struct Div
 82 | {
 83 | 	typedef Fixed<(L::Value * fixed_shift) / R::Value> Result;
 84 | };
 85 | 
 86 | template<class x0, class y0, class z0,
 87 | 		 class x1, class y1, class z1>
 88 | struct Div<Vec3<x0,y0,z0>, Vec3<x1,y1,z1> >
 89 | {
 90 | 	typedef Vec3<typename Div<x0,x1>::Result, typename Div<y0,y1>::Result,
 91 | 		typename Div<z0,z1>::Result> Result;
 92 | };
 93 | 
 94 | template<class x0, class y0, class z0, class Scalar>
 95 | struct Div<Vec3<x0,y0,z0>, Scalar>
 96 | {
 97 | 	typedef Vec3<typename Div<x0,Scalar>::Result, typename Div<y0,Scalar>::Result,
 98 | 		typename Div<z0,Scalar>::Result> Result;
 99 | };
100 | ///////////////////////////////////////////////////////////////////////////////
101 | template<class L, class R> struct Dot;
102 | 
103 | template<class x0, class y0, class z0,
104 | 		 class x1, class y1, class z1>
105 | struct Dot<Vec3<x0,y0,z0>, Vec3<x1,y1,z1> >
106 | {
107 | 	typedef typename Add<typename Add<typename Mul<x0,x1>::Result, typename Mul<y0,y1>::Result>::Result,
108 | 		typename Mul<z0,z1>::Result>::Result Result;
109 | };
110 | ///////////////////////////////////////////////////////////////////////////////
111 | template<int64_t V, int64_t L = 1, int64_t U = V> 
112 | struct ISqrt;
113 | 
114 | template<int64_t V, int64_t R>
115 | struct ISqrt<V, R, R>
116 | {
117 | 	static const int64_t Result = R;
118 | };
119 | 
120 | template<int64_t L, int64_t U>
121 | struct ISqrt<0,L,U>
122 | {
123 | 	static const int64_t Result = 0;
124 | };
125 | 
126 | template<int64_t V, int64_t L, int64_t U>
127 | struct ISqrt
128 | {
129 | 	static const int64_t t0 = (L + U) / 2;
130 | 	static const int64_t t1 = t0 * t0;
131 | 	static const bool CND = t1 >= V;
132 | 	static const int64_t Result = ISqrt<V, CND ? L : (t0 + 1),
133 | 		CND ? t0 : U>::Result;
134 | };
135 | 
136 | template<int64_t val>
137 | struct SqrtImpl
138 | {
139 | 	static const bool CND = val < One::Value;
140 | 	static const int64_t UPPER = CND ? (val * fixed_root) : ((val/fixed_root)+1);
141 | 	typedef Fixed<ISqrt<val, 1, UPPER>::Result * fixed_root> Result;
142 | };
143 | 
144 | template<class V> 
145 | struct Sqrt
146 | {
147 | 	typedef typename SqrtImpl<V::Value>::Result Result;
148 | };
149 | ///////////////////////////////////////////////////////////////////////////////
150 | template<class V>
151 | struct Length
152 | {
153 | 	typedef typename Sqrt<typename Dot<V,V>::Result>::Result Result;
154 | };
155 | ///////////////////////////////////////////////////////////////////////////////
156 | template<class V> struct Normalize
157 | {
158 | 	typedef typename Div<V, typename Length<V>::Result>::Result Result;
159 | };
160 | ///////////////////////////////////////////////////////////////////////////////
161 | template<class A, class B> struct Max;
162 | 
163 | template<int64_t a, int64_t b>
164 | struct Max<Fixed<a>, Fixed<b> >
165 | {
166 | 	static const int64_t val = (a >= b) ? a : b;
167 | 	typedef Fixed<val> Result;
168 | };
169 | ///////////////////////////////////////////////////////////////////////////////
170 | 


--------------------------------------------------------------------------------
/Plane.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include "BasicTypes.h"
24 | #include "Op.h"
25 | #include "Util.h"
26 | 
27 | ///////////////////////////////////////////////////////////////////////////////
28 | template<class N, class D> 
29 | struct Plane
30 | {
31 | 	typedef N Normal;
32 | 	typedef D Distance;
33 | };
34 | ///////////////////////////////////////////////////////////////////////////////
35 | template<bool DO, class NUMER, class DENOM> 
36 | struct CalcPlaneHit
37 | {
38 | 	typedef HitResult<Missed,MaxFixed> Result;
39 | };
40 | 
41 | template<class NUMER, class DENOM>
42 | struct CalcPlaneHit<true, NUMER, DENOM>
43 | {
44 | 	typedef typename Div<NUMER, DENOM>::Result HitDist;
45 | 	static const bool CND = (HitDist::Value < 0);
46 | 	typedef If<CND, HitResult<Missed, MaxFixed>,
47 | 		HitResult<Hit, HitDist> > Result;
48 | };
49 | 
50 | template<class ORIGIN, class DIR, class NORM, class DIST>
51 | struct IntersectPlane
52 | {
53 | 	typedef typename Dot<DIR,NORM>::Result DN;
54 | 	typedef typename Dot<ORIGIN,NORM>::Result ON;
55 | 	typedef typename Sub<Fixed<0>, typename Add<ON, DIST>::Result>::Result NUMER;
56 | 	
57 | 	static const bool CND = DN::Value < 0;
58 | 
59 | 	typedef typename CalcPlaneHit<CND, NUMER, DN>::Result intersection;
60 | };
61 | 
62 | template<class R, class P> struct Intersect;
63 | 
64 | template<class ORIGIN, class DIR, class NORM, class DIST>
65 | struct Intersect<Ray<ORIGIN,DIR>, Plane<NORM,DIST> > : 
66 | 	public IntersectPlane<ORIGIN,DIR,NORM,DIST>::intersection
67 | {
68 | private:
69 | 	typedef typename IntersectPlane<ORIGIN,DIR,NORM,DIST>::intersection Base;
70 | 
71 | public:
72 | 	typedef typename CalcPosition<Base::Type == Hit, ORIGIN, DIR, Base>::Result Position;
73 | 	typedef NORM Normal;
74 | 	typedef DIR View;
75 | };
76 | ///////////////////////////////////////////////////////////////////////////////
77 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | ================================================
 2 | TemplateTrace - Description
 3 | ================================================
 4 | TemplateTrace is a C++ compile-time raytracer written for the fun of it.
 5 | Run Raytrace.py specifying --width, --height and --output to generate an image.  
 6 | The script will invoke gcc on Main.cpp to generate two program instances at 
 7 | a time and with each program instance covering a 4x1 portion of the final 
 8 | generated image.  As you can imagine this can be a very lengthy process...  
 9 | Modify TestScene.h if you want to modify the scene being traced.
10 | 
11 | 
12 | 
13 | =================================================
14 | TemplateTrace - License Info
15 | =================================================
16 | Copyright (c) 2011 Chris Lentini
17 | http://divergentcoder.com
18 | 
19 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
20 | this software and associated documentation files (the "Software"), to deal in 
21 | the Software without restriction, including without limitation the rights to use, 
22 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
23 | Software, and to permit persons to whom the Software is furnished to do so, 
24 | subject to the following conditions:
25 | 
26 | The above copyright notice and this permission notice shall be included in all 
27 | copies or substantial portions of the Software.
28 | 
29 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
30 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
31 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
32 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
33 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
34 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 | 


--------------------------------------------------------------------------------
/Raytrace.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2011 Chris Lentini
  2 | # http://divergentcoder.com
  3 | #
  4 | # Permission is hereby granted, free of charge, to any person obtaining a copy of 
  5 | # this software and associated documentation files (the "Software"), to deal in 
  6 | # the Software without restriction, including without limitation the rights to use, 
  7 | # copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
  8 | # Software, and to permit persons to whom the Software is furnished to do so, 
  9 | # subject to the following conditions:
 10 | #
 11 | # The above copyright notice and this permission notice shall be included in all 
 12 | # copies or substantial portions of the Software.
 13 | #
 14 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 15 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
 16 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
 17 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
 18 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
 19 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 20 | 
 21 | from subprocess import Popen, PIPE
 22 | from sys import stdout
 23 | import struct
 24 | from optparse import OptionParser
 25 | from datetime import datetime
 26 | 
 27 | ################################################################################
 28 | 
 29 | cmdline = OptionParser()
 30 | cmdline.add_option("--output", help="Specifies bitmap destination file",
 31 |                    action="store", dest="filename", default="output.bmp")
 32 | cmdline.add_option("--width", help="Specifies output image width",
 33 |                    action="store", dest="width", default=64)
 34 | cmdline.add_option("--height", help="Specifies output image height",
 35 |                    action="store", dest="height", default=64)
 36 | cmdline.add_option("--tilew", help="Specifies the tiling width",
 37 |                    action="store", dest="tilew", default=4)
 38 | 
 39 | (options, args) = cmdline.parse_args()
 40 | 
 41 | width = int(options.width)
 42 | height = int(options.height)
 43 | tilew = int(options.tilew)
 44 | 
 45 | ################################################################################
 46 | 
 47 | def write_header(file):
 48 |     global width, height
 49 |     l0 = struct.pack('<L', 0)
 50 |     h0 = struct.pack('<H', 0)
 51 |     
 52 |     file.write(struct.pack('<B',66))
 53 |     file.write(struct.pack('<B',77))
 54 |     file.write(l0)
 55 |     file.write(h0)
 56 |     file.write(h0)
 57 |     file.write(struct.pack('<L',54))
 58 |     file.write(struct.pack('<L',40))
 59 |     file.write(struct.pack('<L',width))
 60 |     file.write(struct.pack('<L',height))
 61 |     file.write(struct.pack('<H',1))
 62 |     file.write(struct.pack('<H',24))
 63 |     file.write(l0)
 64 |     file.write(l0)
 65 |     file.write(l0)
 66 |     file.write(l0)
 67 |     file.write(l0)
 68 |     file.write(l0)
 69 | 
 70 | output = open(options.filename, "wb")
 71 | write_header(output)
 72 | 
 73 | ################################################################################
 74 | count = 0
 75 | total = (width / tilew) * height
 76 | start = datetime.now()
 77 | for y in range(0,height,1):
 78 |     for x in range(0,width,tilew*2):
 79 |         inst0 = Popen(["gcc","-o","tmp0.exe","-DOUTW=%d" % width,
 80 |                        "-DOUTH=%d" % height, "-DUX=%d" % x,
 81 |                        "-DUY=%d" % (height-y-1), "-DTILEW=%d" % tilew,
 82 |                        "main.cpp"])
 83 |         
 84 |         inst1 = Popen(["gcc","-o","tmp1.exe","-DOUTW=%d" % width,
 85 |                        "-DOUTH=%d" % height, "-DUX=%d" % (x+tilew),
 86 |                        "-DUY=%d" % (height-y-1), "-DTILEW=%d" % tilew,
 87 |                        "main.cpp"])
 88 |         
 89 |         inst0.wait()
 90 |         inst1.wait()
 91 |         
 92 |         inst0 = Popen(["./tmp0.exe"], stdout=PIPE)
 93 |         out0 = inst0.communicate()[0]
 94 |         output.write(out0)
 95 |         
 96 |         inst1 = Popen(["./tmp1.exe"], stdout=PIPE)
 97 |         out1 = inst1.communicate()[0]
 98 |         output.write(out1)
 99 |         
100 |         count += 2
101 |         stdout.write("\r%d/%d" % (count,total))
102 |         stdout.flush()
103 | end = datetime.now()
104 | delta = end - start
105 | numseconds = delta.seconds + (delta.days * 24 * 3600) + (delta.microseconds / 10**6)
106 | print("\nCompleted %d seconds" % numseconds)
107 | ################################################################################
108 | 
109 | output.close()


--------------------------------------------------------------------------------
/Scene.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include "BasicTypes.h"
24 | #include "Sphere.h"
25 | #include "Plane.h"
26 | #include "Material.h"
27 | 
28 | ///////////////////////////////////////////////////////////////////////////////
29 | template<class Primitive, class Material, class Next>
30 | struct SceneNode
31 | {
32 | 	template<class R>
33 | 	struct IntersectScene
34 | 	{
35 | 		typedef Pair<Intersect<R, Primitive>, Material>				res0;
36 | 		typedef typename Next::template IntersectScene<R>::Result	res1;
37 | 
38 | 		static const bool is_less = res0::One::Value < res1::One::Value;
39 | 
40 | 		typedef typename If<res0::One::Type == Hit && res1::One::Type == Hit,
41 | 					If<is_less, res0, res1>,
42 | 					If<res0::One::Type == Hit, res0, res1> >::Result Result;
43 | 	};
44 | };
45 | ///////////////////////////////////////////////////////////////////////////////
46 | template<class Primitive, class Material>
47 | struct SceneNode<Primitive,Material,Null>
48 | {
49 | 	template<class R>
50 | 	struct IntersectScene
51 | 	{
52 | 		typedef Intersect<R,Primitive> intr0;
53 | 		typedef Pair<intr0, Material> Result;
54 | 	};
55 | };
56 | ///////////////////////////////////////////////////////////////////////////////
57 | template<class Scene, class Lights, int Width, int Height>
58 | struct SceneTracer
59 | {
60 | private:
61 | 	static const int CX = Width/2;
62 | 	static const int CY = Height/2;
63 | 
64 | public:
65 | 	template<int x, int y>
66 | 	struct Tracer
67 | 	{
68 | 		typedef typename Normalize<typename Div<Vec3<ToFixed<x - CX, 0, 1>,
69 | 													 ToFixed<CY - y, 0, 1>,
70 | 													 One>,
71 | 												Vec3<ToFixed<CX,0,1>,
72 | 													 ToFixed<CY,0,1>,
73 | 													 One> >::Result>::Result Dir;
74 | 
75 | 		typedef typename Scene::template IntersectScene<Ray<Vec3Zero, Dir> >::Result Intersection;
76 | 
77 | 		static const bool is_hit = Intersection::One::Type == Hit;
78 | 		typedef typename EvalMaterial<is_hit, typename Intersection::Two,
79 | 			typename Intersection::One, Scene, Lights, 3>::Result Result;
80 | 	};
81 | };
82 | ///////////////////////////////////////////////////////////////////////////////
83 | 


--------------------------------------------------------------------------------
/Sphere.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include "BasicTypes.h"
24 | #include "Op.h"
25 | #include "Util.h"
26 | 
27 | ///////////////////////////////////////////////////////////////////////////////
28 | template<class P, class R> struct Sphere
29 | {
30 | 	typedef P Position;
31 | 	typedef R Radius;
32 | };
33 | ///////////////////////////////////////////////////////////////////////////////
34 | template<class D2, class B>
35 | struct CalcSphereHit
36 | {
37 | private:
38 | 	typedef typename Sqrt<D2>::Result		Root;
39 | 	typedef typename Sub<B,Root>::Result	I0;
40 | 	typedef typename Add<B,Root>::Result	I1;
41 | 
42 | 	static const bool CND0 = I1::Value > 0;
43 | 	static const bool CND1 = I0::Value < 0;
44 | 
45 | public:
46 | 	typedef If<CND0, If<CND1, HitResult<Missed, MaxFixed>, HitResult<Hit, I0> >,
47 | 					 HitResult<Missed, MaxFixed> > Result;
48 | };
49 | 
50 | template<bool IsPos, class D2, class B> 
51 | struct SphereHit : public HitResult<Missed,MaxFixed> {};
52 | 
53 | template<class D2, class B>
54 | struct SphereHit<true, D2, B> : public CalcSphereHit<D2,B>::Result {};
55 | 
56 | template<class ORIGIN, class DIR, class CENTER, class RAD>
57 | struct IntersectSphere
58 | {
59 | 	typedef typename Sub<CENTER,ORIGIN>::Result	V;
60 | 	typedef typename Dot<V,DIR>::Result			B;
61 | 	typedef typename Mul<RAD,RAD>::Result		R2;
62 | 	typedef typename Dot<V,V>::Result			V2;
63 | 	typedef typename Mul<B,B>::Result			B2;
64 | 	
65 | 	typedef typename Add<R2, typename Sub<B2,V2>::Result>::Result D2;
66 | 	typedef SphereHit<(D2::Value > 0), D2, B> intersection;
67 | };
68 | 
69 | template<bool IsHit, class Pos, class Center>
70 | struct SphereNormal
71 | {
72 | 	typedef typename Normalize<typename Sub<Pos, Center>::Result>::Result Result;
73 | };
74 | 
75 | template<class Pos, class Center>
76 | struct SphereNormal<false,Pos,Center>
77 | {
78 | 	typedef Vec3<One,One,One> Result;
79 | };
80 | 
81 | template<class R, class P> struct Intersect;
82 | 
83 | template<class ORIGIN, class DIR, class CENTER, class RAD>
84 | struct Intersect<Ray<ORIGIN,DIR>, Sphere<CENTER,RAD> > : 
85 | 	public IntersectSphere<ORIGIN,DIR,CENTER,RAD>::intersection
86 | {
87 | private:
88 | 	typedef typename IntersectSphere<ORIGIN,DIR,CENTER,RAD>::intersection Base;
89 | public:
90 | 	typedef typename CalcPosition<Base::Type == Hit, ORIGIN, DIR, Base>::Result Position;
91 | 	typedef typename SphereNormal<Base::Type == Hit, Position, CENTER>::Result Normal;
92 | 	typedef DIR View;
93 | };
94 | ///////////////////////////////////////////////////////////////////////////////
95 | 


--------------------------------------------------------------------------------
/TestScene.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | 
23 | #pragma once
24 | #include "Scene.h"
25 | #include "Light.h"
26 | #include "Material.h"
27 | 
28 | // Materials
29 | typedef FlatColor<One,Zero,Zero>	                Red;
30 | typedef FlatColor<Zero,One,Zero>	                Green;
31 | typedef Reflective<Zero,Zero,One,ToFixed<0,2,3> >       Blue;
32 | typedef Reflective<One,One,One,ToFixed<0,3,5> >		White;
33 | 
34 | // Scene primitives
35 | typedef SceneNode<Sphere<Vec3<Zero,Zero,ToFixed<5,0,1> >,
36 | 	ToFixed<1,0,1> >, Red, Null> node0;
37 | 
38 | typedef SceneNode<Sphere<Vec3<ToFixed<2,0,1>,Zero,ToFixed<2,0,1> >,
39 | 	ToFixed<1,1,2> >, Green, node0> node1;
40 | 
41 | typedef SceneNode<Sphere<Vec3<ToFixed<-3,0,1>,ToFixed<2,0,1>,ToFixed<3,0,1> >,
42 | 	ToFixed<1,1,2> >, Blue, node1> node2;
43 | 
44 | typedef SceneNode<Plane<Vec3<Zero,One,Zero>, One>, White, node2> TestScene;
45 | 
46 | // Lights
47 | typedef PointLight<Vec3<Zero, ToFixed<0,1,2>, ToFixed<3,0,1> >,
48 | 	Vec3<ToFixed<1,2,3>, ToFixed<1,2,3>, One>, Null> light0;
49 | 
50 | typedef DirectionalLight<Normalize<Vec3<Fixed<-65536>,Fixed<-65536>,Fixed<-65536> > >::Result,
51 | 	Vec3<ToFixed<0,4,5>, ToFixed<0,1,2>, ToFixed<0,4,5> >, light0> light1;
52 | 
53 | typedef AmbientLight<Vec3<ToFixed<0,1,8>, ToFixed<0,1,8>, ToFixed<0,1,8> >, light1> TestLights;
54 | 


--------------------------------------------------------------------------------
/Tile.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | 
24 | // General Case
25 | template<int ux, int uy, int width, int height,
26 | 	template<int,int> class Function, int x=ux, int y=uy>
27 | struct Tile
28 | {
29 | 	typedef typename Function<x,y>::Result				Result;
30 | 	typedef Tile<ux,uy,width-1,height,Function,x+1,y>	Next;
31 | 
32 | 	template<class Visitor>
33 | 	static void Visit(Visitor v)
34 | 	{
35 | 		v.template Call<Result>(x,y);
36 | 		Next::Visit(v);
37 | 	}
38 | };
39 | 
40 | // First column
41 | template<int ux, int uy, int width, int height,
42 | 	template<int,int> class Function, int y>
43 | struct Tile<ux,uy,width,height,Function,ux,y>
44 | {
45 | 	typedef typename Function<ux,y>::Result Result;
46 | 
47 | 	typedef Tile<ux,uy,width-1,height,Function,ux+1,y> Next;
48 | 	typedef Tile<ux,uy,width,height-1,Function,ux,y+1> NextRow;
49 | 
50 | 	template<class Visitor>
51 | 	static void Visit(Visitor v)
52 | 	{
53 | 		v.template Call<Result>(ux,y);
54 | 		Next::Visit(v);
55 | 		NextRow::Visit(v);
56 | 	}
57 | };
58 | 
59 | // Terminators
60 | template<int ux, int uy, int height,
61 | 	template<int,int> class Function, int x, int y>
62 | struct Tile<ux,uy,0,height,Function,x,y>
63 | {
64 | 	template<class Visitor>
65 | 	static void Visit(Visitor v) {}
66 | };
67 | 
68 | template<int ux, int uy, int width, 
69 | 	template<int,int> class Function, int y>
70 | struct Tile<ux,uy,width,0,Function,ux,y>
71 | {
72 | 	template<class Visitor>
73 | 	static void Visit(Visitor v) {}
74 | };
75 | 


--------------------------------------------------------------------------------
/Util.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2011 Chris Lentini
 3 | http://divergentcoder.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 
 6 | this software and associated documentation files (the "Software"), to deal in 
 7 | the Software without restriction, including without limitation the rights to use, 
 8 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the 
 9 | Software, and to permit persons to whom the Software is furnished to do so, 
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all 
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | */
22 | #pragma once
23 | #include "BasicTypes.h"
24 | #include "Op.h"
25 | 
26 | ///////////////////////////////////////////////////////////////////////////////
27 | template<int64_t ipart, int64_t numer, int64_t denom>
28 | struct ToFixed : public Fixed<(ipart * fixed_shift) + ((numer * fixed_shift) / denom)>
29 | {};
30 | ///////////////////////////////////////////////////////////////////////////////
31 | template<bool CND, class Then, class Else> 
32 | struct If : public Then
33 | {
34 | 	typedef Then Result;
35 | };
36 | 
37 | template<class Then, class Else>
38 | struct If<false, Then, Else> : public Else
39 | {
40 | 	typedef Else Result;
41 | };
42 | ///////////////////////////////////////////////////////////////////////////////
43 | template<class A, class B>
44 | struct Pair
45 | {
46 | 	typedef A One;
47 | 	typedef B Two;
48 | };
49 | ///////////////////////////////////////////////////////////////////////////////
50 | template<bool ishit, class Origin, class Dir, class Dist>
51 | struct CalcPosition
52 | {
53 | 	typedef typename Add<Origin, typename Mul<Dir, Dist>::Result>::Result Result;
54 | };
55 | 
56 | template<class Origin, class Dir, class Dist>
57 | struct CalcPosition<false,Origin,Dir,Dist>
58 | {
59 | 	typedef Vec3Zero Result;
60 | };
61 | ///////////////////////////////////////////////////////////////////////////////
62 | 


--------------------------------------------------------------------------------