├── fit
    ├── plots
    │   └── .dummy
    ├── results
    │   ├── ltc_1.dds
    │   ├── ltc_2.dds
    │   └── ltc.h
    ├── dds.h
    ├── brdf.h
    ├── genie.lua
    ├── brdf_disneyDiffuse.h
    ├── LTC.h
    ├── brdf_beckmann.h
    ├── brdf_ggx.h
    ├── float_to_half.h
    ├── dds.cpp
    ├── nelder_mead.h
    ├── export.h
    ├── plot.h
    └── fitLTC.cpp
├── webgl
    ├── images
    │   └── error_icon.png
    ├── shaders
    │   └── ltc
    │   │   ├── ltc.vs
    │   │   ├── ltc_blit.vs
    │   │   ├── ltc_blit.fs
    │   │   ├── ltc_quad.fs
    │   │   ├── ltc_line.fs
    │   │   └── ltc_disk.fs
    ├── css
    │   ├── normal_map_blending.css
    │   ├── plugin.css
    │   ├── ace_theme_tweaks.css
    │   ├── super_picker.css
    │   ├── sandbox.css
    │   ├── jquery.ui.resizable.css
    │   └── super_slider.css
    ├── js
    │   ├── jquery.mousewheel.min.js
    │   ├── ace
    │   │   ├── theme-clouds_midnight.js
    │   │   └── mode-glsl.js
    │   ├── macton
    │   │   ├── macton-utils.js
    │   │   ├── webgl-utils.js
    │   │   ├── cameracontroller.js
    │   │   ├── matrix4x4.js
    │   │   └── macton-gl-utils.js
    │   ├── super_picker.js
    │   ├── super_slider.js
    │   └── color_picker.js
    └── ltc_quad.html
├── .gitmodules
├── .gitignore
├── README.md
└── LICENSE


/fit/plots/.dummy:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/fit/results/ltc_1.dds:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/selfshadow/ltc_code/HEAD/fit/results/ltc_1.dds


--------------------------------------------------------------------------------
/fit/results/ltc_2.dds:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/selfshadow/ltc_code/HEAD/fit/results/ltc_2.dds


--------------------------------------------------------------------------------
/webgl/images/error_icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/selfshadow/ltc_code/HEAD/webgl/images/error_icon.png


--------------------------------------------------------------------------------
/webgl/shaders/ltc/ltc.vs:
--------------------------------------------------------------------------------
1 | in vec3 position;
2 | 
3 | void main()
4 | {
5 |     gl_Position = vec4(position, 1.0);
6 | }


--------------------------------------------------------------------------------
/webgl/shaders/ltc/ltc_blit.vs:
--------------------------------------------------------------------------------
1 | in vec3 position;
2 | 
3 | void main()
4 | {
5 |     gl_Position = vec4(position, 1.0);
6 | }


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "external/CImg"]
2 | 	path = external/CImg
3 | 	url = https://github.com/dtschump/CImg
4 | [submodule "external/glm"]
5 | 	path = external/glm
6 | 	url = https://github.com/g-truc/glm
7 | 


--------------------------------------------------------------------------------
/fit/dds.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | enum PixelFormat
 4 | {
 5 |     DDS_FORMAT_R16G16B16A16_FLOAT = 0,
 6 |     DDS_FORMAT_R32G32B32A32_FLOAT = 1
 7 | };
 8 | 
 9 | bool SaveDDS(char const* path, PixelFormat format, unsigned texelSizeInBytes, unsigned width, unsigned height, void const* data);
10 | 


--------------------------------------------------------------------------------
/webgl/css/normal_map_blending.css:
--------------------------------------------------------------------------------
 1 | #method {
 2 | 	width: 484px;
 3 | 	float: left;
 4 | 	position: relative;
 5 | 	padding: 8px;
 6 | 	margin: 16px 0px 0px 0px;
 7 | 	background: #191919;
 8 | }
 9 | 
10 | #method_text {
11 | 	font-family: helvetica, arial, sans-serif;
12 | 	color: #999;
13 | 	font-size: 12px
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/webgl/css/plugin.css:
--------------------------------------------------------------------------------
 1 | #colorjack_square {
 2 | 	border: 1px solid #404040;
 3 | 	border-radius: 6px;
 4 | 	background: #191919;
 5 | 	box-shadow: 3px 3px 3px rgba(0,0,0,0.35);
 6 | 	-webkit-box-shadow: 3px 3px 3px rgba(0,0,0,0.35);
 7 | 	-moz-box-shadow: 3px 3px 3px rgba(0,0,0,0.35);
 8 | 	cursor: default;
 9 | 	display: block;
10 | 	font-family: arial, helvetica, sans-serif;
11 | 	font-size: 11px;
12 | 	position: relative;
13 | 	width: 215px;
14 | 	height: 10px;
15 | 	z-index:1;
16 | }
17 | 


--------------------------------------------------------------------------------
/fit/brdf.h:
--------------------------------------------------------------------------------
 1 | #ifndef _BRDF_
 2 | #define _BRDF_
 3 | 
 4 | #include <glm/glm.hpp>
 5 | using namespace glm;
 6 | 
 7 | class Brdf
 8 | {
 9 | public:
10 |     // evaluation of the cosine-weighted BRDF
11 |     // pdf is set to the PDF of sampling L
12 |     virtual float eval(const vec3& V, const vec3& L, const float alpha, float& pdf) const = 0;
13 | 
14 |     // sampling
15 |     virtual vec3 sample(const vec3& V, const float alpha, const float U1, const float U2) const = 0;
16 | };
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 
34 | # Makefiles
35 | Makefile
36 | *.make
37 | 
38 | # Visual Studio
39 | *.sln
40 | *.vcxproj*
41 | *.VC.db
42 | .vs
43 | 
44 | # Build
45 | bin
46 | obj
47 | out
48 | 


--------------------------------------------------------------------------------
/fit/genie.lua:
--------------------------------------------------------------------------------
 1 | solution "fitLTC"
 2 |    configurations { "Debug", "Release" }
 3 | 
 4 |    project "fitLTC"
 5 |       kind "ConsoleApp"
 6 |       language "C++"
 7 |       files { "**.h", "**.cpp", "**.c" }
 8 | 
 9 |       includedirs {
10 |          "../external/CImg",
11 |          "../external/glm"
12 |       }
13 | 
14 |       defines { 
15 |          "cimg_display=0"
16 |       }
17 | 
18 |       configuration "Debug"
19 |          targetdir "bin"
20 |          defines { "DEBUG" }
21 |          flags { "Symbols" }
22 | 
23 |       configuration "Release"
24 |          targetdir "bin"
25 |          defines { "NDEBUG" }
26 |          flags { "Optimize" }
27 | 


--------------------------------------------------------------------------------
/webgl/css/ace_theme_tweaks.css:
--------------------------------------------------------------------------------
 1 | .ace-clouds-midnight .ace_gutter {
 2 |   width: 50px;
 3 |   background: #191919;
 4 |   color: #333;
 5 |   overflow : hidden;
 6 | }
 7 | 
 8 | .ace-clouds-midnight .ace_support.ace_function {
 9 |   color:#B58900;
10 | }
11 | 
12 | .ace-clouds-midnight .ace_constant.ace_language {
13 |   color:#B58900;
14 | }
15 | 
16 | .ace-clouds-midnight .ace_variable.ace_language {
17 |   color:#1F74CF;
18 | }
19 | 
20 | .ace_gutter-cell.ace_error {
21 |   background-image: url("../images/error_icon.png");
22 | }
23 | 
24 | .ace_marker-layer .ace_error {
25 | 	position: absolute;
26 | 	z-index: 5;
27 | 	background: rgba(255, 0, 0, 0.5);
28 | }
29 | 


--------------------------------------------------------------------------------
/webgl/css/super_picker.css:
--------------------------------------------------------------------------------
 1 | /* Default styling for SuperPicker controls */
 2 | 
 3 | .sp_picker {
 4 | 	border: 0px solid #333;
 5 | 	border-radius: 6px;
 6 | 	min-height: 14px;
 7 | 	clear: both;
 8 | 	float: left;
 9 | 	-webkit-user-select: none;
10 | 	-moz-user-select: none;
11 | 	}
12 | .sp_label {
13 | 	font-family: helvetica, arial, sans-serif;
14 | 	clear: both;
15 | 	color: #999;
16 | 	display: block;
17 | 	float: left;
18 | 	font-size: 12px;
19 | 	margin: 0 0 1px 0;
20 | 	-webkit-user-select: none;
21 | 	-moz-user-select: none;
22 | 	}
23 | .sp_label:hover {
24 | 	color: #FFF;
25 | 	}
26 | 
27 | .sp_swatch {
28 | 	background: #ff0000;
29 | 	border-radius: 6px;
30 | 	width: 32px;
31 | 	height: 32px;
32 | 	float: left;
33 | 	position: relative;
34 | 	clear: left;
35 | }


--------------------------------------------------------------------------------
/fit/results/ltc.h:
--------------------------------------------------------------------------------
 1 | struct mat33
 2 | {
 3 |     operator glm::mat3() const
 4 |     {
 5 |         return glm::mat3(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
 6 |     }
 7 | 
 8 |     double m[9];
 9 | };
10 | 
11 | 
12 | #include "ltc.inc"
13 | 
14 | #if 1
15 | mat3 M_GGX(const float cosTheta, const float alpha)
16 | {
17 |     int t = std::max<int>(0, std::min<int>(size - 1, (int)floorf(sqrtf(1.0f - cosTheta) * size)));
18 |     int a = std::max<int>(0, std::min<int>(size - 1, (int)floorf(sqrtf(alpha) * size)));
19 | 
20 |     return tabM[a + t*size];
21 | }
22 | 
23 | float magnitude_GGX(const float cosTheta, const float alpha)
24 | {
25 |     int t = std::max<int>(0, std::min<int>(size - 1, (int)floorf(sqrtf(1.0f - cosTheta) * size)));
26 |     int a = std::max<int>(0, std::min<int>(size - 1, (int)floorf(sqrtf(alpha) * size)));
27 | 
28 |     return tabMagnitude[a + t*size];
29 | }
30 | #endif
31 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Overview
 2 | This repository contains an (evolving) reference implementation for the following publications:
 3 | * [Real-Time Polygonal-Light Shading with Linearly Transformed Cosines](https://eheitzresearch.wordpress.com/415-2/) (2016)
 4 | * [Real-Time Area Lighting: a Journey From Research to Production](https://blog.selfshadow.com/publications/s2016-advances/) (2016)
 5 | * [Linear-Light Shading with Linearly Transformed Cosines](https://blogs.unity3d.com/2017/04/17/linear-light-shading-with-linearly-transformed-cosines/) (2017)
 6 | * [Real-Time Line- and Disk-Light Shading](https://blog.selfshadow.com/publications/s2017-shading-course/) (2017)
 7 | 
 8 | ## Notes:
 9 | * The Linearly Transformed Cosine (LTC) tables in this implementation differ in their parameterisation and storage compared to [the original paper](https://eheitzresearch.wordpress.com/415-2/). See fitting code and WebGL demos for details.
10 | 
11 | ## WebGL Demos
12 | [Quad lights](http://blog.selfshadow.com/ltc/webgl/ltc_quad.html)  
13 | [Line lights](http://blog.selfshadow.com/ltc/webgl/ltc_line.html)  
14 | [Disk lights](http://blog.selfshadow.com/ltc/webgl/ltc_disk.html)  
15 | 


--------------------------------------------------------------------------------
/webgl/js/jquery.mousewheel.min.js:
--------------------------------------------------------------------------------
 1 | /* Copyright (c) 2009 Brandon Aaron (http://brandonaaron.net)
 2 |  * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 3 |  * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
 4 |  * Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers.
 5 |  * Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix.
 6 |  *
 7 |  * Version: 3.0.2
 8 |  * 
 9 |  * Requires: 1.2.2+
10 |  */
11 | (function(c){var a=["DOMMouseScroll","mousewheel"];c.event.special.mousewheel={setup:function(){if(this.addEventListener){for(var d=a.length;d;){this.addEventListener(a[--d],b,false)}}else{this.onmousewheel=b}},teardown:function(){if(this.removeEventListener){for(var d=a.length;d;){this.removeEventListener(a[--d],b,false)}}else{this.onmousewheel=null}}};c.fn.extend({mousewheel:function(d){return d?this.bind("mousewheel",d):this.trigger("mousewheel")},unmousewheel:function(d){return this.unbind("mousewheel",d)}});function b(f){var d=[].slice.call(arguments,1),g=0,e=true;f=c.event.fix(f||window.event);f.type="mousewheel";if(f.wheelDelta){g=f.wheelDelta/120}if(f.detail){g=-f.detail/3}d.unshift(f,g);return c.event.handle.apply(this,d)}})(jQuery);


--------------------------------------------------------------------------------
/webgl/css/sandbox.css:
--------------------------------------------------------------------------------
 1 | body {
 2 | 	background-color: #000000;
 3 | 	margin: 0px;
 4 | 	overflow: hidden;
 5 | }
 6 | 
 7 | 
 8 | #editor {
 9 | 	width: 100%;
10 | 	height: 100%;
11 | 	margin: 0px;
12 | 	border: 2px solid #404040;
13 | 	border-radius: 6px
14 | }
15 | 
16 | 
17 | .canvas {
18 | 	border: 2px solid #404040;
19 | 	border-radius: 6px
20 | }
21 | 
22 | 
23 | #params {
24 | 	display: table;
25 | 	float: left;
26 | 	position: relative;
27 | 	padding: 8px 8px 0px;
28 | 	margin: 8px;
29 | 	background: #191919;
30 | 	border: 2px solid #404040;
31 | 	border-radius: 6px
32 | }
33 | 
34 | 
35 | #status {
36 | 	width: 484px;
37 | 	float: left;
38 | 	position: relative;
39 | 	padding: 8px;
40 | 	margin: 16px 0px 0px 0px;
41 | 	background: #191919;
42 | 	border: 2px solid #404040;
43 | 	border-radius: 6px
44 | }
45 | 
46 | #status_text {
47 | 	font-family: helvetica, arial, sans-serif;
48 | 	color: #999;
49 | 	font-size: 12px
50 | }
51 | 
52 | 
53 | .checkbox_label {
54 | 	font-family: helvetica, arial, sans-serif;
55 | 	clear: both;
56 | 	color: #999;
57 | 	display: block;
58 | 	float: left;
59 | 	font-size: 12px;
60 | 	-webkit-user-select: none;
61 | 	-moz-user-select: none;
62 | }
63 | 
64 | .checkbox_label:hover {
65 | 	color: #FFF;
66 | }


--------------------------------------------------------------------------------
/fit/brdf_disneyDiffuse.h:
--------------------------------------------------------------------------------
 1 | #ifndef _BRDF_DISNEY_DIFFUSE_
 2 | #define _BRDF_DISNEY_DIFFUSE_
 3 | 
 4 | #include "brdf.h"
 5 | 
 6 | class BrdfDisneyDiffuse : public Brdf
 7 | {
 8 | public:
 9 | 
10 |     virtual float eval(const vec3& V, const vec3& L, const float alpha, float& pdf) const
11 |     {
12 |         if (V.z <= 0 || L.z <= 0)
13 |         {
14 |             pdf = 0;
15 |             return 0;
16 |         }
17 | 
18 |         pdf = L.z / 3.14159f;
19 | 
20 |         float NdotV = V.z;
21 |         float NdotL = L.z;
22 |         float LdotH = dot(L, normalize(V + L));
23 |         float perceptualRoughness = sqrtf(alpha);
24 |         float fd90 = 0.5f + 2 * LdotH*LdotH * perceptualRoughness;
25 |         float lightScatter = (1 + (fd90 - 1) * powf(1 - NdotL, 5.0f));
26 |         float viewScatter  = (1 + (fd90 - 1) * powf(1 - NdotV, 5.0f));
27 |         return lightScatter * viewScatter * L.z / 3.14159f;
28 |     }
29 | 
30 |     virtual vec3 sample(const vec3& V, const float alpha, const float U1, const float U2) const
31 |     {
32 |         const float r = sqrtf(U1);
33 |         const float phi = 2.0f*3.14159f * U2;
34 |         const vec3 L = vec3(r*cosf(phi), r*sinf(phi), sqrtf(1.0f - r*r));
35 |         return L;
36 |     }
37 | };
38 | 
39 | #endif
40 | 


--------------------------------------------------------------------------------
/webgl/css/jquery.ui.resizable.css:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * jQuery UI Resizable 1.8.13
 3 |  *
 4 |  * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 5 |  * Dual licensed under the MIT or GPL Version 2 licenses.
 6 |  * http://jquery.org/license
 7 |  *
 8 |  * http://docs.jquery.com/UI/Resizable#theming
 9 |  */
10 | .ui-resizable { position: relative;}
11 | .ui-resizable-handle { position: absolute;font-size: 0.1px;z-index: 99999; display: block;
12 | 	/* http://bugs.jqueryui.com/ticket/7233
13 | 	 - Resizable: resizable handles fail to work in IE if transparent and content overlaps
14 | 	*/
15 | 	background-image:url(data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=);
16 | }
17 | .ui-resizable-disabled .ui-resizable-handle, .ui-resizable-autohide .ui-resizable-handle { display: none; }
18 | .ui-resizable-n { cursor: n-resize; height: 7px; width: 100%; top: -5px; left: 0; }
19 | .ui-resizable-s { cursor: s-resize; height: 7px; width: 100%; bottom: -5px; left: 0; }
20 | .ui-resizable-e { cursor: e-resize; width: 7px; right: -5px; top: 0; height: 100%; }
21 | .ui-resizable-w { cursor: w-resize; width: 7px; left: -5px; top: 0; height: 100%; }
22 | .ui-resizable-se { cursor: se-resize; width: 12px; height: 12px; right: 1px; bottom: 1px; }
23 | .ui-resizable-sw { cursor: sw-resize; width: 9px; height: 9px; left: -5px; bottom: -5px; }
24 | .ui-resizable-nw { cursor: nw-resize; width: 9px; height: 9px; left: -5px; top: -5px; }
25 | .ui-resizable-ne { cursor: ne-resize; width: 9px; height: 9px; right: -5px; top: -5px;}


--------------------------------------------------------------------------------
/fit/LTC.h:
--------------------------------------------------------------------------------
 1 | #ifndef _LTC_
 2 | #define _LTC_
 3 | 
 4 | 
 5 | #include <glm/glm.hpp>
 6 | using namespace glm;
 7 | 
 8 | #include <iostream>
 9 | using namespace std;
10 | 
11 | struct LTC {
12 | 
13 | 	// lobe magnitude
14 | 	float magnitude;
15 | 
16 | 	// Average Schlick Fresnel term
17 | 	float fresnel;
18 | 
19 | 	// parametric representation
20 | 	float m11, m22, m13;
21 | 	vec3 X, Y, Z;
22 | 
23 | 	// matrix representation
24 | 	mat3 M;
25 | 	mat3 invM;
26 | 	float detM;
27 | 
28 | 	LTC()
29 | 	{
30 | 		magnitude = 1;
31 | 		fresnel = 1;
32 | 		m11 = 1;
33 | 		m22 = 1;
34 | 		m13 = 0;
35 | 		X = vec3(1, 0, 0);
36 | 		Y = vec3(0, 1, 0);
37 | 		Z = vec3(0, 0, 1);
38 | 		update();
39 | 	}
40 | 
41 | 	void update() // compute matrix from parameters
42 | 	{
43 | 		M = mat3(X, Y, Z) *
44 | 			mat3(m11, 0, 0,
45 | 				0, m22, 0,
46 | 				m13, 0, 1);
47 | 		invM = inverse(M);
48 | 		detM = abs(glm::determinant(M));
49 | 	}
50 | 
51 | 	float eval(const vec3& L) const
52 | 	{
53 | 		vec3 Loriginal = normalize(invM * L);
54 | 		vec3 L_ = M * Loriginal;
55 | 
56 | 		float l = length(L_);
57 | 		float Jacobian = detM / (l*l*l);
58 | 
59 | 		float D = 1.0f / 3.14159f * glm::max<float>(0.0f, Loriginal.z); 
60 | 		
61 | 		float res = magnitude * D / Jacobian;
62 | 		return res;
63 | 	}
64 | 
65 | 	vec3 sample(const float U1, const float U2) const
66 | 	{
67 | 		const float theta = acosf(sqrtf(U1));
68 | 		const float phi = 2.0f*3.14159f * U2;
69 | 		const vec3 L = normalize(M * vec3(sinf(theta)*cosf(phi), sinf(theta)*sinf(phi), cosf(theta)));
70 | 		return L;
71 | 	}
72 | };
73 | 
74 | #endif
75 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017, Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt.
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * If you use (or adapt) the source code in your own work, please include a 
 8 |   reference to the paper:
 9 | 
10 |   Real-Time Polygonal-Light Shading with Linearly Transformed Cosines.
11 |   Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt.
12 |   ACM Transactions on Graphics (Proceedings of ACM SIGGRAPH 2016) 35(4), 2016.
13 |   Project page: https://eheitzresearch.wordpress.com/415-2/
14 | 
15 | * Redistributions of source code must retain the above copyright notice, this
16 |   list of conditions and the following disclaimer.
17 | 
18 | * Redistributions in binary form must reproduce the above copyright notice,
19 |   this list of conditions and the following disclaimer in the documentation
20 |   and/or other materials provided with the distribution.
21 | 
22 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
26 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
28 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 | 


--------------------------------------------------------------------------------
/fit/brdf_beckmann.h:
--------------------------------------------------------------------------------
 1 | #ifndef _BRDF_BECKMANN_
 2 | #define _BRDF_BECKMANN_
 3 | 
 4 | #include "brdf.h"
 5 | 
 6 | class BrdfBeckmann : public Brdf
 7 | {
 8 | public:
 9 |     virtual float eval(const vec3& V, const vec3& L, const float alpha, float& pdf) const
10 |     {
11 |         if (V.z <= 0)
12 |         {
13 |             pdf = 0;
14 |             return 0;
15 |         }
16 | 
17 |         // masking
18 |         const float LambdaV = lambda(alpha, V.z);
19 | 
20 |         // shadowing
21 |         float G2;
22 |         if (L.z <= 0.0f)
23 |             G2 = 0;
24 |         else
25 |         {
26 |             const float LambdaL = lambda(alpha, L.z);
27 |             G2 = 1.0f/(1.0f + LambdaV + LambdaL);
28 |         }
29 | 
30 |         // D
31 |         const vec3 H = normalize(V + L);
32 |         const float slopex = H.x/H.z;
33 |         const float slopey = H.y/H.z;
34 |         float D = expf(-(slopex*slopex + slopey*slopey)/(alpha*alpha)) / (3.14159f * alpha*alpha * H.z*H.z*H.z*H.z);
35 | 
36 |         pdf = fabsf(D * H.z / 4.0f / dot(V, H));
37 |         float res = D * G2 / 4.0f / V.z;
38 | 
39 |         return res;
40 |     }
41 | 
42 |     virtual vec3 sample(const vec3& V, const float alpha, const float U1, const float U2) const
43 |     {
44 |         const float phi = 2.0f*3.14159f * U1;
45 |         const float r = alpha*sqrtf(-logf(U2));
46 |         const vec3 N = normalize(vec3(r*cosf(phi), r*sinf(phi), 1.0f));
47 |         const vec3 L = -V + 2.0f * N * dot(N, V);
48 |         return L;
49 |     }
50 | 
51 | private:
52 |     float lambda(const float alpha, const float cosTheta) const
53 |     {
54 |         const float a = 1.0f / alpha / tanf(acosf(cosTheta));
55 |         return (cosTheta < 1.0f) ? (1.0f - 1.259f*a + 0.396f*a*a) / (3.535f*a + 2.181f*a*a) : 0.0f;
56 |     }
57 | };
58 | 
59 | #endif
60 | 


--------------------------------------------------------------------------------
/fit/brdf_ggx.h:
--------------------------------------------------------------------------------
 1 | #ifndef _BRDF_GGX_
 2 | #define _BRDF_GGX_
 3 | 
 4 | #include "brdf.h"
 5 | 
 6 | class BrdfGGX : public Brdf
 7 | {
 8 | public:
 9 |     virtual float eval(const vec3& V, const vec3& L, const float alpha, float& pdf) const
10 |     {
11 |         if (V.z <= 0)
12 |         {
13 |             pdf = 0;
14 |             return 0;
15 |         }
16 | 
17 |         // masking
18 |         const float LambdaV = lambda(alpha, V.z);
19 | 
20 |         // shadowing
21 |         float G2;
22 |         if (L.z <= 0.0f)
23 |             G2 = 0;
24 |         else
25 |         {
26 |             const float LambdaL = lambda(alpha, L.z);
27 |             G2 = 1.0f/(1.0f + LambdaV + LambdaL);
28 |         }
29 | 
30 |         // D
31 |         const vec3 H = normalize(V + L);
32 |         const float slopex = H.x/H.z;
33 |         const float slopey = H.y/H.z;
34 |         float D = 1.0f / (1.0f + (slopex*slopex + slopey*slopey)/alpha/alpha);
35 |         D = D*D;
36 |         D = D/(3.14159f * alpha*alpha * H.z*H.z*H.z*H.z);
37 | 
38 |         pdf = fabsf(D * H.z / 4.0f / dot(V, H));
39 |         float res = D * G2 / 4.0f / V.z;
40 | 
41 |         return res;
42 |     }
43 | 
44 |     virtual vec3 sample(const vec3& V, const float alpha, const float U1, const float U2) const
45 |     {
46 |         const float phi = 2.0f*3.14159f * U1;
47 |         const float r = alpha*sqrtf(U2/(1.0f - U2));
48 |         const vec3 N = normalize(vec3(r*cosf(phi), r*sinf(phi), 1.0f));
49 |         const vec3 L = -V + 2.0f * N * dot(N, V);
50 |         return L;
51 |     }
52 | 
53 | private:
54 |     float lambda(const float alpha, const float cosTheta) const
55 |     {
56 |         const float a = 1.0f / alpha / tanf(acosf(cosTheta));
57 |         return (cosTheta < 1.0f) ? 0.5f * (-1.0f + sqrtf(1.0f + 1.0f/a/a)) : 0.0f;    
58 |     }
59 | };
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/fit/float_to_half.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // Adapted from:
 4 | // https://gist.github.com/rygorous/2156668
 5 | 
 6 | union FP32
 7 | {
 8 |     uint32_t u;
 9 |     float f;
10 |     struct
11 |     {
12 |         uint32_t Mantissa : 23;
13 |         uint32_t Exponent : 8;
14 |         uint32_t Sign : 1;
15 |     };
16 | };
17 | 
18 | union FP16
19 | {
20 |     uint16_t u;
21 |     struct
22 |     {
23 |         uint32_t Mantissa : 10;
24 |         uint32_t Exponent : 5;
25 |         uint32_t Sign : 1;
26 |     };
27 | };
28 | 
29 | static uint16_t float_to_half_fast(float x)
30 | {
31 |     FP32 f;
32 |     f.f = x;
33 | 
34 |     FP16 o = { 0 };
35 | 
36 |     // Based on ISPC reference code (with minor modifications)
37 |     if (f.Exponent == 255) // Inf or NaN (all exponent bits set)
38 |     {
39 |         o.Exponent = 31;
40 |         o.Mantissa = f.Mantissa ? 0x200 : 0; // NaN->qNaN and Inf->Inf
41 |     }
42 |     else // Normalized number
43 |     {
44 |         // Exponent unbias the single, then bias the halfp
45 |         int newexp = f.Exponent - 127 + 15;
46 |         if (newexp >= 31) // Overflow, return signed infinity
47 |             o.Exponent = 31;
48 |         else if (newexp <= 0) // Underflow
49 |         {
50 |             if ((14 - newexp) <= 24) // Mantissa might be non-zero
51 |             {
52 |                 uint32_t mant = f.Mantissa | 0x800000; // Hidden 1 bit
53 |                 o.Mantissa = mant >> (14 - newexp);
54 |                 if ((mant >> (13 - newexp)) & 1) // Check for rounding
55 |                     o.u++; // Round, might overflow into exp bit, but this is OK
56 |             }
57 |         }
58 |         else
59 |         {
60 |             o.Exponent = newexp;
61 |             o.Mantissa = f.Mantissa >> 13;
62 |             if (f.Mantissa & 0x1000) // Check for rounding
63 |                 o.u++; // Round, might overflow to inf, this is OK
64 |         }
65 |     }
66 | 
67 |     o.Sign = f.Sign;
68 |     return o.u;
69 | }


--------------------------------------------------------------------------------
/webgl/shaders/ltc/ltc_blit.fs:
--------------------------------------------------------------------------------
 1 | 
 2 | uniform vec2 resolution;
 3 | 
 4 | uniform sampler2D tex;
 5 | 
 6 | vec3 rrt_odt_fit(vec3 v)
 7 | {
 8 |     vec3 a = v*(         v + 0.0245786) - 0.000090537;
 9 |     vec3 b = v*(0.983729*v + 0.4329510) + 0.238081;
10 |     return a/b;
11 | }
12 | 
13 | mat3 mat3_from_rows(vec3 c0, vec3 c1, vec3 c2)
14 | {
15 |     mat3 m = mat3(c0, c1, c2);
16 |     m = transpose(m);
17 | 
18 |     return m;
19 | }
20 | 
21 | vec3 mul(mat3 m, vec3 v)
22 | {
23 |     return m * v;
24 | }
25 | 
26 | mat3 mul(mat3 m1, mat3 m2)
27 | {
28 |     return m1 * m2;
29 | }
30 | 
31 | float saturate(float v)
32 | {
33 |     return clamp(v, 0.0, 1.0);
34 | }
35 | 
36 | vec3 saturate(vec3 v)
37 | {
38 |     return vec3(saturate(v.x), saturate(v.y), saturate(v.z));
39 | }
40 | 
41 | vec3 aces_fitted(vec3 color)
42 | {
43 |     mat3 ACES_INPUT_MAT = mat3_from_rows(
44 |         vec3( 0.59719, 0.35458, 0.04823),
45 |         vec3( 0.07600, 0.90834, 0.01566),
46 |         vec3( 0.02840, 0.13383, 0.83777));
47 | 
48 |     mat3 ACES_OUTPUT_MAT = mat3_from_rows(
49 |         vec3( 1.60475,-0.53108,-0.07367),
50 |         vec3(-0.10208, 1.10813,-0.00605),
51 |         vec3(-0.00327,-0.07276, 1.07602));
52 | 
53 |     color = mul(ACES_INPUT_MAT, color);
54 | 
55 |     // Apply RRT and ODT
56 |     color = rrt_odt_fit(color);
57 | 
58 |     color = mul(ACES_OUTPUT_MAT, color);
59 | 
60 |     // Clamp to [0, 1]
61 |     color = saturate(color);
62 | 
63 |     return color;
64 | }
65 | 
66 | vec3 PowVec3(vec3 v, float p)
67 | {
68 |     return vec3(pow(v.x, p), pow(v.y, p), pow(v.z, p));
69 | }
70 | 
71 | const float gamma = 2.2;
72 | vec3 ToSRGB(vec3 v) { return PowVec3(v, 1.0/gamma); }
73 | 
74 | out vec4 FragColor;
75 | 
76 | void main()
77 | {
78 |     vec2 pos = gl_FragCoord.xy/resolution;
79 | 
80 |     vec4 col = texture(tex, pos);
81 | 
82 |     // Rescale by number of samples
83 |     col /= col.w;
84 | 
85 |     col.rgb = aces_fitted(col.rgb);
86 |     col.rgb = ToSRGB(col.rgb);
87 | 
88 |     FragColor = vec4(col);
89 | }
90 | 


--------------------------------------------------------------------------------
/webgl/js/ace/theme-clouds_midnight.js:
--------------------------------------------------------------------------------
1 | define("ace/theme/clouds_midnight",["require","exports","module","ace/lib/dom"],function(e,t,n){t.isDark=!0,t.cssClass="ace-clouds-midnight",t.cssText=".ace-clouds-midnight .ace_gutter {background: #232323;color: #929292}.ace-clouds-midnight .ace_print-margin {width: 1px;background: #232323}.ace-clouds-midnight{background-color: #191919;color: #929292}.ace-clouds-midnight .ace_cursor {color: #7DA5DC}.ace-clouds-midnight .ace_marker-layer .ace_selection {background: #000000}.ace-clouds-midnight.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px #191919;border-radius: 2px}.ace-clouds-midnight .ace_marker-layer .ace_step {background: rgb(102, 82, 0)}.ace-clouds-midnight .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid #BFBFBF}.ace-clouds-midnight .ace_marker-layer .ace_active-line {background: rgba(215, 215, 215, 0.031)}.ace-clouds-midnight .ace_gutter-active-line {background-color: rgba(215, 215, 215, 0.031)}.ace-clouds-midnight .ace_marker-layer .ace_selected-word {border: 1px solid #000000}.ace-clouds-midnight .ace_invisible {color: #BFBFBF}.ace-clouds-midnight .ace_keyword,.ace-clouds-midnight .ace_meta,.ace-clouds-midnight .ace_support.ace_constant.ace_property-value {color: #927C5D}.ace-clouds-midnight .ace_keyword.ace_operator {color: #4B4B4B}.ace-clouds-midnight .ace_keyword.ace_other.ace_unit {color: #366F1A}.ace-clouds-midnight .ace_constant.ace_language {color: #39946A}.ace-clouds-midnight .ace_constant.ace_numeric {color: #46A609}.ace-clouds-midnight .ace_constant.ace_character.ace_entity {color: #A165AC}.ace-clouds-midnight .ace_invalid {color: #FFFFFF;background-color: #E92E2E}.ace-clouds-midnight .ace_fold {background-color: #927C5D;border-color: #929292}.ace-clouds-midnight .ace_storage,.ace-clouds-midnight .ace_support.ace_class,.ace-clouds-midnight .ace_support.ace_function,.ace-clouds-midnight .ace_support.ace_other,.ace-clouds-midnight .ace_support.ace_type {color: #E92E2E}.ace-clouds-midnight .ace_string {color: #5D90CD}.ace-clouds-midnight .ace_comment {color: #3C403B}.ace-clouds-midnight .ace_entity.ace_name.ace_tag,.ace-clouds-midnight .ace_entity.ace_other.ace_attribute-name {color: #606060}.ace-clouds-midnight .ace_indent-guide {background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWNgYGBgYHB3d/8PAAOIAdULw8qMAAAAAElFTkSuQmCC) right repeat-y;}";var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)})


--------------------------------------------------------------------------------
/fit/dds.cpp:
--------------------------------------------------------------------------------
 1 | #include "dds.h"
 2 | #include <stdint.h>
 3 | #include <stdio.h>
 4 | #include <string.h>
 5 | #include <cstddef>
 6 | 
 7 | #pragma pack(push, 1)
 8 | struct DDS_PIXELFORMAT
 9 | {
10 |     uint32_t dwSize;
11 |     uint32_t dwFlags;
12 |     uint32_t dwFourCC;
13 |     uint32_t dwRGBBitCount;
14 |     uint32_t dwRBitMask;
15 |     uint32_t dwGBitMask;
16 |     uint32_t dwBBitMask;
17 |     uint32_t dwABitMask;
18 | };
19 | 
20 | struct DDS_HEADER
21 | {
22 |     uint32_t        dwSize;
23 |     uint32_t        dwFlags;
24 |     uint32_t        dwHeight;
25 |     uint32_t        dwWidth;
26 |     uint32_t        dwPitchOrLinearSize;
27 |     uint32_t        dwDepth;
28 |     uint32_t        dwMipMapCount;
29 |     uint32_t        dwReserved1[11];
30 |     DDS_PIXELFORMAT ddspf;
31 |     uint32_t        dwCaps;
32 |     uint32_t        dwCaps2;
33 |     uint32_t        dwCaps3;
34 |     uint32_t        dwCaps4;
35 |     uint32_t        dwReserved2;
36 | };
37 | #pragma pack(pop)
38 | 
39 | uint32_t const DDS_MAGIC                        = 0x20534444; // "DDS "
40 | uint32_t const DDS_HEADER_FLAGS_TEXTURE         = 0x00001007; // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
41 | uint32_t const DDS_HEADER_FLAGS_PITCH           = 0x00000008;
42 | uint32_t const DDS_SURFACE_FLAGS_TEXTURE        = 0x00001000; // DDSCAPS_TEXTURE
43 | uint32_t const DDS_PF_FLAGS_FOURCC              = 0x00000004;
44 | uint32_t const DDS_RESOURCE_DIMENSION_TEXTURE2D = 3;
45 | 
46 | DDS_PIXELFORMAT const DDSPF_RGBA16F = { sizeof(DDS_PIXELFORMAT), DDS_PF_FLAGS_FOURCC, 113, 0, 0, 0, 0, 0 };
47 | DDS_PIXELFORMAT const DDSPF_RGBA32F = { sizeof(DDS_PIXELFORMAT), DDS_PF_FLAGS_FOURCC, 116, 0, 0, 0, 0, 0 };
48 | 
49 | DDS_PIXELFORMAT const* GetDDSPixelFormat(PixelFormat format)
50 | {
51 |     switch (format)
52 |     {
53 |         case DDS_FORMAT_R16G16B16A16_FLOAT: return &DDSPF_RGBA16F;
54 |         case DDS_FORMAT_R32G32B32A32_FLOAT: return &DDSPF_RGBA32F;
55 |     }
56 | 
57 |     return nullptr;
58 | }
59 | 
60 | bool SaveDDS(char const* path, PixelFormat format, unsigned texelSizeInBytes, unsigned width, unsigned height, void const* data)
61 | {
62 |     FILE* f = fopen(path, "wb");
63 |     if (!f)
64 |         return false;
65 | 
66 |     fwrite(&DDS_MAGIC, sizeof(DDS_MAGIC), 1, f);
67 | 
68 |     DDS_PIXELFORMAT const* ddspf = GetDDSPixelFormat(format);
69 |     if (ddspf == nullptr)
70 |         return false;
71 | 
72 |     DDS_HEADER hdr;
73 |     memset(&hdr, 0, sizeof(hdr));
74 |     hdr.dwSize              = sizeof(hdr);
75 |     hdr.dwFlags             = DDS_HEADER_FLAGS_TEXTURE | DDS_HEADER_FLAGS_PITCH;
76 |     hdr.dwHeight            = height;
77 |     hdr.dwWidth             = width;
78 |     hdr.dwDepth             = 1;
79 |     hdr.dwMipMapCount       = 1;
80 |     hdr.dwPitchOrLinearSize = width*texelSizeInBytes;
81 |     hdr.ddspf               = *ddspf;
82 |     hdr.dwCaps              = DDS_SURFACE_FLAGS_TEXTURE;
83 |     fwrite(&hdr, sizeof(hdr), 1, f);
84 | 
85 |     fwrite(data, width * height * texelSizeInBytes, 1, f);
86 | 
87 |     fclose(f);
88 | 
89 |     return true;
90 | }


--------------------------------------------------------------------------------
/webgl/js/macton/macton-utils.js:
--------------------------------------------------------------------------------
  1 | jQuery.getFiles = function( file_list, success )
  2 | {
  3 |   var results    = [];
  4 |   var file_count = file_list.length;
  5 | 
  6 |   var hold_file = function( ndx, data )
  7 |   {
  8 |     results[ndx] = data;
  9 |     file_count--;
 10 |     if ( file_count == 0 ) success( results );
 11 |   }    
 12 | 
 13 |   var get_file = function( ndx, url )
 14 |   {
 15 |     $.get( url, function( data ) { hold_file( ndx, data ); } );
 16 |   }
 17 | 
 18 |   for (var i=0;i<file_count;i++)
 19 |   {
 20 |     get_file( i, file_list[i] );
 21 |   } 
 22 | }
 23 | 
 24 | jQuery.TriggerEvent = function( event_name, event_parameters_array )
 25 | {
 26 |   $(document).trigger( event_name, event_parameters_array );
 27 | }
 28 | 
 29 | jQuery.BindEvent = function( event_name, callback_function )
 30 | {
 31 |   $(document).bind( event_name, callback_function );
 32 | }
 33 | 
 34 | jQuery.UnbindEvent = function( event_name )
 35 | {
 36 |   $(document).unbind( event_name );
 37 | }
 38 | 
 39 | function fieldCount( obj )
 40 | {
 41 |   var field_count = 0;
 42 |   for (k in obj) 
 43 |   {
 44 |     if (obj.hasOwnProperty(k))
 45 |     {
 46 |       field_count++;
 47 |     }
 48 |   }
 49 |   return (field_count);
 50 | }
 51 | 
 52 | // LD - Lukasz Stilger (javascript version) http://www.mgilleland.com/ld/ldjavascript.htm
 53 | // Levenshtein Distance http://www.merriampark.com/ld.htm 
 54 | 
 55 | function stringLD(t) 
 56 | {
 57 |   var s  = this;
 58 |   var dG = new Array();
 59 |   
 60 |   function Minimum(a, b, c) 
 61 |   {
 62 |     var mi;
 63 |     mi = a;
 64 |     if (b < mi)
 65 |       mi = b;
 66 |     if (c < mi)
 67 |       mi = c;
 68 |     return mi;
 69 |   }
 70 |  
 71 |   var d = new Array();
 72 |   var n; // length of s
 73 |   var m; // length of t
 74 |   var i; // iterates through s
 75 |   var j; // iterates through t
 76 |   var s_i; // ith character of s
 77 |   var t_j; // jth character of t
 78 |   var cost; // cost
 79 |  
 80 |  
 81 |   // Step 1
 82 |   n = s.length;
 83 |   m = t.length;
 84 |   if (n == 0) {
 85 |     return m;
 86 |   }
 87 |  
 88 |   if (m == 0) {
 89 |     return n;
 90 |   }
 91 |   
 92 |   //inicjacja tablicy dwu-wymiarowej w Javascript  
 93 |   for(i=0; i<=n; i++)
 94 |     d[i] = new Array();
 95 |  
 96 |  
 97 |   // Step 2
 98 |   for (i = 0; i <= n; i++) {
 99 |     d[i][0] = i;
100 |   }
101 |  
102 |   for (j = 0; j <= m; j++) {
103 |     d[0][j] = j;
104 |   }
105 |  
106 |   // Step 3
107 |   for (i = 1; i <= n; i++) {
108 |  
109 |     s_i = s.charAt(i - 1);
110 |  
111 |     
112 |     // Step 4
113 |     for (j = 1; j <= m; j++) {
114 |  
115 |       t_j = t.charAt(j - 1);
116 |  
117 |       // Step 5
118 |       if (s_i == t_j) {
119 |         cost = 0;
120 |       }
121 |       else {
122 |         cost = 1;
123 |       }
124 |  
125 |       // Step 6
126 |       d[i][j] = Minimum (d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1] + cost);
127 |     }
128 |  
129 |   }
130 |   
131 |   //przepisanie do tablicy globalnej
132 |   for(i=1; i<=n; i++) {
133 |     dG[i] = new Array();
134 |     for(j=1; j<=m; j++)
135 |       dG[i][j] = d[i][j];
136 |   }
137 |  
138 |   // Step 7
139 |   return d[n][m];
140 | }
141 | 
142 | String.prototype.LD = stringLD;
143 | 


--------------------------------------------------------------------------------
/webgl/js/super_picker.js:
--------------------------------------------------------------------------------
  1 | 
  2 | function SuperPicker(id, opts) {
  3 | 	this.id = id;
  4 | 	this.init(opts);
  5 | 	
  6 | 	return this.picker;
  7 | }
  8 | 
  9 | SuperPicker.prototype = {
 10 | 	
 11 | 	init: function (opts) {
 12 | 		var self = this,
 13 | 			opt,
 14 | 			style;
 15 | 	
 16 | 		this.pick = null;
 17 | 	
 18 | 		this.options =  { 
 19 | 			picker_class   : 'sp_picker', // picker class name
 20 | 			swatch_class   : 'sp_swatch', // swatch class name
 21 | 			label_class    : 'sp_label',  // label class name
 22 | 			default_value  : { r: 255, g: 255, b: 255 },
 23 | 			value          : { r: 255, g: 255, b: 255 },
 24 | 			label          : null,        // label
 25 | 			callback       : undefined
 26 | 		};
 27 | 	
 28 | 		for (opt in opts) {
 29 | 			if (opts.hasOwnProperty.call(opts, opt)) {
 30 | 				this.options[opt] = opts[opt];
 31 | 			}
 32 | 		}
 33 | 
 34 | 		// Build picker
 35 | 		this.picker = $("<div>")
 36 | 			.addClass(this.options.picker_class)
 37 | 			.css("webkitUserSelect", 'none');
 38 | 
 39 | 		if (this.options.label) {
 40 | 			this.label = $("<label>")
 41 | 				.text(this.options.label)
 42 | 				.addClass(this.options.label_class)
 43 | 				.attr("title", "Click to reset to default");
 44 | 			this.picker.append(this.label.get(0));
 45 | 		}
 46 | 		
 47 | 		var setBackgroundColor = function(element, r, g, b) {
 48 | 			self.r = r;
 49 | 			self.g = g;
 50 | 			self.b = b;		
 51 | 			element.css("background", "rgba(" + r + ", " + g + ", " + b + ", 1)");
 52 | 		}
 53 | 
 54 | 		this.swatch = $("<div>")
 55 | 			.addClass(this.options.swatch_class)
 56 | 			.css("webkitUserSelect", 'none');
 57 | 
 58 | 		var v = this.options.value;
 59 | 		var r = Math.round(v.r*255);
 60 | 		var g = Math.round(v.g*255);
 61 | 		var b = Math.round(v.b*255);
 62 | 		setBackgroundColor(this.swatch, r, g, b);
 63 | 
 64 | 		this.picker.append(this.swatch.get(0));
 65 | 
 66 | 		function newPicker(fade) {
 67 | 			var that = this;
 68 | 			var swatch = self.swatch;
 69 | 			var callback = self.options.callback;
 70 | 			var hsv = ColorXXX.rgb2hsv(self.r, self.g, self.b);
 71 | 
 72 | 			var picker = new ColorXXX.Picker({
 73 | 				hue: hsv[0],
 74 | 				sat: hsv[1],
 75 | 				val: hsv[2],
 76 | 				fade: fade,
 77 | 				callback: function(rgb) {
 78 | 					setBackgroundColor(self.swatch, rgb.R, rgb.G, rgb.B);
 79 | 					var c = new Color(rgb.R/255, rgb.G/255, rgb.B/255);
 80 | 					callback(c);
 81 | 				}
 82 | 			});
 83 | 
 84 | 			picker.el.style.top  = "0px";
 85 | 			picker.el.style.left = "40px";
 86 | 			
 87 | 			self.swatch.append(picker.el);
 88 | 
 89 | 			return picker;
 90 | 		}
 91 | 
 92 | 
 93 | 		// Define event listeners
 94 | 
 95 | 		this.labelClick = function (event) {
 96 | 			self.label.trigger("reset");
 97 | 
 98 | 			var v = self.options.default_value;
 99 | 			var r = Math.round(v.r*255);
100 | 			var g = Math.round(v.g*255);
101 | 			var b = Math.round(v.b*255);
102 | 			setBackgroundColor(self.swatch, r, g, b);
103 | 
104 | 			if (self.pick !== null) {
105 | 				var visible = self.pick.visible();
106 | 				self.picker.destroy();
107 | 				if (visible)
108 | 					self.pick = newPicker(false);
109 | 			}
110 | 
111 | 			return false;
112 | 		};
113 | 
114 | 		this.swatchClick = function (event) {
115 | 			if (self.pick === null)
116 | 				self.pick = newPicker(true);
117 | 			else
118 | 				self.pick.toggle();
119 | 
120 | 			return false;
121 | 		}
122 | 
123 | 		this.picker.bind("DOMNodeInserted", function (event) {
124 | 			self.pickerInserted(event);
125 | 			self.initialised = true;
126 | 		});
127 | 
128 | 		this.picker.bind("DOMNodeRemoved", function (event) {
129 | 			self.pickerRemoved(event);
130 | 		});
131 | 
132 | 		this.picker.destroy = function() {
133 | 			if (self.pick === null)
134 | 				return;
135 | 
136 | 			self.pick.destroyMe();
137 | 			self.pick = null;
138 | 		}
139 | 
140 | 		this.infocus = false;
141 | 	},
142 | 	
143 | 
144 | 	// Picker inserted into the DOM and ready for action
145 | 	pickerInserted: function (event) {
146 | 		var self = this;
147 | 		
148 | 		if (self.initialised)
149 | 			return;
150 | 	
151 | 		if (this.label) {
152 | 			this.label.bind("click", this.labelClick);
153 | 		}
154 | 
155 | 		this.swatch.bind("click", this.swatchClick);
156 | 	},
157 | 
158 | 	pickerRemoved: function (event) {	
159 | 		this.picker.destroy();
160 | 	},
161 | };
162 | 
163 | 
164 | 


--------------------------------------------------------------------------------
/fit/nelder_mead.h:
--------------------------------------------------------------------------------
  1 | #ifndef NELDER_MEAD_H
  2 | #define NELDER_MEAD_H
  3 | 
  4 | void mov(float* r, const float* v, int dim)
  5 | {
  6 |     for (int i = 0; i < dim; ++i)
  7 |         r[i] = v[i];
  8 | }
  9 | 
 10 | void set(float* r, const float v, int dim)
 11 | {
 12 |     for (int i = 0; i < dim; ++i)
 13 |         r[i] = v;
 14 | }
 15 | 
 16 | void add(float* r, const float* v, int dim)
 17 | {
 18 |     for (int i = 0; i < dim; ++i)
 19 |         r[i] += v[i];
 20 | }
 21 | 
 22 | // Downhill simplex solver:
 23 | // http://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method#One_possible_variation_of_the_NM_algorithm
 24 | // using the termination criterion from Numerical Recipes in C++ (3rd Ed.)
 25 | template<int DIM, typename FUNC>
 26 | float NelderMead(
 27 |     float* pmin, const float* start, float delta, float tolerance, int maxIters, FUNC objectiveFn)
 28 | {
 29 |     // standard coefficients from Nelder-Mead
 30 |     const float reflect  = 1.0f;
 31 |     const float expand   = 2.0f;
 32 |     const float contract = 0.5f;
 33 |     const float shrink   = 0.5f;
 34 | 
 35 |     typedef float point[DIM];
 36 |     const int NB_POINTS = DIM + 1;
 37 | 
 38 |     point s[NB_POINTS];
 39 |     float f[NB_POINTS];
 40 | 
 41 |     // initialise simplex
 42 |     mov(s[0], start, DIM);
 43 |     for (int i = 1; i < NB_POINTS; i++)
 44 |     {
 45 |         mov(s[i], start, DIM);
 46 |         s[i][i - 1] += delta;
 47 |     }
 48 | 
 49 |     // evaluate function at each point on simplex
 50 |     for (int i = 0; i < NB_POINTS; i++)
 51 |         f[i] = objectiveFn(s[i]);
 52 | 
 53 |     int lo = 0, hi, nh;
 54 | 
 55 |     for (int j = 0; j < maxIters; j++)
 56 |     {
 57 |         // find lowest, highest and next highest
 58 |         lo = hi = nh = 0;
 59 |         for (int i = 1; i < NB_POINTS; i++)
 60 |         {
 61 |             if (f[i] < f[lo])
 62 |                 lo = i;
 63 |             if (f[i] > f[hi])
 64 |             {
 65 |                 nh = hi;
 66 |                 hi = i;
 67 |             }
 68 |             else if (f[i] > f[nh])
 69 |                 nh = i;
 70 |         }
 71 | 
 72 |         // stop if we've reached the required tolerance level
 73 |         float a = fabsf(f[lo]);
 74 |         float b = fabsf(f[hi]);
 75 |         if (2.0f*fabsf(a - b) < (a + b)*tolerance)
 76 |             break;
 77 | 
 78 |         // compute centroid (excluding the worst point)
 79 |         point o;
 80 |         set(o, 0.0f, DIM);
 81 |         for (int i = 0; i < NB_POINTS; i++)
 82 |         {
 83 |             if (i == hi) continue;
 84 |             add(o, s[i], DIM);
 85 |         }
 86 | 
 87 |         for (int i = 0; i < DIM; i++)
 88 |             o[i] /= DIM;
 89 | 
 90 |         // reflection
 91 |         point r;
 92 |         for (int i = 0; i < DIM; i++)
 93 |             r[i] = o[i] + reflect*(o[i] - s[hi][i]);
 94 | 
 95 |         float fr = objectiveFn(r);
 96 |         if (fr < f[nh])
 97 |         {
 98 |             if (fr < f[lo])
 99 |             {
100 |                 // expansion
101 |                 point e;
102 |                 for (int i = 0; i < DIM; i++)
103 |                     e[i] = o[i] + expand*(o[i] - s[hi][i]);
104 | 
105 |                 float fe = objectiveFn(e);
106 |                 if (fe < fr)
107 |                 {
108 |                     mov(s[hi], e, DIM);
109 |                     f[hi] = fe;
110 |                     continue;
111 |                 }
112 |             }
113 | 
114 |             mov(s[hi], r, DIM);
115 |             f[hi] = fr;
116 |             continue;
117 |         }
118 | 
119 |         // contraction
120 |         point c;
121 |         for (int i = 0; i < DIM; i++)
122 |             c[i] = o[i] - contract*(o[i] - s[hi][i]);
123 | 
124 |         float fc = objectiveFn(c);
125 |         if (fc < f[hi])
126 |         {
127 |             mov(s[hi], c, DIM);
128 |             f[hi] = fc;
129 |             continue;
130 |         }
131 | 
132 |         // reduction
133 |         for (int k = 0; k < NB_POINTS; k++)
134 |         {
135 |             if (k == lo) continue;
136 |             for (int i = 0; i < DIM; i++)
137 |                 s[k][i] = s[lo][i] + shrink*(s[k][i] - s[lo][i]);
138 |             f[k] = objectiveFn(s[k]);
139 |         }
140 |     }
141 | 
142 |     // return best point and its value
143 |     mov(pmin, s[lo], DIM);
144 |     return f[lo];
145 | }
146 | 
147 | #endif // NELDER_MEAD_H
148 | 


--------------------------------------------------------------------------------
/webgl/css/super_slider.css:
--------------------------------------------------------------------------------
  1 | /* Default styling for SuperSlider controls */
  2 | 
  3 | .ss_slider {
  4 | 	border: 0px solid #333;
  5 | 	border-radius: 6px;
  6 | 	min-height: 14px;
  7 | 	clear: both;
  8 | 	float: left;
  9 | 	-webkit-user-select: none;
 10 | 	-moz-user-select: none;
 11 | 	}
 12 | .ss_label {
 13 | 	font-family: helvetica, arial, sans-serif;
 14 | 	clear: both;
 15 | 	color: #999;
 16 | 	display: block;
 17 | 	float: left;
 18 | 	font-size: 12px;
 19 | 	margin: 0 0 1px 0;
 20 | 	padding: 0;
 21 | 	-webkit-user-select: none;
 22 | 	-moz-user-select: none;
 23 | 	}
 24 | .ss_label:hover {
 25 | 	color: #FFF;
 26 | 	}
 27 | .ss_track {
 28 | 	background-color: #404040;
 29 | 	border-radius: 4px;
 30 | 	padding: 1px;
 31 | 	width: 150px;
 32 | 	height: 12px;
 33 | 	float: left;
 34 | 	position: relative;
 35 | 	clear: left;
 36 | 	-webkit-user-select: none;
 37 | 	-webkit-user-drag: none;
 38 | 	-moz-user-select: none;
 39 | 	}
 40 | .ss_track:hover {
 41 | 	background-color: #666;
 42 | 	}
 43 | .ss_handle {
 44 | 	background-color: #999;
 45 | 	border-radius: 4px;
 46 | 	width: 20px;
 47 | 	height: 12px;
 48 | 	position: relative;
 49 | 	left: 0;
 50 | 	top: 0;
 51 | 	cursor: pointer;
 52 | 	}
 53 | .ss_handle:focus,
 54 | .ss_handle:hover {
 55 | 	background-color: #FFF;
 56 | 	cursor: pointer;
 57 | 	}
 58 | .ss_input {
 59 | 	font-family: helvetica, arial, sans-serif;
 60 | 	border-radius: 4px;
 61 | 	width: 3em;
 62 | 	font-size: 11px;
 63 | 	color: #999;
 64 | 	border: 1px solid #404040;
 65 | 	background: transparent;
 66 | 	outline: none;
 67 | 	padding: 0;
 68 | 	line-height: 1;
 69 | 	vertical-align: top;
 70 | 	margin: 0 0 0 10px;
 71 | 	float: left;
 72 | 	text-align: right;
 73 | 	-webkit-user-select: text;
 74 | 	-moz-user-select: text;
 75 | 	}
 76 | .ss_input:focus {
 77 | 	background-color: #333;
 78 | 	color: #FFF;
 79 | 	}
 80 | 
 81 | 
 82 | /*
 83 | // New
 84 | 
 85 | .ss_slider
 86 | {
 87 |     padding: 5px;
 88 |     border: 1px solid #333;
 89 |     border-radius: 2px;
 90 |     min-height: 14px;
 91 |     clear: both;
 92 |     margin: 5px;
 93 |     float: left;
 94 |     -webkit-user-select:none;
 95 |     -moz-user-select:none
 96 | }
 97 | 
 98 | .ss_label{
 99 | 	font-family: helvetica, arial, sans-serif;
100 | 	clear:both;
101 | 	color: #999;
102 |     display: block;
103 |     float: left;
104 |     font - size: 12px;
105 | 	margin: 0 0 3px 0;
106 |     padding: 0;
107 |     -webkit-user-select: none;
108 |     -moz-user-select: none;
109 |     text-shadow: 0 1px 0 rgba(0, 0, 0, 0.5)
110 | }
111 | 
112 | .ss_slider: hover.ss_label
113 | {
114 |     color: #FFF!important
115 | }
116 | 
117 | .ss_label: hover
118 | {
119 |     color: #FFF
120 | }
121 | 
122 | .ss_track
123 | {
124 |     background-color: #555;
125 |     border-radius: 7px;
126 |     -moz-border-radius: 7px;
127 |     padding: 1px;
128 |     width: 150px;
129 |     height: 13px;
130 |     float: left;
131 |     position: relative;
132 |     clear: left;
133 |     -webkit-user-select: none;
134 |     -webkit-user-drag: none;
135 |     -moz-user-select: none;
136 |     -webkit-box-shadow: inset 0 1px 0 rgba(0,0,0,0.45),inset 0 -1px 0 rgba(255,255,255,0.1),inset 0 3px 5px rgba(0,0,0,0.3),0 5px 10px rgba(0,0,0,0.1),0 -3px 10px rgba(255,255,255,0.1);
137 |     -moz-box-shadow: inset 0 1px 0 rgba(0,0,0,0.45),inset 0 -1px 0 rgba(255,255,255,0.1),inset 0 3px 5px rgba(0,0,0,0.3),0 5px 10px rgba(0,0,0,0.1),0 -3px 10px rgba(255,255,255,0.1)
138 | }
139 | 
140 | .ss_track: hover
141 | {
142 | 	background-color:# 666
143 | }
144 | 
145 | .ss_handle
146 | {
147 |     background-color: #999;
148 |     border-radius:6px;
149 |     -moz-border-radius:6px;
150 |     width:20px;
151 |     height:11px;
152 |     position:relative;
153 |     left:0;
154 |     top:1px;
155 |     cursor:pointer!important;
156 |     -webkit-user-select:none;
157 |     -webkit-user-drag:none;-moz-user-select:none;
158 |     -webkit-box-shadow:0 0 1px rgba(0,0,0,0.6),inset 0 1px 0 rgba(255,255,255,0.1),inset 0 2px 5px rgba(255,255,255,0.3);
159 |     -moz-box-shadow:0 0 1px rgba(0,0,0,0.6),inset 0 1px 0 rgba(255,255,255,0.1),inset 0 2px 5px rgba(255,255,255,0.3)
160 | }
161 | 
162 | .ss_handle:active,.ss_handle:focus,.ss_handle:hover
163 | {
164 | 	background-color: #FFF;
165 |     cursor: pointer!important
166 | }
167 | 
168 | .ss_input
169 | {
170 |     font-family: helvetica,
171 |     arial,
172 |     sans - serif;
173 |     width: 3.5em;
174 |     font - size: 11px;
175 |     color: #999;
176 |     border:none;
177 |     background:transparent;
178 |     outline:none;
179 |     padding:0;
180 |     line-height:1;
181 |     vertical-align:top;
182 |     margin:0 0 0 10px;
183 |     float:left;
184 |     -webkit-user-select:text;
185 |     -moz-user-select:text
186 | }
187 | 
188 | .ss_input:focus{
189 | 	background-color:# 222;
190 |     color: #FFF;
191 |     -webkit-user-select: text!important;
192 |     -moz-user-select: text!important
193 | }*/


--------------------------------------------------------------------------------
/fit/export.h:
--------------------------------------------------------------------------------
  1 | #ifndef _EXPORT_
  2 | #define _EXPORT_
  3 | 
  4 | // export data to C
  5 | void writeTabC(mat3 * tab, vec2 * tabMagFresnel, int N)
  6 | {
  7 |     ofstream file("results/ltc.inc");
  8 | 
  9 |     file << std::fixed;
 10 |     file << std::setprecision(6);
 11 | 
 12 |     file << "static const int size = " << N  << ";" << endl << endl;
 13 | 
 14 |     file << "static const mat33 tabM[size*size] = {" << endl;
 15 |     for (int t = 0; t < N; ++t)
 16 |     for (int a = 0; a < N; ++a)
 17 |     {
 18 |         file << "{";
 19 |         file << tab[a + t*N][0][0] << ", " << tab[a + t*N][0][1] << ", " << tab[a + t*N][0][2] << ", ";
 20 |         file << tab[a + t*N][1][0] << ", " << tab[a + t*N][1][1] << ", " << tab[a + t*N][1][2] << ", ";
 21 |         file << tab[a + t*N][2][0] << ", " << tab[a + t*N][2][1] << ", " << tab[a + t*N][2][2] << "}";
 22 |         if (a != N - 1 || t != N - 1)
 23 |             file << ", ";
 24 |         file << endl;
 25 |     }
 26 |     file << "};" << endl << endl;
 27 | 
 28 |     file << "static const mat33 tabMinv[size*size] = {" << endl;
 29 |     for (int t = 0; t < N; ++t)
 30 |     for (int a = 0; a < N; ++a)
 31 |     {
 32 |         mat3 Minv = glm::inverse(tab[a + t*N]);
 33 | 
 34 |         file << "{";
 35 |         file << Minv[0][0] << ", " << Minv[0][1] << ", " << Minv[0][2] << ", ";
 36 |         file << Minv[1][0] << ", " << Minv[1][1] << ", " << Minv[1][2] << ", ";
 37 |         file << Minv[2][0] << ", " << Minv[2][1] << ", " << Minv[2][2] << "}";
 38 |         if (a != N - 1 || t != N - 1)
 39 |             file << ", ";
 40 |         file << endl;
 41 |     }
 42 |     file << "};" << endl << endl;
 43 | 
 44 |     file << "static const float tabMagnitude[size*size] = {" << endl;
 45 |     for (int t = 0; t < N; ++t)
 46 |     for (int a = 0; a < N; ++a)
 47 |     {
 48 |         file << tabMagFresnel[a + t*N][0] << "f";
 49 |         if (a != N - 1 || t != N - 1)
 50 |             file << ", ";
 51 |         file << endl;
 52 |     }
 53 |     file << "};" << endl;
 54 | 
 55 |     file.close();
 56 | }
 57 | 
 58 | // export data to MATLAB
 59 | void writeTabMatlab(mat3 * tab, vec2 * tabMagFresnel, int N)
 60 | {
 61 |     ofstream file("results/ltc.mat");
 62 | 
 63 |     file << "# name: tabMagnitude" << endl;
 64 |     file << "# type: matrix" << endl;
 65 |     file << "# ndims: 2" << endl;
 66 |     file << " " << N << " " << N << endl;
 67 | 
 68 |     for (int t = 0; t < N; ++t)
 69 |     {
 70 |         for (int a = 0; a < N; ++a)
 71 |             file << tabMagFresnel[a + t*N][0] << " ";
 72 |         file << endl;
 73 |     }
 74 | 
 75 |     for (int row = 0; row < 3; ++row)
 76 |     for (int column = 0; column < 3; ++column)
 77 |     {
 78 | 
 79 |         file << "# name: tab" << column << row << endl;
 80 |         file << "# type: matrix" << endl;
 81 |         file << "# ndims: 2" << endl;
 82 |         file << " " << N << " " << N << endl;
 83 | 
 84 |         for (int t = 0; t < N; ++t)
 85 |         {
 86 |             for (int a = 0; a < N; ++a)
 87 |                 file << tab[a + t*N][column][row] << " ";
 88 |             file << endl;
 89 |         }
 90 | 
 91 |         file << endl;
 92 |     }
 93 | 
 94 |     file.close();
 95 | }
 96 | 
 97 | // export data to DDS
 98 | #include "dds.h"
 99 | #include "float_to_half.h"
100 | 
101 | void writeDDS(const char* path, float* data, int N)
102 | {
103 |     int numTerms = N*N*4;
104 | 
105 |     uint16_t* half = new uint16_t[numTerms];
106 | 
107 |     for (int i = 0; i < numTerms; ++i)
108 |         half[i] = float_to_half_fast(data[i]);
109 | 
110 |     SaveDDS(path, DDS_FORMAT_R16G16B16A16_FLOAT, sizeof(uint16_t)*4, N, N, (void const*)half);
111 | 
112 |     delete[] half;
113 | }
114 | 
115 | void writeDDS(vec4* data1, vec4* data2, int N)
116 | {
117 |     writeDDS("results/ltc_1.dds", &data1[0][0], N);
118 |     writeDDS("results/ltc_2.dds", &data2[0][0], N);
119 | }
120 | 
121 | // export data to Javascript
122 | void writeJS(vec4* data1, vec4* data2, int N)
123 | {
124 |     ofstream file("results/ltc.js");
125 | 
126 |     file << "var g_ltc_1 = [" << endl;
127 | 
128 |     for (int i = 0; i < N*N; ++i)
129 |     {
130 |         // store the variable terms
131 |         file << data1[i].x << ", ";
132 |         file << data1[i].y << ", ";
133 |         file << data1[i].z << ", ";
134 |         file << data1[i].w << ", " << endl;
135 |     }
136 |     file << "];" << endl;
137 | 
138 |     file << "var g_ltc_2 = [";
139 |     for (int i = 0; i < N*N; ++i)
140 |     {
141 |         file << data2[i].x << ", ";
142 |         file << data2[i].y << ", ";
143 |         file << data2[i].z << ", ";
144 |         file << data2[i].w << ", " << endl;
145 |     }
146 |     file << "];" << endl;
147 | 
148 |     file.close();
149 | }
150 | 
151 | #endif
152 | 


--------------------------------------------------------------------------------
/webgl/js/macton/webgl-utils.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2010, Google Inc.
  3 |  * All rights reserved.
  4 |  *
  5 |  * Redistribution and use in source and binary forms, with or without
  6 |  * modification, are permitted provided that the following conditions are
  7 |  * met:
  8 |  *
  9 |  *     * Redistributions of source code must retain the above copyright
 10 |  * notice, this list of conditions and the following disclaimer.
 11 |  *     * Redistributions in binary form must reproduce the above
 12 |  * copyright notice, this list of conditions and the following disclaimer
 13 |  * in the documentation and/or other materials provided with the
 14 |  * distribution.
 15 |  *     * Neither the name of Google Inc. nor the names of its
 16 |  * contributors may be used to endorse or promote products derived from
 17 |  * this software without specific prior written permission.
 18 |  *
 19 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 20 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 21 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 22 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 23 |  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 24 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 25 |  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 26 |  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 27 |  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 28 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 29 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30 |  */
 31 | 
 32 | 
 33 | /**
 34 |  * @fileoverview This file contains functions every webgl program will need
 35 |  * a version of one way or another.
 36 |  *
 37 |  * Instead of setting up a context manually it is recommended to
 38 |  * use. This will check for success or failure. On failure it
 39 |  * will attempt to present an approriate message to the user.
 40 |  *
 41 |  *       gl = WebGLUtils.setupWebGL(canvas);
 42 |  *
 43 |  * For animated WebGL apps use of setTimeout or setInterval are
 44 |  * discouraged. It is recommended you structure your rendering
 45 |  * loop like this.
 46 |  *
 47 |  *       function render() {
 48 |  *         window.requestAnimFrame(render, canvas);
 49 |  *
 50 |  *         // do rendering
 51 |  *         ...
 52 |  *       }
 53 |  *       render();
 54 |  *
 55 |  * This will call your rendering function up to the refresh rate
 56 |  * of your display but will stop rendering if your app is not
 57 |  * visible.
 58 |  */
 59 | 
 60 | WebGLUtils = function() {
 61 | 
 62 | /**
 63 |  * Creates the HTLM for a failure message
 64 |  * @param {string} canvasContainerId id of container of th
 65 |  *        canvas.
 66 |  * @return {string} The html.
 67 |  */
 68 | var makeFailHTML = function(msg) {
 69 |   return '' +
 70 |     '<table style="background-color: #8CE; width: 100%; height: 100%;"><tr>' +
 71 |     '<td align="center">' +
 72 |     '<div style="display: table-cell; vertical-align: middle;">' +
 73 |     '<div style="">' + msg + '</div>' +
 74 |     '</div>' +
 75 |     '</td></tr></table>';
 76 | };
 77 | 
 78 | /**
 79 |  * Mesasge for getting a webgl browser
 80 |  * @type {string}
 81 |  */
 82 | var GET_A_WEBGL_BROWSER = '' +
 83 |   'This page requires a browser that supports WebGL.<br/>' +
 84 |   '<a href="http://get.webgl.org">Click here to upgrade your browser.</a>';
 85 | 
 86 | /**
 87 |  * Mesasge for need better hardware
 88 |  * @type {string}
 89 |  */
 90 | var OTHER_PROBLEM = '' +
 91 |   "It doesn't appear your computer can support WebGL.<br/>" +
 92 |   '<a href="http://get.webgl.org/troubleshooting/">Click here for more information.</a>';
 93 | 
 94 | /**
 95 |  * Creates a webgl context. If creation fails it will
 96 |  * change the contents of the container of the <canvas>
 97 |  * tag to an error message with the correct links for WebGL.
 98 |  * @param {Element} canvas. The canvas element to create a
 99 |  *     context from.
100 |  * @param {WebGLContextCreationAttirbutes} opt_attribs Any
101 |  *     creation attributes you want to pass in.
102 |  * @return {WebGLRenderingContext} The created context.
103 |  */
104 | var setupWebGL = function(canvas, opt_attribs) {
105 |   function showLink(str) {
106 |     var container = canvas.parentNode;
107 |     if (container) {
108 |       container.innerHTML = makeFailHTML(str);
109 |     }
110 |   };
111 | 
112 |   if (!window.WebGLRenderingContext) {
113 |     showLink(GET_A_WEBGL_BROWSER);
114 |     return null;
115 |   }
116 | 
117 |   var context = create3DContext(canvas, opt_attribs);
118 |   if (!context) {
119 |     showLink(OTHER_PROBLEM);
120 |   }
121 |   return context;
122 | };
123 | 
124 | /**
125 |  * Creates a webgl context.
126 |  * @param {!Canvas} canvas The canvas tag to get context
127 |  *     from. If one is not passed in one will be created.
128 |  * @return {!WebGLContext} The created context.
129 |  */
130 | var create3DContext = function(canvas, opt_attribs) {
131 |   var names = ["webgl", "experimental-webgl", "webkit-3d", "moz-webgl"];
132 |   var context = null;
133 |   for (var ii = 0; ii < names.length; ++ii) {
134 |     try {
135 |       context = canvas.getContext(names[ii], opt_attribs);
136 |     } catch(e) {}
137 |     if (context) {
138 |       break;
139 |     }
140 |   }
141 |   return context;
142 | }
143 | 
144 | return {
145 |   create3DContext: create3DContext,
146 |   setupWebGL: setupWebGL
147 | };
148 | }();
149 | 
150 | /**
151 |  * Provides requestAnimationFrame in a cross browser way.
152 |  */
153 | window.requestAnimFrame = (function() {
154 |   return window.requestAnimationFrame ||
155 |          window.webkitRequestAnimationFrame ||
156 |          window.mozRequestAnimationFrame ||
157 |          window.oRequestAnimationFrame ||
158 |          window.msRequestAnimationFrame ||
159 |          function(/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) {
160 |            window.setTimeout(callback, 1000/60);
161 |          };
162 | })();
163 | 
164 | 
165 | 


--------------------------------------------------------------------------------
/webgl/js/macton/cameracontroller.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2009 The Chromium Authors. All rights reserved.
  3 |  *
  4 |  * Redistribution and use in source and binary forms, with or without
  5 |  * modification, are permitted provided that the following conditions are
  6 |  * met:
  7 |  *
  8 |  *    * Redistributions of source code must retain the above copyright
  9 |  * notice, this list of conditions and the following disclaimer.
 10 |  *    * Redistributions in binary form must reproduce the above
 11 |  * copyright notice, this list of conditions and the following disclaimer
 12 |  * in the documentation and/or other materials provided with the
 13 |  * distribution.
 14 |  *    * Neither the name of Google Inc. nor the names of its
 15 |  * contributors may be used to endorse or promote products derived from
 16 |  * this software without specific prior written permission.
 17 |  *
 18 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 19 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 20 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 21 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 22 |  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 23 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 24 |  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 25 |  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 26 |  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 28 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 |  */
 30 | 
 31 | // A simple camera controller which uses an HTML element as the event
 32 | // source for constructing a view matrix. Assign an "onchange"
 33 | // function to the controller as follows to receive the updated X and
 34 | // Y angles for the camera:
 35 | //
 36 | //   var controller = new CameraController(canvas);
 37 | //   controller.onchange = function(xRot, yRot) { ... };
 38 | //
 39 | // The view matrix is computed elsewhere.
 40 | //
 41 | // opt_canvas (an HTMLCanvasElement) and opt_context (a
 42 | // WebGLRenderingContext) can be passed in to make the hit detection
 43 | // more precise -- only opaque pixels will be considered as the start
 44 | // of a drag action.
 45 | function CameraController(element, opt_canvas, opt_context) {
 46 |     var controller = this;
 47 |     this.onchange = null;
 48 |     this.xRot = 0;
 49 |     this.yRot = 0;
 50 |     this.scaleFactor = 3.0;
 51 |     this.dragging = false;
 52 |     this.curX = 0;
 53 |     this.curY = 0;
 54 | 
 55 |     if (opt_canvas)
 56 |         this.canvas_ = opt_canvas;
 57 | 
 58 |     if (opt_context)
 59 |         this.context_ = opt_context;
 60 | 
 61 |     // Assign a mouse down handler to the HTML element.
 62 |     element.onmousedown = function(ev) {
 63 |     	// $(element).css("cursor", "url(images/blank.png), default");
 64 |         $(element).css("cursor", "none");
 65 | 
 66 |         controller.curX = ev.clientX;
 67 |         controller.curY = ev.clientY;
 68 |         var dragging = false;
 69 |         if (controller.canvas_ && controller.context_) {
 70 |             var rect = controller.canvas_.getBoundingClientRect();
 71 |             // Transform the event's x and y coordinates into the coordinate
 72 |             // space of the canvas
 73 |             var canvasRelativeX = ev.pageX - rect.left;
 74 |             var canvasRelativeY = ev.pageY - rect.top;
 75 |             var canvasWidth = controller.canvas_.width;
 76 |             var canvasHeight = controller.canvas_.height;
 77 | 
 78 |             // Read back a small portion of the frame buffer around this point
 79 |             if (canvasRelativeX > 0 && canvasRelativeX < canvasWidth &&
 80 |                 canvasRelativeY > 0 && canvasRelativeY < canvasHeight) {
 81 |                 var pixels = new Uint8Array(1);
 82 |                 controller.context_.readPixels(canvasRelativeX,
 83 |                                                canvasHeight - canvasRelativeY,
 84 |                                                1,
 85 |                                                1,
 86 |                                                controller.context_.RGBA,
 87 |                                                controller.context_.UNSIGNED_BYTE,
 88 |                                                pixels);
 89 |                 // See whether this pixel has an alpha value of >= about 10%
 90 |                 if (pixels[3] > (255.0 / 10.0)) {
 91 |                     dragging = true;
 92 |                 }
 93 |             }
 94 |         } else {
 95 |             dragging = true;
 96 |         }
 97 | 
 98 |         controller.dragging = dragging;
 99 |     };
100 | 
101 |     // Assign a mouse up handler to the HTML element.
102 |     element.onmouseup = function(ev) {
103 |     	$(element).css("cursor", "default");
104 |         controller.dragging = false;
105 |     };
106 | 
107 |     // Assign a mouse move handler to the HTML element.
108 |     element.onmousemove = function(ev) {
109 |         if (controller.dragging) {
110 |             // Determine how far we have moved since the last mouse move
111 |             // event.
112 |             var curX = ev.clientX;
113 |             var curY = ev.clientY;
114 |             var deltaX = (controller.curX - curX) / controller.scaleFactor;
115 |             var deltaY = (controller.curY - curY) / controller.scaleFactor;
116 |             controller.curX = curX;
117 |             controller.curY = curY;
118 |             // Update the X and Y rotation angles based on the mouse motion.
119 |             controller.yRot = (controller.yRot + deltaX) % 360;
120 |             controller.xRot = (controller.xRot + deltaY);
121 |             // Clamp the X rotation to prevent the camera from going upside
122 |             // down.
123 |             if (controller.xRot < -90) {
124 |                 controller.xRot = -90;
125 |             } else if (controller.xRot > 90) {
126 |                 controller.xRot = 90;
127 |             }
128 |             // Send the onchange event to any listener.
129 |             if (controller.onchange != null) {
130 |                 controller.onchange(controller.xRot, controller.yRot);
131 |             }
132 |         }
133 |     };
134 | }
135 | 


--------------------------------------------------------------------------------
/fit/plot.h:
--------------------------------------------------------------------------------
  1 | #ifndef _PLOT_
  2 | #define _PLOT_
  3 | 
  4 | #include <glm/glm.hpp>
  5 | using namespace glm;
  6 | 
  7 | #include "CImg.h"
  8 | using namespace cimg_library;
  9 | 
 10 | CImg<float> colorMap(33, 1, 1, 3);
 11 | 
 12 | const unsigned char colorMap_data[33*3]  =
 13 | {
 14 |      59,  76, 192,
 15 |      68,  90, 204,
 16 |      77, 104, 215,
 17 |      87, 117, 225,
 18 |      98, 130, 234,
 19 |     108, 142, 241,
 20 |     119, 154, 247,
 21 |     130, 165, 251,
 22 |     141, 176, 254,
 23 |     152, 185, 255,
 24 |     163, 194, 255,
 25 |     174, 201, 253,
 26 |     184, 208, 249,
 27 |     194, 213, 244,
 28 |     204, 217, 238,
 29 |     213, 219, 230,
 30 |     221, 221, 221,
 31 |     229, 216, 209,
 32 |     236, 211, 197,
 33 |     241, 204, 185,
 34 |     245, 196, 173,
 35 |     247, 187, 160,
 36 |     247, 177, 148,
 37 |     247, 166, 135,
 38 |     244, 154, 123,
 39 |     241, 141, 111,
 40 |     236, 127,  99,
 41 |     229, 112,  88,
 42 |     222,  96,  77,
 43 |     213,  80,  66,
 44 |     203,  62,  56,
 45 |     192,  40,  47,
 46 |     180,   4,  38
 47 | };
 48 | 
 49 | #include "LTC.h"
 50 | #include "brdf.h"
 51 | 
 52 | class BrdfOrLTC
 53 | {
 54 | public:
 55 |     BrdfOrLTC(
 56 |         const LTC* ltc_,
 57 |         const Brdf* brdf_,
 58 |         const vec3 V_ = vec3(0, 0, 1),
 59 |         const float alpha_ = 1.0f) :
 60 |         ltc(ltc_), brdf(brdf_), V(V_), alpha(alpha_)
 61 |     {
 62 |         isBrdf = brdf != nullptr;
 63 |     }
 64 | 
 65 |     float eval(const vec3& L) const
 66 |     {
 67 |         if (isBrdf)
 68 |         {
 69 |             float pdf;
 70 |             return brdf->eval(V, L, alpha, pdf);
 71 |         }
 72 |         else
 73 |             return ltc->eval(L);
 74 |     }
 75 | 
 76 |     vec3 sample(const float U1, const float U2) const
 77 |     {
 78 |         return isBrdf ? brdf->sample(V, alpha, U1, U2) : ltc->sample(U1, U2);
 79 |     }
 80 | 
 81 |     float computeMaxValue() const
 82 |     {
 83 |         float max_value = 0.0;
 84 | 
 85 |         const int Nsample = 50;
 86 |         for (int j = 0; j < Nsample; ++j)
 87 |         for (int i = 0; i < Nsample; ++i)
 88 |         {
 89 |             const float U1 = (i + 0.5f)/Nsample;
 90 |             const float U2 = (j + 0.5f)/Nsample;
 91 |             max_value = std::max<float>(max_value, eval(sample(U1, U2)));
 92 |         }
 93 | 
 94 |         return max_value;
 95 |     }
 96 | 
 97 |     bool isBrdf;
 98 |     const Brdf* brdf;
 99 |     const vec3 V;
100 |     const float alpha;
101 |     const LTC* ltc;
102 | };
103 | 
104 | // raytrace a sphere
105 | // evaluate the BRDF or the LTC
106 | // call the color map
107 | void spherical_plot(const BrdfOrLTC& brdforltc, const char* filename)
108 | {
109 |     // image
110 |     const int image_size = 256;
111 |     CImg<float> image(image_size, image_size, 1, 3);
112 | 
113 |     // camera
114 |     vec3 Z = normalize(vec3(-1, 1, 1));
115 |     vec3 X = normalize(vec3( 1, 1, 0));
116 |     X = normalize(X - Z*dot(X,Z));
117 |     vec3 Y = -cross(X,Z);
118 | 
119 |     // maximum value of the function (color map scaling)
120 |     float max_value = brdforltc.computeMaxValue();
121 | 
122 |     // loop over pixels
123 |     for (int j = 0; j < image_size; ++j)
124 |     for (int i = 0; i < image_size; ++i)
125 |     {
126 |         // intersection point on the sphere
127 |         const float x = -1.1f + 2.2f * (i + 0.5f)/image_size;
128 |         const float y = -1.1f + 2.2f * (j + 0.5f)/image_size;
129 |         if (x*x + y*y > 1.0f)
130 |         {
131 |             image(i, j, 0, 0) = 255.0f;
132 |             image(i, j, 0, 1) = 255.0f;
133 |             image(i, j, 0, 2) = 255.0f;
134 |             continue;
135 |         }
136 |         const float z = sqrtf(1.0f - x*x - y*y);
137 |         vec3 L = x*X + y*Y + z*Z;
138 | 
139 |         // evaluate function
140 |         float value = brdforltc.eval(L) / max_value;
141 | 
142 |         // color map
143 |         image(i, j, 0, 0) = colorMap.linear_atX(value*(colorMap.width() - 1.0f), 0, 0, 0);
144 |         image(i, j, 0, 1) = colorMap.linear_atX(value*(colorMap.width() - 1.0f), 0, 0, 1);
145 |         image(i, j, 0, 2) = colorMap.linear_atX(value*(colorMap.width() - 1.0f), 0, 0, 2);
146 |     }
147 | 
148 |     image.save(filename);
149 | }
150 | 
151 | #include <sstream>
152 | #include <iomanip>
153 | 
154 | void make_spherical_plots(const Brdf& brdf, const mat3* tab, const int N)
155 | {
156 |     // init color map texture (for linear interpolation)
157 |     for(int i = 0; i < 33; ++i)
158 |     {
159 |         colorMap(i, 0, 0, 0) = colorMap_data[3*i + 0];
160 |         colorMap(i, 0, 0, 1) = colorMap_data[3*i + 1];
161 |         colorMap(i, 0, 0, 2) = colorMap_data[3*i + 2];
162 |     }
163 | 
164 |     // fill LTC matrices in texture (for linear interpolation)
165 |     CImg<float> LTC_matrices(N, N, 1, 9);
166 |     for(int j = 0; j < N; ++j)
167 |     for(int i = 0; i < N; ++i)
168 |     {
169 |         LTC_matrices(i, j, 0, 0) = tab[i + j*N][0][0];
170 |         LTC_matrices(i, j, 0, 1) = tab[i + j*N][0][1];
171 |         LTC_matrices(i, j, 0, 2) = tab[i + j*N][0][2];
172 |         LTC_matrices(i, j, 0, 3) = tab[i + j*N][1][0];
173 |         LTC_matrices(i, j, 0, 4) = tab[i + j*N][1][1];
174 |         LTC_matrices(i, j, 0, 5) = tab[i + j*N][1][2];
175 |         LTC_matrices(i, j, 0, 6) = tab[i + j*N][2][0];
176 |         LTC_matrices(i, j, 0, 7) = tab[i + j*N][2][1];
177 |         LTC_matrices(i, j, 0, 8) = tab[i + j*N][2][2];
178 |     }
179 | 
180 |     // render spherical plots
181 |     float alpha_tab[] = {0.05f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 1.0f};
182 |     float theta_tab[] = {0.0f, 15.0f, 30.0f, 45.0f, 60.0f, 75.0f, 89.0f};
183 |     for (int a = 0; a < 7; ++a)
184 |     for (int t = 0; t < 7; ++t)
185 |     {
186 |         // configuration
187 |         const float alpha = alpha_tab[a];
188 |         const float theta = theta_tab[t] * 3.14159f/180.0f;
189 |         const vec3 V(sinf(theta), 0.0f, cosf(theta));
190 | 
191 |         // fetch texture with parameterization = [(sqrtf(alpha), sqrt(1 - cosf(theta))]
192 |         float x = sqrtf(alpha)*(LTC_matrices.width() - 1.0f);
193 |         float y = sqrtf(1.0f - V.z)*(LTC_matrices.height() - 1.0f);
194 |         mat3 M = mat3(
195 |                     LTC_matrices.linear_atXY(x, y, 0, 0),
196 |                     LTC_matrices.linear_atXY(x, y, 0, 1),
197 |                     LTC_matrices.linear_atXY(x, y, 0, 2),
198 |                     LTC_matrices.linear_atXY(x, y, 0, 3),
199 |                     LTC_matrices.linear_atXY(x, y, 0, 4),
200 |                     LTC_matrices.linear_atXY(x, y, 0, 5),
201 |                     LTC_matrices.linear_atXY(x, y, 0, 6),
202 |                     LTC_matrices.linear_atXY(x, y, 0, 7),
203 |                     LTC_matrices.linear_atXY(x, y, 0, 8));
204 | 
205 |         // init LTC
206 |         LTC ltc;
207 |         ltc.M = M;
208 |         ltc.invM = inverse(M);
209 |         ltc.detM = abs(glm::determinant(M));
210 | 
211 |         // filename LTC
212 |         std::stringstream filename_ltc;
213 |         filename_ltc << "plots/";
214 |         filename_ltc << "alpha_";
215 |         filename_ltc << std::setfill('0') << std::setw(3) << (int)(100.0f*alpha_tab[a]);
216 |         filename_ltc << "_theta_";
217 |         filename_ltc << std::setfill('0') << std::setw(2) << (int)theta_tab[t] << "_ltc.bmp";
218 | 
219 |         // filename BRDF
220 |         std::stringstream filename_brdf;
221 |         filename_brdf << "plots/";
222 |         filename_brdf << "alpha_";
223 |         filename_brdf << std::setfill('0') << std::setw(3) << (int)(100.0f*alpha_tab[a]);
224 |         filename_brdf << "_theta_";
225 |         filename_brdf << std::setfill('0') << std::setw(2) << (int)theta_tab[t] << "_brdf.bmp";
226 | 
227 |         // plot LTC
228 |         spherical_plot(BrdfOrLTC(&ltc, NULL), filename_ltc.str().c_str());
229 | 
230 |         // plot BRDF
231 |         spherical_plot(BrdfOrLTC(NULL, &brdf, V, alpha), filename_brdf.str().c_str());
232 |     }
233 | }
234 | 
235 | #endif
236 | 


--------------------------------------------------------------------------------
/webgl/js/super_slider.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Super Slider
  3 |  * Last update: 12 Jan 2011
  4 |  * 
  5 |  * Changelog:
  6 |  *   0.1   - Initial release
  7 |  * 
  8 |  * 
  9 |  * Copyright (c) 2011 Tom Beddard
 10 |  * http://www.subblue.com
 11 |  * 
 12 |  * Released under the MIT License: 
 13 |  * http://www.opensource.org/licenses/mit-license.php
 14 |  */ 
 15 | 
 16 | /*global window, $, document*/
 17 | 
 18 | function SuperSlider(id, opts) {
 19 | 	this.id = id;
 20 | 	this.init(opts);
 21 | 	
 22 | 	return this.slider;
 23 | }
 24 | 
 25 | SuperSlider.prototype = {
 26 | 	
 27 | 	init: function (opts) {
 28 | 		var self = this,
 29 | 			opt,
 30 | 			style;
 31 | 	
 32 | 		this.options =  { 
 33 | 			slider_class   : 'ss_slider', // slider class name
 34 | 			track_class    : 'ss_track',  // track class name
 35 | 			handle_class   : 'ss_handle', // handle class name
 36 | 			input_class    : 'ss_input',  // input class name
 37 | 			label_class    : 'ss_label',  // label class name
 38 | 			min            : 0,           // minimum value
 39 | 			max            : 1,           // maximum value
 40 | 			step           : 0.01,        // step increment
 41 | 			default_value  : 0.5,         // default value
 42 | 			value          : 0.5,         // current value
 43 | 			decimal_places : 3,           // decimal place rounding
 44 | 			label          : null,        // label
 45 | 			name           : null         // input name attribute
 46 | 		};
 47 | 	
 48 | 		for (opt in opts) {
 49 | 			if (opts.hasOwnProperty.call(opts, opt)) {
 50 | 				this.options[opt] = opts[opt];
 51 | 			}
 52 | 		}
 53 | 		
 54 | 		// Build slider
 55 | 		this.slider = $("<div>")
 56 | 			.addClass(this.options.slider_class)
 57 | 			.css("webkitUserSelect", 'none');
 58 | 	
 59 | 		this.track  = $("<div>").addClass(this.options.track_class);
 60 | 		this.handle = $("<div>").addClass(this.options.handle_class);
 61 | 	
 62 | 		this.input = $("<input>")
 63 | 			.attr("type", "input")
 64 | 			.addClass(this.options.input_class)
 65 | 			.attr("value", this.options.value);
 66 | 	
 67 | 		if (this.options.name) {
 68 | 			this.input.attr("name", this.options.name);
 69 | 		}
 70 | 	
 71 | 		if (this.options.label) {
 72 | 			this.label = $("<label>")
 73 | 				.text(this.options.label)
 74 | 				.addClass(this.options.label_class)
 75 | 				.attr("title", "Click to reset to default");
 76 | 			this.slider.append(this.label.get(0));
 77 | 		}
 78 | 	
 79 | 		this.track.append(this.handle.get(0));
 80 | 		this.slider.append(this.track.get(0));
 81 | 		this.slider.append(this.input.get(0));
 82 | 		
 83 | 		// Define event listeners
 84 | 		this.mouseDown = function (event) {
 85 | 			self.startDrag(event);
 86 | 		};
 87 | 
 88 | 		this.mouseMove = function (event) {
 89 | 			self.onDrag(event);
 90 | 		};
 91 | 
 92 | 		this.mouseUp = function (event) {
 93 | 			self.endDrag(event);
 94 | 		};
 95 | 	
 96 | 		this.mouseOver = function (event) {
 97 | 			self.infocus = true;
 98 | 			event.stopPropagation();
 99 | 		};
100 | 	
101 | 		this.mouseOut = function (event) {
102 | 			self.infocus = false;
103 | 			event.stopPropagation();
104 | 		};
105 | 	
106 | 		this.keyDown = function (event) {
107 | 			self.keyPress(event);
108 | 		};
109 | 	
110 | 		this.startEdit = function (event) {
111 | 			self.editing = true;
112 | 		};
113 | 	
114 | 		this.endEdit = function (event) {
115 | 			self.value(self.input.get(0).value);
116 | 			self.editing = false;
117 | 		};
118 | 	
119 | 		this.labelClick = function (event) {
120 | 			self.updateSlider(self.options.default_value);
121 | 			self.input.trigger("reset");
122 | 			return false;
123 | 		};
124 | 
125 | 		this.slider.bind("DOMNodeInserted", function (event) {
126 | 			// We only want to call sliderInserted once, but Chrome
127 | 			// won't attach bindings or update the slider until it's
128 | 			// parented
129 | 			var really_inserted = (self.slider.parent().length != 0);
130 | 
131 | 		    if (!self.initialised && really_inserted) {
132 |     			self.sliderInserted(event);
133 | 	    		self.initialised = true;
134 | 	    	}
135 | 		});
136 | 	
137 | 		this.infocus = false;
138 | 	},
139 | 	
140 | 	
141 | 	// Slider inserted into the DOM and ready for action
142 | 	sliderInserted: function (event) {
143 | 		// Get computed style dimensions
144 | 		this.handle_width = parseInt(window.getComputedStyle(this.handle.get(0), null).getPropertyValue("width"), 10);
145 | 		this.track_width = parseInt(window.getComputedStyle(this.track.get(0), null).getPropertyValue("width"), 10) - this.handle_width;
146 | 
147 | 		// Setup current value
148 | 		this.updateSlider(this.options.value);
149 | 
150 | 		if (this.label) {
151 | 			this.label.bind("click", this.labelClick);
152 | 		}
153 | 
154 | 		this.track.bind("mousedown", this.mouseDown);
155 | 		this.slider.bind("mouseover", this.mouseOver);
156 | 		this.slider.bind("mouseout", this.mouseOut);
157 | 		this.input.bind("blur", this.endEdit);
158 | 		document.addEventListener("keydown", this.keyDown, false);
159 | 	},
160 | 
161 | 	value: function (v) {
162 | 		if (typeof v !== "undefined") {
163 | 			this.updateSlider(v);
164 | 		}
165 | 		return this.val;
166 | 	},
167 | 
168 | 	
169 | 	// Update the slider and fire the change event
170 | 	updateSlider: function (value) {
171 | 		var v = Math.min(Math.max(value, this.options.min), this.options.max),
172 | 			pos = this.track_width * ((v - this.options.min) / (this.options.max - this.options.min)),
173 | 			val = this.round(parseFloat(v), this.options.decimal_places);
174 | 
175 | 		if (isNaN(val) || value === '') {
176 | 			// Invalid number, reset
177 | 			this.input.attr("value", this.val);
178 | 			this.input.get(0).value = this.val;
179 | 		} else {
180 | 			// Valid number
181 | 			this.handle.css("left", pos + "px");
182 | 			this.val = val;
183 | 			this.input.attr("value", this.val);
184 | 			this.input.get(0).value = this.val;		// This way too therwise the field doesn't always update
185 | 			this.input.get(0).val = this.val;
186 | 			
187 | 			if (this.initialised && this.old_val !== this.val) {
188 | 				this.input.trigger("change");
189 | 				this.old_val = this.val;
190 | 			}
191 | 		}
192 | 	},
193 | 	
194 | 	
195 | 	startDrag: function (event) {
196 | 		// event.preventDefault();
197 | 		if (event.currentTarget === event.target) {
198 | 			// Clicked track
199 | 			this.ox = this.handle_width / 2;
200 | 			this.onDrag(event);
201 | 		} else {
202 | 			// Clicked handle
203 | 			this.ox = event.offsetX || event.layerX;
204 | 		}
205 | 	
206 | 		this.track.get(0).addEventListener("mousemove", this.mouseMove, false);
207 | 		$("body").bind("mouseup", this.mouseUp);
208 | 	},
209 | 
210 | 
211 | 	onDrag: function (event) {
212 | 		var x, v;
213 | 	
214 | 		if (event.currentTarget === event.target) {
215 | 			// track clicked
216 | 			x = event.offsetX || event.layerX;
217 | 		} else {
218 | 			// handle clicked
219 | 			x = event.target.offsetLeft + (event.offsetX || event.layerX);
220 | 		}
221 | 	
222 | 		x -= this.ox;
223 | 		v = (x / this.track_width) * (this.options.max - this.options.min);
224 | 	
225 | 		if (!event.altKey) {
226 | 			// Snap to step increments
227 | 			v = Math.floor(v / this.options.step) * this.options.step;
228 | 		}
229 | 	
230 | 		this.updateSlider(this.options.min + v);
231 | 	},
232 | 
233 | 
234 | 	endDrag: function (event) {
235 | 		this.track.get(0).removeEventListener("mousemove", this.mouseMove, false);
236 | 		$("body").unbind("mouseup", this.mouseUp);
237 | 	},
238 | 	
239 | 	
240 | 	keyPress: function (event) {
241 | 		var delta = 0,
242 | 			mult = 1;
243 | 	
244 | 		if (this.infocus) {
245 | 			// console.log("key", event);
246 | 			if (event.shiftKey && event.altKey) {
247 | 				mult = 0.01;
248 | 			} else if (event.altKey) {
249 | 				mult = 0.1;
250 | 			} else if (event.shiftKey) {
251 | 				mult = 10;
252 | 			}
253 | 		
254 | 			switch (event.keyCode) {
255 | 			case 38:
256 | 				// Up arrow 38 - event.DOM_VK_UP
257 | 				this.value(this.val += this.options.step * mult);
258 | 				break;
259 | 			case 40:
260 | 				// Down arrow 40 - event.DOM_VK_DOWN
261 | 				this.value(this.val -= this.options.step * mult);
262 | 				break;
263 | 			case 13:
264 | 				// Enter pressed 13 - event.DOM_VK_RETURN
265 | 				this.input.get(0).blur();
266 | 				return false;
267 | 			}
268 | 		}
269 | 	
270 | 		return true;
271 | 	},
272 | 
273 | 	round: function (v, n) {
274 | 		var exp = Math.pow(10, n || 1);
275 | 		return Math.round(v * exp) / exp;
276 | 	}
277 | };
278 | 
279 | 
280 | 


--------------------------------------------------------------------------------
/fit/fitLTC.cpp:
--------------------------------------------------------------------------------
  1 | // fitLTC.cpp : Defines the entry point for the console application.
  2 | //
  3 | #include <glm/glm.hpp>
  4 | using namespace glm;
  5 | 
  6 | #include <algorithm>
  7 | #include <fstream>
  8 | #include <iomanip>
  9 | 
 10 | #include "LTC.h"
 11 | #include "brdf.h"
 12 | #include "brdf_ggx.h"
 13 | #include "brdf_beckmann.h"
 14 | #include "brdf_disneyDiffuse.h"
 15 | 
 16 | #include "nelder_mead.h"
 17 | 
 18 | #include "export.h"
 19 | #include "plot.h"
 20 | 
 21 | // size of precomputed table (theta, alpha)
 22 | const int N = 64;
 23 | // number of samples used to compute the error during fitting
 24 | const int Nsample = 32;
 25 | // minimal roughness (avoid singularities)
 26 | const float MIN_ALPHA = 0.00001f;
 27 | 
 28 | const float pi = acosf(-1.0f);
 29 | 
 30 | // computes
 31 | // * the norm (albedo) of the BRDF
 32 | // * the average Schlick Fresnel value
 33 | // * the average direction of the BRDF
 34 | void computeAvgTerms(const Brdf& brdf, const vec3& V, const float alpha,
 35 |     float& norm, float& fresnel, vec3& averageDir)
 36 | {
 37 |     norm = 0.0f;
 38 |     fresnel = 0.0f;
 39 |     averageDir = vec3(0, 0, 0);
 40 | 
 41 |     for (int j = 0; j < Nsample; ++j)
 42 |     for (int i = 0; i < Nsample; ++i)
 43 |     {
 44 |         const float U1 = (i + 0.5f)/Nsample;
 45 |         const float U2 = (j + 0.5f)/Nsample;
 46 | 
 47 |         // sample
 48 |         const vec3 L = brdf.sample(V, alpha, U1, U2);
 49 | 
 50 |         // eval
 51 |         float pdf;
 52 |         float eval = brdf.eval(V, L, alpha, pdf);
 53 | 
 54 |         if (pdf > 0)
 55 |         {
 56 |             float weight = eval / pdf;
 57 | 
 58 |             vec3 H = normalize(V+L);
 59 | 
 60 |             // accumulate
 61 |             norm       += weight;
 62 |             fresnel    += weight * pow(1.0f - glm::max(dot(V, H), 0.0f), 5.0f);
 63 |             averageDir += weight * L;
 64 |         }
 65 |     }
 66 | 
 67 |     norm    /= (float)(Nsample*Nsample);
 68 |     fresnel /= (float)(Nsample*Nsample);
 69 | 
 70 |     // clear y component, which should be zero with isotropic BRDFs
 71 |     averageDir.y = 0.0f;
 72 | 
 73 |     averageDir = normalize(averageDir);
 74 | }
 75 | 
 76 | // compute the error between the BRDF and the LTC
 77 | // using Multiple Importance Sampling
 78 | float computeError(const LTC& ltc, const Brdf& brdf, const vec3& V, const float alpha)
 79 | {
 80 |     double error = 0.0;
 81 | 
 82 |     for (int j = 0; j < Nsample; ++j)
 83 |     for (int i = 0; i < Nsample; ++i)
 84 |     {
 85 |         const float U1 = (i + 0.5f)/Nsample;
 86 |         const float U2 = (j + 0.5f)/Nsample;
 87 | 
 88 |         // importance sample LTC
 89 |         {
 90 |             // sample
 91 |             const vec3 L = ltc.sample(U1, U2);
 92 | 
 93 |             float pdf_brdf;
 94 |             float eval_brdf = brdf.eval(V, L, alpha, pdf_brdf);
 95 |             float eval_ltc = ltc.eval(L);
 96 |             float pdf_ltc = eval_ltc/ltc.magnitude;
 97 | 
 98 |             // error with MIS weight
 99 |             double error_ = fabsf(eval_brdf - eval_ltc);
100 |             error_ = error_*error_*error_;
101 |             error += error_/(pdf_ltc + pdf_brdf);
102 |         }
103 | 
104 |         // importance sample BRDF
105 |         {
106 |             // sample
107 |             const vec3 L = brdf.sample(V, alpha, U1, U2);
108 | 
109 |             float pdf_brdf;
110 |             float eval_brdf = brdf.eval(V, L, alpha, pdf_brdf);
111 |             float eval_ltc = ltc.eval(L);
112 |             float pdf_ltc = eval_ltc/ltc.magnitude;
113 | 
114 |             // error with MIS weight
115 |             double error_ = fabsf(eval_brdf - eval_ltc);
116 |             error_ = error_*error_*error_;
117 |             error += error_/(pdf_ltc + pdf_brdf);
118 |         }
119 |     }
120 | 
121 |     return (float)error / (float)(Nsample*Nsample);
122 | }
123 | 
124 | struct FitLTC
125 | {
126 |     FitLTC(LTC& ltc_, const Brdf& brdf, bool isotropic_, const vec3& V_, float alpha_) :
127 |         ltc(ltc_), brdf(brdf), V(V_), alpha(alpha_), isotropic(isotropic_)
128 |     {
129 |     }
130 | 
131 |     void update(const float* params)
132 |     {
133 |         float m11 = std::max<float>(params[0], 1e-7f);
134 |         float m22 = std::max<float>(params[1], 1e-7f);
135 |         float m13 = params[2];
136 | 
137 |         if (isotropic)
138 |         {
139 |             ltc.m11 = m11;
140 |             ltc.m22 = m11;
141 |             ltc.m13 = 0.0f;
142 |         }
143 |         else
144 |         {
145 |             ltc.m11 = m11;
146 |             ltc.m22 = m22;
147 |             ltc.m13 = m13;
148 |         }
149 |         ltc.update();
150 |     }
151 | 
152 |     float operator()(const float* params)
153 |     {
154 |         update(params);
155 |         return computeError(ltc, brdf, V, alpha);
156 |     }
157 | 
158 |     const Brdf& brdf;
159 |     LTC& ltc;
160 |     bool isotropic;
161 | 
162 |     const vec3& V;
163 |     float alpha;
164 | };
165 | 
166 | // fit brute force
167 | // refine first guess by exploring parameter space
168 | void fit(LTC& ltc, const Brdf& brdf, const vec3& V, const float alpha, const float epsilon = 0.05f, const bool isotropic = false)
169 | {
170 |     float startFit[3] = { ltc.m11, ltc.m22, ltc.m13 };
171 |     float resultFit[3];
172 | 
173 |     FitLTC fitter(ltc, brdf, isotropic, V, alpha);
174 | 
175 |     // Find best-fit LTC lobe (scale, alphax, alphay)
176 |     float error = NelderMead<3>(resultFit, startFit, epsilon, 1e-5f, 100, fitter);
177 | 
178 |     // Update LTC with best fitting values
179 |     fitter.update(resultFit);
180 | }
181 | 
182 | // fit data
183 | void fitTab(mat3* tab, vec2* tabMagFresnel, const int N, const Brdf& brdf)
184 | {
185 |     LTC ltc;
186 | 
187 |     // loop over theta and alpha
188 |     for (int a = N - 1; a >=     0; --a)
189 |     for (int t =     0; t <= N - 1; ++t)
190 |     {
191 |         // parameterised by sqrt(1 - cos(theta))
192 |         float x = t/float(N - 1);
193 |         float ct = 1.0f - x*x;
194 |         float theta = std::min<float>(1.57f, acosf(ct));
195 |         const vec3 V = vec3(sinf(theta), 0, cosf(theta));
196 | 
197 |         // alpha = roughness^2
198 |         float roughness = a/float(N - 1);
199 |         float alpha = std::max<float>(roughness*roughness, MIN_ALPHA);
200 | 
201 |         cout << "a = " << a << "\t t = " << t  << endl;
202 |         cout << "alpha = " << alpha << "\t theta = " << theta << endl;
203 |         cout << endl;
204 | 
205 |         vec3 averageDir;
206 |         computeAvgTerms(brdf, V, alpha, ltc.magnitude, ltc.fresnel, averageDir);
207 | 
208 |         bool isotropic;
209 | 
210 |         // 1. first guess for the fit
211 |         // init the hemisphere in which the distribution is fitted
212 |         // if theta == 0 the lobe is rotationally symmetric and aligned with Z = (0 0 1)
213 |         if (t == 0)
214 |         {
215 |             ltc.X = vec3(1, 0, 0);
216 |             ltc.Y = vec3(0, 1, 0);
217 |             ltc.Z = vec3(0, 0, 1);
218 | 
219 |             if (a == N - 1) // roughness = 1
220 |             {
221 |                 ltc.m11 = 1.0f;
222 |                 ltc.m22 = 1.0f;
223 |             }
224 |             else // init with roughness of previous fit
225 |             {
226 |                 ltc.m11 = tab[a + 1 + t*N][0][0];
227 |                 ltc.m22 = tab[a + 1 + t*N][1][1];
228 |             }
229 | 
230 |             ltc.m13 = 0;
231 |             ltc.update();
232 | 
233 |             isotropic = true;
234 |         }
235 |         // otherwise use previous configuration as first guess
236 |         else
237 |         {
238 |             vec3 L = averageDir;
239 |             vec3 T1(L.z, 0, -L.x);
240 |             vec3 T2(0, 1, 0);
241 |             ltc.X = T1;
242 |             ltc.Y = T2;
243 |             ltc.Z = L;
244 | 
245 |             ltc.update();
246 | 
247 |             isotropic = false;
248 |         }
249 | 
250 |         // 2. fit (explore parameter space and refine first guess)
251 |         float epsilon = 0.05f;
252 |         fit(ltc, brdf, V, alpha, epsilon, isotropic);
253 | 
254 |         // copy data
255 |         tab[a + t*N] = ltc.M;
256 |         tabMagFresnel[a + t*N][0] = ltc.magnitude;
257 |         tabMagFresnel[a + t*N][1] = ltc.fresnel;
258 | 
259 |         // kill useless coefs in matrix
260 |         tab[a+t*N][0][1] = 0;
261 |         tab[a+t*N][1][0] = 0;
262 |         tab[a+t*N][2][1] = 0;
263 |         tab[a+t*N][1][2] = 0;
264 | 
265 |         cout << tab[a+t*N][0][0] << "\t " << tab[a+t*N][1][0] << "\t " << tab[a+t*N][2][0] << endl;
266 |         cout << tab[a+t*N][0][1] << "\t " << tab[a+t*N][1][1] << "\t " << tab[a+t*N][2][1] << endl;
267 |         cout << tab[a+t*N][0][2] << "\t " << tab[a+t*N][1][2] << "\t " << tab[a+t*N][2][2] << endl;
268 |         cout << endl;
269 |     }
270 | }
271 | 
272 | float sqr(float x)
273 | {
274 |     return x*x;
275 | }
276 | 
277 | float G(float w, float s, float g)
278 | {
279 |     return -2.0f*sinf(w)*cosf(s)*cosf(g) + pi/2.0f - g + sinf(g)*cosf(g);
280 | }
281 | 
282 | float H(float w, float s, float g)
283 | {
284 |     float sinsSq = sqr(sin(s));
285 |     float cosgSq = sqr(cos(g));
286 | 
287 |     return cosf(w)*(cosf(g)*sqrtf(sinsSq - cosgSq) + sinsSq*asinf(cosf(g)/sinf(s)));
288 | }
289 | 
290 | float ihemi(float w, float s)
291 | {
292 |     float g = asinf(cosf(s)/sinf(w));
293 |     float sinsSq = sqr(sinf(s));
294 | 
295 |     if (w >= 0.0f && w <= (pi/2.0f - s))
296 |         return pi*cosf(w)*sinsSq;
297 | 
298 |     if (w >= (pi/2.0f - s) && w < pi/2.0f)
299 |         return pi*cosf(w)*sinsSq + G(w, s, g) - H(w, s, g);
300 | 
301 |     if (w >= pi/2.0f && w < (pi/2.0f + s))
302 |         return G(w, s, g) + H(w, s, g);
303 | 
304 |     return 0.0f;
305 | }
306 | 
307 | void genSphereTab(float* tabSphere, int N)
308 | {
309 |     for (int j = 0; j < N; ++j)
310 |     for (int i = 0; i < N; ++i)
311 |     {
312 |         const float U1 = float(i)/(N - 1);
313 |         const float U2 = float(j)/(N - 1);
314 | 
315 |         // z = cos(elevation angle)
316 |         float z = 2.0f*U1 - 1.0f;
317 | 
318 |         // length of average dir., proportional to sin(sigma)^2
319 |         float len = U2;
320 | 
321 |         float sigma = asinf(sqrtf(len));
322 |         float omega = acosf(z);
323 | 
324 |         // compute projected (cosine-weighted) solid angle of spherical cap
325 |         float value = 0.0f;
326 | 
327 |         if (sigma > 0.0f)
328 |             value = ihemi(omega, sigma)/(pi*len);
329 |         else
330 |             value = std::max<float>(z, 0.0f);
331 | 
332 |         if (value != value)
333 |             printf("nan!\n");
334 | 
335 |         tabSphere[i + j*N] = value;
336 |     }
337 | }
338 | 
339 | void packTab(
340 |     vec4* tex1, vec4* tex2,
341 |     const mat3*  tab,
342 |     const vec2*  tabMagFresnel,
343 |     const float* tabSphere,
344 |     int N)
345 | {
346 |     for (int i = 0; i < N*N; ++i)
347 |     {
348 |         const mat3& m = tab[i];
349 | 
350 |         mat3 invM = inverse(m);
351 | 
352 |         // normalize by the middle element
353 |         invM /= invM[1][1];
354 | 
355 |         // store the variable terms
356 |         tex1[i].x = invM[0][0];
357 |         tex1[i].y = invM[0][2];
358 |         tex1[i].z = invM[2][0];
359 |         tex1[i].w = invM[2][2];
360 |         tex2[i].x = tabMagFresnel[i][0];
361 |         tex2[i].y = tabMagFresnel[i][1];
362 |         tex2[i].z = 0.0f; // unused
363 |         tex2[i].w = tabSphere[i];
364 |     }
365 | }
366 | 
367 | int main(int argc, char* argv[])
368 | {
369 |     // BRDF to fit
370 |     BrdfGGX brdf;
371 |     //BrdfBeckmann brdf;
372 |     //BrdfDisneyDiffuse brdf;
373 | 
374 |     // allocate data
375 |     mat3*  tab = new mat3[N*N];
376 |     vec2*  tabMagFresnel = new vec2[N*N];
377 |     float* tabSphere = new float[N*N];
378 | 
379 |     // fit
380 |     fitTab(tab, tabMagFresnel, N, brdf);
381 | 
382 |     // projected solid angle of a spherical cap, clipped to the horizon
383 |     genSphereTab(tabSphere, N);
384 | 
385 |     // pack tables (texture representation)
386 |     vec4* tex1 = new vec4[N*N];
387 |     vec4* tex2 = new vec4[N*N];
388 |     packTab(tex1, tex2, tab, tabMagFresnel, tabSphere, N);
389 | 
390 |     // export to C, MATLAB and DDS
391 |     writeTabMatlab(tab, tabMagFresnel, N);
392 |     writeTabC(tab, tabMagFresnel, N);
393 |     writeDDS(tex1, tex2, N);
394 |     writeJS(tex1, tex2, N);
395 | 
396 |     // spherical plots
397 |     // make_spherical_plots(brdf, tab, N);
398 | 
399 |     // delete data
400 |     delete[] tab;
401 |     delete[] tabMagFresnel;
402 |     delete[] tabSphere;
403 |     delete[] tex1;
404 |     delete[] tex2;
405 | 
406 |     return 0;
407 | }
408 | 


--------------------------------------------------------------------------------
/webgl/shaders/ltc/ltc_quad.fs:
--------------------------------------------------------------------------------
  1 | // bind roughness   {label:"Roughness", default:0.25, min:0.01, max:1, step:0.001}
  2 | // bind dcolor      {label:"Diffuse Color",  r:1.0, g:1.0, b:1.0}
  3 | // bind scolor      {label:"Specular Color", r:0.23, g:0.23, b:0.23}
  4 | // bind intensity   {label:"Light Intensity", default:4, min:0, max:10}
  5 | // bind width       {label:"Width",  default: 8, min:0.1, max:15, step:0.1}
  6 | // bind height      {label:"Height", default: 8, min:0.1, max:15, step:0.1}
  7 | // bind roty        {label:"Rotation Y", default: 0, min:0, max:1, step:0.001}
  8 | // bind rotz        {label:"Rotation Z", default: 0, min:0, max:1, step:0.001}
  9 | // bind twoSided    {label:"Two-sided", default:false}
 10 | // bind clipless    {label:"Clipless Approximation", default:false}
 11 | 
 12 | uniform float roughness;
 13 | uniform vec3  dcolor;
 14 | uniform vec3  scolor;
 15 | 
 16 | uniform float intensity;
 17 | uniform float width;
 18 | uniform float height;
 19 | uniform float roty;
 20 | uniform float rotz;
 21 | 
 22 | uniform bool twoSided;
 23 | uniform bool clipless;
 24 | 
 25 | uniform sampler2D ltc_1;
 26 | uniform sampler2D ltc_2;
 27 | 
 28 | uniform mat4  view;
 29 | uniform vec2  resolution;
 30 | uniform int   sampleCount;
 31 | 
 32 | const float LUT_SIZE  = 64.0;
 33 | const float LUT_SCALE = (LUT_SIZE - 1.0)/LUT_SIZE;
 34 | const float LUT_BIAS  = 0.5/LUT_SIZE;
 35 | 
 36 | const float pi = 3.14159265;
 37 | 
 38 | // Tracing and intersection
 39 | ///////////////////////////
 40 | 
 41 | struct Ray
 42 | {
 43 |     vec3 origin;
 44 |     vec3 dir;
 45 | };
 46 | 
 47 | struct Rect
 48 | {
 49 |     vec3  center;
 50 |     vec3  dirx;
 51 |     vec3  diry;
 52 |     float halfx;
 53 |     float halfy;
 54 | 
 55 |     vec4  plane;
 56 | };
 57 | 
 58 | bool RayPlaneIntersect(Ray ray, vec4 plane, out float t)
 59 | {
 60 |     t = -dot(plane, vec4(ray.origin, 1.0))/dot(plane.xyz, ray.dir);
 61 |     return t > 0.0;
 62 | }
 63 | 
 64 | bool RayRectIntersect(Ray ray, Rect rect, out float t)
 65 | {
 66 |     bool intersect = RayPlaneIntersect(ray, rect.plane, t);
 67 |     if (intersect)
 68 |     {
 69 |         vec3 pos  = ray.origin + ray.dir*t;
 70 |         vec3 lpos = pos - rect.center;
 71 | 
 72 |         float x = dot(lpos, rect.dirx);
 73 |         float y = dot(lpos, rect.diry);
 74 | 
 75 |         if (abs(x) > rect.halfx || abs(y) > rect.halfy)
 76 |             intersect = false;
 77 |     }
 78 | 
 79 |     return intersect;
 80 | }
 81 | 
 82 | // Camera functions
 83 | ///////////////////
 84 | 
 85 | Ray GenerateCameraRay()
 86 | {
 87 |     Ray ray;
 88 | 
 89 |     vec2 xy = 2.0*gl_FragCoord.xy/resolution - vec2(1.0);
 90 | 
 91 |     ray.dir = normalize(vec3(xy, 2.0));
 92 | 
 93 |     float focalDistance = 2.0;
 94 |     float ft = focalDistance/ray.dir.z;
 95 |     vec3 pFocus = ray.dir*ft;
 96 | 
 97 |     ray.origin = vec3(0);
 98 |     ray.dir    = normalize(pFocus - ray.origin);
 99 | 
100 |     // Apply camera transform
101 |     ray.origin = (view*vec4(ray.origin, 1)).xyz;
102 |     ray.dir    = (view*vec4(ray.dir,    0)).xyz;
103 | 
104 |     return ray;
105 | }
106 | 
107 | vec3 mul(mat3 m, vec3 v)
108 | {
109 |     return m * v;
110 | }
111 | 
112 | mat3 mul(mat3 m1, mat3 m2)
113 | {
114 |     return m1 * m2;
115 | }
116 | 
117 | vec3 rotation_y(vec3 v, float a)
118 | {
119 |     vec3 r;
120 |     r.x =  v.x*cos(a) + v.z*sin(a);
121 |     r.y =  v.y;
122 |     r.z = -v.x*sin(a) + v.z*cos(a);
123 |     return r;
124 | }
125 | 
126 | vec3 rotation_z(vec3 v, float a)
127 | {
128 |     vec3 r;
129 |     r.x =  v.x*cos(a) - v.y*sin(a);
130 |     r.y =  v.x*sin(a) + v.y*cos(a);
131 |     r.z =  v.z;
132 |     return r;
133 | }
134 | 
135 | vec3 rotation_yz(vec3 v, float ay, float az)
136 | {
137 |     return rotation_z(rotation_y(v, ay), az);
138 | }
139 | 
140 | // Linearly Transformed Cosines
141 | ///////////////////////////////
142 | 
143 | vec3 IntegrateEdgeVec(vec3 v1, vec3 v2)
144 | {
145 |     float x = dot(v1, v2);
146 |     float y = abs(x);
147 | 
148 |     float a = 0.8543985 + (0.4965155 + 0.0145206*y)*y;
149 |     float b = 3.4175940 + (4.1616724 + y)*y;
150 |     float v = a / b;
151 | 
152 |     float theta_sintheta = (x > 0.0) ? v : 0.5*inversesqrt(max(1.0 - x*x, 1e-7)) - v;
153 | 
154 |     return cross(v1, v2)*theta_sintheta;
155 | }
156 | 
157 | float IntegrateEdge(vec3 v1, vec3 v2)
158 | {
159 |     return IntegrateEdgeVec(v1, v2).z;
160 | }
161 | 
162 | void ClipQuadToHorizon(inout vec3 L[5], out int n)
163 | {
164 |     // detect clipping config
165 |     int config = 0;
166 |     if (L[0].z > 0.0) config += 1;
167 |     if (L[1].z > 0.0) config += 2;
168 |     if (L[2].z > 0.0) config += 4;
169 |     if (L[3].z > 0.0) config += 8;
170 | 
171 |     // clip
172 |     n = 0;
173 | 
174 |     if (config == 0)
175 |     {
176 |         // clip all
177 |     }
178 |     else if (config == 1) // V1 clip V2 V3 V4
179 |     {
180 |         n = 3;
181 |         L[1] = -L[1].z * L[0] + L[0].z * L[1];
182 |         L[2] = -L[3].z * L[0] + L[0].z * L[3];
183 |     }
184 |     else if (config == 2) // V2 clip V1 V3 V4
185 |     {
186 |         n = 3;
187 |         L[0] = -L[0].z * L[1] + L[1].z * L[0];
188 |         L[2] = -L[2].z * L[1] + L[1].z * L[2];
189 |     }
190 |     else if (config == 3) // V1 V2 clip V3 V4
191 |     {
192 |         n = 4;
193 |         L[2] = -L[2].z * L[1] + L[1].z * L[2];
194 |         L[3] = -L[3].z * L[0] + L[0].z * L[3];
195 |     }
196 |     else if (config == 4) // V3 clip V1 V2 V4
197 |     {
198 |         n = 3;
199 |         L[0] = -L[3].z * L[2] + L[2].z * L[3];
200 |         L[1] = -L[1].z * L[2] + L[2].z * L[1];
201 |     }
202 |     else if (config == 5) // V1 V3 clip V2 V4) impossible
203 |     {
204 |         n = 0;
205 |     }
206 |     else if (config == 6) // V2 V3 clip V1 V4
207 |     {
208 |         n = 4;
209 |         L[0] = -L[0].z * L[1] + L[1].z * L[0];
210 |         L[3] = -L[3].z * L[2] + L[2].z * L[3];
211 |     }
212 |     else if (config == 7) // V1 V2 V3 clip V4
213 |     {
214 |         n = 5;
215 |         L[4] = -L[3].z * L[0] + L[0].z * L[3];
216 |         L[3] = -L[3].z * L[2] + L[2].z * L[3];
217 |     }
218 |     else if (config == 8) // V4 clip V1 V2 V3
219 |     {
220 |         n = 3;
221 |         L[0] = -L[0].z * L[3] + L[3].z * L[0];
222 |         L[1] = -L[2].z * L[3] + L[3].z * L[2];
223 |         L[2] =  L[3];
224 |     }
225 |     else if (config == 9) // V1 V4 clip V2 V3
226 |     {
227 |         n = 4;
228 |         L[1] = -L[1].z * L[0] + L[0].z * L[1];
229 |         L[2] = -L[2].z * L[3] + L[3].z * L[2];
230 |     }
231 |     else if (config == 10) // V2 V4 clip V1 V3) impossible
232 |     {
233 |         n = 0;
234 |     }
235 |     else if (config == 11) // V1 V2 V4 clip V3
236 |     {
237 |         n = 5;
238 |         L[4] = L[3];
239 |         L[3] = -L[2].z * L[3] + L[3].z * L[2];
240 |         L[2] = -L[2].z * L[1] + L[1].z * L[2];
241 |     }
242 |     else if (config == 12) // V3 V4 clip V1 V2
243 |     {
244 |         n = 4;
245 |         L[1] = -L[1].z * L[2] + L[2].z * L[1];
246 |         L[0] = -L[0].z * L[3] + L[3].z * L[0];
247 |     }
248 |     else if (config == 13) // V1 V3 V4 clip V2
249 |     {
250 |         n = 5;
251 |         L[4] = L[3];
252 |         L[3] = L[2];
253 |         L[2] = -L[1].z * L[2] + L[2].z * L[1];
254 |         L[1] = -L[1].z * L[0] + L[0].z * L[1];
255 |     }
256 |     else if (config == 14) // V2 V3 V4 clip V1
257 |     {
258 |         n = 5;
259 |         L[4] = -L[0].z * L[3] + L[3].z * L[0];
260 |         L[0] = -L[0].z * L[1] + L[1].z * L[0];
261 |     }
262 |     else if (config == 15) // V1 V2 V3 V4
263 |     {
264 |         n = 4;
265 |     }
266 | 
267 |     if (n == 3)
268 |         L[3] = L[0];
269 |     if (n == 4)
270 |         L[4] = L[0];
271 | }
272 | 
273 | 
274 | vec3 LTC_Evaluate(
275 |     vec3 N, vec3 V, vec3 P, mat3 Minv, vec3 points[4], bool twoSided)
276 | {
277 |     // construct orthonormal basis around N
278 |     vec3 T1, T2;
279 |     T1 = normalize(V - N*dot(V, N));
280 |     T2 = cross(N, T1);
281 | 
282 |     // rotate area light in (T1, T2, N) basis
283 |     Minv = mul(Minv, transpose(mat3(T1, T2, N)));
284 | 
285 |     // polygon (allocate 5 vertices for clipping)
286 |     vec3 L[5];
287 |     L[0] = mul(Minv, points[0] - P);
288 |     L[1] = mul(Minv, points[1] - P);
289 |     L[2] = mul(Minv, points[2] - P);
290 |     L[3] = mul(Minv, points[3] - P);
291 | 
292 |     // integrate
293 |     float sum = 0.0;
294 | 
295 |     if (clipless)
296 |     {
297 |         vec3 dir = points[0].xyz - P;
298 |         vec3 lightNormal = cross(points[1] - points[0], points[3] - points[0]);
299 |         bool behind = (dot(dir, lightNormal) < 0.0);
300 | 
301 |         L[0] = normalize(L[0]);
302 |         L[1] = normalize(L[1]);
303 |         L[2] = normalize(L[2]);
304 |         L[3] = normalize(L[3]);
305 | 
306 |         vec3 vsum = vec3(0.0);
307 | 
308 |         vsum += IntegrateEdgeVec(L[0], L[1]);
309 |         vsum += IntegrateEdgeVec(L[1], L[2]);
310 |         vsum += IntegrateEdgeVec(L[2], L[3]);
311 |         vsum += IntegrateEdgeVec(L[3], L[0]);
312 | 
313 |         float len = length(vsum);
314 |         float z = vsum.z/len;
315 | 
316 |         if (behind)
317 |             z = -z;
318 | 
319 |         vec2 uv = vec2(z*0.5 + 0.5, len);
320 |         uv = uv*LUT_SCALE + LUT_BIAS;
321 | 
322 |         float scale = texture(ltc_2, uv).w;
323 | 
324 |         sum = len*scale;
325 | 
326 |         if (behind && !twoSided)
327 |             sum = 0.0;
328 |     }
329 |     else
330 |     {
331 |         int n;
332 |         ClipQuadToHorizon(L, n);
333 | 
334 |         if (n == 0)
335 |             return vec3(0, 0, 0);
336 |         // project onto sphere
337 |         L[0] = normalize(L[0]);
338 |         L[1] = normalize(L[1]);
339 |         L[2] = normalize(L[2]);
340 |         L[3] = normalize(L[3]);
341 |         L[4] = normalize(L[4]);
342 | 
343 |         // integrate
344 |         sum += IntegrateEdge(L[0], L[1]);
345 |         sum += IntegrateEdge(L[1], L[2]);
346 |         sum += IntegrateEdge(L[2], L[3]);
347 |         if (n >= 4)
348 |             sum += IntegrateEdge(L[3], L[4]);
349 |         if (n == 5)
350 |             sum += IntegrateEdge(L[4], L[0]);
351 | 
352 |         sum = twoSided ? abs(sum) : max(0.0, sum);
353 |     }
354 | 
355 |     vec3 Lo_i = vec3(sum, sum, sum);
356 | 
357 |     return Lo_i;
358 | }
359 | 
360 | // Scene helpers
361 | ////////////////
362 | 
363 | void InitRect(out Rect rect)
364 | {
365 |     rect.dirx = rotation_yz(vec3(1, 0, 0), roty*2.0*pi, rotz*2.0*pi);
366 |     rect.diry = rotation_yz(vec3(0, 1, 0), roty*2.0*pi, rotz*2.0*pi);
367 | 
368 |     rect.center = vec3(0, 6, 32);
369 |     rect.halfx  = 0.5*width;
370 |     rect.halfy  = 0.5*height;
371 | 
372 |     vec3 rectNormal = cross(rect.dirx, rect.diry);
373 |     rect.plane = vec4(rectNormal, -dot(rectNormal, rect.center));
374 | }
375 | 
376 | void InitRectPoints(Rect rect, out vec3 points[4])
377 | {
378 |     vec3 ex = rect.halfx*rect.dirx;
379 |     vec3 ey = rect.halfy*rect.diry;
380 | 
381 |     points[0] = rect.center - ex - ey;
382 |     points[1] = rect.center + ex - ey;
383 |     points[2] = rect.center + ex + ey;
384 |     points[3] = rect.center - ex + ey;
385 | }
386 | 
387 | // Misc. helpers
388 | ////////////////
389 | 
390 | float saturate(float v)
391 | {
392 |     return clamp(v, 0.0, 1.0);
393 | }
394 | 
395 | vec3 PowVec3(vec3 v, float p)
396 | {
397 |     return vec3(pow(v.x, p), pow(v.y, p), pow(v.z, p));
398 | }
399 | 
400 | const float gamma = 2.2;
401 | vec3 ToLinear(vec3 v) { return PowVec3(v, gamma); }
402 | 
403 | out vec4 FragColor;
404 | 
405 | void main()
406 | {
407 |     Rect rect;
408 |     InitRect(rect);
409 | 
410 |     vec3 points[4];
411 |     InitRectPoints(rect, points);
412 | 
413 |     vec4 floorPlane = vec4(0, 1, 0, 0);
414 | 
415 |     vec3 lcol = vec3(intensity);
416 |     vec3 dcol = ToLinear(dcolor);
417 |     vec3 scol = ToLinear(scolor);
418 | 
419 |     vec3 col = vec3(0);
420 | 
421 |     Ray ray = GenerateCameraRay();
422 | 
423 |     float distToFloor;
424 |     bool hitFloor = RayPlaneIntersect(ray, floorPlane, distToFloor);
425 |     if (hitFloor)
426 |     {
427 |         vec3 pos = ray.origin + ray.dir*distToFloor;
428 | 
429 |         vec3 N = floorPlane.xyz;
430 |         vec3 V = -ray.dir;
431 | 
432 |         float ndotv = saturate(dot(N, V));
433 |         vec2 uv = vec2(roughness, sqrt(1.0 - ndotv));
434 |         uv = uv*LUT_SCALE + LUT_BIAS;
435 | 
436 |         vec4 t1 = texture(ltc_1, uv);
437 |         vec4 t2 = texture(ltc_2, uv);
438 | 
439 |         mat3 Minv = mat3(
440 |             vec3(t1.x, 0, t1.y),
441 |             vec3(  0,  1,    0),
442 |             vec3(t1.z, 0, t1.w)
443 |         );
444 | 
445 |         vec3 spec = LTC_Evaluate(N, V, pos, Minv, points, twoSided);
446 |         // BRDF shadowing and Fresnel
447 |         spec *= scol*t2.x + (1.0 - scol)*t2.y;
448 | 
449 |         vec3 diff = LTC_Evaluate(N, V, pos, mat3(1), points, twoSided);
450 | 
451 |         col = lcol*(spec + dcol*diff);
452 |     }
453 | 
454 |     float distToRect;
455 |     if (RayRectIntersect(ray, rect, distToRect))
456 |         if ((distToRect < distToFloor) || !hitFloor)
457 |             col = lcol;
458 | 
459 |     FragColor = vec4(col, 1.0);
460 | }


--------------------------------------------------------------------------------
/webgl/shaders/ltc/ltc_line.fs:
--------------------------------------------------------------------------------
  1 | // bind roughness   {label:"Roughness", default:0.2, min:0.01, max:1, step:0.001}
  2 | // bind dcolor      {label:"Diffuse Color",  r:1.0, g:1.0, b:1.0}
  3 | // bind scolor      {label:"Specular Color", r:0.23, g:0.23, b:0.23}
  4 | // bind intensity   {label:"Light Intensity", default:100, min:0, max:100, step:1}
  5 | // bind L           {label:"Length", default: 10, min:0.1, max:15, step:0.1}
  6 | // bind R           {label:"Radius", default: 0.2, min:0.05, max:1, step:0.01}
  7 | 
  8 | // bind roty        {label:"Rotation Y", default: 0, min:0, max:1, step:0.001}
  9 | // bind rotz        {label:"Rotation Z", default: 0, min:0, max:1, step:0.001}
 10 | 
 11 | // bind analytic    {label:"Analytic", default:true}
 12 | // bind endCaps     {label:"End Caps", default:false}
 13 | 
 14 | uniform float roughness;
 15 | uniform vec3  dcolor;
 16 | uniform vec3  scolor;
 17 | 
 18 | uniform float intensity;
 19 | uniform float L;
 20 | uniform float R;
 21 | 
 22 | uniform bool analytic;
 23 | uniform bool endCaps;
 24 | 
 25 | uniform sampler2D ltc_1;
 26 | uniform sampler2D ltc_2;
 27 | 
 28 | uniform float roty;
 29 | uniform float rotz;
 30 | 
 31 | uniform mat4  view;
 32 | uniform vec2  resolution;
 33 | 
 34 | const float LUT_SIZE  = 64.0;
 35 | const float LUT_SCALE = (LUT_SIZE - 1.0)/LUT_SIZE;
 36 | const float LUT_BIAS  = 0.5/LUT_SIZE;
 37 | 
 38 | const float PI = 3.14159265;
 39 | 
 40 | // Math
 41 | ////////////////
 42 | 
 43 | vec3 mul(mat3 m, vec3 v)
 44 | {
 45 |     return m * v;
 46 | }
 47 | 
 48 | mat3 mul(mat3 m1, mat3 m2)
 49 | {
 50 |     return m1 * m2;
 51 | }
 52 | 
 53 | vec3 rotation_y(vec3 v, float a)
 54 | {
 55 |     vec3 r;
 56 |     r.x =  v.x*cos(a) + v.z*sin(a);
 57 |     r.y =  v.y;
 58 |     r.z = -v.x*sin(a) + v.z*cos(a);
 59 |     return r;
 60 | }
 61 | 
 62 | vec3 rotation_z(vec3 v, float a)
 63 | {
 64 |     vec3 r;
 65 |     r.x =  v.x*cos(a) - v.y*sin(a);
 66 |     r.y =  v.x*sin(a) + v.y*cos(a);
 67 |     r.z =  v.z;
 68 |     return r;
 69 | }
 70 | 
 71 | vec3 rotation_yz(vec3 v, float ay, float az)
 72 | {
 73 |     return rotation_z(rotation_y(v, ay), az);
 74 | }
 75 | 
 76 | vec3 rotation_yz_inv(vec3 v, float ay, float az)
 77 | {
 78 |     return rotation_y(rotation_z(v, -az), -ay);
 79 | }
 80 | 
 81 | // Cylinder helpers
 82 | ////////////////
 83 | 
 84 | vec3 cylinderCenter()  {return vec3(0, 6, 32);}
 85 | vec3 cylinderTangent() {return rotation_yz(vec3(1, 0, 0), roty * 2.0*PI, rotz * 2.0*PI);}
 86 | vec3 cylinderP1()      {return cylinderCenter() - 0.5 * L * cylinderTangent();}
 87 | vec3 cylinderP2()      {return cylinderCenter() + 0.5 * L * cylinderTangent();}
 88 | 
 89 | // Camera functions
 90 | ///////////////////
 91 | 
 92 | struct Ray
 93 | {
 94 |     vec3 origin;
 95 |     vec3 dir;
 96 | };
 97 | 
 98 | Ray GenerateCameraRay()
 99 | {
100 |     Ray ray;
101 | 
102 |     vec2 xy = 2.0*gl_FragCoord.xy/resolution - vec2(1.0);
103 | 
104 |     ray.dir = normalize(vec3(xy, 2.0));
105 | 
106 |     float focalDistance = 2.0;
107 |     float ft = focalDistance/ray.dir.z;
108 |     vec3 pFocus = ray.dir*ft;
109 | 
110 |     ray.origin = vec3(0);
111 |     ray.dir    = normalize(pFocus - ray.origin);
112 | 
113 |     // Apply camera transform
114 |     ray.origin = (view*vec4(ray.origin, 1)).xyz;
115 |     ray.dir    = (view*vec4(ray.dir,    0)).xyz;
116 | 
117 |     return ray;
118 | }
119 | 
120 | bool RayPlaneIntersect(Ray ray, vec4 plane, out float t)
121 | {
122 |     t = -dot(plane, vec4(ray.origin, 1.0))/dot(plane.xyz, ray.dir);
123 |     return t > 0.0;
124 | }
125 | 
126 | bool quadratic(float a, float b, float c, out float t0, out float t1) {
127 | 
128 |     float d = b*b - 4.0*a*c;
129 |     if (d < 0.0) return false;
130 |     float sqrt_d = sqrt(d);
131 |     float q;
132 |     if (b < 0.0)
133 |         q = -0.5 * (b - sqrt_d);
134 |     else
135 |         q = -0.5 * (b + sqrt_d);
136 |     t0 = q / a;
137 |     t1 = c / q;
138 |     return true;
139 | }
140 | 
141 | bool RayDisksIntersect(Ray ray, out float t)
142 | {
143 |     ray.origin -= cylinderCenter();
144 | 
145 |     ray.origin = rotation_yz_inv(ray.origin, roty * 2.0*PI, rotz * 2.0*PI);
146 |     ray.dir    = rotation_yz_inv(ray.dir,    roty * 2.0*PI, rotz * 2.0*PI);
147 | 
148 |     if (abs(ray.dir.x) < 1e-7) return false;
149 | 
150 |     float t1, t2, height;
151 |     bool d1 = false, d2 = false;
152 | 
153 |     t1 = (-0.5*L - ray.origin.x) / ray.dir.x;
154 |     if (t1 > 0.0)
155 |     {
156 |         vec3 point = ray.origin + t1*ray.dir;
157 |         float dist2 = point.y * point.y + point.z * point.z;
158 |         if (dist2 < R * R)
159 |             d1 = true;
160 |     }
161 | 
162 |     t2 = (+0.5*L - ray.origin.x) / ray.dir.x;
163 |     if (t2 > 0.0)
164 |     {
165 |         vec3 point = ray.origin + t2*ray.dir;
166 |         float dist2 = point.y * point.y + point.z * point.z;
167 |         if (dist2 < R * R)
168 |             d2 = true;
169 |     }
170 | 
171 |     if (d1 && d2)
172 |     {
173 |         t = min(t1, t2);
174 |         return true;
175 |     }
176 |     if (d1)
177 |     {
178 |         t = t1;
179 |         return true;
180 |     }
181 |     if (d2)
182 |     {
183 |         t = t2;
184 |         return true;
185 |     }
186 | 
187 |     return false;
188 | }
189 | 
190 | bool RayCylinderIntersect(Ray ray, out float t)
191 | {
192 |     if (endCaps && RayDisksIntersect(ray, t))
193 |         return true;
194 | 
195 |     ray.origin -= cylinderCenter();
196 | 
197 |     ray.origin = rotation_yz_inv(ray.origin, roty * 2.0*PI, rotz * 2.0*PI);
198 |     ray.dir    = rotation_yz_inv(ray.dir,    roty * 2.0*PI, rotz * 2.0*PI);
199 | 
200 |     float A = ray.dir.z*ray.dir.z + ray.dir.y*ray.dir.y;
201 |     float B = 2.0 * (ray.dir.z*ray.origin.z + ray.dir.y*ray.origin.y);
202 |     float C = ray.origin.z*ray.origin.z + ray.origin.y*ray.origin.y - R*R;
203 | 
204 |     float t0, t1;
205 |     if (!quadratic(A, B, C, t0, t1))
206 |         return false;
207 | 
208 |     if (t0 < 0.0 && t1 < 0.0)
209 |         return false;
210 | 
211 |     t = min(t0, t1);
212 |     if (t0 < 0.0)
213 |         t = t0;
214 |     if (t1 < 0.0)
215 |         t = t1;
216 | 
217 |     // intersection
218 |     vec3 point = ray.origin + t * ray.dir;
219 | 
220 |     if (abs(point.x) > 0.5*L)
221 |         return false;
222 | 
223 |     return true;
224 | }
225 | 
226 | // code from [Frisvad2012]
227 | void buildOrthonormalBasis(
228 | in vec3 n, out vec3 b1, out vec3 b2)
229 | {
230 |     if (n.z < -0.9999999)
231 |     {
232 |         b1 = vec3( 0.0, -1.0, 0.0);
233 |         b2 = vec3(-1.0,  0.0, 0.0);
234 |         return;
235 |     }
236 |     float a = 1.0 / (1.0 + n.z);
237 |     float b = -n.x*n.y*a;
238 |     b1 = vec3(1.0 - n.x*n.x*a, b, -n.x);
239 |     b2 = vec3(b, 1.0 - n.y*n.y*a, -n.y);
240 | }
241 | 
242 | mat3 Minv;
243 | float D(vec3 w)
244 | {
245 |     vec3 wo = Minv * w;
246 |     float lo = length(wo);
247 |     float res = 1.0/PI * max(0.0, wo.z/lo) * abs(determinant(Minv)) / (lo*lo*lo);
248 |     return res;
249 | }
250 | 
251 | float I_cylinder_numerical(vec3 p1, vec3 p2, float R)
252 | {
253 |     // init orthonormal basis
254 |     float L = length(p2 - p1);
255 |     vec3 wt = normalize(p2 - p1);
256 |     vec3 wt1, wt2;
257 |     buildOrthonormalBasis(wt, wt1, wt2);
258 | 
259 |     // integral discretization
260 |     float I = 0.0;
261 |     const int nSamplesphi = 20;
262 |     const int nSamplesl   = 100;
263 |     for (int i = 0; i < nSamplesphi; ++i)
264 |     for (int j = 0; j < nSamplesl;   ++j)
265 |     {
266 |         // normal
267 |         float phi = 2.0 * PI * float(i)/float(nSamplesphi);
268 |         vec3 wn = cos(phi)*wt1 + sin(phi)*wt2;
269 | 
270 |         // position
271 |         float l = L * float(j)/float(nSamplesl - 1);
272 |         vec3 p = p1 + l*wt + R*wn;
273 | 
274 |         // normalized direction
275 |         vec3 wp = normalize(p);
276 | 
277 |         // integrate
278 |         I += D(wp) * max(0.0, dot(-wp, wn)) / dot(p, p);
279 |     }
280 | 
281 |     I *= 2.0 * PI * R * L / float(nSamplesphi*nSamplesl);
282 |     return I;
283 | }
284 | 
285 | float Fpo(float d, float l)
286 | {
287 |     return l/(d*(d*d + l*l)) + atan(l/d)/(d*d);
288 | }
289 | 
290 | float Fwt(float d, float l)
291 | {
292 |     return l*l/(d*(d*d + l*l));
293 | }
294 | 
295 | float I_diffuse_line(vec3 p1, vec3 p2)
296 | {
297 |     // tangent
298 |     vec3 wt = normalize(p2 - p1);
299 | 
300 |     // clamping
301 |     if (p1.z <= 0.0 && p2.z <= 0.0) return 0.0;
302 |     if (p1.z < 0.0) p1 = (+p1*p2.z - p2*p1.z) / (+p2.z - p1.z);
303 |     if (p2.z < 0.0) p2 = (-p1*p2.z + p2*p1.z) / (-p2.z + p1.z);
304 | 
305 |     // parameterization
306 |     float l1 = dot(p1, wt);
307 |     float l2 = dot(p2, wt);
308 | 
309 |     // shading point orthonormal projection on the line
310 |     vec3 po = p1 - l1*wt;
311 | 
312 |     // distance to line
313 |     float d = length(po);
314 | 
315 |     // integral
316 |     float I = (Fpo(d, l2) - Fpo(d, l1)) * po.z +
317 |               (Fwt(d, l2) - Fwt(d, l1)) * wt.z;
318 |     return I / PI;
319 | }
320 | 
321 | float I_ltc_line(vec3 p1, vec3 p2)
322 | {
323 |     // transform to diffuse configuration
324 |     vec3 p1o = Minv * p1;
325 |     vec3 p2o = Minv * p2;
326 |     float I_diffuse = I_diffuse_line(p1o, p2o);
327 | 
328 |     // width factor
329 |     vec3 ortho = normalize(cross(p1, p2));
330 |     float w =  1.0 / length(inverse(transpose(Minv)) * ortho);
331 | 
332 |     return w * I_diffuse;
333 | }
334 | 
335 | float I_disks_numerical(vec3 p1, vec3 p2, float R)
336 | {
337 |     // init orthonormal basis
338 |     float L = length(p2 - p1);
339 |     vec3 wt = normalize(p2 - p1);
340 |     vec3 wt1, wt2;
341 |     buildOrthonormalBasis(wt, wt1, wt2);
342 | 
343 |     // integration
344 |     float Idisks = 0.0;
345 |     const int nSamplesphi = 20;
346 |     const int nSamplesr   = 200;
347 |     for (int i = 0; i < nSamplesphi; ++i)
348 |     for (int j = 0; j < nSamplesr;   ++j)
349 |     {
350 |         float phi = 2.0 * PI * float(i)/float(nSamplesphi);
351 |         float r = R * float(j)/float(nSamplesr - 1);
352 |         vec3 p, wp;
353 | 
354 |         p = p1 + r * (cos(phi)*wt1 + sin(phi)*wt2);
355 |         wp = normalize(p);
356 |         Idisks += r * D(wp) * max(0.0, dot(wp, +wt)) / dot(p, p);
357 | 
358 |         p = p2 + r * (cos(phi)*wt1 + sin(phi)*wt2);
359 |         wp = normalize(p);
360 |         Idisks += r * D(wp) * max(0.0, dot(wp, -wt)) / dot(p, p);
361 |     }
362 | 
363 |     Idisks *= 2.0 * PI * R / float(nSamplesr*nSamplesphi);
364 |     return Idisks;
365 | }
366 | 
367 | float I_ltc_disks(vec3 p1, vec3 p2, float R)
368 | {
369 |     float A = PI * R * R;
370 |     vec3 wt  = normalize(p2 - p1);
371 |     vec3 wp1 = normalize(p1);
372 |     vec3 wp2 = normalize(p2);
373 |     float Idisks = A * (
374 |     D(wp1) * max(0.0, dot(+wt, wp1)) / dot(p1, p1) +
375 |     D(wp2) * max(0.0, dot(-wt, wp2)) / dot(p2, p2));
376 |     return Idisks;
377 | }
378 | 
379 | vec3 LTC_Evaluate(vec3 N, vec3 V, vec3 P)
380 | {
381 |     // construct orthonormal basis around N
382 |     vec3 T1, T2;
383 |     T1 = normalize(V - N*dot(V, N));
384 |     T2 = cross(N, T1);
385 | 
386 |     mat3 B = transpose(mat3(T1, T2, N));
387 | 
388 |     vec3 p1 = mul(B, cylinderP1() - P);
389 |     vec3 p2 = mul(B, cylinderP2() - P);
390 | 
391 |     if (analytic) // analytic integration
392 |     {
393 |         float Iline = R * I_ltc_line(p1, p2);
394 |         float Idisks = endCaps ? I_ltc_disks(p1, p2, R) : 0.0;
395 |         return vec3(min(1.0, Iline + Idisks));
396 |     }
397 |     else // numerical integration
398 |     {
399 |         float Icylinder = I_cylinder_numerical(p1, p2, R);
400 |         float Idisks = endCaps ? I_disks_numerical(p1, p2, R) : 0.0;
401 |         return vec3(Icylinder + Idisks);
402 |     }
403 | }
404 | 
405 | // Misc. helpers
406 | ////////////////
407 | 
408 | float saturate(float v)
409 | {
410 |     return clamp(v, 0.0, 1.0);
411 | }
412 | 
413 | vec3 PowVec3(vec3 v, float p)
414 | {
415 |     return vec3(pow(v.x, p), pow(v.y, p), pow(v.z, p));
416 | }
417 | 
418 | const float gamma = 2.2;
419 | vec3 ToLinear(vec3 v) { return PowVec3(v, gamma); }
420 | 
421 | out vec4 FragColor;
422 | 
423 | // Main
424 | ////////////////
425 | 
426 | void main()
427 | {
428 |     vec4 floorPlane = vec4(0, 1, 0, 0);
429 | 
430 |     vec3 lcol = vec3(intensity);
431 |     vec3 dcol = ToLinear(dcolor);
432 |     vec3 scol = ToLinear(scolor);
433 | 
434 |     vec3 col = vec3(0);
435 | 
436 |     {
437 |         Ray ray = GenerateCameraRay();
438 | 
439 |         float distToFloor;
440 |         bool hitFloor = RayPlaneIntersect(ray, floorPlane, distToFloor);
441 |         if (hitFloor)
442 |         {
443 |             vec3 pos = ray.origin + ray.dir*distToFloor;
444 | 
445 |             vec3 N = floorPlane.xyz;
446 |             vec3 V = -ray.dir;
447 | 
448 |             float ndotv = saturate(dot(N, V));
449 |             vec2 uv = vec2(roughness, sqrt(1.0 - ndotv));
450 |             uv = uv*LUT_SCALE + LUT_BIAS;
451 | 
452 |             vec4 t1 = texture(ltc_1, uv);
453 |             vec4 t2 = texture(ltc_2, uv);
454 | 
455 |             Minv = mat3(
456 |                 vec3(t1.x, 0, t1.y),
457 |                 vec3(  0,  1,    0),
458 |                 vec3(t1.z, 0, t1.w)
459 |             );
460 | 
461 |             vec3 spec = LTC_Evaluate(N, V, pos);
462 |             // BRDF shadowing and Fresnel
463 |             spec *= scol*t2.x + (1.0 - scol)*t2.y;
464 | 
465 |             Minv = mat3(1);
466 |             vec3 diff = LTC_Evaluate(N, V, pos);
467 | 
468 |             col  = lcol*(spec + dcol*diff);
469 |             col /= 2.0*PI;
470 |         }
471 | 
472 |         float distToCylinder;
473 |         if (RayCylinderIntersect(ray, distToCylinder))
474 |             if ((distToCylinder < distToFloor) || !hitFloor)
475 |                 col = lcol;
476 |     }
477 | 
478 |     FragColor = vec4(col, 1.0);
479 | }


--------------------------------------------------------------------------------
/webgl/js/color_picker.js:
--------------------------------------------------------------------------------
  1 | 
  2 | if (window.ColorXXX == undefined) ColorXXX = {};
  3 | 
  4 | ColorXXX.Picker = function (props) {
  5 | 
  6 | 	/// loading properties
  7 | 	if (typeof(props) == "undefined") props = {};
  8 | 	this.callback = props.callback; // bind custom function
  9 | 	this.hue = props.hue || 0; // 0-360
 10 | 	this.sat = props.sat || 0; // 0-100
 11 | 	this.val = props.val || 100; // 0-100
 12 | 	this.element = props.element || document.body;
 13 | 	this.size = 165; // size of colorpicker
 14 | 	this.margin = 10; // margins on colorpicker
 15 | 	this.offset = this.margin / 2;
 16 | 	this.hueWidth = 30;
 17 | 
 18 | 	/// creating colorpicker (header)
 19 | 	var plugin = document.createElement("div");
 20 | 	plugin.id = "colorjack_square";
 21 | 	plugin.style.cssText  = "height: " + (this.size + this.margin * 2) + "px";
 22 | 
 23 |     this.visible = function() {
 24 | 		var current = plugin.style.display;
 25 |         return current !== "none";
 26 |     }
 27 | 
 28 | 	this.hide = function () {
 29 | 		plugin.style.display = "none";
 30 | 	}
 31 | 
 32 | 	this.show = function () {
 33 | 		plugin.style.display = "block";
 34 | 	}
 35 | 
 36 | 	this.toggle = function () {
 37 | 		if (this.visible())
 38 | 			$(plugin).fadeOut("fast", "linear");		
 39 | 		else
 40 | 			$(plugin).fadeIn("fast", "linear");
 41 | 
 42 | 		//plugin.style.display = (current === "none") ? "block" : "none";
 43 | 	}
 44 | 
 45 |     if (props.fade) {
 46 | 	    plugin.style.cssText += "display: none";
 47 | 	    this.toggle();
 48 |     }
 49 | 
 50 | 	var that = this;
 51 | 
 52 | 	/// creating media-resources
 53 | 	var arrows = document.createElement("canvas");
 54 | 	arrows.width = 40;
 55 | 	arrows.height = 5;
 56 | 	(function () { // creating arrows
 57 | 		var ctx = arrows.getContext("2d");
 58 | 		var width = 3;
 59 | 		var height = 5;
 60 | 		var size = 9;
 61 | 		var top = -size / 4;
 62 | 		var left = 1;
 63 | 		for (var n = 0; n < 20; n++) { // multiply anti-aliasing
 64 | 			ctx.beginPath();
 65 | 			ctx.fillStyle = "#FFF";
 66 | 			ctx.moveTo(left + size / 4, size / 2 + top);
 67 | 			ctx.lineTo(left, size / 4 + top);
 68 | 			ctx.lineTo(left, size / 4 * 3 + top);
 69 | 			ctx.fill();
 70 | 		}
 71 | 		ctx.translate(width, height);
 72 | 		ctx.rotate(180 * Math.PI / 180); // rotate arrows
 73 | 		ctx.drawImage(arrows, -29, 0);
 74 | 		ctx.translate(-width, -height);
 75 | 	})();
 76 | 
 77 | 	var circle = document.createElement("canvas");
 78 | 	circle.width = 10;
 79 | 	circle.height = 10;
 80 | 	(function () { // creating circle-selection
 81 | 		var ctx = circle.getContext("2d");
 82 | 		ctx.lineWidth = 1;
 83 | 		ctx.beginPath();
 84 | 		var x = circle.width / 2;
 85 | 		var y = circle.width / 2;
 86 | 		ctx.arc(x, y, 4.5, 0, Math.PI * 2, true);
 87 | 		ctx.strokeStyle = '#000';
 88 | 		ctx.stroke();
 89 | 		ctx.beginPath();
 90 | 		ctx.arc(x, y, 3.5, 0, Math.PI * 2, true);
 91 | 		ctx.strokeStyle = '#FFF';
 92 | 		ctx.stroke();
 93 | 	})();
 94 | 
 95 | 	/// creating colorpicker sliders
 96 | 	var canvas = document.createElement("canvas");
 97 | 	var ctx = canvas.getContext("2d");
 98 | 	canvas.style.cssText = "position: absolute; top: 5px; left: " + (this.offset) + "px;";
 99 | 	canvas.width = this.size + this.hueWidth + this.margin;
100 | 	canvas.height = this.size + this.margin;
101 | 	plugin.appendChild(canvas);
102 | 
103 | 	plugin.onclick = function(e) {
104 | 	    e.stopPropagation();
105 | 	}
106 | 
107 | 	plugin.onmousemove =
108 | 	plugin.onmousedown = function (e) {
109 | 		var down = (e.type == "mousedown");
110 | 		var offset = that.margin / 2;
111 | 
112 | 	    var of = $(canvas).offset();
113 | 	    var oX = of.left;
114 | 	    var oY = of.top;
115 | 
116 | 		var x0 = (e.pageX - oX) - offset;
117 | 		var y0 = (e.pageY - oY) - offset;
118 | 		var x = clamp(x0, 0, canvas.width);
119 | 		var y = clamp(y0, 0, that.size);
120 | 
121 | 		if (x != x0 || y != y0) { // move colorpicker
122 | 			/*plugin.style.cursor = "move";
123 | 			if (down) dragElement({
124 | 				type: "difference",
125 | 				event: e,
126 | 				element: plugin,
127 | 				callback: function (coords, state) {
128 | 					plugin.style.left = coords.x + "px";
129 | 					plugin.style.top = coords.y + "px";
130 | 				}
131 | 			});*/
132 | 			return;
133 | 		} else if (x <= that.size) { // saturation-value selection
134 | 			plugin.style.cursor = "crosshair";
135 | 			if (down) dragElement({
136 | 				type: "relative",
137 | 				event: e,
138 | 				element: canvas,
139 | 				callback: function (coords, state) {
140 | 					var x = clamp(coords.x - that.offset, 0, that.size);
141 | 					var y = clamp(coords.y - that.offset, 0, that.size);
142 | 					that.sat = x / that.size * 100; // scale saturation
143 | 					that.val = 100 - (y / that.size * 100); // scale value
144 | 					that.drawSample();
145 | 				}
146 | 			});
147 | 		} else if (x > that.size + that.margin && x <= that.size + that.hueWidth) { // hue selection
148 | 			plugin.style.cursor = "crosshair";
149 | 			if (down) dragElement({
150 | 				type: "relative",
151 | 				event: e,
152 | 				element: canvas,
153 | 				callback: function (coords, state) {
154 | 					var y = clamp(coords.y - that.offset, 0, that.size);
155 | 					that.hue = Math.min(1, y / that.size) * 360;
156 | 					that.drawSample();
157 | 				}
158 | 			});
159 | 		} else { // margin between hue/saturation-value
160 | 			plugin.style.cursor = "default";
161 | 		}
162 | 		
163 | 		return false; // prevent selection
164 | 	};
165 | 	// appending to elementc
166 | 	this.element.appendChild(plugin);
167 | 
168 | 	/// helper functions
169 | 	var that = this;
170 | 	this.el = plugin;
171 | 	this.drawSample = function () {
172 | 		// clearing canvas
173 | 		ctx.clearRect(0, 0, canvas.width, canvas.height)
174 | 		that.drawSquare();
175 | 		that.drawHue();
176 | 
177 | 		// arrow-selection
178 | 		var y = (that.hue / 362) * that.size - 2;
179 | 		ctx.drawImage(arrows, that.size + that.offset + 4, Math.round(y) + that.offset);
180 | 
181 | 		// circle-selection
182 | 		var x = that.sat / 100 * that.size;
183 | 		var y = (1 - (that.val / 100)) * that.size;
184 | 		x = x - circle.width / 2;
185 | 		y = y - circle.height / 2;
186 |  		ctx.drawImage(circle, Math.round(x) + that.offset, Math.round(y) + that.offset);
187 | 
188 | 		// run custom code
189 | 		if (that.callback) {
190 |             var rgb = ColorXXX.HSV_RGB({
191 |                 H: that.hue,
192 |                 S: that.sat,
193 |                 V: that.val
194 |             });
195 | 
196 | 		    that.callback(rgb);
197 | 		}
198 | 	};
199 | 
200 | 	this.drawSquare = function () {
201 | 		// retrieving hex-code
202 | 		var hex = ColorXXX.HSV_HEX({
203 | 			H: that.hue,
204 | 			S: 100,
205 | 			V: 100
206 | 		});
207 | 		var offset = that.offset;
208 | 		var size = that.size;
209 | 		// drawing color
210 | 		ctx.fillStyle = "#" + hex;
211 | 		ctx.fillRect(offset, offset, size, size);
212 | 		// overlaying saturation
213 | 		var gradient = ctx.createLinearGradient(offset, offset, size + offset, 0);
214 | 		gradient.addColorStop(0, "rgba(255, 255, 255, 1)");
215 | 		gradient.addColorStop(1, "rgba(255, 255, 255, 0)");
216 | 		ctx.fillStyle = gradient;
217 | 		ctx.fillRect(offset, offset, size, size);
218 | 		// overlaying value
219 | 		var gradient = ctx.createLinearGradient(offset, offset, 0, size + offset);
220 | 		gradient.addColorStop(0, "rgba(0, 0, 0, 0)");
221 | 		gradient.addColorStop(1, "rgba(0, 0, 0, 1)");
222 | 		ctx.fillStyle = gradient;
223 | 		ctx.fillRect(offset, offset, size, size);
224 | 		// drawing outer bounds
225 | 		ctx.strokeStyle = "rgba(255,255,255,0.15)";
226 | 		ctx.strokeRect(offset+0.5, offset+0.5, size-1, size-1);
227 | 	};
228 | 
229 | 	this.drawHue = function () {
230 | 		// drawing hue selector
231 | 		var left = that.size + that.margin + that.offset;
232 | 		var gradient = ctx.createLinearGradient(0, 0, 0, that.size);
233 | 		gradient.addColorStop(0.00, "rgba(255,   0,  0,  1)");
234 | 		gradient.addColorStop(0.15, "rgba(255, 255,  0,  1)");
235 | 		gradient.addColorStop(0.30, "rgba(0,   255,  0,  1)");
236 | 		gradient.addColorStop(0.50, "rgba(0,   255, 255, 1)");
237 | 		gradient.addColorStop(0.65, "rgba(0,     0, 255, 1)");
238 | 		gradient.addColorStop(0.80, "rgba(255,   0, 255, 1)");
239 | 		gradient.addColorStop(1.00, "rgba(255,   0,   0, 1)");
240 | 		ctx.fillStyle = gradient;
241 | 		ctx.fillRect(left, that.offset, 20, that.size);
242 | 		// drawing outer bounds
243 | 		ctx.strokeStyle = "rgba(255,255,255,0.2)";
244 | 		ctx.strokeRect(left + 0.5, that.offset + 0.5, 19, that.size-1);
245 | 	};
246 | 
247 | 	this.destroyMe = function () {
248 | 	    $(plugin).remove();
249 | 		for (var key in that) delete that[key];
250 | 	};
251 | 
252 | 	// drawing color selection
253 | 	this.drawSample();
254 | 
255 | 	return this;
256 | };
257 | 
258 | 
259 | var dragElement = function(props) {
260 | 	function mouseMove(e, state) {
261 | 		if (typeof(state) == "undefined") state = "move";
262 | 		var coord = XY(e);
263 | 		switch (props.type) {
264 | 			case "difference": 
265 | 				props.callback({
266 | 					x: coord.x + oX - eX,
267 | 					y: coord.y + oY - eY
268 | 				}, state);
269 | 				break;
270 | 			case "relative":
271 | 				props.callback({
272 | 					x: coord.x - oX,
273 | 					y: coord.y - oY
274 | 				}, state);
275 | 				break;
276 | 			default: // "absolute"
277 | 				props.callback({
278 | 					x: coord.x,
279 | 					y: coord.y
280 | 				}, state);
281 | 				break;
282 | 		}
283 | 	};
284 | 	function mouseUp(e) {
285 | 		window.removeEventListener("mousemove", mouseMove, false);
286 | 		window.removeEventListener("mouseup", mouseUp, false);
287 | 		mouseMove(e, "up");
288 | 	};
289 | 	function mouseClick(e) {
290 | 	    console.log("hghghfghh");
291 | 	    e.stopPropagation();
292 | 	}
293 | 
294 | 	// current element position
295 | 	var el = props.element;
296 | 
297 | 
298 | 	var of = $(el).offset();
299 | 	var oX = of.left;
300 | 	var oY = of.top;
301 | 
302 | //	var origin = abPos(el);
303 | //	var oX = origin.x;
304 | //	var oY = origin.y;
305 | 
306 | 	// current mouse position
307 | 	var e = props.event;
308 | 	var coord = XY(e);
309 | 	var eX = coord.x;
310 | 	var eY = coord.y;
311 | 
312 | 	// events
313 | 	window.addEventListener("mousemove", mouseMove, false);
314 | 	window.addEventListener("mouseup", mouseUp, false);
315 | 	mouseMove(e, "down"); // run mouse-down
316 | };
317 | 
318 | var clamp = function(n, min, max) {
319 | 	return (n < min) ? min : ((n > max) ? max : n);
320 | };
321 | 
322 | var XY = window.ActiveXObject ? // fix XY to work in various browsers
323 | 	function(event) {
324 | 		return {
325 | 			x: event.clientX + document.documentElement.scrollLeft,
326 | 			y: event.clientY + document.documentElement.scrollTop
327 | 		};
328 | 	} : function(event) {
329 | 		return {
330 | 			x: event.pageX,
331 | 			y: event.pageY
332 | 		};
333 | 	};
334 | 
335 | var abPos = function(o) { 
336 | 	o = typeof(o) == 'object' ? o : $(o);
337 | 	var offset = { x: 0, y: 0 };
338 | 	while(o != null) { 
339 | 		offset.x += o.offsetLeft; 
340 | 		offset.y += o.offsetTop; 
341 | 		o = o.offsetParent; 
342 | 	};
343 | 	return offset;
344 | };
345 | 
346 | 
347 | ColorXXX.HEX_STRING = function (o) {
348 | 	var z = o.toString(16);
349 | 	var n = z.length;
350 | 	while (n < 6) {
351 | 		z = '0' + z;
352 | 		n ++;
353 | 	}
354 | 	return z;
355 | };
356 | 
357 | ColorXXX.RGB_HEX = function (o) {
358 | 	return o.R << 16 | o.G << 8 | o.B;
359 | };
360 | 
361 | ColorXXX.HSV_RGB = function (o) {
362 | 	var H = o.H / 360,
363 | 		S = o.S / 100,
364 | 		V = o.V / 100,
365 | 		R, G, B;
366 | 	var A, B, C, D;
367 | 	if (S == 0) {
368 | 		R = G = B = Math.round(V * 255);
369 | 	} else {
370 | 		if (H >= 1) H = 0;
371 | 		H = 6 * H;
372 | 		D = H - Math.floor(H);
373 | 		A = Math.round(255 * V * (1 - S));
374 | 		B = Math.round(255 * V * (1 - (S * D)));
375 | 		C = Math.round(255 * V * (1 - (S * (1 - D))));
376 | 		V = Math.round(255 * V);
377 | 		switch (Math.floor(H)) {
378 | 			case 0:
379 | 				R = V;
380 | 				G = C;
381 | 				B = A;
382 | 				break;
383 | 			case 1:
384 | 				R = B;
385 | 				G = V;
386 | 				B = A;
387 | 				break;
388 | 			case 2:
389 | 				R = A;
390 | 				G = V;
391 | 				B = C;
392 | 				break;
393 | 			case 3:
394 | 				R = A;
395 | 				G = B;
396 | 				B = V;
397 | 				break;
398 | 			case 4:
399 | 				R = C;
400 | 				G = A;
401 | 				B = V;
402 | 				break;
403 | 			case 5:
404 | 				R = V;
405 | 				G = A;
406 | 				B = B;
407 | 				break;
408 | 		}
409 | 	}
410 | 	return {
411 | 		R: R,
412 | 		G: G,
413 | 		B: B
414 | 	};
415 | };
416 | 
417 | ColorXXX.HSV_HEX = function (o) {
418 | 	return ColorXXX.HEX_STRING(ColorXXX.RGB_HEX(ColorXXX.HSV_RGB(o)));
419 | };
420 | 
421 | ColorXXX.rgb2hsv = function (r, g, b) {
422 | 	var color = typeof(r) === 'number' ? [r / 255, g / 255, b / 255] : [r.r / 255, r.g / 255, r.b / 255],
423 | 		rgb_min = Math.min(color[0], Math.min(color[1], color[2])),
424 | 		rgb_max = Math.max(color[0], Math.max(color[1], color[2])),
425 | 		rgb_delta = rgb_max - rgb_min,
426 | 		v = rgb_max,
427 | 		h, s, r_delta, g_delta, b_delta;
428 | 	
429 |     if (rgb_delta === 0.0) {
430 |         // Grey
431 |         h = 0.0;
432 |         s = 0.0;
433 |     } else {
434 |         // Colour
435 |         s = rgb_delta / rgb_max;
436 |         r_delta = (((rgb_max - color[0]) / 6.0) + (rgb_delta / 2.0)) / rgb_delta;
437 |         g_delta = (((rgb_max - color[1]) / 6.0) + (rgb_delta / 2.0)) / rgb_delta;
438 |         b_delta = (((rgb_max - color[2]) / 6.0) + (rgb_delta / 2.0)) / rgb_delta;
439 | 
440 |         if (color[0] === rgb_max) {
441 |             h = b_delta - g_delta;
442 |         } else if (color[1] === rgb_max) {
443 |             h = 1.0 / 3.0 + r_delta - b_delta;
444 |         } else if (color[2] === rgb_max) {
445 |             h = 2.0 / 3.0 + g_delta - r_delta;
446 |         }
447 | 
448 |         if (h < 0.0) {
449 | 			h += 1.0;
450 | 		}
451 |         if (h > 1.0) {
452 | 			h -= 1.0;
453 | 		}
454 |     }
455 | 	
456 |     return [Math.round(h * 359), Math.round(s * 100), Math.round(v * 100)];
457 | };
458 | 


--------------------------------------------------------------------------------
/webgl/js/macton/matrix4x4.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2009, Mozilla Corp
  3 |  * All rights reserved.
  4 |  *
  5 |  * Redistribution and use in source and binary forms, with or without
  6 |  * modification, are permitted provided that the following conditions are met:
  7 |  *     * Redistributions of source code must retain the above copyright
  8 |  *       notice, this list of conditions and the following disclaimer.
  9 |  *     * Redistributions in binary form must reproduce the above copyright
 10 |  *       notice, this list of conditions and the following disclaimer in the
 11 |  *       documentation and/or other materials provided with the distribution.
 12 |  *     * Neither the name of the <organization> nor the
 13 |  *       names of its contributors may be used to endorse or promote products
 14 |  *       derived from this software without specific prior written permission.
 15 |  *
 16 |  * THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
 17 |  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18 |  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19 |  * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
 20 |  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21 |  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22 |  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23 |  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 |  */
 27 | 
 28 | /*
 29 |  * Based on sample code from the OpenGL(R) ES 2.0 Programming Guide, which carriers
 30 |  * the following header:
 31 |  *
 32 |  * Book:      OpenGL(R) ES 2.0 Programming Guide
 33 |  * Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
 34 |  * ISBN-10:   0321502795
 35 |  * ISBN-13:   9780321502797
 36 |  * Publisher: Addison-Wesley Professional
 37 |  * URLs:      http://safari.informit.com/9780321563835
 38 |  *            http://www.opengles-book.com
 39 |  */
 40 | 
 41 | //
 42 | // A simple 4x4 Matrix utility class
 43 | //
 44 | 
 45 | function Matrix4x4() {
 46 |   this.elements = Array(16);
 47 |   this.loadIdentity();
 48 | }
 49 | 
 50 | Matrix4x4.prototype = {
 51 |   scale: function (sx, sy, sz) {
 52 |     this.elements[0*4+0] *= sx;
 53 |     this.elements[0*4+1] *= sx;
 54 |     this.elements[0*4+2] *= sx;
 55 |     this.elements[0*4+3] *= sx;
 56 | 
 57 |     this.elements[1*4+0] *= sy;
 58 |     this.elements[1*4+1] *= sy;
 59 |     this.elements[1*4+2] *= sy;
 60 |     this.elements[1*4+3] *= sy;
 61 | 
 62 |     this.elements[2*4+0] *= sz;
 63 |     this.elements[2*4+1] *= sz;
 64 |     this.elements[2*4+2] *= sz;
 65 |     this.elements[2*4+3] *= sz;
 66 | 
 67 |     return this;
 68 |   },
 69 | 
 70 |   translate: function (tx, ty, tz) {
 71 |     this.elements[3*4+0] += this.elements[0*4+0] * tx + this.elements[1*4+0] * ty + this.elements[2*4+0] * tz;
 72 |     this.elements[3*4+1] += this.elements[0*4+1] * tx + this.elements[1*4+1] * ty + this.elements[2*4+1] * tz;
 73 |     this.elements[3*4+2] += this.elements[0*4+2] * tx + this.elements[1*4+2] * ty + this.elements[2*4+2] * tz;
 74 |     this.elements[3*4+3] += this.elements[0*4+3] * tx + this.elements[1*4+3] * ty + this.elements[2*4+3] * tz;
 75 | 
 76 |     return this;
 77 |   },
 78 | 
 79 |   rotate: function (angle, x, y, z) {
 80 |     var mag = Math.sqrt(x*x + y*y + z*z);
 81 |     var sinAngle = Math.sin(angle * Math.PI / 180.0);
 82 |     var cosAngle = Math.cos(angle * Math.PI / 180.0);
 83 | 
 84 |     if (mag > 0) {
 85 |       var xx, yy, zz, xy, yz, zx, xs, ys, zs;
 86 |       var oneMinusCos;
 87 |       var rotMat;
 88 | 
 89 |       x /= mag;
 90 |       y /= mag;
 91 |       z /= mag;
 92 | 
 93 |       xx = x * x;
 94 |       yy = y * y;
 95 |       zz = z * z;
 96 |       xy = x * y;
 97 |       yz = y * z;
 98 |       zx = z * x;
 99 |       xs = x * sinAngle;
100 |       ys = y * sinAngle;
101 |       zs = z * sinAngle;
102 |       oneMinusCos = 1.0 - cosAngle;
103 | 
104 |       rotMat = new Matrix4x4();
105 | 
106 |       rotMat.elements[0*4+0] = (oneMinusCos * xx) + cosAngle;
107 |       rotMat.elements[0*4+1] = (oneMinusCos * xy) - zs;
108 |       rotMat.elements[0*4+2] = (oneMinusCos * zx) + ys;
109 |       rotMat.elements[0*4+3] = 0.0;
110 | 
111 |       rotMat.elements[1*4+0] = (oneMinusCos * xy) + zs;
112 |       rotMat.elements[1*4+1] = (oneMinusCos * yy) + cosAngle;
113 |       rotMat.elements[1*4+2] = (oneMinusCos * yz) - xs;
114 |       rotMat.elements[1*4+3] = 0.0;
115 | 
116 |       rotMat.elements[2*4+0] = (oneMinusCos * zx) - ys;
117 |       rotMat.elements[2*4+1] = (oneMinusCos * yz) + xs;
118 |       rotMat.elements[2*4+2] = (oneMinusCos * zz) + cosAngle;
119 |       rotMat.elements[2*4+3] = 0.0;
120 | 
121 |       rotMat.elements[3*4+0] = 0.0;
122 |       rotMat.elements[3*4+1] = 0.0;
123 |       rotMat.elements[3*4+2] = 0.0;
124 |       rotMat.elements[3*4+3] = 1.0;
125 | 
126 |       rotMat = rotMat.multiply(this);
127 |       this.elements = rotMat.elements;
128 |     }
129 | 
130 |     return this;
131 |   },
132 | 
133 |   frustum: function (left, right, bottom, top, nearZ, farZ) {
134 |     var deltaX = right - left;
135 |     var deltaY = top - bottom;
136 |     var deltaZ = farZ - nearZ;
137 |     var frust;
138 | 
139 |     if ( (nearZ <= 0.0) || (farZ <= 0.0) ||
140 |          (deltaX <= 0.0) || (deltaY <= 0.0) || (deltaZ <= 0.0) )
141 |          return this;
142 | 
143 |     frust = new Matrix4x4();
144 | 
145 |     frust.elements[0*4+0] = 2.0 * nearZ / deltaX;
146 |     frust.elements[0*4+1] = frust.elements[0*4+2] = frust.elements[0*4+3] = 0.0;
147 | 
148 |     frust.elements[1*4+1] = 2.0 * nearZ / deltaY;
149 |     frust.elements[1*4+0] = frust.elements[1*4+2] = frust.elements[1*4+3] = 0.0;
150 | 
151 |     frust.elements[2*4+0] = (right + left) / deltaX;
152 |     frust.elements[2*4+1] = (top + bottom) / deltaY;
153 |     frust.elements[2*4+2] = -(nearZ + farZ) / deltaZ;
154 |     frust.elements[2*4+3] = -1.0;
155 | 
156 |     frust.elements[3*4+2] = -2.0 * nearZ * farZ / deltaZ;
157 |     frust.elements[3*4+0] = frust.elements[3*4+1] = frust.elements[3*4+3] = 0.0;
158 | 
159 |     frust = frust.multiply(this);
160 |     this.elements = frust.elements;
161 | 
162 |     return this;
163 |   },
164 | 
165 |   perspective: function (fovy, aspect, nearZ, farZ) {
166 |     var frustumH = Math.tan(fovy / 360.0 * Math.PI) * nearZ;
167 |     var frustumW = frustumH * aspect;
168 | 
169 |     return this.frustum(-frustumW, frustumW, -frustumH, frustumH, nearZ, farZ);
170 |   },
171 | 
172 |   ortho: function (left, right, bottom, top, nearZ, farZ) {
173 |     var deltaX = right - left;
174 |     var deltaY = top - bottom;
175 |     var deltaZ = farZ - nearZ;
176 | 
177 |     var ortho = new Matrix4x4();
178 | 
179 |     if ( (deltaX == 0.0) || (deltaY == 0.0) || (deltaZ == 0.0) )
180 |         return this;
181 | 
182 |     ortho.elements[0*4+0] = 2.0 / deltaX;
183 |     ortho.elements[3*4+0] = -(right + left) / deltaX;
184 |     ortho.elements[1*4+1] = 2.0 / deltaY;
185 |     ortho.elements[3*4+1] = -(top + bottom) / deltaY;
186 |     ortho.elements[2*4+2] = -2.0 / deltaZ;
187 |     ortho.elements[3*4+2] = -(nearZ + farZ) / deltaZ;
188 | 
189 |     ortho = ortho.multiply(this);
190 |     this.elements = ortho.elements;
191 | 
192 |     return this;
193 |   },
194 | 
195 |   multiply: function (right) {
196 |     var tmp = new Matrix4x4();
197 | 
198 |     for (var i = 0; i < 4; i++) {
199 |       tmp.elements[i*4+0] =
200 | 	(this.elements[i*4+0] * right.elements[0*4+0]) +
201 | 	(this.elements[i*4+1] * right.elements[1*4+0]) +
202 | 	(this.elements[i*4+2] * right.elements[2*4+0]) +
203 | 	(this.elements[i*4+3] * right.elements[3*4+0]) ;
204 | 
205 |       tmp.elements[i*4+1] =
206 | 	(this.elements[i*4+0] * right.elements[0*4+1]) +
207 | 	(this.elements[i*4+1] * right.elements[1*4+1]) +
208 | 	(this.elements[i*4+2] * right.elements[2*4+1]) +
209 | 	(this.elements[i*4+3] * right.elements[3*4+1]) ;
210 | 
211 |       tmp.elements[i*4+2] =
212 | 	(this.elements[i*4+0] * right.elements[0*4+2]) +
213 | 	(this.elements[i*4+1] * right.elements[1*4+2]) +
214 | 	(this.elements[i*4+2] * right.elements[2*4+2]) +
215 | 	(this.elements[i*4+3] * right.elements[3*4+2]) ;
216 | 
217 |       tmp.elements[i*4+3] =
218 | 	(this.elements[i*4+0] * right.elements[0*4+3]) +
219 | 	(this.elements[i*4+1] * right.elements[1*4+3]) +
220 | 	(this.elements[i*4+2] * right.elements[2*4+3]) +
221 | 	(this.elements[i*4+3] * right.elements[3*4+3]) ;
222 |     }
223 | 
224 |     this.elements = tmp.elements;
225 |     return this;
226 |   },
227 | 
228 |   copy: function () {
229 |     var tmp = new Matrix4x4();
230 |     for (var i = 0; i < 16; i++) {
231 |       tmp.elements[i] = this.elements[i];
232 |     }
233 |     return tmp;
234 |   },
235 | 
236 |   get: function (row, col) {
237 |     return this.elements[4*row+col];
238 |   },
239 | 
240 |   // In-place inversion
241 |   invert: function () {
242 |     var tmp_0 = this.get(2,2) * this.get(3,3);
243 |     var tmp_1 = this.get(3,2) * this.get(2,3);
244 |     var tmp_2 = this.get(1,2) * this.get(3,3);
245 |     var tmp_3 = this.get(3,2) * this.get(1,3);
246 |     var tmp_4 = this.get(1,2) * this.get(2,3);
247 |     var tmp_5 = this.get(2,2) * this.get(1,3);
248 |     var tmp_6 = this.get(0,2) * this.get(3,3);
249 |     var tmp_7 = this.get(3,2) * this.get(0,3);
250 |     var tmp_8 = this.get(0,2) * this.get(2,3);
251 |     var tmp_9 = this.get(2,2) * this.get(0,3);
252 |     var tmp_10 = this.get(0,2) * this.get(1,3);
253 |     var tmp_11 = this.get(1,2) * this.get(0,3);
254 |     var tmp_12 = this.get(2,0) * this.get(3,1);
255 |     var tmp_13 = this.get(3,0) * this.get(2,1);
256 |     var tmp_14 = this.get(1,0) * this.get(3,1);
257 |     var tmp_15 = this.get(3,0) * this.get(1,1);
258 |     var tmp_16 = this.get(1,0) * this.get(2,1);
259 |     var tmp_17 = this.get(2,0) * this.get(1,1);
260 |     var tmp_18 = this.get(0,0) * this.get(3,1);
261 |     var tmp_19 = this.get(3,0) * this.get(0,1);
262 |     var tmp_20 = this.get(0,0) * this.get(2,1);
263 |     var tmp_21 = this.get(2,0) * this.get(0,1);
264 |     var tmp_22 = this.get(0,0) * this.get(1,1);
265 |     var tmp_23 = this.get(1,0) * this.get(0,1);
266 | 
267 |     var t0 = ((tmp_0 * this.get(1,1) + tmp_3 * this.get(2,1) + tmp_4 * this.get(3,1)) -
268 |               (tmp_1 * this.get(1,1) + tmp_2 * this.get(2,1) + tmp_5 * this.get(3,1)));
269 |     var t1 = ((tmp_1 * this.get(0,1) + tmp_6 * this.get(2,1) + tmp_9 * this.get(3,1)) -
270 |               (tmp_0 * this.get(0,1) + tmp_7 * this.get(2,1) + tmp_8 * this.get(3,1)));
271 |     var t2 = ((tmp_2 * this.get(0,1) + tmp_7 * this.get(1,1) + tmp_10 * this.get(3,1)) -
272 |               (tmp_3 * this.get(0,1) + tmp_6 * this.get(1,1) + tmp_11 * this.get(3,1)));
273 |     var t3 = ((tmp_5 * this.get(0,1) + tmp_8 * this.get(1,1) + tmp_11 * this.get(2,1)) -
274 |               (tmp_4 * this.get(0,1) + tmp_9 * this.get(1,1) + tmp_10 * this.get(2,1)));
275 | 
276 |     var d = 1.0 / (this.get(0,0) * t0 + this.get(1,0) * t1 + this.get(2,0) * t2 + this.get(3,0) * t3);
277 | 
278 |     var out_00 = d * t0;
279 |     var out_01 = d * t1;
280 |     var out_02 = d * t2;
281 |     var out_03 = d * t3;
282 | 
283 |     var out_10 = d * ((tmp_1 * this.get(1,0) + tmp_2 * this.get(2,0) + tmp_5 * this.get(3,0)) -
284 |                       (tmp_0 * this.get(1,0) + tmp_3 * this.get(2,0) + tmp_4 * this.get(3,0)));
285 |     var out_11 = d * ((tmp_0 * this.get(0,0) + tmp_7 * this.get(2,0) + tmp_8 * this.get(3,0)) -
286 |                       (tmp_1 * this.get(0,0) + tmp_6 * this.get(2,0) + tmp_9 * this.get(3,0)));
287 |     var out_12 = d * ((tmp_3 * this.get(0,0) + tmp_6 * this.get(1,0) + tmp_11 * this.get(3,0)) -
288 |                       (tmp_2 * this.get(0,0) + tmp_7 * this.get(1,0) + tmp_10 * this.get(3,0)));
289 |     var out_13 = d * ((tmp_4 * this.get(0,0) + tmp_9 * this.get(1,0) + tmp_10 * this.get(2,0)) -
290 |                       (tmp_5 * this.get(0,0) + tmp_8 * this.get(1,0) + tmp_11 * this.get(2,0)));
291 | 
292 |     var out_20 = d * ((tmp_12 * this.get(1,3) + tmp_15 * this.get(2,3) + tmp_16 * this.get(3,3)) -
293 |                       (tmp_13 * this.get(1,3) + tmp_14 * this.get(2,3) + tmp_17 * this.get(3,3)));
294 |     var out_21 = d * ((tmp_13 * this.get(0,3) + tmp_18 * this.get(2,3) + tmp_21 * this.get(3,3)) -
295 |                       (tmp_12 * this.get(0,3) + tmp_19 * this.get(2,3) + tmp_20 * this.get(3,3)));
296 |     var out_22 = d * ((tmp_14 * this.get(0,3) + tmp_19 * this.get(1,3) + tmp_22 * this.get(3,3)) -
297 |                       (tmp_15 * this.get(0,3) + tmp_18 * this.get(1,3) + tmp_23 * this.get(3,3)));
298 |     var out_23 = d * ((tmp_17 * this.get(0,3) + tmp_20 * this.get(1,3) + tmp_23 * this.get(2,3)) -
299 |                       (tmp_16 * this.get(0,3) + tmp_21 * this.get(1,3) + tmp_22 * this.get(2,3)));
300 |     
301 |     var out_30 = d * ((tmp_14 * this.get(2,2) + tmp_17 * this.get(3,2) + tmp_13 * this.get(1,2)) -
302 |                       (tmp_16 * this.get(3,2) + tmp_12 * this.get(1,2) + tmp_15 * this.get(2,2)));
303 |     var out_31 = d * ((tmp_20 * this.get(3,2) + tmp_12 * this.get(0,2) + tmp_19 * this.get(2,2)) -
304 |                       (tmp_18 * this.get(2,2) + tmp_21 * this.get(3,2) + tmp_13 * this.get(0,2)));
305 |     var out_32 = d * ((tmp_18 * this.get(1,2) + tmp_23 * this.get(3,2) + tmp_15 * this.get(0,2)) -
306 |                       (tmp_22 * this.get(3,2) + tmp_14 * this.get(0,2) + tmp_19 * this.get(1,2)));
307 |     var out_33 = d * ((tmp_22 * this.get(2,2) + tmp_16 * this.get(0,2) + tmp_21 * this.get(1,2)) -
308 |                       (tmp_20 * this.get(1,2) + tmp_23 * this.get(2,2) + tmp_17 * this.get(0,2)));
309 | 
310 |     this.elements[0*4+0] = out_00;
311 |     this.elements[0*4+1] = out_01;
312 |     this.elements[0*4+2] = out_02;
313 |     this.elements[0*4+3] = out_03;
314 |     this.elements[1*4+0] = out_10;
315 |     this.elements[1*4+1] = out_11;
316 |     this.elements[1*4+2] = out_12;
317 |     this.elements[1*4+3] = out_13;
318 |     this.elements[2*4+0] = out_20;
319 |     this.elements[2*4+1] = out_21;
320 |     this.elements[2*4+2] = out_22;
321 |     this.elements[2*4+3] = out_23;
322 |     this.elements[3*4+0] = out_30;
323 |     this.elements[3*4+1] = out_31;
324 |     this.elements[3*4+2] = out_32;
325 |     this.elements[3*4+3] = out_33;
326 |     return this;
327 |   },
328 | 
329 |   // Returns new matrix which is the inverse of this
330 |   inverse: function () {
331 |     var tmp = this.copy();
332 |     return tmp.invert();
333 |   },
334 |   
335 |   // In-place transpose
336 |   transpose: function () {
337 |     var tmp = this.elements[0*4+1];
338 |     this.elements[0*4+1] = this.elements[1*4+0];
339 |     this.elements[1*4+0] = tmp;
340 | 
341 |     tmp = this.elements[0*4+2];
342 |     this.elements[0*4+2] = this.elements[2*4+0];
343 |     this.elements[2*4+0] = tmp;
344 | 
345 |     tmp = this.elements[0*4+3];
346 |     this.elements[0*4+3] = this.elements[3*4+0];
347 |     this.elements[3*4+0] = tmp;
348 | 
349 |     tmp = this.elements[1*4+2];
350 |     this.elements[1*4+2] = this.elements[2*4+1];
351 |     this.elements[2*4+1] = tmp;
352 | 
353 |     tmp = this.elements[1*4+3];
354 |     this.elements[1*4+3] = this.elements[3*4+1];
355 |     this.elements[3*4+1] = tmp;
356 | 
357 |     tmp = this.elements[2*4+3];
358 |     this.elements[2*4+3] = this.elements[3*4+2];
359 |     this.elements[3*4+2] = tmp;
360 | 
361 |     return this;
362 |   },
363 | 
364 |   loadIdentity: function () {
365 |     for (var i = 0; i < 16; i++)
366 |       this.elements[i] = 0;
367 |     this.elements[0*4+0] = 1.0;
368 |     this.elements[1*4+1] = 1.0;
369 |     this.elements[2*4+2] = 1.0;
370 |     this.elements[3*4+3] = 1.0;
371 |     return this;
372 |   }
373 | };
374 | 


--------------------------------------------------------------------------------
/webgl/js/ace/mode-glsl.js:
--------------------------------------------------------------------------------
1 | define("ace/mode/glsl",["require","exports","module","ace/lib/oop","ace/mode/c_cpp","ace/tokenizer","ace/mode/glsl_highlight_rules","ace/mode/matching_brace_outdent","ace/range","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle"],function(e,t,n){var r=e("../lib/oop"),i=e("./c_cpp").Mode,s=e("../tokenizer").Tokenizer,o=e("./glsl_highlight_rules").glslHighlightRules,u=e("./matching_brace_outdent").MatchingBraceOutdent,a=e("../range").Range,f=e("./behaviour/cstyle").CstyleBehaviour,l=e("./folding/cstyle").FoldMode,c=function(){this.HighlightRules=o,this.$outdent=new u,this.$behaviour=new f,this.foldingRules=new l};r.inherits(c,i),t.Mode=c}),define("ace/mode/c_cpp",["require","exports","module","ace/lib/oop","ace/mode/text","ace/tokenizer","ace/mode/c_cpp_highlight_rules","ace/mode/matching_brace_outdent","ace/range","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle"],function(e,t,n){var r=e("../lib/oop"),i=e("./text").Mode,s=e("../tokenizer").Tokenizer,o=e("./c_cpp_highlight_rules").c_cppHighlightRules,u=e("./matching_brace_outdent").MatchingBraceOutdent,a=e("../range").Range,f=e("./behaviour/cstyle").CstyleBehaviour,l=e("./folding/cstyle").FoldMode,c=function(){this.HighlightRules=o,this.$outdent=new u,this.$behaviour=new f,this.foldingRules=new l};r.inherits(c,i),function(){this.lineCommentStart="//",this.blockComment={start:"/*",end:"*/"},this.getNextLineIndent=function(e,t,n){var r=this.$getIndent(t),i=this.getTokenizer().getLineTokens(t,e),s=i.tokens,o=i.state;if(s.length&&s[s.length-1].type=="comment")return r;if(e=="start"){var u=t.match(/^.*[\{\(\[]\s*$/);u&&(r+=n)}else if(e=="doc-start"){if(o=="start")return"";var u=t.match(/^\s*(\/?)\*/);u&&(u[1]&&(r+=" "),r+="* ")}return r},this.checkOutdent=function(e,t,n){return this.$outdent.checkOutdent(t,n)},this.autoOutdent=function(e,t,n){this.$outdent.autoOutdent(t,n)}}.call(c.prototype),t.Mode=c}),define("ace/mode/c_cpp_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/doc_comment_highlight_rules","ace/mode/text_highlight_rules"],function(e,t,n){var r=e("../lib/oop"),i=e("./doc_comment_highlight_rules").DocCommentHighlightRules,s=e("./text_highlight_rules").TextHighlightRules,o=t.cFunctions="\\s*\\bhypot(?:f|l)?|s(?:scanf|ystem|nprintf|ca(?:nf|lb(?:n(?:f|l)?|ln(?:f|l)?))|i(?:n(?:h(?:f|l)?|f|l)?|gn(?:al|bit))|tr(?:s(?:tr|pn)|nc(?:py|at|mp)|c(?:spn|hr|oll|py|at|mp)|to(?:imax|d|u(?:l(?:l)?|max)|k|f|l(?:d|l)?)|error|pbrk|ftime|len|rchr|xfrm)|printf|et(?:jmp|vbuf|locale|buf)|qrt(?:f|l)?|w(?:scanf|printf)|rand)|n(?:e(?:arbyint(?:f|l)?|xt(?:toward(?:f|l)?|after(?:f|l)?))|an(?:f|l)?)|c(?:s(?:in(?:h(?:f|l)?|f|l)?|qrt(?:f|l)?)|cos(?:h(?:f)?|f|l)?|imag(?:f|l)?|t(?:ime|an(?:h(?:f|l)?|f|l)?)|o(?:s(?:h(?:f|l)?|f|l)?|nj(?:f|l)?|pysign(?:f|l)?)|p(?:ow(?:f|l)?|roj(?:f|l)?)|e(?:il(?:f|l)?|xp(?:f|l)?)|l(?:o(?:ck|g(?:f|l)?)|earerr)|a(?:sin(?:h(?:f|l)?|f|l)?|cos(?:h(?:f|l)?|f|l)?|tan(?:h(?:f|l)?|f|l)?|lloc|rg(?:f|l)?|bs(?:f|l)?)|real(?:f|l)?|brt(?:f|l)?)|t(?:ime|o(?:upper|lower)|an(?:h(?:f|l)?|f|l)?|runc(?:f|l)?|gamma(?:f|l)?|mp(?:nam|file))|i(?:s(?:space|n(?:ormal|an)|cntrl|inf|digit|u(?:nordered|pper)|p(?:unct|rint)|finite|w(?:space|c(?:ntrl|type)|digit|upper|p(?:unct|rint)|lower|al(?:num|pha)|graph|xdigit|blank)|l(?:ower|ess(?:equal|greater)?)|al(?:num|pha)|gr(?:eater(?:equal)?|aph)|xdigit|blank)|logb(?:f|l)?|max(?:div|abs))|di(?:v|fftime)|_Exit|unget(?:c|wc)|p(?:ow(?:f|l)?|ut(?:s|c(?:har)?|wc(?:har)?)|error|rintf)|e(?:rf(?:c(?:f|l)?|f|l)?|x(?:it|p(?:2(?:f|l)?|f|l|m1(?:f|l)?)?))|v(?:s(?:scanf|nprintf|canf|printf|w(?:scanf|printf))|printf|f(?:scanf|printf|w(?:scanf|printf))|w(?:scanf|printf)|a_(?:start|copy|end|arg))|qsort|f(?:s(?:canf|e(?:tpos|ek))|close|tell|open|dim(?:f|l)?|p(?:classify|ut(?:s|c|w(?:s|c))|rintf)|e(?:holdexcept|set(?:e(?:nv|xceptflag)|round)|clearexcept|testexcept|of|updateenv|r(?:aiseexcept|ror)|get(?:e(?:nv|xceptflag)|round))|flush|w(?:scanf|ide|printf|rite)|loor(?:f|l)?|abs(?:f|l)?|get(?:s|c|pos|w(?:s|c))|re(?:open|e|ad|xp(?:f|l)?)|m(?:in(?:f|l)?|od(?:f|l)?|a(?:f|l|x(?:f|l)?)?))|l(?:d(?:iv|exp(?:f|l)?)|o(?:ngjmp|cal(?:time|econv)|g(?:1(?:p(?:f|l)?|0(?:f|l)?)|2(?:f|l)?|f|l|b(?:f|l)?)?)|abs|l(?:div|abs|r(?:int(?:f|l)?|ound(?:f|l)?))|r(?:int(?:f|l)?|ound(?:f|l)?)|gamma(?:f|l)?)|w(?:scanf|c(?:s(?:s(?:tr|pn)|nc(?:py|at|mp)|c(?:spn|hr|oll|py|at|mp)|to(?:imax|d|u(?:l(?:l)?|max)|k|f|l(?:d|l)?|mbs)|pbrk|ftime|len|r(?:chr|tombs)|xfrm)|to(?:b|mb)|rtomb)|printf|mem(?:set|c(?:hr|py|mp)|move))|a(?:s(?:sert|ctime|in(?:h(?:f|l)?|f|l)?)|cos(?:h(?:f|l)?|f|l)?|t(?:o(?:i|f|l(?:l)?)|exit|an(?:h(?:f|l)?|2(?:f|l)?|f|l)?)|b(?:s|ort))|g(?:et(?:s|c(?:har)?|env|wc(?:har)?)|mtime)|r(?:int(?:f|l)?|ound(?:f|l)?|e(?:name|alloc|wind|m(?:ove|quo(?:f|l)?|ainder(?:f|l)?))|a(?:nd|ise))|b(?:search|towc)|m(?:odf(?:f|l)?|em(?:set|c(?:hr|py|mp)|move)|ktime|alloc|b(?:s(?:init|towcs|rtowcs)|towc|len|r(?:towc|len)))\\b",u=function(){var e="break|case|continue|default|do|else|for|goto|if|_Pragma|return|switch|while|catch|operator|try|throw|using",t="asm|__asm__|auto|bool|_Bool|char|_Complex|double|enum|float|_Imaginary|int|long|short|signed|struct|typedef|union|unsigned|void|class|wchar_t|template",n="const|extern|register|restrict|static|volatile|inline|private:|protected:|public:|friend|explicit|virtual|export|mutable|typename",r="and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|typeid|xor|xor_eqconst_cast|dynamic_cast|reinterpret_cast|static_cast|sizeof|namespace",s="NULL|true|false|TRUE|FALSE",u=this.$keywords=this.createKeywordMapper({"keyword.control":e,"storage.type":t,"storage.modifier":n,"keyword.operator":r,"variable.language":"this","constant.language":s},"identifier"),a="[a-zA-Z\\$_¡-￿][a-zA-Zd\\$_¡-￿]*\\b";this.$rules={start:[{token:"comment",regex:"\\/\\/.*$"},i.getStartRule("doc-start"),{token:"comment",regex:"\\/\\*",next:"comment"},{token:"string",regex:'["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'},{token:"string",regex:'["].*\\\\$',next:"qqstring"},{token:"string",regex:"['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"},{token:"string",regex:"['].*\\\\$",next:"qstring"},{token:"constant.numeric",regex:"0[xX][0-9a-fA-F]+(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b"},{token:"constant.numeric",regex:"[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b"},{token:"keyword",regex:"#\\s*(?:include|import|pragma|line|define|undef|if|ifdef|else|elif|ifndef)\\b",next:"directive"},{token:"keyword",regex:"(?:#\\s*endif)\\b"},{token:"support.function.C99.c",regex:o},{token:u,regex:"[a-zA-Z_$][a-zA-Z0-9_$]*\\b"},{token:"keyword.operator",regex:"!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|==|=|!=|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\\|\\||\\?\\:|\\*=|%=|\\+=|\\-=|&=|\\^=|\\b(?:in|new|delete|typeof|void)"},{token:"punctuation.operator",regex:"\\?|\\:|\\,|\\;|\\."},{token:"paren.lparen",regex:"[[({]"},{token:"paren.rparen",regex:"[\\])}]"},{token:"text",regex:"\\s+"}],comment:[{token:"comment",regex:".*?\\*\\/",next:"start"},{token:"comment",regex:".+"}],qqstring:[{token:"string",regex:'(?:(?:\\\\.)|(?:[^"\\\\]))*?"',next:"start"},{token:"string",regex:".+"}],qstring:[{token:"string",regex:"(?:(?:\\\\.)|(?:[^'\\\\]))*?'",next:"start"},{token:"string",regex:".+"}],directive:[{token:"constant.other.multiline",regex:/\\/},{token:"constant.other.multiline",regex:/.*\\/},{token:"constant.other",regex:"\\s*<.+?>",next:"start"},{token:"constant.other",regex:'\\s*["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]',next:"start"},{token:"constant.other",regex:"\\s*['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']",next:"start"},{token:"constant.other",regex:/[^\\\/]+/,next:"start"}]},this.embedRules(i,"doc-",[i.getEndRule("start")])};r.inherits(u,s),t.c_cppHighlightRules=u}),define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"],function(e,t,n){var r=e("../lib/oop"),i=e("./text_highlight_rules").TextHighlightRules,s=function(){this.$rules={start:[{token:"comment.doc.tag",regex:"@[\\w\\d_]+"},{token:"comment.doc.tag",regex:"\\bTODO\\b"},{defaultToken:"comment.doc"}]}};r.inherits(s,i),s.getStartRule=function(e){return{token:"comment.doc",regex:"\\/\\*(?=\\*)",next:e}},s.getEndRule=function(e){return{token:"comment.doc",regex:"\\*\\/",next:e}},t.DocCommentHighlightRules=s}),define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"],function(e,t,n){var r=e("../range").Range,i=function(){};(function(){this.checkOutdent=function(e,t){return/^\s+$/.test(e)?/^\s*\}/.test(t):!1},this.autoOutdent=function(e,t){var n=e.getLine(t),i=n.match(/^(\s*\})/);if(!i)return 0;var s=i[1].length,o=e.findMatchingBracket({row:t,column:s});if(!o||o.row==t)return 0;var u=this.$getIndent(e.getLine(o.row));e.replace(new r(t,0,t,s-1),u)},this.$getIndent=function(e){return e.match(/^\s*/)[0]}}).call(i.prototype),t.MatchingBraceOutdent=i}),define("ace/mode/behaviour/cstyle",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/token_iterator","ace/lib/lang"],function(e,t,n){var r=e("../../lib/oop"),i=e("../behaviour").Behaviour,s=e("../../token_iterator").TokenIterator,o=e("../../lib/lang"),u=["text","paren.rparen","punctuation.operator"],a=["text","paren.rparen","punctuation.operator","comment"],f=0,l=-1,c="",h=0,p=-1,d="",v="",m=function(){m.isSaneInsertion=function(e,t){var n=e.getCursorPosition(),r=new s(t,n.row,n.column);if(!this.$matchTokenType(r.getCurrentToken()||"text",u)){var i=new s(t,n.row,n.column+1);if(!this.$matchTokenType(i.getCurrentToken()||"text",u))return!1}return r.stepForward(),r.getCurrentTokenRow()!==n.row||this.$matchTokenType(r.getCurrentToken()||"text",a)},m.$matchTokenType=function(e,t){return t.indexOf(e.type||e)>-1},m.recordAutoInsert=function(e,t,n){var r=e.getCursorPosition(),i=t.doc.getLine(r.row);this.isAutoInsertedClosing(r,i,c[0])||(f=0),l=r.row,c=n+i.substr(r.column),f++},m.recordMaybeInsert=function(e,t,n){var r=e.getCursorPosition(),i=t.doc.getLine(r.row);this.isMaybeInsertedClosing(r,i)||(h=0),p=r.row,d=i.substr(0,r.column)+n,v=i.substr(r.column),h++},m.isAutoInsertedClosing=function(e,t,n){return f>0&&e.row===l&&n===c[0]&&t.substr(e.column)===c},m.isMaybeInsertedClosing=function(e,t){return h>0&&e.row===p&&t.substr(e.column)===v&&t.substr(0,e.column)==d},m.popAutoInsertedClosing=function(){c=c.substr(1),f--},m.clearMaybeInsertedClosing=function(){h=0,p=-1},this.add("braces","insertion",function(e,t,n,r,i){var s=n.getCursorPosition(),u=r.doc.getLine(s.row);if(i=="{"){var a=n.getSelectionRange(),f=r.doc.getTextRange(a);if(f!==""&&f!=="{"&&n.getWrapBehavioursEnabled())return{text:"{"+f+"}",selection:!1};if(m.isSaneInsertion(n,r))return/[\]\}\)]/.test(u[s.column])?(m.recordAutoInsert(n,r,"}"),{text:"{}",selection:[1,1]}):(m.recordMaybeInsert(n,r,"{"),{text:"{",selection:[1,1]})}else if(i=="}"){var l=u.substring(s.column,s.column+1);if(l=="}"){var c=r.$findOpeningBracket("}",{column:s.column+1,row:s.row});if(c!==null&&m.isAutoInsertedClosing(s,u,i))return m.popAutoInsertedClosing(),{text:"",selection:[1,1]}}}else if(i=="\n"||i=="\r\n"){var p="";m.isMaybeInsertedClosing(s,u)&&(p=o.stringRepeat("}",h),m.clearMaybeInsertedClosing());var l=u.substring(s.column,s.column+1);if(l=="}"||p!==""){var d=r.findMatchingBracket({row:s.row,column:s.column},"}");if(!d)return null;var v=this.getNextLineIndent(e,u.substring(0,s.column),r.getTabString()),g=this.$getIndent(u);return{text:"\n"+v+"\n"+g+p,selection:[1,v.length,1,v.length]}}}}),this.add("braces","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&s=="{"){var o=r.doc.getLine(i.start.row),u=o.substring(i.end.column,i.end.column+1);if(u=="}")return i.end.column++,i;h--}}),this.add("parens","insertion",function(e,t,n,r,i){if(i=="("){var s=n.getSelectionRange(),o=r.doc.getTextRange(s);if(o!==""&&n.getWrapBehavioursEnabled())return{text:"("+o+")",selection:!1};if(m.isSaneInsertion(n,r))return m.recordAutoInsert(n,r,")"),{text:"()",selection:[1,1]}}else if(i==")"){var u=n.getCursorPosition(),a=r.doc.getLine(u.row),f=a.substring(u.column,u.column+1);if(f==")"){var l=r.$findOpeningBracket(")",{column:u.column+1,row:u.row});if(l!==null&&m.isAutoInsertedClosing(u,a,i))return m.popAutoInsertedClosing(),{text:"",selection:[1,1]}}}}),this.add("parens","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&s=="("){var o=r.doc.getLine(i.start.row),u=o.substring(i.start.column+1,i.start.column+2);if(u==")")return i.end.column++,i}}),this.add("brackets","insertion",function(e,t,n,r,i){if(i=="["){var s=n.getSelectionRange(),o=r.doc.getTextRange(s);if(o!==""&&n.getWrapBehavioursEnabled())return{text:"["+o+"]",selection:!1};if(m.isSaneInsertion(n,r))return m.recordAutoInsert(n,r,"]"),{text:"[]",selection:[1,1]}}else if(i=="]"){var u=n.getCursorPosition(),a=r.doc.getLine(u.row),f=a.substring(u.column,u.column+1);if(f=="]"){var l=r.$findOpeningBracket("]",{column:u.column+1,row:u.row});if(l!==null&&m.isAutoInsertedClosing(u,a,i))return m.popAutoInsertedClosing(),{text:"",selection:[1,1]}}}}),this.add("brackets","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&s=="["){var o=r.doc.getLine(i.start.row),u=o.substring(i.start.column+1,i.start.column+2);if(u=="]")return i.end.column++,i}}),this.add("string_dquotes","insertion",function(e,t,n,r,i){if(i=='"'||i=="'"){var s=i,o=n.getSelectionRange(),u=r.doc.getTextRange(o);if(u!==""&&u!=="'"&&u!='"'&&n.getWrapBehavioursEnabled())return{text:s+u+s,selection:!1};var a=n.getCursorPosition(),f=r.doc.getLine(a.row),l=f.substring(a.column-1,a.column);if(l=="\\")return null;var c=r.getTokens(o.start.row),h=0,p,d=-1;for(var v=0;v<c.length;v++){p=c[v],p.type=="string"?d=-1:d<0&&(d=p.value.indexOf(s));if(p.value.length+h>o.start.column)break;h+=c[v].value.length}if(!p||d<0&&p.type!=="comment"&&(p.type!=="string"||o.start.column!==p.value.length+h-1&&p.value.lastIndexOf(s)===p.value.length-1)){if(!m.isSaneInsertion(n,r))return;return{text:s+s,selection:[1,1]}}if(p&&p.type==="string"){var g=f.substring(a.column,a.column+1);if(g==s)return{text:"",selection:[1,1]}}}}),this.add("string_dquotes","deletion",function(e,t,n,r,i){var s=r.doc.getTextRange(i);if(!i.isMultiLine()&&(s=='"'||s=="'")){var o=r.doc.getLine(i.start.row),u=o.substring(i.start.column+1,i.start.column+2);if(u==s)return i.end.column++,i}})};r.inherits(m,i),t.CstyleBehaviour=m}),define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"],function(e,t,n){var r=e("../../lib/oop"),i=e("../../range").Range,s=e("./fold_mode").FoldMode,o=t.FoldMode=function(e){e&&(this.foldingStartMarker=new RegExp(this.foldingStartMarker.source.replace(/\|[^|]*?$/,"|"+e.start)),this.foldingStopMarker=new RegExp(this.foldingStopMarker.source.replace(/\|[^|]*?$/,"|"+e.end)))};r.inherits(o,s),function(){this.foldingStartMarker=/(\{|\[)[^\}\]]*$|^\s*(\/\*)/,this.foldingStopMarker=/^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/,this.getFoldWidgetRange=function(e,t,n){var r=e.getLine(n),i=r.match(this.foldingStartMarker);if(i){var s=i.index;return i[1]?this.openingBracketBlock(e,i[1],n,s):e.getCommentFoldRange(n,s+i[0].length,1)}if(t!=="markbeginend")return;var i=r.match(this.foldingStopMarker);if(i){var s=i.index+i[0].length;return i[1]?this.closingBracketBlock(e,i[1],n,s):e.getCommentFoldRange(n,s,-1)}}}.call(o.prototype)}),define("ace/mode/glsl_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/c_cpp_highlight_rules"],function(e,t,n){var r=e("../lib/oop"),i=e("./c_cpp_highlight_rules").c_cppHighlightRules,s=function(){var e="attribute|const|uniform|varying|break|continue|do|for|while|if|else|in|out|inout|float|int|void|bool|true|false|lowp|mediump|highp|precision|invariant|discard|return|mat2|mat3|mat4|vec2|vec3|vec4|ivec2|ivec3|ivec4|bvec2|bvec3|bvec4|sampler2D|samplerCube|struct",t="radians|degrees|sin|cos|tan|asin|acos|atan|pow|exp|log|exp2|log2|sqrt|inversesqrt|abs|sign|floor|ceil|fract|mod|min|max|clamp|mix|step|smoothstep|length|distance|dot|cross|normalize|faceforward|reflect|refract|matrixCompMult|lessThan|lessThanEqual|greaterThan|greaterThanEqual|equal|notEqual|any|all|not|dFdx|dFdy|fwidth|texture2D|texture2DProj|texture2DLod|texture2DProjLod|textureCube|textureCubeLod|gl_MaxVertexAttribs|gl_MaxVertexUniformVectors|gl_MaxVaryingVectors|gl_MaxVertexTextureImageUnits|gl_MaxCombinedTextureImageUnits|gl_MaxTextureImageUnits|gl_MaxFragmentUniformVectors|gl_MaxDrawBuffers|gl_DepthRangeParameters|gl_DepthRange|gl_Position|gl_PointSize|gl_FragCoord|gl_FrontFacing|gl_PointCoord|gl_FragColor|gl_FragData",n=this.createKeywordMapper({"variable.language":"this",keyword:e,"constant.language":t},"identifier");this.$rules=(new i).$rules,this.$rules.start.forEach(function(e){typeof e.token=="function"&&(e.token=n)})};r.inherits(s,i),t.glslHighlightRules=s})


--------------------------------------------------------------------------------
/webgl/shaders/ltc/ltc_disk.fs:
--------------------------------------------------------------------------------
  1 | // bind roughness   {label:"Roughness", default:0.25, min:0.001, max:1, step:0.001}
  2 | // bind dcolor      {label:"Diffuse Color",  r:1.0, g:1.0, b:1.0}
  3 | // bind scolor      {label:"Specular Color", r:0.23, g:0.23, b:0.23}
  4 | // bind intensity   {label:"Light Intensity", default:4, min:0, max:10}
  5 | // bind width       {label:"Width",  default: 8, min:0.1, max:15, step:0.1}
  6 | // bind height      {label:"Height", default: 8, min:0.1, max:15, step:0.1}
  7 | // bind roty        {label:"Rotation Y", default: 0, min:0, max:1, step:0.001}
  8 | // bind rotz        {label:"Rotation Z", default: 0, min:0, max:1, step:0.001}
  9 | // bind twoSided    {label:"Two-sided", default:false}
 10 | // bind groundTruth {label:"Ground Truth", default:false}
 11 | 
 12 | uniform float roughness;
 13 | uniform vec3  dcolor;
 14 | uniform vec3  scolor;
 15 | 
 16 | uniform float intensity;
 17 | uniform float width;
 18 | uniform float height;
 19 | uniform float roty;
 20 | uniform float rotz;
 21 | 
 22 | uniform bool groundTruth;
 23 | 
 24 | uniform bool twoSided;
 25 | 
 26 | uniform sampler2D ltc_1;
 27 | uniform sampler2D ltc_2;
 28 | 
 29 | uniform mat4  view;
 30 | uniform vec2  resolution;
 31 | uniform int   sampleCount;
 32 | 
 33 | const float LUT_SIZE  = 64.0;
 34 | const float LUT_SCALE = (LUT_SIZE - 1.0)/LUT_SIZE;
 35 | const float LUT_BIAS  = 0.5/LUT_SIZE;
 36 | 
 37 | const int   NUM_SAMPLES = 1;
 38 | const float pi = 3.14159265;
 39 | const float NO_HIT = 1e9;
 40 | 
 41 | // Tracing and intersection
 42 | ///////////////////////////
 43 | 
 44 | struct Ray
 45 | {
 46 |     vec3 origin;
 47 |     vec3 dir;
 48 | };
 49 | 
 50 | struct Disk
 51 | {
 52 |     vec3  center;
 53 |     vec3  dirx;
 54 |     vec3  diry;
 55 |     float halfx;
 56 |     float halfy;
 57 | 
 58 |     vec4  plane;
 59 | };
 60 | 
 61 | float RayPlaneIntersect(Ray ray, vec4 plane)
 62 | {
 63 |     float t = -dot(plane, vec4(ray.origin, 1.0))/dot(plane.xyz, ray.dir);
 64 |     return (t > 0.0) ? t : NO_HIT;
 65 | }
 66 | 
 67 | float sqr(float x) { return x*x; }
 68 | 
 69 | float RayDiskIntersect(Ray ray, Disk disk)
 70 | {
 71 |     float t = RayPlaneIntersect(ray, disk.plane);
 72 |     if (t != NO_HIT)
 73 |     {
 74 |         vec3 pos  = ray.origin + ray.dir*t;
 75 |         vec3 lpos = pos - disk.center;
 76 | 
 77 |         float x = dot(lpos, disk.dirx);
 78 |         float y = dot(lpos, disk.diry);
 79 | 
 80 |         if (sqr(x/disk.halfx) + sqr(y/disk.halfy) > 1.0)
 81 |             t = NO_HIT;
 82 |     }
 83 | 
 84 |     return t;
 85 | }
 86 | 
 87 | // Camera functions
 88 | ///////////////////
 89 | 
 90 | Ray GenerateCameraRay()
 91 | {
 92 |     Ray ray;
 93 | 
 94 |     vec2 xy = 2.0*gl_FragCoord.xy/resolution - vec2(1.0);
 95 | 
 96 |     ray.dir = normalize(vec3(xy, 2.0));
 97 | 
 98 |     float focalDistance = 2.0;
 99 |     float ft = focalDistance/ray.dir.z;
100 |     vec3 pFocus = ray.dir*ft;
101 | 
102 |     ray.origin = vec3(0);
103 |     ray.dir    = normalize(pFocus - ray.origin);
104 | 
105 |     // Apply camera transform
106 |     ray.origin = (view*vec4(ray.origin, 1)).xyz;
107 |     ray.dir    = (view*vec4(ray.dir,    0)).xyz;
108 | 
109 |     return ray;
110 | }
111 | 
112 | // Matrix functions
113 | ///////////////////
114 | 
115 | vec3 mul(mat3 m, vec3 v)
116 | {
117 |     return m * v;
118 | }
119 | 
120 | mat3 mul(mat3 m1, mat3 m2)
121 | {
122 |     return m1 * m2;
123 | }
124 | 
125 | vec3 rotation_y(vec3 v, float a)
126 | {
127 |     vec3 r;
128 |     r.x =  v.x*cos(a) + v.z*sin(a);
129 |     r.y =  v.y;
130 |     r.z = -v.x*sin(a) + v.z*cos(a);
131 |     return r;
132 | }
133 | 
134 | vec3 rotation_z(vec3 v, float a)
135 | {
136 |     vec3 r;
137 |     r.x =  v.x*cos(a) - v.y*sin(a);
138 |     r.y =  v.x*sin(a) + v.y*cos(a);
139 |     r.z =  v.z;
140 |     return r;
141 | }
142 | 
143 | vec3 rotation_yz(vec3 v, float ay, float az)
144 | {
145 |     return rotation_z(rotation_y(v, ay), az);
146 | }
147 | 
148 | mat3 mat3_from_columns(vec3 c0, vec3 c1, vec3 c2)
149 | {
150 |     mat3 m = mat3(c0, c1, c2);
151 |     return m;
152 | }
153 | 
154 | // Sample generation
155 | ////////////////////
156 | 
157 | float Halton(int index, float base)
158 | {
159 |     float result = 0.0;
160 |     float f = 1.0/base;
161 |     float i = float(index);
162 |     for (int x = 0; x < 8; x++)
163 |     {
164 |         if (i <= 0.0) break;
165 | 
166 |         result += f*mod(i, base);
167 |         i = floor(i/base);
168 |         f = f/base;
169 |     }
170 | 
171 |     return result;
172 | }
173 | 
174 | void Halton2D(out vec2 s[NUM_SAMPLES], int offset)
175 | {
176 |     for (int i = 0; i < NUM_SAMPLES; i++)
177 |     {
178 |         s[i].x = Halton(i + offset, 2.0);
179 |         s[i].y = Halton(i + offset, 3.0);
180 |     }
181 | }
182 | 
183 | // TODO: replace this
184 | float rand(vec2 co)
185 | {
186 |     return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);
187 | }
188 | 
189 | // Scene helpers
190 | ////////////////
191 | 
192 | Disk InitDisk(vec3 center, vec3 dirx, vec3 diry, float halfx, float halfy)
193 | {
194 |     Disk disk;
195 | 
196 |     disk.center = center;
197 |     disk.dirx   = dirx;
198 |     disk.diry   = diry;
199 |     disk.halfx  = halfx;
200 |     disk.halfy  = halfy;
201 | 
202 |     vec3 diskNormal = cross(disk.dirx, disk.diry);
203 |     disk.plane = vec4(diskNormal, -dot(diskNormal, disk.center));
204 | 
205 |     return disk;
206 | }
207 | 
208 | void InitDiskPoints(Disk disk, out vec3 points[4])
209 | {
210 |     vec3 ex = disk.halfx*disk.dirx;
211 |     vec3 ey = disk.halfy*disk.diry;
212 | 
213 |     points[0] = disk.center - ex - ey;
214 |     points[1] = disk.center + ex - ey;
215 |     points[2] = disk.center + ex + ey;
216 |     points[3] = disk.center - ex + ey;
217 | }
218 | 
219 | // Misc.
220 | ////////
221 | 
222 | // An extended version of the implementation from
223 | // "How to solve a cubic equation, revisited"
224 | // http://momentsingraphics.de/?p=105
225 | vec3 SolveCubic(vec4 Coefficient)
226 | {
227 |     // Normalize the polynomial
228 |     Coefficient.xyz /= Coefficient.w;
229 |     // Divide middle coefficients by three
230 |     Coefficient.yz /= 3.0;
231 | 
232 |     float A = Coefficient.w;
233 |     float B = Coefficient.z;
234 |     float C = Coefficient.y;
235 |     float D = Coefficient.x;
236 | 
237 |     // Compute the Hessian and the discriminant
238 |     vec3 Delta = vec3(
239 |         -Coefficient.z*Coefficient.z + Coefficient.y,
240 |         -Coefficient.y*Coefficient.z + Coefficient.x,
241 |         dot(vec2(Coefficient.z, -Coefficient.y), Coefficient.xy)
242 |     );
243 | 
244 |     float Discriminant = dot(vec2(4.0*Delta.x, -Delta.y), Delta.zy);
245 | 
246 |     vec3 RootsA, RootsD;
247 | 
248 |     vec2 xlc, xsc;
249 | 
250 |     // Algorithm A
251 |     {
252 |         float A_a = 1.0;
253 |         float C_a = Delta.x;
254 |         float D_a = -2.0*B*Delta.x + Delta.y;
255 | 
256 |         // Take the cubic root of a normalized complex number
257 |         float Theta = atan(sqrt(Discriminant), -D_a)/3.0;
258 | 
259 |         float x_1a = 2.0*sqrt(-C_a)*cos(Theta);
260 |         float x_3a = 2.0*sqrt(-C_a)*cos(Theta + (2.0/3.0)*pi);
261 | 
262 |         float xl;
263 |         if ((x_1a + x_3a) > 2.0*B)
264 |             xl = x_1a;
265 |         else
266 |             xl = x_3a;
267 | 
268 |         xlc = vec2(xl - B, A);
269 |     }
270 | 
271 |     // Algorithm D
272 |     {
273 |         float A_d = D;
274 |         float C_d = Delta.z;
275 |         float D_d = -D*Delta.y + 2.0*C*Delta.z;
276 | 
277 |         // Take the cubic root of a normalized complex number
278 |         float Theta = atan(D*sqrt(Discriminant), -D_d)/3.0;
279 | 
280 |         float x_1d = 2.0*sqrt(-C_d)*cos(Theta);
281 |         float x_3d = 2.0*sqrt(-C_d)*cos(Theta + (2.0/3.0)*pi);
282 | 
283 |         float xs;
284 |         if (x_1d + x_3d < 2.0*C)
285 |             xs = x_1d;
286 |         else
287 |             xs = x_3d;
288 | 
289 |         xsc = vec2(-D, xs + C);
290 |     }
291 | 
292 |     float E =  xlc.y*xsc.y;
293 |     float F = -xlc.x*xsc.y - xlc.y*xsc.x;
294 |     float G =  xlc.x*xsc.x;
295 | 
296 |     vec2 xmc = vec2(C*F - B*G, -B*F + C*E);
297 | 
298 |     vec3 Root = vec3(xsc.x/xsc.y, xmc.x/xmc.y, xlc.x/xlc.y);
299 | 
300 |     if (Root.x < Root.y && Root.x < Root.z)
301 |         Root.xyz = Root.yxz;
302 |     else if (Root.z < Root.x && Root.z < Root.y)
303 |         Root.xyz = Root.xzy;
304 | 
305 |     return Root;
306 | }
307 | 
308 | // Linearly Transformed Cosines
309 | ///////////////////////////////
310 | 
311 | vec3 LTC_Evaluate(
312 |     vec3 N, vec3 V, vec3 P, mat3 Minv, vec3 points[4], bool twoSided, float u1, float u2)
313 | {
314 |     // construct orthonormal basis around N
315 |     vec3 T1, T2;
316 |     T1 = normalize(V - N*dot(V, N));
317 |     T2 = cross(N, T1);
318 | 
319 |     // rotate area light in (T1, T2, N) basis
320 |     mat3 R = transpose(mat3(T1, T2, N));
321 | 
322 |     // polygon (allocate 5 vertices for clipping)
323 |     vec3 L_[3];
324 |     L_[0] = mul(R, points[0] - P);
325 |     L_[1] = mul(R, points[1] - P);
326 |     L_[2] = mul(R, points[2] - P);
327 | 
328 |     vec3 Lo_i = vec3(0);
329 | 
330 |     // init ellipse
331 |     vec3 C  = 0.5 * (L_[0] + L_[2]);
332 |     vec3 V1 = 0.5 * (L_[1] - L_[2]);
333 |     vec3 V2 = 0.5 * (L_[1] - L_[0]);
334 | 
335 |     C  = Minv * C;
336 |     V1 = Minv * V1;
337 |     V2 = Minv * V2;
338 | 
339 |     if(!twoSided && dot(cross(V1, V2), C) < 0.0)
340 |         return vec3(0.0);
341 | 
342 |     // compute eigenvectors of ellipse
343 |     float a, b;
344 |     float d11 = dot(V1, V1);
345 |     float d22 = dot(V2, V2);
346 |     float d12 = dot(V1, V2);
347 |     if (abs(d12)/sqrt(d11*d22) > 0.0001)
348 |     {
349 |         float tr = d11 + d22;
350 |         float det = -d12*d12 + d11*d22;
351 | 
352 |         // use sqrt matrix to solve for eigenvalues
353 |         det = sqrt(det);
354 |         float u = 0.5*sqrt(tr - 2.0*det);
355 |         float v = 0.5*sqrt(tr + 2.0*det);
356 |         float e_max = sqr(u + v);
357 |         float e_min = sqr(u - v);
358 | 
359 |         vec3 V1_, V2_;
360 | 
361 |         if (d11 > d22)
362 |         {
363 |             V1_ = d12*V1 + (e_max - d11)*V2;
364 |             V2_ = d12*V1 + (e_min - d11)*V2;
365 |         }
366 |         else
367 |         {
368 |             V1_ = d12*V2 + (e_max - d22)*V1;
369 |             V2_ = d12*V2 + (e_min - d22)*V1;
370 |         }
371 | 
372 |         a = 1.0 / e_max;
373 |         b = 1.0 / e_min;
374 |         V1 = normalize(V1_);
375 |         V2 = normalize(V2_);
376 |     }
377 |     else
378 |     {
379 |         a = 1.0 / dot(V1, V1);
380 |         b = 1.0 / dot(V2, V2);
381 |         V1 *= sqrt(a);
382 |         V2 *= sqrt(b);
383 |     }
384 | 
385 |     vec3 V3 = cross(V1, V2);
386 |     if (dot(C, V3) < 0.0)
387 |         V3 *= -1.0;
388 | 
389 |     float L  = dot(V3, C);
390 |     float x0 = dot(V1, C) / L;
391 |     float y0 = dot(V2, C) / L;
392 | 
393 |     float E1 = inversesqrt(a);
394 |     float E2 = inversesqrt(b);
395 | 
396 |     a *= L*L;
397 |     b *= L*L;
398 | 
399 |     float c0 = a*b;
400 |     float c1 = a*b*(1.0 + x0*x0 + y0*y0) - a - b;
401 |     float c2 = 1.0 - a*(1.0 + x0*x0) - b*(1.0 + y0*y0);
402 |     float c3 = 1.0;
403 | 
404 |     vec3 roots = SolveCubic(vec4(c0, c1, c2, c3));
405 |     float e1 = roots.x;
406 |     float e2 = roots.y;
407 |     float e3 = roots.z;
408 | 
409 |     vec3 avgDir = vec3(a*x0/(a - e2), b*y0/(b - e2), 1.0);
410 | 
411 |     mat3 rotate = mat3_from_columns(V1, V2, V3);
412 | 
413 |     avgDir = rotate*avgDir;
414 |     avgDir = normalize(avgDir);
415 | 
416 |     float L1 = sqrt(-e2/e3);
417 |     float L2 = sqrt(-e2/e1);
418 | 
419 |     float formFactor = L1*L2*inversesqrt((1.0 + L1*L1)*(1.0 + L2*L2));
420 | 
421 |     // use tabulated horizon-clipped sphere
422 |     vec2 uv = vec2(avgDir.z*0.5 + 0.5, formFactor);
423 |     uv = uv*LUT_SCALE + LUT_BIAS;
424 |     float scale = texture(ltc_2, uv).w;
425 | 
426 |     float spec = formFactor*scale;
427 | 
428 |     if (groundTruth)
429 |     {
430 |         spec = 0.0;
431 | 
432 |         float diskArea = pi*E1*E2;
433 | 
434 |         // light sample
435 |         {
436 |             // random point on ellipse
437 |             float rad = sqrt(u1);
438 |             float phi = 2.0*pi*u2;
439 |             float x = E1*rad*cos(phi);
440 |             float y = E2*rad*sin(phi);
441 | 
442 |             vec3 p = x*V1 + y*V2 + C;
443 |             vec3 v = normalize(p);
444 | 
445 |             float c2 = max(dot(V3, v), 0.0);
446 |             float solidAngle = max(c2/dot(p, p), 1e-7);
447 |             float pdfLight = 1.0/solidAngle/diskArea;
448 | 
449 |             float cosTheta = max(v.z, 0.0);
450 |             float brdf = 1.0/pi;
451 |             float pdfBRDF = cosTheta/pi;
452 | 
453 |             if (cosTheta > 0.0)
454 |                 spec += brdf*cosTheta/(pdfBRDF + pdfLight);
455 |         }
456 | 
457 |         // BRDF sample
458 |         {
459 |             // generate a cosine-distributed direction
460 |             float rad = sqrt(u1);
461 |             float phi = 2.0*pi*u2;
462 |             float x = rad*cos(phi);
463 |             float y = rad*sin(phi);
464 |             vec3 dir = vec3(x, y, sqrt(1.0 - u1));
465 | 
466 |             Ray ray;
467 |             ray.origin = vec3(0, 0, 0);
468 |             ray.dir = dir;
469 | 
470 |             Disk disk = InitDisk(C, V1, V2, E1, E2);
471 | 
472 |             vec3 diskNormal = V3;
473 |             disk.plane = vec4(diskNormal, -dot(diskNormal, disk.center));
474 | 
475 |             float distToDisk = RayDiskIntersect(ray, disk);
476 |             bool  intersect  = distToDisk != NO_HIT;
477 | 
478 |             float cosTheta = max(dir.z, 0.0);
479 |             float brdf = 1.0/pi;
480 |             float pdfBRDF = cosTheta/pi;
481 | 
482 |             float pdfLight = 0.0;
483 |             if (intersect)
484 |             {
485 |                 vec3 p = distToDisk*ray.dir;
486 |                 vec3 v = normalize(p);
487 |                 float c2 = max(dot(V3, v), 0.0);
488 |                 float solidAngle = max(c2/dot(p, p), 1e-7);
489 |                 pdfLight = 1.0/solidAngle/diskArea;
490 |             }
491 | 
492 |             if (intersect)
493 |                 spec += brdf*cosTheta/(pdfBRDF + pdfLight);
494 |         }
495 |     }
496 | 
497 |     Lo_i = vec3(spec, spec, spec);
498 | 
499 |     return vec3(Lo_i);
500 | }
501 | 
502 | // Misc. helpers
503 | ////////////////
504 | 
505 | float saturate(float v)
506 | {
507 |     return clamp(v, 0.0, 1.0);
508 | }
509 | 
510 | vec3 PowVec3(vec3 v, float p)
511 | {
512 |     return vec3(pow(v.x, p), pow(v.y, p), pow(v.z, p));
513 | }
514 | 
515 | const float gamma = 2.2;
516 | vec3 ToLinear(vec3 v) { return PowVec3(v, gamma); }
517 | 
518 | out vec4 FragColor;
519 | 
520 | void main()
521 | {
522 |     float ay = 2.0*pi*roty;
523 |     float az = 2.0*pi*rotz;
524 | 
525 |     Disk disk = InitDisk(
526 |         vec3(0, 6, 32),
527 |         rotation_yz(vec3(1, 0, 0), ay, az),
528 |         rotation_yz(vec3(0, 1, 0), ay, az),
529 |         0.5*width,
530 |         0.5*height
531 |     );
532 | 
533 |     vec3 points[4];
534 |     InitDiskPoints(disk, points);
535 | 
536 |     vec4 floorPlane = vec4(0, 1, 0, 0);
537 | 
538 |     vec3 lcol = vec3(intensity);
539 |     vec3 dcol = ToLinear(dcolor);
540 |     vec3 scol = ToLinear(scolor);
541 | 
542 |     vec3 col = vec3(0);
543 | 
544 |     Ray ray = GenerateCameraRay();
545 | 
546 |     float dist = RayPlaneIntersect(ray, floorPlane);
547 | 
548 |     vec2 seq[NUM_SAMPLES];
549 |     Halton2D(seq, sampleCount);
550 | 
551 |     float u1 = rand(gl_FragCoord.xy*0.01);
552 |     float u2 = rand(gl_FragCoord.yx*0.01);
553 | 
554 |     u1 = fract(u1 + seq[0].x);
555 |     u2 = fract(u2 + seq[0].y);
556 | 
557 |     if (dist != NO_HIT)
558 |     {
559 |         // Clamp distance to some sane maximum to prevent instability
560 |         dist = min(dist, 10000.0);
561 | 
562 |         vec3 pos = ray.origin + dist*ray.dir;
563 | 
564 |         vec3 N = floorPlane.xyz;
565 |         vec3 V = -ray.dir;
566 | 
567 |         float ndotv = saturate(dot(N, V));
568 |         vec2 uv = vec2(roughness, sqrt(1.0 - ndotv));
569 |         uv = uv*LUT_SCALE + LUT_BIAS;
570 | 
571 |         vec4 t1 = texture(ltc_1, uv);
572 |         vec4 t2 = texture(ltc_2, uv);
573 | 
574 |         mat3 Minv = mat3(
575 |             vec3(t1.x, 0, t1.y),
576 |             vec3(  0,  1,    0),
577 |             vec3(t1.z, 0, t1.w)
578 |         );
579 | 
580 |         vec3 spec = LTC_Evaluate(N, V, pos, Minv, points, twoSided, u1, u2);
581 |         // BRDF shadowing and Fresnel
582 |         spec *= scol*t2.x + (1.0 - scol)*t2.y;
583 | 
584 |         vec3 diff = LTC_Evaluate(N, V, pos, mat3(1), points, twoSided, u1, u2);
585 | 
586 |         col = lcol*(spec + dcol*diff);
587 |     }
588 | 
589 |     float distToDisk = RayDiskIntersect(ray, disk);
590 |     if (distToDisk < dist)
591 |         col = lcol;
592 | 
593 |     FragColor = vec4(col, 1.0);
594 | }
595 | 


--------------------------------------------------------------------------------
/webgl/js/macton/macton-gl-utils.js:
--------------------------------------------------------------------------------
  1 | jQuery.glCheckError = function( gl, error_log ) 
  2 | {
  3 |   var error = gl.getError();
  4 |   if (error != gl.NO_ERROR) 
  5 |   {
  6 |     var error_str = "GL Error: " + error + " " + gl.enum_strings[error];
  7 | 
  8 |     if ( typeof error_log === 'function' ) 
  9 |     {
 10 |       error_log( error_str );
 11 |     }
 12 | 
 13 |     throw error_str;
 14 |   }
 15 | }
 16 | 
 17 | // jQuery.glProgram = function( gl, config, complete )
 18 | //
 19 | // Example config:
 20 | //
 21 | // var g_BumpReflectProgram = 
 22 | // {
 23 | //   VertexProgramURL:   '/shaders/bump_reflect.vs',
 24 | //   FragmentProgramURL: '/shaders/bump_reflect.fs',
 25 | //   ErrorLog:           error_log,
 26 | // };
 27 | 
 28 | jQuery.glProgram = function( gl, config, complete )
 29 | {
 30 |   this.Program           = null;
 31 |   this.UniformLocations  = { };
 32 |   this.AttributeIndices  = [];
 33 |   this.Uniforms          = [];
 34 |   this.UniformTypes      = { };
 35 |   this.Attributes        = [];
 36 |   this.AttributeTypes    = { };
 37 |   this.ErrorLog          = config.error_log;
 38 |   this.BoundTextureCount = 0;
 39 | 
 40 |   this.Use = function()
 41 |   {
 42 |     gl.useProgram( this.Program );
 43 | 
 44 |     this.BoundTextureCount = 0;
 45 |   }
 46 | 
 47 |   this.BindModel = function( model, bindings )
 48 |   {
 49 |     var attribute_ndx = this.AttributeIndices;
 50 | 
 51 |     gl.bindBuffer(gl.ARRAY_BUFFER, model.VertexBuffer );
 52 | 
 53 |     for ( var model_stream_name in bindings )
 54 |     {
 55 |       var program_stream_name = bindings[ model_stream_name ];
 56 |       var program_attribute   = this.AttributeIndices[ program_stream_name ];
 57 |       var model_stream_offset = model.VertexStreamBufferOffsets[ model_stream_name ];
 58 |       var model_stream_stride = model.VertexStreamBufferStrides[ model_stream_name ];
 59 |       var model_stream_type   = model.VertexStreamBufferGLTypes[ model_stream_name ];
 60 | 
 61 |       gl.vertexAttribPointer( program_attribute, model_stream_stride, model_stream_type, false, 0, model_stream_offset );
 62 |       gl.enableVertexAttribArray( program_attribute );
 63 |     }
 64 | 
 65 |     gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, model.IndexBuffer );
 66 | 
 67 |     $.glCheckError( gl, this.ErrorLog );
 68 | 
 69 |     this.Model = model;
 70 |   }
 71 | 
 72 |   this.BindUniform = function( uniform_name, value )
 73 |   { 
 74 |     var uniform_type = this.UniformTypes[ uniform_name ];
 75 |  
 76 |     switch (uniform_type)
 77 |     {
 78 |       case 'mat4':
 79 |       {
 80 |         gl.uniformMatrix4fv( this.UniformLocations[ uniform_name ], gl.FALSE, new Float32Array( value ) );
 81 |       }
 82 |       break;
 83 | 
 84 |       case 'sampler2D':
 85 |       {
 86 |         gl.activeTexture( gl[ 'TEXTURE' + this.BoundTextureCount ] );
 87 |  
 88 |         if ( value instanceof jQuery.glTexture )
 89 |         {
 90 |           gl.bindTexture( gl.TEXTURE_2D, value.Texture );
 91 |         }
 92 |         else
 93 |         {
 94 |           gl.bindTexture( gl.TEXTURE_2D, value );
 95 |         }
 96 | 
 97 |         gl.uniform1i( this.UniformLocations[ uniform_name ], this.BoundTextureCount );
 98 |         this.BoundTextureCount++;
 99 |       }
100 |       break;
101 | 
102 |       case 'samplerCube':
103 |       {
104 |         gl.activeTexture( gl[ 'TEXTURE' + this.BoundTextureCount ] );
105 |         gl.bindTexture( gl.TEXTURE_CUBE_MAP, value );
106 |         gl.uniform1i( this.UniformLocations[ uniform_name ], this.BoundTextureCount );
107 |         this.BoundTextureCount++;
108 |       }
109 |       break;
110 |     }
111 |   }
112 | 
113 |   this.DrawModel = function()
114 |   {
115 |     var model = this.Model; // Model must be bound with BindModel first.
116 | 
117 |     gl.drawElements( gl.TRIANGLES, model.IndexCount, model.IndexStreamGLType, 0 );
118 |   }
119 | 
120 |   this.CreateBestVertexBindings = function( model )
121 |   {
122 |     var bindings = new Object();
123 | 
124 |     for (var i=0;i<model.VertexStreamNames.length;i++)
125 |     {
126 |       var vertex_stream_name = model.VertexStreamNames[i];
127 |       var best_dist          = 1000;
128 | 
129 |       for (var j=0;j<this.Attributes.length;j++)
130 |       {
131 |         var attribute_name = this.Attributes[j];
132 |         var dist           = vertex_stream_name.LD( attribute_name );
133 |         if ( dist < best_dist )
134 |         { 
135 |           bindings[ vertex_stream_name ] = attribute_name;
136 |           best_dist                      = dist;
137 |         }
138 |       }
139 |     }
140 | 
141 |     return (bindings);
142 |   }
143 | 
144 |   var vertex_shader   = null;
145 |   var fragment_shader = null;
146 | 
147 |   var CompileShader = function( type, source )
148 |   {
149 |     var shader = gl.createShader(type);
150 | 
151 |     if (shader == null) 
152 |     {
153 |       return null;
154 |     }
155 | 
156 |     gl.shaderSource(shader, source);
157 |     gl.compileShader(shader);
158 | 
159 |     if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) 
160 |     {
161 |       var infoLog = gl.getShaderInfoLog(shader);
162 |       output("Error compiling shader:\n" + infoLog);
163 |       gl.deleteShader(shader);
164 |       return null;
165 |     }
166 | 
167 |     return shader;
168 |   }
169 | 
170 |   var TryErrorLog = function( msg )
171 |   {
172 |     if ( typeof config.ErrorLog !== 'function' ) return;
173 | 
174 |     config.ErrorLog( msg );
175 |   }
176 | 
177 |   var TryBuildProgram = function()
178 |   {
179 |     if ( vertex_shader   == null ) return;
180 |     if ( fragment_shader == null ) return;
181 | 
182 |     this.Program = gl.createProgram();
183 |     if (this.Program == null) 
184 |     {
185 |       TryErrorLog("Could not create GL program");
186 |       return;
187 |     }
188 | 
189 |     gl.attachShader( this.Program, vertex_shader );
190 |     gl.attachShader( this.Program, fragment_shader );
191 | 
192 |     for (var i=0;i<this.Attributes.length;i++)
193 |     {
194 |       var attribute_name = this.Attributes[i];
195 | 
196 |       this.AttributeIndices[ attribute_name ] = i;
197 | 
198 |       gl.bindAttribLocation( this.Program, i, attribute_name );
199 |     }
200 | 
201 |     gl.linkProgram( this.Program );
202 | 
203 |     var linked = gl.getProgramParameter( this.Program, gl.LINK_STATUS );
204 |     if (!linked) 
205 |     {
206 |       var infoLog = gl.getProgramInfoLog(this.Program);
207 | 
208 |       TryErrorLog("GL program link failed: " + infoLog);
209 | 
210 |       gl.deleteProgram( this.Program );
211 |       this.Program = null;
212 | 
213 |       return;
214 |     }
215 | 
216 |     for (var i=0;i<this.Uniforms.length;i++)
217 |     {
218 |       var uniform_name = this.Uniforms[i];
219 | 
220 |       this.UniformLocations[ uniform_name ] = gl.getUniformLocation( this.Program, uniform_name );
221 |     }
222 | 
223 |     $.glCheckError( gl, config.error_log );
224 | 
225 |     if ( typeof complete === 'function' ) complete( this );
226 |   }
227 | 
228 |   var AddUniforms = function( source )
229 |   {
230 |     var uniform_match = /uniform\s+(\w+)\s+(\w+)\s*;/g
231 |     var uniforms      = source.match( uniform_match );
232 | 
233 |     for (var i=0;i<uniforms.length;i++)
234 |     {
235 |       var uniform       = uniforms[i].split( uniform_match );
236 |       var uniform_type  = uniform[1];
237 |       var uniform_name  = uniform[2];
238 |   
239 |       this.Uniforms.push( uniform_name );
240 |       this.UniformTypes[ uniform_name ] = uniform_type;
241 |     }
242 |   }
243 | 
244 |   var AddAttributes = function( source )
245 |   {
246 |     var attribute_match = /attribute\s+(\w+)\s+(\w+)\s*;/g
247 |     var attributes      = source.match( attribute_match );
248 | 
249 |     for (var i=0;i<attributes.length;i++)
250 |     {
251 |       var attribute       = attributes[i].split( attribute_match );
252 |       var attribute_type  = attribute[1];
253 |       var attribute_name  = attribute[2];
254 |   
255 |       this.Attributes.push( attribute_name );
256 |       this.AttributeTypes[ attribute_name ] = attribute_type;
257 |     }
258 |   }
259 | 
260 |   var LoadVertexShader = function( source )
261 |   {
262 |     vertex_shader = CompileShader.apply( this, [ gl.VERTEX_SHADER, source ] );
263 | 
264 |     AddUniforms.apply( this, [ source ] );
265 |     AddAttributes.apply( this, [ source ] );
266 | 
267 |     TryBuildProgram.apply( this );
268 |   }
269 | 
270 |   var LoadFragmentShader = function( source )
271 |   {
272 |     fragment_shader = CompileShader.apply( this, [ gl.FRAGMENT_SHADER, source ] );
273 |    
274 |     AddUniforms.apply( this, [ source ] );
275 |     TryBuildProgram.apply( this );
276 |   }
277 | 
278 |   var that = this;
279 | 
280 |   this.get = function( url, fn )
281 |   {
282 | 	var request = new XMLHttpRequest();
283 | 	request.open( "GET", url, true );
284 | 	request.send( null );
285 | 	fn( request.responseText );
286 |   }
287 | 
288 |   this.get( config.VertexProgramURL,   function( source ) { LoadVertexShader.apply( that, arguments ); } );
289 |   this.get( config.FragmentProgramURL, function( source ) { LoadFragmentShader.apply( that, arguments ); } );
290 | 
291 | //  $.get( config.VertexProgramURL,   function( source ) { LoadVertexShader.apply( that, arguments ); } );
292 | //  $.get( config.FragmentProgramURL, function( source ) { LoadFragmentShader.apply( that, arguments ); } );
293 | }
294 | 
295 | // jQuery.glModel = function( gl, model_url, complete )
296 | //
297 | // Model JSON format:
298 | // {
299 | //   VertexStreams: [
300 | //     {
301 | //       Name: "position",
302 | //       Type: "float",
303 | //       Stride: 3,
304 | //       Stream: [ 1.0, 1.0, 1.0, ... ]
305 | //     }
306 | //     ,...
307 | //   ]
308 | //   Indices:  
309 | //   {
310 | //     Type: "uint16_t",
311 | //     Stream: [ 0, 1, 2, 2, 3, 4, ... ]
312 | //     }
313 | //   }
314 | // }
315 | 
316 | jQuery.glModel = function( gl, model_url, complete )
317 | {
318 |   this.VertexStreamNames         = [];
319 |   this.VertexStreamBuffers       = [];
320 |   this.VertexStreamBufferOffsets = [];
321 |   this.VertexStreamBufferStrides = [];
322 |   this.VertexStreamBufferGLTypes = [];
323 |   this.VertexBuffer              = null;
324 |   this.IndexStreamBuffer         = null;
325 |   this.IndexStreamGLType         = null;
326 |   this.IndexBuffer               = null;
327 |   this.IndexCount                = 0;
328 | 
329 |   var LoadModel = function( source )
330 |   {
331 |     var CreateArrayByStdType = function( type, source )
332 |     {
333 |       if (type == 'float')
334 |       {
335 |         return new Float32Array( source );
336 |       }
337 |       else if (type == 'uint16_t')
338 |       {
339 |         return new Uint16Array( source );
340 |       }
341 |       else if (type == 'uint32_t')
342 |       {
343 |         return new Uint32Array( source );
344 |       }
345 |       else if (type == 'uint8_t')
346 |       {
347 |         return new Uint8Array( source );
348 |       }
349 |     }
350 | 
351 |     var GLTypeByStdType = function( type )
352 |     {
353 |       if (type == 'float')
354 |       {
355 |         return gl.FLOAT;
356 |       }
357 |       else if (type == 'uint16_t')
358 |       {
359 |         return gl.UNSIGNED_SHORT;
360 |       }
361 |       else if (type == 'uint32_t')
362 |       {
363 |         return gl.UNSIGNED_INT;
364 |       }
365 |       else if (type == 'uint8_t')
366 |       {
367 |         return gl.UNSIGNED_BYTE;
368 |       }
369 |     }
370 | 
371 |     var vertex_stream_count = source.VertexStreams.length;
372 |     var vertex_buffer_size  = 0;
373 | 
374 |     for (var i=0;i<vertex_stream_count;i++)
375 |     {
376 |       var stream_source  = source.VertexStreams[i];
377 |       var stream_name    = stream_source.Name;
378 |       var stream_buffer  = CreateArrayByStdType( stream_source.Type, stream_source.Stream );
379 |       var stream_stride  = stream_source.Stride;
380 |       var stream_type    = stream_source.Type;
381 |       var stream_gl_type = GLTypeByStdType( stream_type );
382 | 
383 |       this.VertexStreamBuffers[i]                   = stream_buffer;
384 |       this.VertexStreamNames[i]                     = stream_name;
385 |       this.VertexStreamBufferOffsets[ stream_name ] = vertex_buffer_size;
386 |       this.VertexStreamBufferStrides[ stream_name ] = stream_stride;
387 |       this.VertexStreamBufferGLTypes[ stream_name ] = stream_gl_type;
388 | 
389 |       if ( stream_buffer )
390 |       {
391 |         vertex_buffer_size += stream_buffer.byteLength;
392 |       }
393 |     }  
394 | 
395 |     this.VertexBuffer = gl.createBuffer();
396 | 
397 |     gl.bindBuffer( gl.ARRAY_BUFFER, this.VertexBuffer );
398 |     gl.bufferData( gl.ARRAY_BUFFER, vertex_buffer_size, gl.STATIC_DRAW );
399 | 
400 |     for (var i=0;i<vertex_stream_count;i++)
401 |     {
402 |       var stream_source = source.VertexStreams[i];
403 |       var stream_name   = stream_source.Name;
404 | 
405 |       gl.bufferSubData( gl.ARRAY_BUFFER, this.VertexStreamBufferOffsets[ stream_name ], this.VertexStreamBuffers[i] );
406 |     }
407 | 
408 |     this.IndexBuffer       = gl.createBuffer();
409 |     this.IndexStreamBuffer = CreateArrayByStdType( source.Indices.Type, source.Indices.Stream );
410 |     this.IndexStreamGLType = GLTypeByStdType( source.Indices.Type );
411 |     this.IndexCount        = source.Indices.Stream.length;
412 | 
413 |     gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, this.IndexBuffer );
414 |     gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, this.IndexStreamBuffer, gl.STATIC_DRAW );
415 | 
416 |     if ( typeof complete === 'function' ) complete( this );
417 |   }
418 | 
419 |   var that = this;
420 | 
421 | 	$.ajax({
422 | 		url: model_url,
423 | 		dataType: 'json',
424 | 		mimeType: 'application/json',
425 | 		success: function( source ) { LoadModel.apply( that, arguments ); }
426 | 	});
427 | 
428 |   //$.getJSON( model_url, function( source ) { LoadModel.apply( that, arguments ); } );
429 | }
430 | 
431 | 
432 | jQuery.glModel2 = function( gl, model, complete )
433 | {
434 |   this.VertexStreamNames         = [];
435 |   this.VertexStreamBuffers       = [];
436 |   this.VertexStreamBufferOffsets = [];
437 |   this.VertexStreamBufferStrides = [];
438 |   this.VertexStreamBufferGLTypes = [];
439 |   this.VertexBuffer              = null;
440 |   this.IndexStreamBuffer         = null;
441 |   this.IndexStreamGLType         = null;
442 |   this.IndexBuffer               = null;
443 |   this.IndexCount                = 0;
444 | 
445 |   var LoadModel = function( source )
446 |   {
447 |     var CreateArrayByStdType = function( type, source )
448 |     {
449 |       if (type == 'float')
450 |       {
451 |         return new Float32Array( source );
452 |       }
453 |       else if (type == 'uint16_t')
454 |       {
455 |         return new Uint16Array( source );
456 |       }
457 |       else if (type == 'uint32_t')
458 |       {
459 |         return new Uint32Array( source );
460 |       }
461 |       else if (type == 'uint8_t')
462 |       {
463 |         return new Uint8Array( source );
464 |       }
465 |     }
466 | 
467 |     var GLTypeByStdType = function( type )
468 |     {
469 |       if (type == 'float')
470 |       {
471 |         return gl.FLOAT;
472 |       }
473 |       else if (type == 'uint16_t')
474 |       {
475 |         return gl.UNSIGNED_SHORT;
476 |       }
477 |       else if (type == 'uint32_t')
478 |       {
479 |         return gl.UNSIGNED_INT;
480 |       }
481 |       else if (type == 'uint8_t')
482 |       {
483 |         return gl.UNSIGNED_BYTE;
484 |       }
485 |     }
486 | 
487 |     var vertex_stream_count = source.VertexStreams.length;
488 |     var vertex_buffer_size  = 0;
489 | 
490 |     for (var i=0;i<vertex_stream_count;i++)
491 |     {
492 |       var stream_source  = source.VertexStreams[i];
493 |       var stream_name    = stream_source.Name;
494 |       var stream_buffer  = CreateArrayByStdType( stream_source.Type, stream_source.Stream );
495 |       var stream_stride  = stream_source.Stride;
496 |       var stream_type    = stream_source.Type;
497 |       var stream_gl_type = GLTypeByStdType( stream_type );
498 | 
499 |       this.VertexStreamBuffers[i]                   = stream_buffer;
500 |       this.VertexStreamNames[i]                     = stream_name;
501 |       this.VertexStreamBufferOffsets[ stream_name ] = vertex_buffer_size;
502 |       this.VertexStreamBufferStrides[ stream_name ] = stream_stride;
503 |       this.VertexStreamBufferGLTypes[ stream_name ] = stream_gl_type;
504 | 
505 |       if ( stream_buffer )
506 |       {
507 |         vertex_buffer_size += stream_buffer.byteLength;
508 |       }
509 |     }  
510 | 
511 |     this.VertexBuffer = gl.createBuffer();
512 | 
513 |     gl.bindBuffer( gl.ARRAY_BUFFER, this.VertexBuffer );
514 |     gl.bufferData( gl.ARRAY_BUFFER, vertex_buffer_size, gl.STATIC_DRAW );
515 | 
516 |     for (var i=0;i<vertex_stream_count;i++)
517 |     {
518 |       var stream_source = source.VertexStreams[i];
519 |       var stream_name   = stream_source.Name;
520 | 
521 |       gl.bufferSubData( gl.ARRAY_BUFFER, this.VertexStreamBufferOffsets[ stream_name ], this.VertexStreamBuffers[i] );
522 |     }
523 | 
524 |     this.IndexBuffer       = gl.createBuffer();
525 |     this.IndexStreamBuffer = CreateArrayByStdType( source.Indices.Type, source.Indices.Stream );
526 |     this.IndexStreamGLType = GLTypeByStdType( source.Indices.Type );
527 |     this.IndexCount        = source.Indices.Stream.length;
528 | 
529 |     gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, this.IndexBuffer );
530 |     gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, this.IndexStreamBuffer, gl.STATIC_DRAW );
531 | 
532 |     if ( typeof complete === 'function' ) complete( this );
533 |   }
534 | 
535 |   var that = this;
536 | /*
537 | 	$.ajax({
538 | 		url: model_url,
539 | 		dataType: 'json',
540 | 		mimeType: 'application/json',
541 | 		success: function( source ) { LoadModel.apply( that, arguments ); }
542 | 	});
543 | */
544 |   LoadModel.apply( this, [ model ] );
545 | }
546 | 
547 | 
548 | // jQuery.glTexture = function( gl, config, complete )
549 | // 
550 | // Example config:
551 | // 
552 | //   var g_BumpTextureConfig =
553 | //   {
554 | //     Type:      'TEXTURE_2D',
555 | //     ImageURL:  './images/bump.jpg',
556 | //     TexParameters: 
557 | //     {
558 | //       TEXTURE_MIN_FILTER: 'LINEAR',
559 | //       TEXTURE_MAG_FILTER: 'LINEAR',
560 | //       TEXTURE_WRAP_S:     'REPEAT',
561 | //       TEXTURE_WRAP_T:     'REPEAT'
562 | //     },
563 | //     PixelStoreParameters:
564 | //     {
565 | //       UNPACK_FLIP_Y_WEBGL: true
566 | //     }
567 | //   };
568 | 
569 | jQuery.glTexture = function( gl, config, complete )
570 | {
571 |   this.Texture  = gl.createTexture();
572 |   this.ErrorLog = config.ErrorLog;
573 | 
574 |   var texture_type = gl[ config.Type ];
575 |   var images_remaining;
576 |   var that = this;
577 | 
578 |   if ( this.Texture == null )
579 |   {
580 |     return null;
581 |   }
582 | 
583 |   gl.bindTexture( texture_type, this.Texture );
584 | 
585 |   for ( var pname in config.TexParameters )
586 |   {
587 |     var pvalue          = config.TexParameters[ pname ];
588 |     var parameter_name  = gl[ pname ]; 
589 |     var parameter_value = gl[ pvalue ];
590 | 
591 |     gl.texParameteri( texture_type, parameter_name, parameter_value );
592 |     $.glCheckError( gl, this.ErrorLog );
593 |   }
594 | 
595 |   var ImageLoaded = function( image, image_type, mip )
596 |   {
597 |     gl.bindTexture( texture_type, this.Texture );
598 |     $.glCheckError( gl, this.ErrorLog );
599 | 
600 |     for ( var pname in config.PixelStoreParameters )
601 |     {
602 |       var parameter_name  = gl[ pname ];
603 |       var parameter_value = config.PixelStoreParameters[ pname ];
604 | 
605 |       gl.pixelStorei( parameter_name, parameter_value );
606 |       $.glCheckError( gl, this.ErrorLog );
607 |     }
608 | 
609 |     gl.texImage2D( image_type, mip, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image );
610 | 
611 |     $.glCheckError( gl, this.ErrorLog );
612 | 
613 | 	if ( texture_type === gl.TEXTURE_CUBE_MAP && image_type === gl.TEXTURE_CUBE_MAP_NEGATIVE_Z )
614 | 		gl.generateMipmap( texture_type );
615 | 
616 | 	if ( texture_type === gl.TEXTURE_2D && config.MipURL == undefined )
617 | 		gl.generateMipmap( texture_type );
618 | 
619 |     $.glCheckError( gl, this.ErrorLog );
620 | 
621 |     images_remaining--;
622 | 
623 |     if ( images_remaining == 0 ) 
624 |     {
625 |     	if ( typeof complete === 'function' ) complete( this );
626 |     }
627 |   }
628 | 
629 |   var LoadImage = function( src, image_type, mip )
630 |   {
631 |     var image        = new Image();
632 |     image.onload     = function() { ImageLoaded.apply( that, [ image, image_type, mip ] ); };
633 |     image.src        = src;
634 |   }
635 | 
636 |   if ( typeof config.ImageURL == 'string' )
637 |   {
638 |     images_remaining = 1;
639 |     
640 |     if ( config.MipURL !== undefined )
641 |     {
642 |     	images_remaining += config.MipURL.length;
643 |     }
644 |     
645 |     LoadImage( config.ImageURL, gl[ config.Type ], 0 );
646 | 
647 | 	if ( config.MipURL !== undefined )
648 | 	{
649 | 		for (var i=0;i<config.MipURL.length;i++)
650 | 		{
651 | 		  LoadImage( config.MipURL[i], gl[ config.Type ], i + 1 );
652 | 		}
653 | 	}
654 |   }
655 |   else
656 |   {
657 |     images_remaining = config.ImageURL.length;
658 |     for (var i=0;i<config.ImageURL.length;i++)
659 |     {
660 |       LoadImage( config.ImageURL[i], gl[ config.ImageType[i] ], 0 );
661 |     }
662 |   }
663 | }
664 | 


--------------------------------------------------------------------------------
/webgl/ltc_quad.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE HTML>
  2 | <html lang="en">
  3 | 
  4 | <head>
  5 |     <title>Shader Sandbox</title>
  6 |     <meta charset="utf-8"></meta>
  7 | </head>
  8 | 
  9 | <body style="background: #191919">
 10 | 
 11 | 
 12 | <link href="css/sandbox.css" rel="stylesheet" type="text/css"/>
 13 | <link href="css/super_slider.css" media="screen" rel="stylesheet" type="text/css"/>
 14 | <link href="css/super_picker.css" media="screen" rel="stylesheet" type="text/css"/>
 15 | <link href="css/plugin.css" media="screen" rel="stylesheet" type="text/css"/>
 16 | <link href="css/ace_theme_tweaks.css" rel="stylesheet" type="text/css"/>
 17 | <link href="css/jquery.ui.resizable.css" rel="stylesheet">
 18 | 
 19 | 
 20 | <div id="peekaboo" style="display: none; float: left; margin: 0px 8px 0px 0px; width: 750px; height: 600px; position: relative">
 21 |     <pre id="editor"></pre>
 22 | </div>
 23 | 
 24 | 
 25 | <div id="stuff" style="display: none; overflow: auto; height: 100%">
 26 | 
 27 | <div style="float: left; width: 512px; margin: 8px">
 28 |     <div id="effect" style="width: 512px; height: 512px; float: left; position: relative;"></div>
 29 |     <div id="status" style="min-width: 496px">
 30 |         <p id="status_text"></p>
 31 |     </div>
 32 | </div>
 33 | 
 34 | <div id="params"></div>
 35 | 
 36 | </div>
 37 | 
 38 | 
 39 | <script>
 40 |     function Color(r, g, b) {
 41 |         this.r = r;
 42 |         this.g = g;
 43 |         this.b = b;
 44 |     }
 45 | </script>
 46 | 
 47 | 
 48 | <script src="js/color_picker.js" type="text/javascript"></script>
 49 | <script src="js/jquery-1.6.1.min.js"></script>
 50 | <script src="js/ace/ace.js" type="text/javascript" charset="utf-8"></script>
 51 | <script src="js/ace/theme-clouds_midnight.js" type="text/javascript" charset="utf-8"></script>
 52 | <script src="js/ace/mode-glsl.js" type="text/javascript" charset="utf-8"></script>
 53 | <script src="js/super_picker.js" type="text/javascript"></script>
 54 | <script src="js/super_slider.js" type="text/javascript"></script>
 55 | <script src="js/jquery.mousewheel.min.js" type="text/javascript"></script>
 56 | 
 57 | <script src="js/macton/macton-utils.js" type="text/javascript"></script>
 58 | <script src="js/macton/macton-gl-utils.js" type="text/javascript"></script>
 59 | <script src="js/macton/webgl-utils.js" type="text/javascript"></script>
 60 | <script src="js/macton/matrix4x4.js" type="text/javascript"></script>
 61 | <script src="js/macton/cameracontroller.js" type="text/javascript"></script>
 62 | 
 63 | <script src="js/jquery-ui-1.8.13.custom.min.js" type="text/javascript"></script>
 64 | 
 65 | <script src="../fit/results/ltc.js" type="text/javascript"></script>
 66 | 
 67 | 
 68 | <script>
 69 | var g_vshader = null;
 70 | 
 71 | var g_param_types = {};
 72 | var g_params = {};
 73 | var g_param_edited = {};
 74 | var g_param_default = {};
 75 | 
 76 | var g_sample_count = 0;
 77 | 
 78 | var bindSlider = function(name, label, default_value, value, state) {
 79 |     var slider = new SuperSlider(name, {
 80 |         label: label,
 81 |         default_value: default_value,
 82 |         value: value,
 83 |         min:  state.min,
 84 |         max:  state.max,
 85 |         step: state.step });
 86 | 
 87 |     slider.bind("change", function(event) {
 88 |         g_params[name] = event.target.val;
 89 |         g_param_edited[name] = true;
 90 |         g_sample_count = 0;
 91 |     });
 92 | 
 93 |     slider.bind("reset", function(event) {
 94 |         g_param_edited[name] = undefined;
 95 |         g_sample_count = 0;
 96 |     });
 97 | 
 98 |     return slider;
 99 | }
100 | 
101 | var bindPicker = function(name, label, default_value, value) {
102 |     var picker = new SuperPicker(name, {
103 |         label: label,
104 |         default_value: default_value,
105 |         value: value,
106 |         callback: function(col) {
107 |             g_params[name] = col;
108 |             g_param_edited[name] = true;
109 |             g_sample_count = 0;
110 |         }
111 |     });
112 | 
113 |     picker.bind("reset", function (event) {
114 |         g_param_edited[name] = undefined;
115 |         g_sample_count = 0;
116 |     });
117 | 
118 |     return picker;
119 | }
120 | 
121 | var bindCheckbox = function(name, label, value) {
122 |     var control = $("<input>")
123 |         .attr({ type: "checkbox", /*id: name,*/ checked: value })
124 |         .css("margin", "0 0 0 4px");
125 | 
126 |     var cb_label = $("<label>")
127 |         .attr("for", name)
128 |         .text(label)
129 |         .addClass("checkbox_label");
130 | 
131 |     cb_label.append(control);
132 | 
133 |     control.bind("change", function (event) {
134 |         g_params[name] = event.target.checked;
135 |         g_param_edited[name] = true;
136 |         g_sample_count = 0;
137 |     });
138 | 
139 |     cb_label.bind("click", function (event) {
140 |         control.prop("checked", g_param_default[name]);
141 |         control.trigger("change");
142 |         g_param_edited[name] = undefined;
143 |         g_sample_count = 0;
144 |     });
145 | 
146 |     control.bind("click", function (event) {
147 |         event.stopPropagation();
148 |     });
149 | 
150 |     return cb_label;
151 | }
152 | </script>
153 | 
154 | 
155 | <script type="text/javascript">
156 | /**
157 |  * Provides requestAnimationFrame in a cross browser way.
158 |  * http://paulirish.com/2011/requestanimationframe-for-smart-animating/
159 |  */
160 | if (!window.requestAnimationFrame) {
161 |     window.requestAnimationFrame = (function() {
162 |         return window.webkitRequestAnimationFrame ||
163 |         window.mozRequestAnimationFrame ||
164 |         window.oRequestAnimationFrame   ||
165 |         window.msRequestAnimationFrame  ||
166 |         function(/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) {
167 |             window.setTimeout(callback, 1000/60);
168 |         };
169 |     })();
170 | }
171 | </script>
172 | 
173 | 
174 | <script type="text/javascript">
175 | var effectDiv, sourceDiv, canvas, gl, buffer,
176 | vertex_shader, fragment_shader, currentProgram,
177 | vertexPositionLocation, textureLocation,
178 | parameters = { start_time: new Date().getTime(), time: 0, screenWidth: 0, screenHeight: 0 };
179 | 
180 | var g_zoom = 0;
181 | 
182 | var model      = new Matrix4x4();
183 | var view       = new Matrix4x4();
184 | var projection = new Matrix4x4();
185 | var controller = null;
186 | 
187 | var ltc_texture_1 = null;
188 | var ltc_texture_2 = null;
189 | 
190 | var rttFramebuffer = null;
191 | var rttTexture = null;
192 | 
193 | var blit_vs = null;
194 | var blit_fs = null;
195 | var blitProgram = null;
196 | 
197 | 
198 | function FetchFile(url, cache)
199 | {
200 |     var text = $.ajax({
201 |         url:   url,
202 |         async: false,
203 |         dataType: "text",
204 |         mimeType: "text/plain",
205 |         cache: cache,
206 |     }).responseText;
207 | 
208 |     return text;
209 | }
210 | 
211 | function SetClampedTextureState()
212 | {
213 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
214 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
215 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
216 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
217 | }
218 | 
219 | function init() {
220 |     vertex_shader   = FetchFile("shaders/ltc/ltc.vs", false);
221 |     fragment_shader = FetchFile("shaders/ltc/ltc_quad.fs", false);
222 | 
223 |     g_vshader = vertex_shader;
224 |     $("#editor").text(fragment_shader);
225 | 
226 |     canvas = document.createElement("canvas");
227 |     canvas.style.cssText = "border: 2px solid #404040; border-radius: 6px";
228 | 
229 |     effectDiv = document.getElementById("effect");
230 |     effectDiv.appendChild(canvas);
231 | 
232 |     // Initialise WebGL
233 |     try {
234 |         gl = canvas.getContext("webgl2");
235 |     } catch(error) { }
236 | 
237 |     if (!gl) {
238 |         alert("WebGL not supported");
239 |         throw "cannot create webgl context";
240 |     }
241 | 
242 |     // Check for float-RT support
243 |     if (!gl.getExtension("EXT_color_buffer_float")) {
244 |         alert("EXT_color_buffer_float not supported");
245 |         throw "missing webgl extension";
246 |     }
247 | 
248 |     if (!gl.getExtension("OES_texture_float_linear")) {
249 |         alert("OES_texture_float_linear not supported");
250 |         throw "missing webgl extension";
251 |     }
252 | 
253 | 
254 |     // Add enum strings to context
255 |     if (gl.enum_strings === undefined) {
256 |         gl.enum_strings = { };
257 |         for (var propertyName in gl) {
258 |           if (typeof gl[propertyName] == "number") {
259 |             gl.enum_strings[gl[propertyName]] = propertyName;
260 |           }
261 |         }
262 |     }
263 | 
264 |     // Create Vertex buffer (2 triangles)
265 |     buffer = gl.createBuffer();
266 |     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
267 |     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0]), gl.STATIC_DRAW);
268 | 
269 |     // Create Program
270 |     currentProgram = createProgram(vertex_shader, fragment_shader);
271 | 
272 | ////
273 |     rttFramebuffer = gl.createFramebuffer();
274 |     gl.bindFramebuffer(gl.FRAMEBUFFER, rttFramebuffer);
275 |     rttFramebuffer.width  = 512; // FIXME
276 |     rttFramebuffer.height = 512;
277 | 
278 |     rttTexture = gl.createTexture();
279 |     gl.bindTexture(gl.TEXTURE_2D, rttTexture);
280 |     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, rttFramebuffer.width, rttFramebuffer.height, 0, gl.RGBA, gl.FLOAT, null);
281 | 
282 |     gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, rttTexture, 0);
283 |     gl.bindFramebuffer(gl.FRAMEBUFFER, null);
284 | 
285 |     gl.bindTexture(gl.TEXTURE_2D, null);
286 | 
287 | 
288 |     blit_vs = FetchFile("shaders/ltc/ltc_blit.vs", false);
289 |     blit_fs = FetchFile("shaders/ltc/ltc_blit.fs", false);
290 | 
291 |     var header = "#version 300 es\nprecision highp float;\n#line 0\n";
292 |     blit_vs = header + blit_vs;
293 |     blit_fs = header + blit_fs;
294 | 
295 |     blitProgram = gl.createProgram();
296 | 
297 |     var vs = createShader(blit_vs, gl.VERTEX_SHADER);
298 |     var fs = createShader(blit_fs, gl.FRAGMENT_SHADER);
299 | 
300 |     gl.attachShader(blitProgram, vs);
301 |     gl.attachShader(blitProgram, fs);
302 | 
303 |     gl.deleteShader(vs);
304 |     gl.deleteShader(fs);
305 | 
306 |     gl.linkProgram(blitProgram);
307 | ////
308 | 
309 |     onWindowResize();
310 |     window.addEventListener("resize", onWindowResize, false);
311 | 
312 |     $("canvas").mousewheel(function(event, delta) {
313 |         g_zoom += delta*10.0;
314 |         g_sample_count = 0;
315 | //      console.log("pageX: " + event.pageX + " pageY: " + event.pageY);
316 |         return false;
317 |     });
318 | 
319 |     $("canvas").attr("tabindex", "0").keydown(function(event) {
320 |         //console.log(event);
321 |         return false;
322 |     });
323 | 
324 |     ltc_texture_1 = gl.createTexture();
325 |     gl.bindTexture(gl.TEXTURE_2D, ltc_texture_1);
326 |     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, 64, 64, 0, gl.RGBA, gl.FLOAT, new Float32Array(g_ltc_1));
327 |     SetClampedTextureState();
328 | 
329 |     ltc_texture_2 = gl.createTexture();
330 |     gl.bindTexture(gl.TEXTURE_2D, ltc_texture_2);
331 |     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, 64, 64, 0, gl.RGBA, gl.FLOAT, new Float32Array(g_ltc_2));
332 |     SetClampedTextureState();
333 | 
334 |     // Fetch media and kick off the main program once everything has loaded
335 |     $(function() {
336 |         $(document).ajaxStop(function() {
337 |             $(this).unbind("ajaxStop");
338 |             main_prog();
339 |         });
340 | 
341 |         // Load data here
342 | 
343 |         main_prog();
344 |     });
345 | }
346 | 
347 | 
348 | function onWindowResize(event) {
349 |     $("#peekaboo").css("height", window.innerHeight);
350 |     $("#stuff").css("height", window.innerHeight);
351 | 
352 |     canvas.width  = 512; // window.innerWidth;
353 |     canvas.height = 512; // window.innerHeight;
354 | 
355 |     parameters.screenWidth = canvas.width;
356 |     parameters.screenHeight = canvas.height;
357 | 
358 |     gl.viewport(0, 0, canvas.width, canvas.height);
359 | }
360 | 
361 | 
362 | function glUniformTypeToString(type) {
363 |     switch (type) {
364 |         case gl.FLOAT:        return "FLOAT";
365 |         case gl.FLOAT_VEC2:   return "FLOAT_VEC2";
366 |         case gl.FLOAT_VEC3:   return "FLOAT_VEC3";
367 |         case gl.FLOAT_VEC4:   return "FLOAT_VEC4";
368 |         case gl.INT:          return "INT";
369 |         case gl.INT_VEC2:     return "INT_VEC2";
370 |         case gl.INT_VEC3:     return "INT_VEC3";
371 |         case gl.INT_VEC4:     return "INT_VEC4";
372 |         case gl.BOOL:         return "BOOL";
373 |         case gl.BOOL_VEC2:    return "BOOL_VEC2";
374 |         case gl.BOOL_VEC3:    return "BOOL_VEC3";
375 |         case gl.BOOL_VEC4:    return "BOOL_VEC4";
376 |         case gl.FLOAT_MAT2:   return "FLOAT_MAT2";
377 |         case gl.FLOAT_MAT3:   return "FLOAT_MAT3";
378 |         case gl.FLOAT_MAT4:   return "FLOAT_MAT4";
379 |         case gl.SAMPLER_2D:   return "SAMPLER_2D";
380 |         case gl.SAMPLER_CUBE: return "SAMPLER_CUBE";
381 |     }
382 | 
383 |     return "unknown";
384 | }
385 | 
386 | 
387 | function createProgram(vertex, fragment) {
388 |     var header = "#version 300 es\nprecision highp float;\n#line 0\n";
389 |     vertex   = header + vertex;
390 |     fragment = header + fragment;
391 | 
392 |     var program = gl.createProgram();
393 | 
394 |     var vs = createShader(vertex, gl.VERTEX_SHADER);
395 |     var fs = createShader(fragment, gl.FRAGMENT_SHADER);
396 | 
397 |     if (vs == null || fs == null)
398 |         return null;
399 | 
400 |     gl.attachShader(program, vs);
401 |     gl.attachShader(program, fs);
402 | 
403 |     gl.deleteShader(vs);
404 |     gl.deleteShader(fs);
405 | 
406 |     gl.linkProgram(program);
407 | 
408 | 
409 |     if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
410 | /*
411 |         alert( "ERROR:\n" +
412 |         "VALIDATE_STATUS: " + gl.getProgramParameter( program, gl.VALIDATE_STATUS ) + "\n" +
413 |         "ERROR: " + gl.getError() + "\n\n" +
414 |         "- Vertex Shader -\n" + vertex + "\n\n" +
415 |         "- Fragment Shader -\n" + fragment );
416 | */
417 |         return null;
418 |     }
419 | 
420 | 
421 |     var control_names = new Array();
422 |     var controls = {};
423 | 
424 |     var lines = fragment.split("\n");
425 | 
426 |     var bindings = { }
427 | 
428 |     // Adds double quotes around labels
429 |     function preprocessJSON(str) {
430 |         return str.replace(/("(\\.|[^"])*"|'(\\.|[^'])*')|(\w+)\s*:/g,
431 |         function(all, string, strDouble, strSingle, jsonLabel) {
432 |             if (jsonLabel) {
433 |                 return '"' + jsonLabel + '": ';
434 |             }
435 |             return all;
436 |         });
437 |     }
438 | 
439 |     for (var x in lines) {
440 |         var line = lines[x];
441 |         var re = /^\/\/ bind\s+(.*?)\s(.*)/;
442 |         var m = re.exec(line);
443 |         if (m) {
444 |             try {
445 |                 var obj = $.parseJSON(preprocessJSON(m[2]));
446 |                 bindings[m[1]] = obj;
447 |                 control_names.push(m[1]);
448 |             }
449 |             catch (e) {
450 |                 console.log("Failed to parse shader binding: " + m[1]);
451 |             }
452 |         }
453 |     }
454 | 
455 |     function CopyProperties(src, dest) {
456 |         for (x in src) {
457 |             if (dest.hasOwnProperty(x) && typeof(dest[x]) === typeof(src[x]))
458 |                 dest[x] = src[x];
459 |         }
460 |     }
461 | 
462 |     // Destroy existing children
463 |     var container = $("#params");
464 | 
465 |     var children = container.children();
466 |     children.each(function() {
467 |         var v = $(this);
468 |         v.detach();
469 |     })
470 |     container.empty();
471 | 
472 |     g_param_types = {};
473 | 
474 |     var nb_uniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
475 |     for (var i = 0; i < nb_uniforms; i++) {
476 |         var uni = gl.getActiveUniform(program, i);
477 | 
478 |         var label = uni.name;
479 |         var bind = bindings[uni.name];
480 |         if (bind && typeof(bind.label) === "string")
481 |             label = bind.label;
482 | 
483 |         var old_value  = g_params[uni.name];
484 |         var is_default = !g_param_edited[uni.name];
485 |         var new_value  = undefined;
486 | 
487 |         var control = undefined;
488 | 
489 |         if (uni.type === gl.FLOAT) {
490 |             var state = {
491 |                 default : 1.0,
492 |                 min  : 0.0,
493 |                 max  : 1.0,
494 |                 step : 0.01,
495 |             };
496 | 
497 |             CopyProperties(bind, state);
498 | 
499 |             var is_default = !g_param_edited[uni.name];
500 | 
501 |             new_value = is_default ? state.default : old_value;
502 |             control = bindSlider(uni.name, label, state.default, new_value, state);
503 |         }
504 |         else if (uni.type === gl.FLOAT_VEC3) {
505 |             var def_col = new Color(1, 1, 1)
506 | 
507 |             CopyProperties(bind, def_col);
508 | 
509 |             new_value = is_default ? def_col : old_value;
510 |             control = bindPicker(uni.name, label, def_col, new_value);
511 |         }
512 |         else if (uni.type === gl.BOOL) {
513 |             var def_val = true;
514 | 
515 |             if (bind && typeof(bind.default) === "boolean")
516 |                 def_val = bind.default;
517 | 
518 |             g_param_default[uni.name] = def_val;
519 | 
520 |             new_value = is_default ? def_val : old_value;
521 |             control = bindCheckbox(uni.name, label, new_value);
522 |         }
523 |         else {
524 |             continue;
525 |         }
526 | 
527 |         g_param_types[uni.name] = uni.type;
528 |         g_params[uni.name] = new_value;
529 | 
530 |         if (bind === undefined)
531 |             control_names.push(uni.name);
532 |         controls[uni.name] = control;
533 |     }
534 | 
535 |     // Finally add the controls to the page
536 |     for (x in control_names) {
537 |         var control = controls[control_names[x]];
538 | 
539 |         // Skip any binds that don't reference active uniforms
540 |         if (control === undefined)
541 |             continue;
542 | 
543 |         // Pad for next element
544 |         control.css("margin", "0 0 6px 0");
545 | 
546 |         container.append(control);
547 |     }
548 | 
549 |     return program;
550 | }
551 | 
552 | 
553 | var gl_shader_error = null;
554 | 
555 | function createShader(src, type) {
556 |     var shader = gl.createShader(type);
557 | 
558 |     gl.shaderSource(shader, src);
559 |     gl.compileShader(shader);
560 | 
561 |     gl_shader_error = null;
562 | 
563 |     if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
564 |         gl_shader_error = gl.getShaderInfoLog(shader);
565 | //      console.log((type == gl.VERTEX_SHADER ? "VERTEX" : "FRAGMENT") + " SHADER:\n" + gl.getShaderInfoLog(shader));
566 |         return null;
567 |     }
568 | 
569 |     return shader;
570 | }
571 | 
572 | 
573 | function animate() {
574 |     requestAnimationFrame(animate);
575 |     draw();
576 | }
577 | 
578 | function main_prog() {
579 |     controller = new CameraController(canvas);
580 |     // Try the following (and uncomment the "pointer-events: none;" in
581 |     // the index.html) to try the more precise hit detection
582 |     //  controller = new CameraController(document.getElementById("body"), c, gl);
583 |     controller.onchange = function(xRot, yRot) {
584 |         draw();
585 |         g_sample_count = 0;
586 |     };
587 | 
588 |     requestAnimationFrame(animate);
589 | 
590 |     draw();
591 | }
592 | 
593 | 
594 | function checkGLError() {
595 |     var error = gl.getError();
596 |     if (error != gl.NO_ERROR) {
597 |         var str = "GL Error: " + error + " " + gl.enum_strings[error];
598 |         console.log(str);
599 |         throw str;
600 |     }
601 | }
602 | 
603 | 
604 | function draw() {
605 |     parameters.time = new Date().getTime() - parameters.start_time;
606 | 
607 |     gl.enable(gl.DEPTH_TEST);
608 |     gl.clearColor(0.0, 0.0, 0.0, 0.0);
609 | 
610 |     // Note: the viewport is automatically set up to cover the entire Canvas.
611 |     gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
612 | 
613 |     checkGLError();
614 | 
615 |     // Load program into GPU
616 |     gl.useProgram(currentProgram);
617 | 
618 |     checkGLError();
619 | 
620 |     // Add in camera controller's rotation
621 |     view.loadIdentity();
622 |     view.translate(0, 6, 0.1*g_zoom - 0.5);
623 |     view.rotate(controller.xRot - 10.0, 1, 0, 0);
624 |     view.rotate(controller.yRot, 0, 1, 0);;
625 | 
626 |     // Get var locations
627 |     vertexPositionLocation = gl.getAttribLocation(currentProgram, "position");
628 | 
629 |     function location(u) {
630 |         return gl.getUniformLocation(currentProgram, u);
631 |     }
632 | 
633 |     // Set values to program variables
634 |     for (var x in g_params) {
635 |         var type  = g_param_types[x];
636 |         var value = g_params[x];
637 |         var loc   = location(x);
638 | 
639 |         if (type === gl.FLOAT)      gl.uniform1f(loc, value);
640 |         if (type === gl.FLOAT_VEC3) gl.uniform3f(loc, value.r, value.g, value.b);
641 |         if (type === gl.BOOL)       gl.uniform1i(loc, value);
642 |     }
643 | 
644 |     gl.uniformMatrix4fv(location("view"), false, new Float32Array(view.elements));
645 |     gl.uniform1f(location("time"), parameters.time/1000);
646 |     gl.uniform2f(location("resolution"), parameters.screenWidth, parameters.screenHeight);
647 | 
648 |     gl.activeTexture(gl.TEXTURE0);
649 |     gl.bindTexture(gl.TEXTURE_2D, ltc_texture_1);
650 |     gl.uniform1i(gl.getUniformLocation(currentProgram, "ltc_1"), 0);
651 | 
652 |     gl.activeTexture(gl.TEXTURE1);
653 |     gl.bindTexture(gl.TEXTURE_2D, ltc_texture_2);
654 |     gl.uniform1i(gl.getUniformLocation(currentProgram, "ltc_2"), 1);
655 | 
656 |     checkGLError();
657 | 
658 |     gl.bindFramebuffer(gl.FRAMEBUFFER, rttFramebuffer);
659 | 
660 |     if (g_sample_count === 0) {
661 |         gl.clearColor(0, 0, 0, 0);
662 |         gl.clear(gl.COLOR_BUFFER_BIT);
663 |     }
664 | 
665 |     gl.uniform1i(location("sampleCount"), g_sample_count);
666 |     g_sample_count += 8;
667 | 
668 |     gl.enable(gl.BLEND);
669 |     gl.blendFunc(gl.ONE, gl.ONE);
670 | 
671 |     // Render geometry
672 |     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
673 |     gl.vertexAttribPointer(vertexPositionLocation, 2, gl.FLOAT, false, 0, 0);
674 |     gl.enableVertexAttribArray(vertexPositionLocation);
675 |     gl.drawArrays(gl.TRIANGLES, 0, 6);
676 |     gl.disableVertexAttribArray(vertexPositionLocation);
677 | 
678 |     gl.bindFramebuffer(gl.FRAMEBUFFER, null);
679 |     gl.useProgram(blitProgram);
680 | 
681 |     gl.disable(gl.BLEND);
682 | 
683 |     // Set textures
684 |     gl.activeTexture(gl.TEXTURE0);
685 |     gl.bindTexture(gl.TEXTURE_2D, rttTexture);
686 |     gl.uniform1i(gl.getUniformLocation(blitProgram, "tex"), 0);
687 | 
688 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
689 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
690 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S,     gl.CLAMP_TO_EDGE);
691 |     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T,     gl.CLAMP_TO_EDGE);
692 | 
693 |     gl.uniform2f(gl.getUniformLocation(blitProgram, "resolution"), parameters.screenWidth, parameters.screenHeight);
694 | 
695 |     // Blit pass
696 |     gl.enableVertexAttribArray(vertexPositionLocation);
697 |     gl.drawArrays(gl.TRIANGLES, 0, 6);
698 |     gl.disableVertexAttribArray(vertexPositionLocation);
699 | 
700 |     gl.bindTexture(gl.TEXTURE_2D, null);
701 | }
702 | </script>
703 | 
704 | 
705 | <script>
706 | window.onload = function() {
707 |     init();
708 | 
709 |     $("#peekaboo").resizable({ minWidth: 500 });
710 |     $("#peekaboo").show();
711 | 
712 |     var editor = ace.edit("editor");
713 |     editor.setTheme("ace/theme/clouds_midnight");
714 | 
715 |     var Mode = require("ace/mode/glsl").Mode;
716 |     editor.getSession().setMode(new Mode());
717 |     editor.getSession().setUseWrapMode(true);
718 |     editor.getSession().setOption("firstLineNumber", 0);
719 |     editor.setShowPrintMargin(false);
720 | 
721 |     editor.renderer.setHScrollBarAlwaysVisible(false);
722 |     editor.renderer.setVScrollBarAlwaysVisible(false);
723 | 
724 |     var markers = [];
725 | 
726 |     var nb_sliders = 0;
727 | 
728 |     var timeout = null;
729 | 
730 |     $("#peekaboo").bind("resize", function(event, ui) {
731 |         editor.resize();
732 |     });
733 | 
734 |     $("#peekaboo").css("height", window.innerHeight);
735 | 
736 |     $("#stuff").show();
737 | 
738 |     var rebuild = function() {
739 |         var vertex_shader, fragment_shader;
740 |         var new_prog;
741 |         var text = editor.getSession().getValue();
742 | 
743 |         vertex_shader   = g_vshader;
744 |         fragment_shader = text;
745 | 
746 |         editor.getSession().clearAnnotations();
747 |         for (m in markers) {
748 |             editor.getSession().removeMarker(markers[m]);
749 |         }
750 |         markers = [];
751 | 
752 |         new_prog = createProgram(vertex_shader, fragment_shader);
753 | 
754 |         var status_color = new_prog ? "#404040" : "#7f0000"
755 |         $("#status").css("border-color", status_color);
756 | 
757 |         marked_lines = [];
758 | 
759 |         var text = "Compiled successfully!";
760 | 
761 |         if (new_prog !== null) {
762 |             currentProgram = new_prog;
763 |         }
764 |         else if (gl_shader_error !== null) {
765 |             gl_shader_error = gl_shader_error.replace(/\0/g, "");
766 |             text = gl_shader_error.replace(/\n/g, "<br>");
767 | 
768 |             var annos = [];
769 | 
770 |             var re = /\d+:(\d+):(.*)\n/g;
771 |             var match;
772 |             while (match = re.exec(gl_shader_error)) {
773 |                 var line = parseInt(match[1]);
774 |                 var error = match[2];
775 | 
776 |                 if (marked_lines[line]) {
777 |                     error = " **** " + error;
778 |                 }
779 | 
780 |                 annos.push({
781 |                   row: line,
782 |                   column: 0,
783 |                   text: error,
784 |                   type: "error"
785 |                 });
786 | 
787 |                 if (marked_lines[line] === undefined) {
788 |                     marked_lines[line] = true;
789 | 
790 |                     var Range = require("ace/range").Range;
791 |                     var line_range = new Range(line, 0, line + 1, 0);
792 | 
793 |                     var marker = editor.getSession().addMarker(line_range, "ace_error", "line", false);
794 |                     markers.push(marker);
795 |                 }
796 |             }
797 | 
798 |             editor.getSession().setAnnotations(annos);
799 |         }
800 | 
801 |         $("#status_text").html(text);
802 | 
803 |         g_sample_count = 0;
804 |     }
805 | 
806 |     $("#editor").keyup(function() {
807 |         clearTimeout(timeout);
808 |         timeout = setTimeout(rebuild, 500);
809 |     });
810 | }
811 | </script>
812 | 
813 | </body>
814 | </html>
815 | 


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