├── AntiGravityPool.html
├── LICENSE
├── README.md
├── css
└── default.css
├── js
├── AntiGravityPool.js
├── InitCommon.js
├── MobileJoystickControls.js
├── PathTracingCommon.js
├── lil-gui.module.min.js
├── oimo.min.js
├── stats.module.js
├── three.core.min.js
└── three.module.min.js
├── shaders
├── AntiGravityPool_Fragment.glsl
├── AntiGravityPool_Fragment_Mobile.glsl
├── ScreenCopy_Fragment.glsl
├── ScreenOutput_Fragment.glsl
└── common_PathTracing_Vertex.glsl
├── sounds
├── chalk.mp3
├── click.mp3
├── click2.mp3
├── cuestick.mp3
├── ping_pong.mp3
├── pocket.mp3
├── rack.mp3
└── rail.mp3
└── textures
└── BlueNoise_R_128.png
/AntiGravityPool.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Anti-Gravity Pool (a fully path traced game)
5 |
30 | Play
31 |
32 |
33 |
34 |
35 | Anti-Gravity Pool (a fully path traced game)
36 |
37 |
38 |
39 | Desktop: press SPACEBAR to start shot
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Creative Commons Legal Code
2 |
3 | CC0 1.0 Universal
4 |
5 | CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
6 | LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
7 | ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
8 | INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
9 | REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
10 | PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
11 | THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
12 | HEREUNDER.
13 |
14 | Statement of Purpose
15 |
16 | The laws of most jurisdictions throughout the world automatically confer
17 | exclusive Copyright and Related Rights (defined below) upon the creator
18 | and subsequent owner(s) (each and all, an "owner") of an original work of
19 | authorship and/or a database (each, a "Work").
20 |
21 | Certain owners wish to permanently relinquish those rights to a Work for
22 | the purpose of contributing to a commons of creative, cultural and
23 | scientific works ("Commons") that the public can reliably and without fear
24 | of later claims of infringement build upon, modify, incorporate in other
25 | works, reuse and redistribute as freely as possible in any form whatsoever
26 | and for any purposes, including without limitation commercial purposes.
27 | These owners may contribute to the Commons to promote the ideal of a free
28 | culture and the further production of creative, cultural and scientific
29 | works, or to gain reputation or greater distribution for their Work in
30 | part through the use and efforts of others.
31 |
32 | For these and/or other purposes and motivations, and without any
33 | expectation of additional consideration or compensation, the person
34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she
35 | is an owner of Copyright and Related Rights in the Work, voluntarily
36 | elects to apply CC0 to the Work and publicly distribute the Work under its
37 | terms, with knowledge of his or her Copyright and Related Rights in the
38 | Work and the meaning and intended legal effect of CC0 on those rights.
39 |
40 | 1. Copyright and Related Rights. A Work made available under CC0 may be
41 | protected by copyright and related or neighboring rights ("Copyright and
42 | Related Rights"). Copyright and Related Rights include, but are not
43 | limited to, the following:
44 |
45 | i. the right to reproduce, adapt, distribute, perform, display,
46 | communicate, and translate a Work;
47 | ii. moral rights retained by the original author(s) and/or performer(s);
48 | iii. publicity and privacy rights pertaining to a person's image or
49 | likeness depicted in a Work;
50 | iv. rights protecting against unfair competition in regards to a Work,
51 | subject to the limitations in paragraph 4(a), below;
52 | v. rights protecting the extraction, dissemination, use and reuse of data
53 | in a Work;
54 | vi. database rights (such as those arising under Directive 96/9/EC of the
55 | European Parliament and of the Council of 11 March 1996 on the legal
56 | protection of databases, and under any national implementation
57 | thereof, including any amended or successor version of such
58 | directive); and
59 | vii. other similar, equivalent or corresponding rights throughout the
60 | world based on applicable law or treaty, and any national
61 | implementations thereof.
62 |
63 | 2. Waiver. To the greatest extent permitted by, but not in contravention
64 | of, applicable law, Affirmer hereby overtly, fully, permanently,
65 | irrevocably and unconditionally waives, abandons, and surrenders all of
66 | Affirmer's Copyright and Related Rights and associated claims and causes
67 | of action, whether now known or unknown (including existing as well as
68 | future claims and causes of action), in the Work (i) in all territories
69 | worldwide, (ii) for the maximum duration provided by applicable law or
70 | treaty (including future time extensions), (iii) in any current or future
71 | medium and for any number of copies, and (iv) for any purpose whatsoever,
72 | including without limitation commercial, advertising or promotional
73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
74 | member of the public at large and to the detriment of Affirmer's heirs and
75 | successors, fully intending that such Waiver shall not be subject to
76 | revocation, rescission, cancellation, termination, or any other legal or
77 | equitable action to disrupt the quiet enjoyment of the Work by the public
78 | as contemplated by Affirmer's express Statement of Purpose.
79 |
80 | 3. Public License Fallback. Should any part of the Waiver for any reason
81 | be judged legally invalid or ineffective under applicable law, then the
82 | Waiver shall be preserved to the maximum extent permitted taking into
83 | account Affirmer's express Statement of Purpose. In addition, to the
84 | extent the Waiver is so judged Affirmer hereby grants to each affected
85 | person a royalty-free, non transferable, non sublicensable, non exclusive,
86 | irrevocable and unconditional license to exercise Affirmer's Copyright and
87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the
88 | maximum duration provided by applicable law or treaty (including future
89 | time extensions), (iii) in any current or future medium and for any number
90 | of copies, and (iv) for any purpose whatsoever, including without
91 | limitation commercial, advertising or promotional purposes (the
92 | "License"). The License shall be deemed effective as of the date CC0 was
93 | applied by Affirmer to the Work. Should any part of the License for any
94 | reason be judged legally invalid or ineffective under applicable law, such
95 | partial invalidity or ineffectiveness shall not invalidate the remainder
96 | of the License, and in such case Affirmer hereby affirms that he or she
97 | will not (i) exercise any of his or her remaining Copyright and Related
98 | Rights in the Work or (ii) assert any associated claims and causes of
99 | action with respect to the Work, in either case contrary to Affirmer's
100 | express Statement of Purpose.
101 |
102 | 4. Limitations and Disclaimers.
103 |
104 | a. No trademark or patent rights held by Affirmer are waived, abandoned,
105 | surrendered, licensed or otherwise affected by this document.
106 | b. Affirmer offers the Work as-is and makes no representations or
107 | warranties of any kind concerning the Work, express, implied,
108 | statutory or otherwise, including without limitation warranties of
109 | title, merchantability, fitness for a particular purpose, non
110 | infringement, or the absence of latent or other defects, accuracy, or
111 | the present or absence of errors, whether or not discoverable, all to
112 | the greatest extent permissible under applicable law.
113 | c. Affirmer disclaims responsibility for clearing rights of other persons
114 | that may apply to the Work or any use thereof, including without
115 | limitation any person's Copyright and Related Rights in the Work.
116 | Further, Affirmer disclaims responsibility for obtaining any necessary
117 | consents, permissions or other rights required for any use of the
118 | Work.
119 | d. Affirmer understands and acknowledges that Creative Commons is not a
120 | party to this document and has no duty or obligation with respect to
121 | this CC0 or use of the Work.
122 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # AntiGravity-Pool
2 | The first real-time pathtraced game for desktop and mobile using WebGL. Desktop Controls
7 |
8 | * Click anywhere to capture mouse
9 | * move Mouse to aim cueball
10 | * Mousewheel to dolly camera in or out
11 | * SPACEBAR to enter shot mode. Power will oscillate up and down
12 | * SPACEBAR again to shoot!
13 | * when shot has been made and balls are moving, WASD to fly around the scene
14 | Mobile Controls
17 |
18 | * Swipe to aim cueball
19 | * Pinch to dolly camera in or out
20 | * small up button above directional controls to enter shot mode. Power will oscillate
21 | * small up button again to shoot!
22 | * when shot has been made and balls are moving, directional arrows to fly around the scene
23 |
24 | TODO
25 |
26 | * Squash sound fx bug due to the physics engine continually reporting collisions between balls and between balls and rails/walls. This results in sound fx playing repeatedly until the offending ball is pocketed. This bug is highly annoying so it gets the highest priority!
27 | * Create simple banners to display game state (for example, "Player 1 Wins!")
28 | * Create widgets to display current target-ball color (red, yellow, or black), as well as shot power meterABOUT
31 |
32 | * To my knowledge in 2019 this is the first real-time fully path traced game for all devices with a browser, including mobile. The technology behind this simple game is a combination of my three.js path tracing [project](https://github.com/erichlof/THREE.js-PathTracing-Renderer), physics simulation through [Oimo.js](https://github.com/lo-th/Oimo.js), and the WebAudio API for sound effects. The goal of this project is enabling path traced real-time games for all players, regardless of their system specs and GPU power. {this._setDraggingStyle(!1,"vertical"),this._callOnFinishChange(),window.removeEventListener("mousemove",o),window.removeEventListener("mouseup",a)};this.$input.addEventListener("input",()=>{let t=parseFloat(this.$input.value);isNaN(t)||(this._stepExplicit&&(t=this._snap(t)),this.setValue(this._clamp(t)))}),this.$input.addEventListener("keydown",i=>{"Enter"===i.code&&this.$input.blur(),"ArrowUp"===i.code&&(i.preventDefault(),t(this._step*this._arrowKeyMultiplier(i))),"ArrowDown"===i.code&&(i.preventDefault(),t(this._step*this._arrowKeyMultiplier(i)*-1))}),this.$input.addEventListener("wheel",i=>{this._inputFocused&&(i.preventDefault(),t(this._step*this._normalizeMouseWheel(i)))},{passive:!1}),this.$input.addEventListener("mousedown",t=>{i=t.clientX,e=s=t.clientY,r=!0,n=this.getValue(),l=0,window.addEventListener("mousemove",o),window.addEventListener("mouseup",a)}),this.$input.addEventListener("focus",()=>{this._inputFocused=!0}),this.$input.addEventListener("blur",()=>{this._inputFocused=!1,this.updateDisplay(),this._callOnFinishChange()})}_initSlider(){this._hasSlider=!0,this.$slider=document.createElement("div"),this.$slider.classList.add("slider"),this.$fill=document.createElement("div"),this.$fill.classList.add("fill"),this.$slider.appendChild(this.$fill),this.$widget.insertBefore(this.$slider,this.$input),this.domElement.classList.add("hasSlider");const t=t=>{const i=this.$slider.getBoundingClientRect();let e=(s=t,n=i.left,l=i.right,r=this._min,o=this._max,(s-n)/(l-n)*(o-r)+r);var s,n,l,r,o;this._snapClampSetValue(e)},i=i=>{t(i.clientX)},e=()=>{this._callOnFinishChange(),this._setDraggingStyle(!1),window.removeEventListener("mousemove",i),window.removeEventListener("mouseup",e)};let s,n,l=!1;const r=i=>{i.preventDefault(),this._setDraggingStyle(!0),t(i.touches[0].clientX),l=!1},o=i=>{if(l){const t=i.touches[0].clientX-s,e=i.touches[0].clientY-n;Math.abs(t)>Math.abs(e)?r(i):(window.removeEventListener("touchmove",o),window.removeEventListener("touchend",a))}else i.preventDefault(),t(i.touches[0].clientX)},a=()=>{this._callOnFinishChange(),this._setDraggingStyle(!1),window.removeEventListener("touchmove",o),window.removeEventListener("touchend",a)},h=this._callOnFinishChange.bind(this);let d;this.$slider.addEventListener("mousedown",s=>{this._setDraggingStyle(!0),t(s.clientX),window.addEventListener("mousemove",i),window.addEventListener("mouseup",e)}),this.$slider.addEventListener("touchstart",t=>{t.touches.length>1||(this._hasScrollBar?(s=t.touches[0].clientX,n=t.touches[0].clientY,l=!0):r(t),window.addEventListener("touchmove",o,{passive:!1}),window.addEventListener("touchend",a))},{passive:!1}),this.$slider.addEventListener("wheel",t=>{if(Math.abs(t.deltaX)this._max&&(t=this._max),t}_snapClampSetValue(t){this.setValue(this._clamp(this._snap(t)))}get _hasScrollBar(){const t=this.parent.root.$children;return t.scrollHeight>t.clientHeight}get _hasMin(){return void 0!==this._min}get _hasMax(){return void 0!==this._max}}class c extends t{constructor(t,i,e,s){super(t,i,e,"option"),this.$select=document.createElement("select"),this.$select.setAttribute("aria-labelledby",this.$name.id),this.$display=document.createElement("div"),this.$display.classList.add("display"),this._values=Array.isArray(s)?s:Object.values(s),this._names=Array.isArray(s)?s:Object.keys(s),this._names.forEach(t=>{const i=document.createElement("option");i.innerHTML=t,this.$select.appendChild(i)}),this.$select.addEventListener("change",()=>{this.setValue(this._values[this.$select.selectedIndex]),this._callOnFinishChange()}),this.$select.addEventListener("focus",()=>{this.$display.classList.add("focus")}),this.$select.addEventListener("blur",()=>{this.$display.classList.remove("focus")}),this.$widget.appendChild(this.$select),this.$widget.appendChild(this.$display),this.$disable=this.$select,this.updateDisplay()}updateDisplay(){const t=this.getValue(),i=this._values.indexOf(t);return this.$select.selectedIndex=i,this.$display.innerHTML=-1===i?t:this._names[i],this}}class u extends t{constructor(t,i,e){super(t,i,e,"string"),this.$input=document.createElement("input"),this.$input.setAttribute("type","text"),this.$input.setAttribute("aria-labelledby",this.$name.id),this.$input.addEventListener("input",()=>{this.setValue(this.$input.value)}),this.$input.addEventListener("keydown",t=>{"Enter"===t.code&&this.$input.blur()}),this.$input.addEventListener("blur",()=>{this._callOnFinishChange()}),this.$widget.appendChild(this.$input),this.$disable=this.$input,this.updateDisplay()}updateDisplay(){return this.$input.value=this.getValue(),this}}let p=!1;class g{constructor({parent:t,autoPlace:i=void 0===t,container:e,width:s,title:n="Controls",injectStyles:l=!0,touchStyles:r=!0}={}){if(this.parent=t,this.root=t?t.root:this,this.children=[],this.controllers=[],this.folders=[],this._closed=!1,this._hidden=!1,this.domElement=document.createElement("div"),this.domElement.classList.add("lil-gui"),this.$title=document.createElement("div"),this.$title.classList.add("title"),this.$title.setAttribute("role","button"),this.$title.setAttribute("aria-expanded",!0),this.$title.setAttribute("tabindex",0),this.$title.addEventListener("click",()=>this.openAnimated(this._closed)),this.$title.addEventListener("keydown",t=>{"Enter"!==t.code&&"Space"!==t.code||(t.preventDefault(),this.$title.click())}),this.$title.addEventListener("touchstart",()=>{},{passive:!0}),this.$children=document.createElement("div"),this.$children.classList.add("children"),this.domElement.appendChild(this.$title),this.domElement.appendChild(this.$children),this.title(n),r&&this.domElement.classList.add("allow-touch-styles"),this.parent)return this.parent.children.push(this),this.parent.folders.push(this),void this.parent.$children.appendChild(this.domElement);this.domElement.classList.add("root"),!p&&l&&(!function(t){const i=document.createElement("style");i.innerHTML=t;const e=document.querySelector("head link[rel=stylesheet], head style");e?document.head.insertBefore(i,e):document.head.appendChild(i)}('.lil-gui{--background-color:#1f1f1f;--text-color:#ebebeb;--title-background-color:#111;--title-text-color:#ebebeb;--widget-color:#424242;--hover-color:#4f4f4f;--focus-color:#595959;--number-color:#2cc9ff;--string-color:#a2db3c;--font-size:11px;--input-font-size:11px;--font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Arial,sans-serif;--font-family-mono:Menlo,Monaco,Consolas,"Droid Sans Mono",monospace;--padding:4px;--spacing:4px;--widget-height:20px;--name-width:45%;--slider-knob-width:2px;--slider-input-width:27%;--color-input-width:27%;--slider-input-min-width:45px;--color-input-min-width:45px;--folder-indent:7px;--widget-padding:0 0 0 3px;--widget-border-radius:2px;--checkbox-size:calc(var(--widget-height)*0.75);--scrollbar-width:5px;background-color:var(--background-color);color:var(--text-color);font-family:var(--font-family);font-size:var(--font-size);font-style:normal;font-weight:400;line-height:1;text-align:left;touch-action:manipulation;user-select:none;-webkit-user-select:none}.lil-gui,.lil-gui *{box-sizing:border-box;margin:0;padding:0}.lil-gui.root{display:flex;flex-direction:column;width:var(--width,245px)}.lil-gui.root>.title{background:var(--title-background-color);color:var(--title-text-color)}.lil-gui.root>.children{overflow-x:hidden;overflow-y:auto}.lil-gui.root>.children::-webkit-scrollbar{background:var(--background-color);height:var(--scrollbar-width);width:var(--scrollbar-width)}.lil-gui.root>.children::-webkit-scrollbar-thumb{background:var(--focus-color);border-radius:var(--scrollbar-width)}.lil-gui.force-touch-styles{--widget-height:28px;--padding:6px;--spacing:6px;--font-size:13px;--input-font-size:16px;--folder-indent:10px;--scrollbar-width:7px;--slider-input-min-width:50px;--color-input-min-width:65px}.lil-gui.autoPlace{max-height:100%;position:fixed;right:15px;top:0;z-index:1001}.lil-gui .controller{align-items:center;display:flex;margin:var(--spacing) 0;padding:0 var(--padding)}.lil-gui .controller.disabled{opacity:.5}.lil-gui .controller.disabled,.lil-gui .controller.disabled *{pointer-events:none!important}.lil-gui .controller>.name{flex-shrink:0;line-height:var(--widget-height);min-width:var(--name-width);padding-right:var(--spacing);white-space:pre}.lil-gui .controller .widget{align-items:center;display:flex;min-height:var(--widget-height);position:relative;width:100%}.lil-gui .controller.string input{color:var(--string-color)}.lil-gui .controller.boolean .widget{cursor:pointer}.lil-gui .controller.color .display{border-radius:var(--widget-border-radius);height:var(--widget-height);position:relative;width:100%}.lil-gui .controller.color input[type=color]{cursor:pointer;height:100%;opacity:0;width:100%}.lil-gui .controller.color input[type=text]{flex-shrink:0;font-family:var(--font-family-mono);margin-left:var(--spacing);min-width:var(--color-input-min-width);width:var(--color-input-width)}.lil-gui .controller.option select{max-width:100%;opacity:0;position:absolute;width:100%}.lil-gui .controller.option .display{background:var(--widget-color);border-radius:var(--widget-border-radius);height:var(--widget-height);line-height:var(--widget-height);max-width:100%;overflow:hidden;padding-left:.55em;padding-right:1.75em;pointer-events:none;position:relative;word-break:break-all}.lil-gui .controller.option .display.active{background:var(--focus-color)}.lil-gui .controller.option .display:after{bottom:0;content:"↕";font-family:lil-gui;padding-right:.375em;position:absolute;right:0;top:0}.lil-gui .controller.option .widget,.lil-gui .controller.option select{cursor:pointer}.lil-gui .controller.number input{color:var(--number-color)}.lil-gui .controller.number.hasSlider input{flex-shrink:0;margin-left:var(--spacing);min-width:var(--slider-input-min-width);width:var(--slider-input-width)}.lil-gui .controller.number .slider{background-color:var(--widget-color);border-radius:var(--widget-border-radius);cursor:ew-resize;height:var(--widget-height);overflow:hidden;padding-right:var(--slider-knob-width);touch-action:pan-y;width:100%}.lil-gui .controller.number .slider.active{background-color:var(--focus-color)}.lil-gui .controller.number .slider.active .fill{opacity:.95}.lil-gui .controller.number .fill{border-right:var(--slider-knob-width) solid var(--number-color);box-sizing:content-box;height:100%}.lil-gui-dragging .lil-gui{--hover-color:var(--widget-color)}.lil-gui-dragging *{cursor:ew-resize!important}.lil-gui-dragging.lil-gui-vertical *{cursor:ns-resize!important}.lil-gui .title{--title-height:calc(var(--widget-height) + var(--spacing)*1.25);-webkit-tap-highlight-color:transparent;text-decoration-skip:objects;cursor:pointer;font-weight:600;height:var(--title-height);line-height:calc(var(--title-height) - 4px);outline:none;padding:0 var(--padding)}.lil-gui .title:before{content:"▾";display:inline-block;font-family:lil-gui;padding-right:2px}.lil-gui .title:active{background:var(--title-background-color);opacity:.75}.lil-gui.root>.title:focus{text-decoration:none!important}.lil-gui.closed>.title:before{content:"▸"}.lil-gui.closed>.children{opacity:0;transform:translateY(-7px)}.lil-gui.closed:not(.transition)>.children{display:none}.lil-gui.transition>.children{overflow:hidden;pointer-events:none;transition-duration:.3s;transition-property:height,opacity,transform;transition-timing-function:cubic-bezier(.2,.6,.35,1)}.lil-gui .children:empty:before{content:"Empty";display:block;font-style:italic;height:var(--widget-height);line-height:var(--widget-height);margin:var(--spacing) 0;opacity:.5;padding:0 var(--padding)}.lil-gui.root>.children>.lil-gui>.title{border-width:0;border-bottom:1px solid var(--widget-color);border-left:0 solid var(--widget-color);border-right:0 solid var(--widget-color);border-top:1px solid var(--widget-color);transition:border-color .3s}.lil-gui.root>.children>.lil-gui.closed>.title{border-bottom-color:transparent}.lil-gui+.controller{border-top:1px solid var(--widget-color);margin-top:0;padding-top:var(--spacing)}.lil-gui .lil-gui .lil-gui>.title{border:none}.lil-gui .lil-gui .lil-gui>.children{border:none;border-left:2px solid var(--widget-color);margin-left:var(--folder-indent)}.lil-gui .lil-gui .controller{border:none}.lil-gui input{-webkit-tap-highlight-color:transparent;background:var(--widget-color);border:0;border-radius:var(--widget-border-radius);color:var(--text-color);font-family:var(--font-family);font-size:var(--input-font-size);height:var(--widget-height);outline:none;width:100%}.lil-gui input:disabled{opacity:1}.lil-gui input[type=number],.lil-gui input[type=text]{padding:var(--widget-padding)}.lil-gui input[type=number]:focus,.lil-gui input[type=text]:focus{background:var(--focus-color)}.lil-gui input::-webkit-inner-spin-button,.lil-gui input::-webkit-outer-spin-button{-webkit-appearance:none;margin:0}.lil-gui input[type=number]{-moz-appearance:textfield}.lil-gui input[type=checkbox]{appearance:none;-webkit-appearance:none;border-radius:var(--widget-border-radius);cursor:pointer;height:var(--checkbox-size);text-align:center;width:var(--checkbox-size)}.lil-gui input[type=checkbox]:checked:before{content:"✓";font-family:lil-gui;font-size:var(--checkbox-size);line-height:var(--checkbox-size)}.lil-gui button{-webkit-tap-highlight-color:transparent;background:var(--widget-color);border:1px solid var(--widget-color);border-radius:var(--widget-border-radius);color:var(--text-color);cursor:pointer;font-family:var(--font-family);font-size:var(--font-size);height:var(--widget-height);line-height:calc(var(--widget-height) - 4px);outline:none;text-align:center;text-transform:none;width:100%}.lil-gui button:active{background:var(--focus-color)}@font-face{font-family:lil-gui;src:url("data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAAAUsAAsAAAAACJwAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABHU1VCAAABCAAAAH4AAADAImwmYE9TLzIAAAGIAAAAPwAAAGBKqH5SY21hcAAAAcgAAAD0AAACrukyyJBnbHlmAAACvAAAAF8AAACEIZpWH2hlYWQAAAMcAAAAJwAAADZfcj2zaGhlYQAAA0QAAAAYAAAAJAC5AHhobXR4AAADXAAAABAAAABMAZAAAGxvY2EAAANsAAAAFAAAACgCEgIybWF4cAAAA4AAAAAeAAAAIAEfABJuYW1lAAADoAAAASIAAAIK9SUU/XBvc3QAAATEAAAAZgAAAJCTcMc2eJxVjbEOgjAURU+hFRBK1dGRL+ALnAiToyMLEzFpnPz/eAshwSa97517c/MwwJmeB9kwPl+0cf5+uGPZXsqPu4nvZabcSZldZ6kfyWnomFY/eScKqZNWupKJO6kXN3K9uCVoL7iInPr1X5baXs3tjuMqCtzEuagm/AAlzQgPAAB4nGNgYRBlnMDAysDAYM/gBiT5oLQBAwuDJAMDEwMrMwNWEJDmmsJwgCFeXZghBcjlZMgFCzOiKOIFAB71Bb8AeJy1kjFuwkAQRZ+DwRAwBtNQRUGKQ8OdKCAWUhAgKLhIuAsVSpWz5Bbkj3dEgYiUIszqWdpZe+Z7/wB1oCYmIoboiwiLT2WjKl/jscrHfGg/pKdMkyklC5Zs2LEfHYpjcRoPzme9MWWmk3dWbK9ObkWkikOetJ554fWyoEsmdSlt+uR0pCJR34b6t/TVg1SY3sYvdf8vuiKrpyaDXDISiegp17p7579Gp3p++y7HPAiY9pmTibljrr85qSidtlg4+l25GLCaS8e6rRxNBmsnERunKbaOObRz7N72ju5vdAjYpBXHgJylOAVsMseDAPEP8LYoUHicY2BiAAEfhiAGJgZWBgZ7RnFRdnVJELCQlBSRlATJMoLV2DK4glSYs6ubq5vbKrJLSbGrgEmovDuDJVhe3VzcXFwNLCOILB/C4IuQ1xTn5FPilBTj5FPmBAB4WwoqAHicY2BkYGAA4sk1sR/j+W2+MnAzpDBgAyEMQUCSg4EJxAEAwUgFHgB4nGNgZGBgSGFggJMhDIwMqEAYAByHATJ4nGNgAIIUNEwmAABl3AGReJxjYAACIQYlBiMGJ3wQAEcQBEV4nGNgZGBgEGZgY2BiAAEQyQWEDAz/wXwGAAsPATIAAHicXdBNSsNAHAXwl35iA0UQXYnMShfS9GPZA7T7LgIu03SSpkwzYTIt1BN4Ak/gKTyAeCxfw39jZkjymzcvAwmAW/wgwHUEGDb36+jQQ3GXGot79L24jxCP4gHzF/EIr4jEIe7wxhOC3g2TMYy4Q7+Lu/SHuEd/ivt4wJd4wPxbPEKMX3GI5+DJFGaSn4qNzk8mcbKSR6xdXdhSzaOZJGtdapd4vVPbi6rP+cL7TGXOHtXKll4bY1Xl7EGnPtp7Xy2n00zyKLVHfkHBa4IcJ2oD3cgggWvt/V/FbDrUlEUJhTn/0azVWbNTNr0Ens8de1tceK9xZmfB1CPjOmPH4kitmvOubcNpmVTN3oFJyjzCvnmrwhJTzqzVj9jiSX911FjeAAB4nG3HMRKCMBBA0f0giiKi4DU8k0V2GWbIZDOh4PoWWvq6J5V8If9NVNQcaDhyouXMhY4rPTcG7jwYmXhKq8Wz+p762aNaeYXom2n3m2dLTVgsrCgFJ7OTmIkYbwIbC6vIB7WmFfAAAA==") format("woff")}@media (pointer:coarse){.lil-gui.allow-touch-styles{--widget-height:28px;--padding:6px;--spacing:6px;--font-size:13px;--input-font-size:16px;--folder-indent:10px;--scrollbar-width:7px;--slider-input-min-width:50px;--color-input-min-width:65px}}@media (hover:hover){.lil-gui .controller.color .display:hover:before{border:1px solid #fff9;border-radius:var(--widget-border-radius);bottom:0;content:" ";display:block;left:0;position:absolute;right:0;top:0}.lil-gui .controller.option .display.focus{background:var(--focus-color)}.lil-gui .controller.option .widget:hover .display{background:var(--hover-color)}.lil-gui .controller.number .slider:hover{background-color:var(--hover-color)}body:not(.lil-gui-dragging) .lil-gui .title:hover{background:var(--title-background-color);opacity:.85}.lil-gui .title:focus{text-decoration:underline var(--focus-color)}.lil-gui input:hover{background:var(--hover-color)}.lil-gui input:active{background:var(--focus-color)}.lil-gui input[type=checkbox]:focus{box-shadow:inset 0 0 0 1px var(--focus-color)}.lil-gui button:hover{background:var(--hover-color);border-color:var(--hover-color)}.lil-gui button:focus{border-color:var(--focus-color)}}'),p=!0),e?e.appendChild(this.domElement):i&&(this.domElement.classList.add("autoPlace"),document.body.appendChild(this.domElement)),s&&this.domElement.style.setProperty("--width",s+"px"),this.domElement.addEventListener("keydown",t=>t.stopPropagation()),this.domElement.addEventListener("keyup",t=>t.stopPropagation())}add(t,e,s,n,l){if(Object(s)===s)return new c(this,t,e,s);const r=t[e];switch(typeof r){case"number":return new d(this,t,e,s,n,l);case"boolean":return new i(this,t,e);case"string":return new u(this,t,e);case"function":return new h(this,t,e)}console.error("gui.add failed\n\tproperty:",e,"\n\tobject:",t,"\n\tvalue:",r)}addColor(t,i,e=1){return new a(this,t,i,e)}addFolder(t){return new g({parent:this,title:t})}load(t,i=!0){return t.controllers&&this.controllers.forEach(i=>{i instanceof h||i._name in t.controllers&&i.load(t.controllers[i._name])}),i&&t.folders&&this.folders.forEach(i=>{i._title in t.folders&&i.load(t.folders[i._title])}),this}save(t=!0){const i={controllers:{},folders:{}};return this.controllers.forEach(t=>{if(!(t instanceof h)){if(t._name in i.controllers)throw new Error(`Cannot save GUI with duplicate property "${t._name}"`);i.controllers[t._name]=t.save()}}),t&&this.folders.forEach(t=>{if(t._title in i.folders)throw new Error(`Cannot save GUI with duplicate folder "${t._title}"`);i.folders[t._title]=t.save()}),i}open(t=!0){return this._closed=!t,this.$title.setAttribute("aria-expanded",!this._closed),this.domElement.classList.toggle("closed",this._closed),this}close(){return this.open(!1)}show(t=!0){return this._hidden=!t,this.domElement.style.display=this._hidden?"none":"",this}hide(){return this.show(!1)}openAnimated(t=!0){return this._closed=!t,this.$title.setAttribute("aria-expanded",!this._closed),requestAnimationFrame(()=>{const i=this.$children.clientHeight;this.$children.style.height=i+"px",this.domElement.classList.add("transition");const e=t=>{t.target===this.$children&&(this.$children.style.height="",this.domElement.classList.remove("transition"),this.$children.removeEventListener("transitionend",e))};this.$children.addEventListener("transitionend",e);const s=t?this.$children.scrollHeight:0;this.domElement.classList.toggle("closed",!t),requestAnimationFrame(()=>{this.$children.style.height=s+"px"})}),this}title(t){return this._title=t,this.$title.innerHTML=t,this}reset(t=!0){return(t?this.controllersRecursive():this.controllers).forEach(t=>t.reset()),this}onChange(t){return this._onChange=t,this}_callOnChange(t){this.parent&&this.parent._callOnChange(t),void 0!==this._onChange&&this._onChange.call(this,{object:t.object,property:t.property,value:t.getValue(),controller:t})}onFinishChange(t){return this._onFinishChange=t,this}_callOnFinishChange(t){this.parent&&this.parent._callOnFinishChange(t),void 0!==this._onFinishChange&&this._onFinishChange.call(this,{object:t.object,property:t.property,value:t.getValue(),controller:t})}destroy(){this.parent&&(this.parent.children.splice(this.parent.children.indexOf(this),1),this.parent.folders.splice(this.parent.folders.indexOf(this),1)),this.domElement.parentElement&&this.domElement.parentElement.removeChild(this.domElement),Array.from(this.children).forEach(t=>t.destroy())}controllersRecursive(){let t=Array.from(this.controllers);return this.folders.forEach(i=>{t=t.concat(i.controllersRecursive())}),t}foldersRecursive(){let t=Array.from(this.folders);return this.folders.forEach(i=>{t=t.concat(i.foldersRecursive())}),t}}export default g;export{i as BooleanController,a as ColorController,t as Controller,h as FunctionController,g as GUI,d as NumberController,c as OptionController,u as StringController};
9 |
--------------------------------------------------------------------------------
/js/stats.module.js:
--------------------------------------------------------------------------------
1 | var Stats = function () {
2 |
3 | var mode = 0;
4 |
5 | var container = document.createElement( 'div' );
6 | container.style.cssText = 'position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000';
7 | container.addEventListener( 'click', function ( event ) {
8 |
9 | event.preventDefault();
10 | showPanel( ++ mode % container.children.length );
11 |
12 | }, false );
13 |
14 | //
15 |
16 | function addPanel( panel ) {
17 |
18 | container.appendChild( panel.dom );
19 | return panel;
20 |
21 | }
22 |
23 | function showPanel( id ) {
24 |
25 | for ( var i = 0; i < container.children.length; i ++ ) {
26 |
27 | container.children[ i ].style.display = i === id ? 'block' : 'none';
28 |
29 | }
30 |
31 | mode = id;
32 |
33 | }
34 |
35 | //
36 |
37 | var beginTime = ( performance || Date ).now(), prevTime = beginTime, frames = 0;
38 |
39 | var fpsPanel = addPanel( new Stats.Panel( 'FPS', '#0ff', '#002' ) );
40 | var msPanel = addPanel( new Stats.Panel( 'MS', '#0f0', '#020' ) );
41 |
42 | if ( self.performance && self.performance.memory ) {
43 |
44 | var memPanel = addPanel( new Stats.Panel( 'MB', '#f08', '#201' ) );
45 |
46 | }
47 |
48 | showPanel( 0 );
49 |
50 | return {
51 |
52 | REVISION: 16,
53 |
54 | dom: container,
55 |
56 | addPanel: addPanel,
57 | showPanel: showPanel,
58 |
59 | begin: function () {
60 |
61 | beginTime = ( performance || Date ).now();
62 |
63 | },
64 |
65 | end: function () {
66 |
67 | frames ++;
68 |
69 | var time = ( performance || Date ).now();
70 |
71 | msPanel.update( time - beginTime, 200 );
72 |
73 | if ( time >= prevTime + 1000 ) {
74 |
75 | fpsPanel.update( ( frames * 1000 ) / ( time - prevTime ), 100 );
76 |
77 | prevTime = time;
78 | frames = 0;
79 |
80 | if ( memPanel ) {
81 |
82 | var memory = performance.memory;
83 | memPanel.update( memory.usedJSHeapSize / 1048576, memory.jsHeapSizeLimit / 1048576 );
84 |
85 | }
86 |
87 | }
88 |
89 | return time;
90 |
91 | },
92 |
93 | update: function () {
94 |
95 | beginTime = this.end();
96 |
97 | },
98 |
99 | // Backwards Compatibility
100 |
101 | domElement: container,
102 | setMode: showPanel
103 |
104 | };
105 |
106 | };
107 |
108 | Stats.Panel = function ( name, fg, bg ) {
109 |
110 | var min = Infinity, max = 0, round = Math.round;
111 | var PR = round( window.devicePixelRatio || 1 );
112 |
113 | var WIDTH = 80 * PR, HEIGHT = 48 * PR,
114 | TEXT_X = 3 * PR, TEXT_Y = 2 * PR,
115 | GRAPH_X = 3 * PR, GRAPH_Y = 15 * PR,
116 | GRAPH_WIDTH = 74 * PR, GRAPH_HEIGHT = 30 * PR;
117 |
118 | var canvas = document.createElement( 'canvas' );
119 | canvas.width = WIDTH;
120 | canvas.height = HEIGHT;
121 | canvas.style.cssText = 'width:80px;height:48px';
122 |
123 | var context = canvas.getContext( '2d' );
124 | context.font = 'bold ' + ( 9 * PR ) + 'px Helvetica,Arial,sans-serif';
125 | context.textBaseline = 'top';
126 |
127 | context.fillStyle = bg;
128 | context.fillRect( 0, 0, WIDTH, HEIGHT );
129 |
130 | context.fillStyle = fg;
131 | context.fillText( name, TEXT_X, TEXT_Y );
132 | context.fillRect( GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT );
133 |
134 | context.fillStyle = bg;
135 | context.globalAlpha = 0.9;
136 | context.fillRect( GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT );
137 |
138 | return {
139 |
140 | dom: canvas,
141 |
142 | update: function ( value, maxValue ) {
143 |
144 | min = Math.min( min, value );
145 | max = Math.max( max, value );
146 |
147 | context.fillStyle = bg;
148 | context.globalAlpha = 1;
149 | context.fillRect( 0, 0, WIDTH, GRAPH_Y );
150 | context.fillStyle = fg;
151 | context.fillText( round( value ) + ' ' + name + ' (' + round( min ) + '-' + round( max ) + ')', TEXT_X, TEXT_Y );
152 |
153 | context.drawImage( canvas, GRAPH_X + PR, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT, GRAPH_X, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT );
154 |
155 | context.fillRect( GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, GRAPH_HEIGHT );
156 |
157 | context.fillStyle = bg;
158 | context.globalAlpha = 0.9;
159 | context.fillRect( GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, round( ( 1 - ( value / maxValue ) ) * GRAPH_HEIGHT ) );
160 |
161 | }
162 |
163 | };
164 |
165 | };
166 |
167 | export default Stats;
168 |
--------------------------------------------------------------------------------
/shaders/AntiGravityPool_Fragment.glsl:
--------------------------------------------------------------------------------
1 | precision highp float;
2 | precision highp int;
3 | precision highp sampler2D;
4 |
5 | #include
6 |
7 | uniform vec3 uBallPositions[24];
8 | uniform bool uShotIsInProgress;
9 |
10 | #define N_LIGHTS 8.0
11 | #define N_SPHERES 8
12 | #define N_BOXES 1
13 |
14 | //-----------------------------------------------------------------------
15 |
16 | vec3 rayOrigin, rayDirection;
17 | // recorded intersection data:
18 | vec3 hitNormal, hitEmission, hitColor;
19 | vec2 hitUV;
20 | float hitObjectID = -INFINITY;
21 | int hitType = -100;
22 |
23 | struct Sphere { float radius; vec3 position; vec3 emission; vec3 color; int type; };
24 | struct Box { vec3 minCorner; vec3 maxCorner; vec3 emission; vec3 color; int type; };
25 |
26 | Sphere spheres[N_SPHERES];
27 | Box boxes[N_BOXES];
28 |
29 |
30 | #include
31 |
32 | #include
33 |
34 | #include
35 |
36 | #include
37 |
38 |
39 |
40 | //---------------------------------------------------------------------------------------
41 | float SceneIntersect()
42 | //---------------------------------------------------------------------------------------
43 | {
44 | float d = INFINITY;
45 | float t = INFINITY;
46 | vec3 n;
47 | int objectCount = 0;
48 |
49 | d = BoxInteriorIntersect( boxes[0].minCorner, boxes[0].maxCorner, rayOrigin, rayDirection, n );
50 | if (d < t)
51 | {
52 | t = d;
53 | hitNormal = n;
54 | hitEmission = boxes[0].emission;
55 | hitColor = boxes[0].color;
56 | hitType = boxes[0].type;
57 | hitObjectID = float(objectCount);
58 | }
59 | objectCount++;
60 |
61 | // white cueball / glass aiming ball
62 | d = SphereIntersect( 2.0, uBallPositions[0], rayOrigin, rayDirection );
63 | if (d < t)
64 | {
65 | t = d;
66 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[0];
67 | hitEmission = vec3(0);
68 | //hitColor = uShotIsInProgress ? vec3(1) : vec3(2);
69 | hitColor = vec3(1);
70 | hitType = uShotIsInProgress ? COAT : REFR;
71 | hitObjectID = float(objectCount);
72 | }
73 | objectCount++;
74 |
75 | // black ball
76 | d = SphereIntersect( 2.0, uBallPositions[1], rayOrigin, rayDirection );
77 | if (d < t)
78 | {
79 | t = d;
80 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[1];
81 | hitEmission = vec3(0);
82 | hitColor = vec3(0.005);
83 | hitType = COAT;
84 | hitObjectID = float(objectCount);
85 | }
86 | objectCount++;
87 |
88 | // red balls
89 |
90 | d = SphereIntersect( 2.0, uBallPositions[2], rayOrigin, rayDirection );
91 | if (d < t)
92 | {
93 | t = d;
94 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[2];
95 | hitEmission = vec3(0);
96 | hitColor = vec3(1.0, 0.0, 0.0);
97 | hitType = COAT;
98 | hitObjectID = float(objectCount);
99 | }
100 | objectCount++;
101 |
102 | d = SphereIntersect( 2.0, uBallPositions[3], rayOrigin, rayDirection );
103 | if (d < t)
104 | {
105 | t = d;
106 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[3];
107 | hitEmission = vec3(0);
108 | hitColor = vec3(1.0, 0.0, 0.0);
109 | hitType = COAT;
110 | hitObjectID = float(objectCount);
111 | }
112 | objectCount++;
113 |
114 | d = SphereIntersect( 2.0, uBallPositions[4], rayOrigin, rayDirection );
115 | if (d < t)
116 | {
117 | t = d;
118 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[4];
119 | hitEmission = vec3(0);
120 | hitColor = vec3(1.0, 0.0, 0.0);
121 | hitType = COAT;
122 | hitObjectID = float(objectCount);
123 | }
124 | objectCount++;
125 |
126 | d = SphereIntersect( 2.0, uBallPositions[5], rayOrigin, rayDirection );
127 | if (d < t)
128 | {
129 | t = d;
130 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[5];
131 | hitEmission = vec3(0);
132 | hitColor = vec3(1.0, 0.0, 0.0);
133 | hitType = COAT;
134 | hitObjectID = float(objectCount);
135 | }
136 | objectCount++;
137 |
138 | d = SphereIntersect( 2.0, uBallPositions[6], rayOrigin, rayDirection );
139 | if (d < t)
140 | {
141 | t = d;
142 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[6];
143 | hitEmission = vec3(0);
144 | hitColor = vec3(1.0, 0.0, 0.0);
145 | hitType = COAT;
146 | hitObjectID = float(objectCount);
147 | }
148 | objectCount++;
149 |
150 | d = SphereIntersect( 2.0, uBallPositions[7], rayOrigin, rayDirection );
151 | if (d < t)
152 | {
153 | t = d;
154 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[7];
155 | hitEmission = vec3(0);
156 | hitColor = vec3(1.0, 0.0, 0.0);
157 | hitType = COAT;
158 | hitObjectID = float(objectCount);
159 | }
160 | objectCount++;
161 |
162 | d = SphereIntersect( 2.0, uBallPositions[8], rayOrigin, rayDirection );
163 | if (d < t)
164 | {
165 | t = d;
166 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[8];
167 | hitEmission = vec3(0);
168 | hitColor = vec3(1.0, 0.0, 0.0);
169 | hitType = COAT;
170 | hitObjectID = float(objectCount);
171 | }
172 | objectCount++;
173 |
174 | // yellow balls
175 |
176 | d = SphereIntersect( 2.0, uBallPositions[9], rayOrigin, rayDirection );
177 | if (d < t)
178 | {
179 | t = d;
180 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[9];
181 | hitEmission = vec3(0);
182 | hitColor = vec3(1.0, 1.0, 0.0);
183 | hitType = COAT;
184 | hitObjectID = float(objectCount);
185 | }
186 | objectCount++;
187 |
188 | d = SphereIntersect( 2.0, uBallPositions[10], rayOrigin, rayDirection );
189 | if (d < t)
190 | {
191 | t = d;
192 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[10];
193 | hitEmission = vec3(0);
194 | hitColor = vec3(1.0, 1.0, 0.0);
195 | hitType = COAT;
196 | hitObjectID = float(objectCount);
197 | }
198 | objectCount++;
199 |
200 | d = SphereIntersect( 2.0, uBallPositions[11], rayOrigin, rayDirection );
201 | if (d < t)
202 | {
203 | t = d;
204 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[11];
205 | hitEmission = vec3(0);
206 | hitColor = vec3(1.0, 1.0, 0.0);
207 | hitType = COAT;
208 | hitObjectID = float(objectCount);
209 | }
210 | objectCount++;
211 |
212 | d = SphereIntersect( 2.0, uBallPositions[12], rayOrigin, rayDirection );
213 | if (d < t)
214 | {
215 | t = d;
216 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[12];
217 | hitEmission = vec3(0);
218 | hitColor = vec3(1.0, 1.0, 0.0);
219 | hitType = COAT;
220 | hitObjectID = float(objectCount);
221 | }
222 | objectCount++;
223 |
224 | d = SphereIntersect( 2.0, uBallPositions[13], rayOrigin, rayDirection );
225 | if (d < t)
226 | {
227 | t = d;
228 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[13];
229 | hitEmission = vec3(0);
230 | hitColor = vec3(1.0, 1.0, 0.0);
231 | hitType = COAT;
232 | hitObjectID = float(objectCount);
233 | }
234 | objectCount++;
235 |
236 | d = SphereIntersect( 2.0, uBallPositions[14], rayOrigin, rayDirection );
237 | if (d < t)
238 | {
239 | t = d;
240 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[14];
241 | hitEmission = vec3(0);
242 | hitColor = vec3(1.0, 1.0, 0.0);
243 | hitType = COAT;
244 | hitObjectID = float(objectCount);
245 | }
246 | objectCount++;
247 |
248 | d = SphereIntersect( 2.0, uBallPositions[15], rayOrigin, rayDirection );
249 | if (d < t)
250 | {
251 | t = d;
252 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[15];
253 | hitEmission = vec3(0);
254 | hitColor = vec3(1.0, 1.0, 0.0);
255 | hitType = COAT;
256 | hitObjectID = float(objectCount);
257 | }
258 | objectCount++;
259 |
260 | // pockets / lights
261 |
262 | d = SphereIntersect( spheres[0].radius, spheres[0].position, rayOrigin, rayDirection );
263 | if (d < t)
264 | {
265 | t = d;
266 | hitNormal = (rayOrigin + rayDirection * t) - spheres[0].position;
267 | hitEmission = spheres[0].emission;
268 | hitColor = spheres[0].color;
269 | hitType = spheres[0].type;
270 | hitObjectID = float(objectCount);
271 | }
272 | objectCount++;
273 |
274 | d = SphereIntersect( spheres[1].radius, spheres[1].position, rayOrigin, rayDirection );
275 | if (d < t)
276 | {
277 | t = d;
278 | hitNormal = (rayOrigin + rayDirection * t) - spheres[1].position;
279 | hitEmission = spheres[1].emission;
280 | hitColor = spheres[1].color;
281 | hitType = spheres[1].type;
282 | hitObjectID = float(objectCount);
283 | }
284 | objectCount++;
285 |
286 | d = SphereIntersect( spheres[2].radius, spheres[2].position, rayOrigin, rayDirection );
287 | if (d < t)
288 | {
289 | t = d;
290 | hitNormal = (rayOrigin + rayDirection * t) - spheres[2].position;
291 | hitEmission = spheres[2].emission;
292 | hitColor = spheres[2].color;
293 | hitType = spheres[2].type;
294 | hitObjectID = float(objectCount);
295 | }
296 | objectCount++;
297 |
298 | d = SphereIntersect( spheres[3].radius, spheres[3].position, rayOrigin, rayDirection );
299 | if (d < t)
300 | {
301 | t = d;
302 | hitNormal = (rayOrigin + rayDirection * t) - spheres[3].position;
303 | hitEmission = spheres[3].emission;
304 | hitColor = spheres[3].color;
305 | hitType = spheres[3].type;
306 | hitObjectID = float(objectCount);
307 | }
308 | objectCount++;
309 |
310 | d = SphereIntersect( spheres[4].radius, spheres[4].position, rayOrigin, rayDirection );
311 | if (d < t)
312 | {
313 | t = d;
314 | hitNormal = (rayOrigin + rayDirection * t) - spheres[4].position;
315 | hitEmission = spheres[4].emission;
316 | hitColor = spheres[4].color;
317 | hitType = spheres[4].type;
318 | hitObjectID = float(objectCount);
319 | }
320 | objectCount++;
321 |
322 | d = SphereIntersect( spheres[5].radius, spheres[5].position, rayOrigin, rayDirection );
323 | if (d < t)
324 | {
325 | t = d;
326 | hitNormal = (rayOrigin + rayDirection * t) - spheres[5].position;
327 | hitEmission = spheres[5].emission;
328 | hitColor = spheres[5].color;
329 | hitType = spheres[5].type;
330 | hitObjectID = float(objectCount);
331 | }
332 | objectCount++;
333 |
334 | d = SphereIntersect( spheres[6].radius, spheres[6].position, rayOrigin, rayDirection );
335 | if (d < t)
336 | {
337 | t = d;
338 | hitNormal = (rayOrigin + rayDirection * t) - spheres[6].position;
339 | hitEmission = spheres[6].emission;
340 | hitColor = spheres[6].color;
341 | hitType = spheres[6].type;
342 | hitObjectID = float(objectCount);
343 | }
344 | objectCount++;
345 |
346 | d = SphereIntersect( spheres[7].radius, spheres[7].position, rayOrigin, rayDirection );
347 | if (d < t)
348 | {
349 | t = d;
350 | hitNormal = (rayOrigin + rayDirection * t) - spheres[7].position;
351 | hitEmission = spheres[7].emission;
352 | hitColor = spheres[7].color;
353 | hitType = spheres[7].type;
354 | hitObjectID = float(objectCount);
355 | }
356 | objectCount++;
357 |
358 |
359 | return t;
360 |
361 | } // end float SceneIntersect( )
362 |
363 |
364 | //-----------------------------------------------------------------------------------------------------------------------------
365 | vec3 CalculateRadiance(out vec3 objectNormal, out vec3 objectColor, out float objectID, out float pixelSharpness )
366 | //-----------------------------------------------------------------------------------------------------------------------------
367 | {
368 | Sphere lightChoice;
369 |
370 | vec3 accumCol = vec3(0);
371 | vec3 mask = vec3(1);
372 | vec3 reflectionMask = vec3(1);
373 | vec3 reflectionRayOrigin = vec3(0);
374 | vec3 reflectionRayDirection = vec3(0);
375 | vec3 diffuseBounceMask = vec3(1);
376 | vec3 diffuseBounceRayOrigin = vec3(0);
377 | vec3 diffuseBounceRayDirection = vec3(0);
378 | vec3 dirToLight;
379 | vec3 x, n, nl;
380 |
381 | float t;
382 | float nc, nt, ratioIoR, Re, Tr;
383 | float weight;
384 | float previousObjectID;
385 |
386 | int reflectionBounces = -1;
387 | int diffuseCount = 0;
388 | int intBest = 0;
389 | int previousIntersecType = -100;
390 | hitType = -100;
391 |
392 | int bounceIsSpecular = TRUE;
393 | int sampleLight = FALSE;
394 | int willNeedReflectionRay = FALSE;
395 | int isReflectionTime = FALSE;
396 | int reflectionNeedsToBeSharp = FALSE;
397 | int willNeedDiffuseBounceRay = FALSE;
398 | int isDiffuseBounceTime = FALSE;
399 |
400 |
401 | for (int bounces = 0; bounces < 10; bounces++)
402 | {
403 | if (isReflectionTime == TRUE)
404 | reflectionBounces++;
405 |
406 | previousIntersecType = hitType;
407 | previousObjectID = hitObjectID;
408 |
409 | t = SceneIntersect();
410 |
411 | // //not used in this scene because we are inside a large box shape - no rays can escape
412 | if (t == INFINITY)
413 | {
414 | break;
415 | }
416 |
417 |
418 | // useful data
419 | n = normalize(hitNormal);
420 | nl = dot(n, rayDirection) < 0.0 ? n : -n;
421 | x = rayOrigin + rayDirection * t;
422 |
423 | if (bounces == 0)
424 | {
425 | objectID = hitObjectID;
426 | }
427 | if (isReflectionTime == FALSE && diffuseCount == 0 && hitObjectID != previousObjectID)
428 | {
429 | objectNormal += n;
430 | objectColor += hitColor;
431 | }
432 |
433 |
434 |
435 | if (hitType == LIGHT)
436 | {
437 | if (diffuseCount == 0 && isReflectionTime == FALSE)
438 | {
439 | pixelSharpness = 1.0;
440 | accumCol += mask * clamp(hitEmission, 0.0, 2.0);
441 | }
442 |
443 | else if (isReflectionTime == TRUE && bounceIsSpecular == TRUE)
444 | {
445 | objectNormal += nl;
446 | //objectColor = hitColor;
447 | objectID += hitObjectID;
448 | accumCol += mask * hitEmission;
449 | }
450 | else if (sampleLight == TRUE)
451 | {
452 | accumCol += mask * clamp(hitEmission, 0.0, 8.0);
453 | }
454 |
455 | if (willNeedDiffuseBounceRay == TRUE)
456 | {
457 | mask = diffuseBounceMask;
458 | rayOrigin = diffuseBounceRayOrigin;
459 | rayDirection = diffuseBounceRayDirection;
460 |
461 | willNeedDiffuseBounceRay = FALSE;
462 | bounceIsSpecular = FALSE;
463 | sampleLight = FALSE;
464 | isDiffuseBounceTime = TRUE;
465 | isReflectionTime = FALSE;
466 | diffuseCount = 1;
467 | continue;
468 | }
469 |
470 | if (willNeedReflectionRay == TRUE)
471 | {
472 | mask = reflectionMask;
473 | rayOrigin = reflectionRayOrigin;
474 | rayDirection = reflectionRayDirection;
475 |
476 | willNeedReflectionRay = FALSE;
477 | bounceIsSpecular = TRUE;
478 | sampleLight = FALSE;
479 | isReflectionTime = TRUE;
480 | isDiffuseBounceTime = FALSE;
481 | continue;
482 | }
483 |
484 | //reached a light, so we can exit
485 | break;
486 | }
487 |
488 |
489 | // if we get here and sampleLight is still true, shadow ray failed to find the light source
490 | // the ray hit an occluding object along its way to the light
491 | if (sampleLight == TRUE)
492 | {
493 | if (willNeedDiffuseBounceRay == TRUE)
494 | {
495 | mask = diffuseBounceMask;
496 | rayOrigin = diffuseBounceRayOrigin;
497 | rayDirection = diffuseBounceRayDirection;
498 |
499 | willNeedDiffuseBounceRay = FALSE;
500 | bounceIsSpecular = FALSE;
501 | sampleLight = FALSE;
502 | isDiffuseBounceTime = TRUE;
503 | isReflectionTime = FALSE;
504 | diffuseCount = 1;
505 | continue;
506 | }
507 |
508 | if (willNeedReflectionRay == TRUE)
509 | {
510 | mask = reflectionMask;
511 | rayOrigin = reflectionRayOrigin;
512 | rayDirection = reflectionRayDirection;
513 |
514 | willNeedReflectionRay = FALSE;
515 | bounceIsSpecular = TRUE;
516 | sampleLight = FALSE;
517 | isReflectionTime = TRUE;
518 | isDiffuseBounceTime = FALSE;
519 | continue;
520 | }
521 |
522 | break;
523 | }
524 |
525 |
526 | if (hitType == DIFF) // Ideal DIFFUSE reflection
527 | {
528 | diffuseCount++;
529 |
530 | mask *= hitColor;
531 |
532 | bounceIsSpecular = FALSE;
533 |
534 | rayOrigin = x + nl * uEPS_intersect;
535 |
536 | if (diffuseCount == 1)
537 | {
538 | diffuseBounceMask = mask;
539 | diffuseBounceRayOrigin = rayOrigin;
540 | diffuseBounceRayDirection = randomCosWeightedDirectionInHemisphere(nl);
541 | willNeedDiffuseBounceRay = TRUE;
542 | }
543 |
544 | // loop through the 8 sphere lights and find the best one to sample
545 | for (int i = 0; i < N_SPHERES; i++)
546 | {
547 | intBest = rng() < dot(nl, normalize(spheres[i].position - x)) ? i : intBest;
548 | }
549 | lightChoice = spheres[intBest];
550 |
551 | dirToLight = randomDirectionInSpecularLobe(normalize(lightChoice.position - x), 0.15);
552 | mask *= N_LIGHTS;
553 | mask *= max(0.0, dot(nl, dirToLight)) * 0.005;
554 |
555 | rayDirection = dirToLight;
556 | sampleLight = TRUE;
557 | continue;
558 |
559 | } // end if (hitType == DIFF)
560 |
561 |
562 | if (hitType == REFR) // Ideal dielectric REFRACTION
563 | {
564 | nc = 1.0; // IOR of Air
565 | nt = 1.3; // IOR of special Glass aiming cueball for this game
566 |
567 | // use 'nl' instead of 'n' in below function arguments for non-ray-bending clear materials
568 | Re = calcFresnelReflectance(rayDirection, n, nc, nt, ratioIoR);
569 | Tr = 1.0 - Re;
570 |
571 | if (Re == 1.0)
572 | {
573 | rayDirection = reflect(rayDirection, nl);
574 | rayOrigin = x + nl * uEPS_intersect;
575 | continue;
576 | }
577 |
578 | if (bounces == 0)
579 | {
580 | reflectionMask = mask * Re;
581 | reflectionRayDirection = reflect(rayDirection, nl); // reflect ray from surface
582 | reflectionRayOrigin = x + nl * uEPS_intersect;
583 | willNeedReflectionRay = TRUE;
584 | }
585 |
586 | // make glass aiming cueball brighter
587 | // if (diffuseCount == 0 && bounces == 1)
588 | // mask = uEPS_intersect == 1.0 ? vec3(6) : vec3(2); // make even brighter on mobile
589 |
590 | mask *= hitColor;
591 | mask *= Tr;
592 |
593 | // transmit ray through surface
594 | rayDirection = rayDirection; // this lets the viewing ray pass through without bending due to refraction
595 | rayOrigin = x - nl * uEPS_intersect;
596 |
597 | continue;
598 |
599 | } // end if (hitType == REFR)
600 |
601 |
602 | if (hitType == COAT) // Diffuse object underneath with ClearCoat on top
603 | {
604 | nc = 1.0; // IOR of Air
605 | nt = 1.8; // IOR of very thick ClearCoat for pool balls
606 | Re = calcFresnelReflectance(rayDirection, nl, nc, nt, ratioIoR);
607 | Tr = 1.0 - Re;
608 |
609 | if (diffuseCount == 0 && hitObjectID != previousObjectID)
610 | {
611 | reflectionMask = mask * Re;
612 | reflectionRayDirection = reflect(rayDirection, nl); // reflect ray from surface
613 | reflectionRayOrigin = x + nl * uEPS_intersect;
614 | willNeedReflectionRay = TRUE;
615 | }
616 |
617 | diffuseCount++;
618 |
619 | mask *= Tr;
620 | mask *= hitColor;
621 |
622 | bounceIsSpecular = FALSE;
623 |
624 | rayOrigin = x + nl * uEPS_intersect;
625 |
626 | if (diffuseCount == 1)
627 | {
628 | diffuseBounceMask = mask;
629 | diffuseBounceRayOrigin = rayOrigin;
630 | diffuseBounceRayDirection = randomCosWeightedDirectionInHemisphere(nl);
631 | willNeedDiffuseBounceRay = TRUE;
632 | }
633 |
634 | // loop through the 8 sphere lights and find the best one to sample
635 | for (int i = 0; i < N_SPHERES; i++)
636 | {
637 | intBest = rng() * 1.5 < dot(nl, normalize(spheres[i].position - x)) ? i : intBest;
638 | }
639 | lightChoice = spheres[intBest];
640 |
641 | dirToLight = randomDirectionInSpecularLobe(normalize(lightChoice.position - x), 0.2);
642 |
643 | mask *= N_LIGHTS;
644 | mask *= max(0.0, dot(nl, dirToLight)) * 0.03;//0.01;
645 |
646 | rayDirection = dirToLight;
647 | sampleLight = TRUE;
648 | continue;
649 |
650 | } //end if (hitType == COAT)
651 |
652 | } // end for (int bounces = 0; bounces < 10; bounces++)
653 |
654 | return max(vec3(0), accumCol);
655 |
656 | } // end vec3 CalculateRadiance( out vec3 objectNormal, out vec3 objectColor, out float objectID, out float pixelSharpness )
657 |
658 |
659 | //-----------------------------------------------------------------------
660 | void SetupScene(void)
661 | //-----------------------------------------------------------------------
662 | {
663 | vec3 z = vec3(0);
664 | vec3 L = vec3(1, 1, 1) * 10.0; // bright White light
665 |
666 | spheres[0] = Sphere(10.0, uBallPositions[16], L, z, LIGHT); // bottom left front spherical light
667 | spheres[1] = Sphere(10.0, uBallPositions[17], L, z, LIGHT); // bottom right front spherical light
668 | spheres[2] = Sphere(10.0, uBallPositions[18], L, z, LIGHT); // top left front spherical light
669 | spheres[3] = Sphere(10.0, uBallPositions[19], L, z, LIGHT); // top right front spherical light
670 |
671 | spheres[4] = Sphere(10.0, uBallPositions[20], L, z, LIGHT); // bottom left back spherical light
672 | spheres[5] = Sphere(10.0, uBallPositions[21], L, z, LIGHT); // bottom right back spherical light
673 | spheres[6] = Sphere(10.0, uBallPositions[22], L, z, LIGHT); // top left back spherical light
674 | spheres[7] = Sphere(10.0, uBallPositions[23], L, z, LIGHT); // top right back spherical light
675 |
676 | boxes[0] = Box(vec3(-50.5), vec3(50.5), z, vec3(0.0, 0.05, 0.99), DIFF); // Diffuse Box
677 | }
678 |
679 |
680 |
681 |
682 | // tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
683 | float tentFilter(float x)
684 | {
685 | return (x < 0.5) ? sqrt(2.0 * x) - 1.0 : 1.0 - sqrt(2.0 - (2.0 * x));
686 | }
687 |
688 |
689 | void main( void )
690 | {
691 | vec3 camRight = vec3( uCameraMatrix[0][0], uCameraMatrix[0][1], uCameraMatrix[0][2]);
692 | vec3 camUp = vec3( uCameraMatrix[1][0], uCameraMatrix[1][1], uCameraMatrix[1][2]);
693 | vec3 camForward = vec3(-uCameraMatrix[2][0], -uCameraMatrix[2][1], -uCameraMatrix[2][2]);
694 | // the following is not needed - three.js has a built-in uniform named cameraPosition
695 | //vec3 camPos = vec3( uCameraMatrix[3][0], uCameraMatrix[3][1], uCameraMatrix[3][2]);
696 |
697 | // calculate unique seed for rng() function
698 | seed = uvec2(uFrameCounter, uFrameCounter + 1.0) * uvec2(gl_FragCoord);
699 | // initialize rand() variables
700 | randNumber = 0.0; // the final randomly-generated number (range: 0.0 to 1.0)
701 | blueNoise = texelFetch(tBlueNoiseTexture, ivec2(mod(floor(gl_FragCoord.xy), 128.0)), 0).r;
702 |
703 | vec2 pixelOffset = vec2( tentFilter(rand()), tentFilter(rand()) );
704 | pixelOffset *= uCameraIsMoving ? 0.5 : 1.5; //1.5 needed to smooth out edges of pool balls
705 |
706 | // we must map pixelPos into the range -1.0 to +1.0
707 | vec2 pixelPos = ((gl_FragCoord.xy + vec2(0.5) + pixelOffset) / uResolution) * 2.0 - 1.0;
708 |
709 | vec3 rayDir = normalize( pixelPos.x * camRight * uULen + pixelPos.y * camUp * uVLen + camForward );
710 |
711 | // depth of field
712 | vec3 focalPoint = uFocusDistance * rayDir;
713 | float randomAngle = rng() * TWO_PI; // pick random point on aperture
714 | float randomRadius = rng() * uApertureSize;
715 | vec3 randomAperturePos = ( cos(randomAngle) * camRight + sin(randomAngle) * camUp ) * sqrt(randomRadius);
716 | // point on aperture to focal point
717 | vec3 finalRayDir = normalize(focalPoint - randomAperturePos);
718 |
719 | rayOrigin = cameraPosition + randomAperturePos;
720 | rayDirection = finalRayDir;
721 |
722 | SetupScene();
723 |
724 | // Edge Detection - don't want to blur edges where either surface normals change abruptly (i.e. room wall corners), objects overlap each other (i.e. edge of a foreground sphere in front of another sphere right behind it),
725 | // or an abrupt color variation on the same smooth surface, even if it has similar surface normals (i.e. checkerboard pattern). Want to keep all of these cases as sharp as possible - no blur filter will be applied.
726 | vec3 objectNormal, objectColor;
727 | float objectID = -INFINITY;
728 | float pixelSharpness = 0.0;
729 |
730 | // perform path tracing and get resulting pixel color
731 | vec4 currentPixel = vec4( vec3(CalculateRadiance(objectNormal, objectColor, objectID, pixelSharpness)), 0.0 );
732 |
733 | // if difference between normals of neighboring pixels is less than the first edge0 threshold, the white edge line effect is considered off (0.0)
734 | float edge0 = 0.2; // edge0 is the minimum difference required between normals of neighboring pixels to start becoming a white edge line
735 | // any difference between normals of neighboring pixels that is between edge0 and edge1 smoothly ramps up the white edge line brightness (smoothstep 0.0-1.0)
736 | float edge1 = 0.6; // once the difference between normals of neighboring pixels is >= this edge1 threshold, the white edge line is considered fully bright (1.0)
737 | float difference_Nx = fwidth(objectNormal.x);
738 | float difference_Ny = fwidth(objectNormal.y);
739 | float difference_Nz = fwidth(objectNormal.z);
740 | float normalDifference = smoothstep(edge0, edge1, difference_Nx) + smoothstep(edge0, edge1, difference_Ny) + smoothstep(edge0, edge1, difference_Nz);
741 |
742 | float objectDifference = min(fwidth(objectID), 1.0);
743 |
744 | float colorDifference = (fwidth(objectColor.r) + fwidth(objectColor.g) + fwidth(objectColor.b)) > 0.0 ? 1.0 : 0.0;
745 | // white-line debug visualization for normal difference
746 | //currentPixel.rgb += (rng() * 1.5) * vec3(normalDifference);
747 | // white-line debug visualization for object difference
748 | //currentPixel.rgb += (rng() * 1.5) * vec3(objectDifference);
749 | // white-line debug visualization for color difference
750 | //currentPixel.rgb += (rng() * 1.5) * vec3(colorDifference);
751 | // white-line debug visualization for all 3 differences
752 | //currentPixel.rgb += (rng() * 1.5) * vec3( clamp(max(normalDifference, max(objectDifference, colorDifference)), 0.0, 1.0) );
753 |
754 | vec4 previousPixel = texelFetch(tPreviousTexture, ivec2(gl_FragCoord.xy), 0);
755 |
756 |
757 | if (uCameraIsMoving) // camera is currently moving
758 | {
759 | previousPixel.rgb *= 0.5; // motion-blur trail amount (old image)
760 | currentPixel.rgb *= 0.5; // brightness of new image (noisy)
761 |
762 | previousPixel.a = 0.0;
763 | }
764 | else
765 | {
766 | previousPixel.rgb *= 0.9; // motion-blur trail amount (old image)
767 | currentPixel.rgb *= 0.1; // brightness of new image (noisy)
768 | }
769 |
770 | currentPixel.a = pixelSharpness;
771 |
772 | // check for all edges that are not light sources
773 | if (pixelSharpness < 1.01 && (colorDifference >= 1.0 || normalDifference >= 0.9 || objectDifference >= 1.0)) // all other edges
774 | currentPixel.a = pixelSharpness = 1.0;
775 |
776 | // makes light source edges (shape boundaries) more stable
777 | // if (previousPixel.a == 1.01)
778 | // currentPixel.a = 1.01;
779 |
780 | // makes sharp edges more stable
781 | if (previousPixel.a == 1.0)
782 | currentPixel.a = 1.0;
783 |
784 | // for dynamic scenes (to clear out old, dark, sharp pixel trails left behind from moving objects)
785 | if (previousPixel.a == 1.0 && rng() < 0.05)
786 | currentPixel.a = 0.0;
787 |
788 |
789 | pc_fragColor = vec4(previousPixel.rgb + currentPixel.rgb, currentPixel.a);
790 | }
791 |
--------------------------------------------------------------------------------
/shaders/AntiGravityPool_Fragment_Mobile.glsl:
--------------------------------------------------------------------------------
1 | precision highp float;
2 | precision highp int;
3 | precision highp sampler2D;
4 |
5 | #include
6 |
7 | uniform vec3 uBallPositions[24];
8 | uniform bool uShotIsInProgress;
9 |
10 | #define N_LIGHTS 8.0
11 | #define N_SPHERES 8
12 | #define N_BOXES 1
13 |
14 | //-----------------------------------------------------------------------
15 |
16 | vec3 rayOrigin, rayDirection;
17 | // recorded intersection data:
18 | vec3 hitNormal, hitEmission, hitColor;
19 | vec2 hitUV;
20 | float hitObjectID = -INFINITY;
21 | int hitType = -100;
22 |
23 | struct Sphere { float radius; vec3 position; vec3 emission; vec3 color; int type; };
24 | struct Box { vec3 minCorner; vec3 maxCorner; vec3 emission; vec3 color; int type; };
25 |
26 | Sphere spheres[N_SPHERES];
27 | Box boxes[N_BOXES];
28 |
29 |
30 | #include
31 |
32 | #include
33 |
34 | #include
35 |
36 | #include
37 |
38 |
39 |
40 | //---------------------------------------------------------------------------------------
41 | float SceneIntersect()
42 | //---------------------------------------------------------------------------------------
43 | {
44 | float d = INFINITY;
45 | float t = INFINITY;
46 | vec3 n;
47 | int objectCount = 0;
48 |
49 | d = BoxInteriorIntersect( boxes[0].minCorner, boxes[0].maxCorner, rayOrigin, rayDirection, n );
50 | if (d < t)
51 | {
52 | t = d;
53 | hitNormal = n;
54 | hitEmission = boxes[0].emission;
55 | hitColor = boxes[0].color;
56 | hitType = boxes[0].type;
57 | hitObjectID = float(objectCount);
58 | }
59 | objectCount++;
60 |
61 | // white cueball / glass aiming ball
62 | d = SphereIntersect( 2.0, uBallPositions[0], rayOrigin, rayDirection );
63 | if (d < t)
64 | {
65 | t = d;
66 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[0];
67 | hitEmission = vec3(0);
68 | //hitColor = uShotIsInProgress ? vec3(1) : vec3(2);
69 | hitColor = vec3(1);
70 | hitType = uShotIsInProgress ? COAT : REFR;
71 | hitObjectID = float(objectCount);
72 | }
73 | objectCount++;
74 |
75 | // black ball
76 | d = SphereIntersect( 2.0, uBallPositions[1], rayOrigin, rayDirection );
77 | if (d < t)
78 | {
79 | t = d;
80 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[1];
81 | hitEmission = vec3(0);
82 | hitColor = vec3(0.005);
83 | hitType = COAT;
84 | hitObjectID = float(objectCount);
85 | }
86 | objectCount++;
87 |
88 | // red balls
89 |
90 | d = SphereIntersect( 2.0, uBallPositions[2], rayOrigin, rayDirection );
91 | if (d < t)
92 | {
93 | t = d;
94 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[2];
95 | hitEmission = vec3(0);
96 | hitColor = vec3(1.0, 0.0, 0.0);
97 | hitType = COAT;
98 | hitObjectID = float(objectCount);
99 | }
100 | objectCount++;
101 |
102 | d = SphereIntersect( 2.0, uBallPositions[3], rayOrigin, rayDirection );
103 | if (d < t)
104 | {
105 | t = d;
106 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[3];
107 | hitEmission = vec3(0);
108 | hitColor = vec3(1.0, 0.0, 0.0);
109 | hitType = COAT;
110 | hitObjectID = float(objectCount);
111 | }
112 | objectCount++;
113 |
114 | d = SphereIntersect( 2.0, uBallPositions[4], rayOrigin, rayDirection );
115 | if (d < t)
116 | {
117 | t = d;
118 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[4];
119 | hitEmission = vec3(0);
120 | hitColor = vec3(1.0, 0.0, 0.0);
121 | hitType = COAT;
122 | hitObjectID = float(objectCount);
123 | }
124 | objectCount++;
125 |
126 | d = SphereIntersect( 2.0, uBallPositions[5], rayOrigin, rayDirection );
127 | if (d < t)
128 | {
129 | t = d;
130 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[5];
131 | hitEmission = vec3(0);
132 | hitColor = vec3(1.0, 0.0, 0.0);
133 | hitType = COAT;
134 | hitObjectID = float(objectCount);
135 | }
136 | objectCount++;
137 |
138 | d = SphereIntersect( 2.0, uBallPositions[6], rayOrigin, rayDirection );
139 | if (d < t)
140 | {
141 | t = d;
142 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[6];
143 | hitEmission = vec3(0);
144 | hitColor = vec3(1.0, 0.0, 0.0);
145 | hitType = COAT;
146 | hitObjectID = float(objectCount);
147 | }
148 | objectCount++;
149 |
150 | d = SphereIntersect( 2.0, uBallPositions[7], rayOrigin, rayDirection );
151 | if (d < t)
152 | {
153 | t = d;
154 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[7];
155 | hitEmission = vec3(0);
156 | hitColor = vec3(1.0, 0.0, 0.0);
157 | hitType = COAT;
158 | hitObjectID = float(objectCount);
159 | }
160 | objectCount++;
161 |
162 | d = SphereIntersect( 2.0, uBallPositions[8], rayOrigin, rayDirection );
163 | if (d < t)
164 | {
165 | t = d;
166 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[8];
167 | hitEmission = vec3(0);
168 | hitColor = vec3(1.0, 0.0, 0.0);
169 | hitType = COAT;
170 | hitObjectID = float(objectCount);
171 | }
172 | objectCount++;
173 |
174 | // yellow balls
175 |
176 | d = SphereIntersect( 2.0, uBallPositions[9], rayOrigin, rayDirection );
177 | if (d < t)
178 | {
179 | t = d;
180 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[9];
181 | hitEmission = vec3(0);
182 | hitColor = vec3(1.0, 1.0, 0.0);
183 | hitType = COAT;
184 | hitObjectID = float(objectCount);
185 | }
186 | objectCount++;
187 |
188 | d = SphereIntersect( 2.0, uBallPositions[10], rayOrigin, rayDirection );
189 | if (d < t)
190 | {
191 | t = d;
192 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[10];
193 | hitEmission = vec3(0);
194 | hitColor = vec3(1.0, 1.0, 0.0);
195 | hitType = COAT;
196 | hitObjectID = float(objectCount);
197 | }
198 | objectCount++;
199 |
200 | d = SphereIntersect( 2.0, uBallPositions[11], rayOrigin, rayDirection );
201 | if (d < t)
202 | {
203 | t = d;
204 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[11];
205 | hitEmission = vec3(0);
206 | hitColor = vec3(1.0, 1.0, 0.0);
207 | hitType = COAT;
208 | hitObjectID = float(objectCount);
209 | }
210 | objectCount++;
211 |
212 | d = SphereIntersect( 2.0, uBallPositions[12], rayOrigin, rayDirection );
213 | if (d < t)
214 | {
215 | t = d;
216 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[12];
217 | hitEmission = vec3(0);
218 | hitColor = vec3(1.0, 1.0, 0.0);
219 | hitType = COAT;
220 | hitObjectID = float(objectCount);
221 | }
222 | objectCount++;
223 |
224 | d = SphereIntersect( 2.0, uBallPositions[13], rayOrigin, rayDirection );
225 | if (d < t)
226 | {
227 | t = d;
228 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[13];
229 | hitEmission = vec3(0);
230 | hitColor = vec3(1.0, 1.0, 0.0);
231 | hitType = COAT;
232 | hitObjectID = float(objectCount);
233 | }
234 | objectCount++;
235 |
236 | d = SphereIntersect( 2.0, uBallPositions[14], rayOrigin, rayDirection );
237 | if (d < t)
238 | {
239 | t = d;
240 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[14];
241 | hitEmission = vec3(0);
242 | hitColor = vec3(1.0, 1.0, 0.0);
243 | hitType = COAT;
244 | hitObjectID = float(objectCount);
245 | }
246 | objectCount++;
247 |
248 | d = SphereIntersect( 2.0, uBallPositions[15], rayOrigin, rayDirection );
249 | if (d < t)
250 | {
251 | t = d;
252 | hitNormal = (rayOrigin + rayDirection * t) - uBallPositions[15];
253 | hitEmission = vec3(0);
254 | hitColor = vec3(1.0, 1.0, 0.0);
255 | hitType = COAT;
256 | hitObjectID = float(objectCount);
257 | }
258 | objectCount++;
259 |
260 | // pockets / lights
261 |
262 | d = SphereIntersect( spheres[0].radius, spheres[0].position, rayOrigin, rayDirection );
263 | if (d < t)
264 | {
265 | t = d;
266 | hitNormal = (rayOrigin + rayDirection * t) - spheres[0].position;
267 | hitEmission = spheres[0].emission;
268 | hitColor = spheres[0].color;
269 | hitType = spheres[0].type;
270 | hitObjectID = float(objectCount);
271 | }
272 | objectCount++;
273 |
274 | d = SphereIntersect( spheres[1].radius, spheres[1].position, rayOrigin, rayDirection );
275 | if (d < t)
276 | {
277 | t = d;
278 | hitNormal = (rayOrigin + rayDirection * t) - spheres[1].position;
279 | hitEmission = spheres[1].emission;
280 | hitColor = spheres[1].color;
281 | hitType = spheres[1].type;
282 | hitObjectID = float(objectCount);
283 | }
284 | objectCount++;
285 |
286 | d = SphereIntersect( spheres[2].radius, spheres[2].position, rayOrigin, rayDirection );
287 | if (d < t)
288 | {
289 | t = d;
290 | hitNormal = (rayOrigin + rayDirection * t) - spheres[2].position;
291 | hitEmission = spheres[2].emission;
292 | hitColor = spheres[2].color;
293 | hitType = spheres[2].type;
294 | hitObjectID = float(objectCount);
295 | }
296 | objectCount++;
297 |
298 | d = SphereIntersect( spheres[3].radius, spheres[3].position, rayOrigin, rayDirection );
299 | if (d < t)
300 | {
301 | t = d;
302 | hitNormal = (rayOrigin + rayDirection * t) - spheres[3].position;
303 | hitEmission = spheres[3].emission;
304 | hitColor = spheres[3].color;
305 | hitType = spheres[3].type;
306 | hitObjectID = float(objectCount);
307 | }
308 | objectCount++;
309 |
310 | d = SphereIntersect( spheres[4].radius, spheres[4].position, rayOrigin, rayDirection );
311 | if (d < t)
312 | {
313 | t = d;
314 | hitNormal = (rayOrigin + rayDirection * t) - spheres[4].position;
315 | hitEmission = spheres[4].emission;
316 | hitColor = spheres[4].color;
317 | hitType = spheres[4].type;
318 | hitObjectID = float(objectCount);
319 | }
320 | objectCount++;
321 |
322 | d = SphereIntersect( spheres[5].radius, spheres[5].position, rayOrigin, rayDirection );
323 | if (d < t)
324 | {
325 | t = d;
326 | hitNormal = (rayOrigin + rayDirection * t) - spheres[5].position;
327 | hitEmission = spheres[5].emission;
328 | hitColor = spheres[5].color;
329 | hitType = spheres[5].type;
330 | hitObjectID = float(objectCount);
331 | }
332 | objectCount++;
333 |
334 | d = SphereIntersect( spheres[6].radius, spheres[6].position, rayOrigin, rayDirection );
335 | if (d < t)
336 | {
337 | t = d;
338 | hitNormal = (rayOrigin + rayDirection * t) - spheres[6].position;
339 | hitEmission = spheres[6].emission;
340 | hitColor = spheres[6].color;
341 | hitType = spheres[6].type;
342 | hitObjectID = float(objectCount);
343 | }
344 | objectCount++;
345 |
346 | d = SphereIntersect( spheres[7].radius, spheres[7].position, rayOrigin, rayDirection );
347 | if (d < t)
348 | {
349 | t = d;
350 | hitNormal = (rayOrigin + rayDirection * t) - spheres[7].position;
351 | hitEmission = spheres[7].emission;
352 | hitColor = spheres[7].color;
353 | hitType = spheres[7].type;
354 | hitObjectID = float(objectCount);
355 | }
356 | objectCount++;
357 |
358 |
359 | return t;
360 |
361 | } // end float SceneIntersect( )
362 |
363 |
364 | //-----------------------------------------------------------------------------------------------------------------------------
365 | vec3 CalculateRadiance(out vec3 objectNormal, out vec3 objectColor, out float objectID, out float pixelSharpness )
366 | //-----------------------------------------------------------------------------------------------------------------------------
367 | {
368 | Sphere lightChoice;
369 |
370 | vec3 accumCol = vec3(0);
371 | vec3 mask = vec3(1);
372 | vec3 reflectionMask = vec3(1);
373 | vec3 reflectionRayOrigin = vec3(0);
374 | vec3 reflectionRayDirection = vec3(0);
375 | vec3 dirToLight;
376 | vec3 x, n, nl;
377 |
378 | float t;
379 | float nc, nt, ratioIoR, Re, Tr;
380 | float weight;
381 | float previousObjectID;
382 |
383 | int reflectionBounces = -1;
384 | int diffuseCount = 0;
385 | int intBest = 0;
386 | int previousIntersecType = -100;
387 | hitType = -100;
388 |
389 | int bounceIsSpecular = TRUE;
390 | int sampleLight = FALSE;
391 | int willNeedReflectionRay = FALSE;
392 | int isReflectionTime = FALSE;
393 | int reflectionNeedsToBeSharp = FALSE;
394 |
395 |
396 | for (int bounces = 0; bounces < 8; bounces++)
397 | {
398 | if (isReflectionTime == TRUE)
399 | reflectionBounces++;
400 |
401 | previousIntersecType = hitType;
402 | previousObjectID = hitObjectID;
403 |
404 | t = SceneIntersect();
405 |
406 | // //not used in this scene because we are inside a large box shape - no rays can escape
407 | if (t == INFINITY)
408 | {
409 | break;
410 | }
411 |
412 |
413 | // useful data
414 | n = normalize(hitNormal);
415 | nl = dot(n, rayDirection) < 0.0 ? n : -n;
416 | x = rayOrigin + rayDirection * t;
417 |
418 | if (bounces == 0)
419 | {
420 | objectID = hitObjectID;
421 | }
422 | if (isReflectionTime == FALSE && diffuseCount == 0 && hitObjectID != previousObjectID)
423 | {
424 | objectNormal += n;
425 | objectColor += hitColor;
426 | }
427 |
428 |
429 |
430 | if (hitType == LIGHT)
431 | {
432 | if (diffuseCount == 0 && isReflectionTime == FALSE)
433 | {
434 | pixelSharpness = 1.0;
435 | accumCol += mask * clamp(hitEmission, 0.0, 2.0);
436 | }
437 |
438 | else if (isReflectionTime == TRUE && bounceIsSpecular == TRUE)
439 | {
440 | objectNormal += nl;
441 | //objectColor = hitColor;
442 | objectID += hitObjectID;
443 | accumCol += mask * hitEmission;
444 | }
445 | else if (sampleLight == TRUE)
446 | {
447 | accumCol += mask * clamp(hitEmission, 0.0, 8.0);
448 | }
449 |
450 | if (willNeedReflectionRay == TRUE)
451 | {
452 | mask = reflectionMask;
453 | rayOrigin = reflectionRayOrigin;
454 | rayDirection = reflectionRayDirection;
455 |
456 | willNeedReflectionRay = FALSE;
457 | bounceIsSpecular = TRUE;
458 | sampleLight = FALSE;
459 | isReflectionTime = TRUE;
460 | continue;
461 | }
462 |
463 | //reached a light, so we can exit
464 | break;
465 | }
466 |
467 |
468 | // if we get here and sampleLight is still true, shadow ray failed to find the light source
469 | // the ray hit an occluding object along its way to the light
470 | if (sampleLight == TRUE)
471 | {
472 | if (willNeedReflectionRay == TRUE)
473 | {
474 | mask = reflectionMask;
475 | rayOrigin = reflectionRayOrigin;
476 | rayDirection = reflectionRayDirection;
477 |
478 | willNeedReflectionRay = FALSE;
479 | bounceIsSpecular = TRUE;
480 | sampleLight = FALSE;
481 | isReflectionTime = TRUE;
482 | continue;
483 | }
484 |
485 | break;
486 | }
487 |
488 |
489 | if (hitType == DIFF) // Ideal DIFFUSE reflection
490 | {
491 | diffuseCount++;
492 |
493 | mask *= hitColor;
494 |
495 | bounceIsSpecular = FALSE;
496 |
497 | if (diffuseCount == 1 && rand() < 0.5)
498 | {
499 | mask *= 2.0;
500 | // choose random Diffuse sample vector
501 | rayDirection = randomCosWeightedDirectionInHemisphere(nl);
502 | rayOrigin = x + nl * uEPS_intersect;
503 | continue;
504 | }
505 |
506 | // loop through the 8 sphere lights and find the best one to sample
507 | for (int i = 0; i < N_SPHERES; i++)
508 | {
509 | intBest = rng() < dot(nl, normalize(spheres[i].position - x)) ? i : intBest;
510 | }
511 | lightChoice = spheres[intBest];
512 |
513 | dirToLight = randomDirectionInSpecularLobe(normalize(lightChoice.position - x), 0.15);
514 | mask *= diffuseCount == 1 ? 2.0 : 1.0;
515 | mask *= N_LIGHTS;
516 | mask *= max(0.0, dot(nl, dirToLight)) * 0.005;
517 |
518 | rayDirection = dirToLight;
519 | rayOrigin = x + nl * uEPS_intersect;
520 |
521 | sampleLight = TRUE;
522 | continue;
523 |
524 | } // end if (hitType == DIFF)
525 |
526 |
527 | if (hitType == REFR) // Ideal dielectric REFRACTION
528 | {
529 | nc = 1.0; // IOR of Air
530 | nt = 1.3; // IOR of special Glass aiming cueball for this game
531 |
532 | // use 'nl' instead of 'n' in below function arguments for non-ray-bending clear materials
533 | Re = calcFresnelReflectance(rayDirection, n, nc, nt, ratioIoR);
534 | Tr = 1.0 - Re;
535 |
536 | if (Re == 1.0)
537 | {
538 | rayDirection = reflect(rayDirection, nl);
539 | rayOrigin = x + nl * uEPS_intersect;
540 | continue;
541 | }
542 |
543 | if (bounces == 0)
544 | {
545 | reflectionMask = mask * Re;
546 | reflectionRayDirection = reflect(rayDirection, nl); // reflect ray from surface
547 | reflectionRayOrigin = x + nl * uEPS_intersect;
548 | willNeedReflectionRay = TRUE;
549 | }
550 |
551 | // make glass aiming cueball brighter
552 | // if (diffuseCount == 0 && bounces == 1)
553 | // mask = uEPS_intersect == 1.0 ? vec3(6) : vec3(2); // make even brighter on mobile
554 |
555 | mask *= hitColor;
556 | mask *= Tr;
557 |
558 | // transmit ray through surface
559 | rayDirection = rayDirection; // this lets the viewing ray pass through without bending due to refraction
560 | rayOrigin = x - nl * uEPS_intersect;
561 |
562 | continue;
563 |
564 | } // end if (hitType == REFR)
565 |
566 |
567 | if (hitType == COAT) // Diffuse object underneath with ClearCoat on top
568 | {
569 | nc = 1.0; // IOR of Air
570 | nt = 1.8; // IOR of very thick ClearCoat for pool balls
571 | Re = calcFresnelReflectance(rayDirection, nl, nc, nt, ratioIoR);
572 | Tr = 1.0 - Re;
573 |
574 | if (diffuseCount == 0 && hitObjectID != previousObjectID)
575 | {
576 | reflectionMask = mask * Re;
577 | reflectionRayDirection = reflect(rayDirection, nl); // reflect ray from surface
578 | reflectionRayOrigin = x + nl * uEPS_intersect;
579 | willNeedReflectionRay = TRUE;
580 | }
581 |
582 | diffuseCount++;
583 |
584 | mask *= Tr;
585 | mask *= hitColor;
586 |
587 | bounceIsSpecular = FALSE;
588 |
589 | // loop through the 8 sphere lights and find the best one to sample
590 | for (int i = 0; i < N_SPHERES; i++)
591 | {
592 | intBest = rng() * 1.5 < dot(nl, normalize(spheres[i].position - x)) ? i : intBest;
593 | }
594 | lightChoice = spheres[intBest];
595 |
596 | dirToLight = randomDirectionInSpecularLobe(normalize(lightChoice.position - x), 0.2);
597 |
598 | mask *= N_LIGHTS;
599 | mask *= max(0.0, dot(nl, dirToLight)) * 0.03;//0.01;
600 |
601 | rayDirection = dirToLight;
602 | rayOrigin = x + nl * uEPS_intersect;
603 |
604 | sampleLight = TRUE;
605 | continue;
606 |
607 | } //end if (hitType == COAT)
608 |
609 | } // end for (int bounces = 0; bounces < 6; bounces++)
610 |
611 | return max(vec3(0), accumCol);
612 |
613 | } // end vec3 CalculateRadiance( out vec3 objectNormal, out vec3 objectColor, out float objectID, out float pixelSharpness )
614 |
615 |
616 | //-----------------------------------------------------------------------
617 | void SetupScene(void)
618 | //-----------------------------------------------------------------------
619 | {
620 | vec3 z = vec3(0);
621 | vec3 L = vec3(1, 1, 1) * 10.0; // bright White light
622 |
623 | spheres[0] = Sphere(10.0, uBallPositions[16], L, z, LIGHT); // bottom left front spherical light
624 | spheres[1] = Sphere(10.0, uBallPositions[17], L, z, LIGHT); // bottom right front spherical light
625 | spheres[2] = Sphere(10.0, uBallPositions[18], L, z, LIGHT); // top left front spherical light
626 | spheres[3] = Sphere(10.0, uBallPositions[19], L, z, LIGHT); // top right front spherical light
627 |
628 | spheres[4] = Sphere(10.0, uBallPositions[20], L, z, LIGHT); // bottom left back spherical light
629 | spheres[5] = Sphere(10.0, uBallPositions[21], L, z, LIGHT); // bottom right back spherical light
630 | spheres[6] = Sphere(10.0, uBallPositions[22], L, z, LIGHT); // top left back spherical light
631 | spheres[7] = Sphere(10.0, uBallPositions[23], L, z, LIGHT); // top right back spherical light
632 |
633 | boxes[0] = Box(vec3(-50.5), vec3(50.5), z, vec3(0.0, 0.05, 0.99), DIFF); // Diffuse Box
634 | }
635 |
636 |
637 |
638 |
639 | // tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
640 | float tentFilter(float x)
641 | {
642 | return (x < 0.5) ? sqrt(2.0 * x) - 1.0 : 1.0 - sqrt(2.0 - (2.0 * x));
643 | }
644 |
645 |
646 | void main( void )
647 | {
648 | vec3 camRight = vec3( uCameraMatrix[0][0], uCameraMatrix[0][1], uCameraMatrix[0][2]);
649 | vec3 camUp = vec3( uCameraMatrix[1][0], uCameraMatrix[1][1], uCameraMatrix[1][2]);
650 | vec3 camForward = vec3(-uCameraMatrix[2][0], -uCameraMatrix[2][1], -uCameraMatrix[2][2]);
651 | // the following is not needed - three.js has a built-in uniform named cameraPosition
652 | //vec3 camPos = vec3( uCameraMatrix[3][0], uCameraMatrix[3][1], uCameraMatrix[3][2]);
653 |
654 | // calculate unique seed for rng() function
655 | seed = uvec2(uFrameCounter, uFrameCounter + 1.0) * uvec2(gl_FragCoord);
656 | // initialize rand() variables
657 | randNumber = 0.0; // the final randomly-generated number (range: 0.0 to 1.0)
658 | blueNoise = texelFetch(tBlueNoiseTexture, ivec2(mod(floor(gl_FragCoord.xy), 128.0)), 0).r;
659 |
660 | vec2 pixelOffset = vec2( tentFilter(rand()), tentFilter(rand()) );
661 | pixelOffset *= uCameraIsMoving ? 0.5 : 1.5; //1.5 needed to smooth out edges of pool balls
662 |
663 | // we must map pixelPos into the range -1.0 to +1.0
664 | vec2 pixelPos = ((gl_FragCoord.xy + vec2(0.5) + pixelOffset) / uResolution) * 2.0 - 1.0;
665 |
666 | vec3 rayDir = normalize( pixelPos.x * camRight * uULen + pixelPos.y * camUp * uVLen + camForward );
667 |
668 | // depth of field
669 | vec3 focalPoint = uFocusDistance * rayDir;
670 | float randomAngle = rng() * TWO_PI; // pick random point on aperture
671 | float randomRadius = rng() * uApertureSize;
672 | vec3 randomAperturePos = ( cos(randomAngle) * camRight + sin(randomAngle) * camUp ) * sqrt(randomRadius);
673 | // point on aperture to focal point
674 | vec3 finalRayDir = normalize(focalPoint - randomAperturePos);
675 |
676 | rayOrigin = cameraPosition + randomAperturePos;
677 | rayDirection = finalRayDir;
678 |
679 | SetupScene();
680 |
681 | // Edge Detection - don't want to blur edges where either surface normals change abruptly (i.e. room wall corners), objects overlap each other (i.e. edge of a foreground sphere in front of another sphere right behind it),
682 | // or an abrupt color variation on the same smooth surface, even if it has similar surface normals (i.e. checkerboard pattern). Want to keep all of these cases as sharp as possible - no blur filter will be applied.
683 | vec3 objectNormal, objectColor;
684 | float objectID = -INFINITY;
685 | float pixelSharpness = 0.0;
686 |
687 | // perform path tracing and get resulting pixel color
688 | vec4 currentPixel = vec4( vec3(CalculateRadiance(objectNormal, objectColor, objectID, pixelSharpness)), 0.0 );
689 |
690 | // if difference between normals of neighboring pixels is less than the first edge0 threshold, the white edge line effect is considered off (0.0)
691 | float edge0 = 0.2; // edge0 is the minimum difference required between normals of neighboring pixels to start becoming a white edge line
692 | // any difference between normals of neighboring pixels that is between edge0 and edge1 smoothly ramps up the white edge line brightness (smoothstep 0.0-1.0)
693 | float edge1 = 0.6; // once the difference between normals of neighboring pixels is >= this edge1 threshold, the white edge line is considered fully bright (1.0)
694 | float difference_Nx = fwidth(objectNormal.x);
695 | float difference_Ny = fwidth(objectNormal.y);
696 | float difference_Nz = fwidth(objectNormal.z);
697 | float normalDifference = smoothstep(edge0, edge1, difference_Nx) + smoothstep(edge0, edge1, difference_Ny) + smoothstep(edge0, edge1, difference_Nz);
698 |
699 | float objectDifference = min(fwidth(objectID), 1.0);
700 |
701 | float colorDifference = (fwidth(objectColor.r) + fwidth(objectColor.g) + fwidth(objectColor.b)) > 0.0 ? 1.0 : 0.0;
702 | // white-line debug visualization for normal difference
703 | //currentPixel.rgb += (rng() * 1.5) * vec3(normalDifference);
704 | // white-line debug visualization for object difference
705 | //currentPixel.rgb += (rng() * 1.5) * vec3(objectDifference);
706 | // white-line debug visualization for color difference
707 | //currentPixel.rgb += (rng() * 1.5) * vec3(colorDifference);
708 | // white-line debug visualization for all 3 differences
709 | //currentPixel.rgb += (rng() * 1.5) * vec3( clamp(max(normalDifference, max(objectDifference, colorDifference)), 0.0, 1.0) );
710 |
711 | vec4 previousPixel = texelFetch(tPreviousTexture, ivec2(gl_FragCoord.xy), 0);
712 |
713 |
714 | if (uCameraIsMoving) // camera is currently moving
715 | {
716 | previousPixel.rgb *= 0.5; // motion-blur trail amount (old image)
717 | currentPixel.rgb *= 0.5; // brightness of new image (noisy)
718 |
719 | previousPixel.a = 0.0;
720 | }
721 | else
722 | {
723 | previousPixel.rgb *= 0.9; // motion-blur trail amount (old image)
724 | currentPixel.rgb *= 0.1; // brightness of new image (noisy)
725 | }
726 |
727 | currentPixel.a = pixelSharpness;
728 |
729 | // check for all edges that are not light sources
730 | if (pixelSharpness < 1.01 && (colorDifference >= 1.0 || normalDifference >= 0.9 || objectDifference >= 1.0)) // all other edges
731 | currentPixel.a = pixelSharpness = 1.0;
732 |
733 | // makes light source edges (shape boundaries) more stable
734 | // if (previousPixel.a == 1.01)
735 | // currentPixel.a = 1.01;
736 |
737 | // makes sharp edges more stable
738 | if (previousPixel.a == 1.0)
739 | currentPixel.a = 1.0;
740 |
741 | // for dynamic scenes (to clear out old, dark, sharp pixel trails left behind from moving objects)
742 | if (previousPixel.a == 1.0 && rng() < 0.05)
743 | currentPixel.a = 0.0;
744 |
745 |
746 | pc_fragColor = vec4(previousPixel.rgb + currentPixel.rgb, currentPixel.a);
747 | }
--------------------------------------------------------------------------------
/shaders/ScreenCopy_Fragment.glsl:
--------------------------------------------------------------------------------
1 | precision highp float;
2 | precision highp int;
3 | precision highp sampler2D;
4 |
5 | uniform sampler2D tPathTracedImageTexture;
6 |
7 | void main()
8 | {
9 | pc_fragColor = texelFetch(tPathTracedImageTexture, ivec2(gl_FragCoord.xy), 0);
10 | }
--------------------------------------------------------------------------------
/shaders/ScreenOutput_Fragment.glsl:
--------------------------------------------------------------------------------
1 | precision highp float;
2 | precision highp int;
3 | precision highp sampler2D;
4 |
5 | uniform sampler2D tPathTracedImageTexture;
6 | uniform float uSampleCounter;
7 | uniform float uOneOverSampleCounter;
8 | uniform float uPixelEdgeSharpness;
9 | uniform float uEdgeSharpenSpeed;
10 | //uniform float uFilterDecaySpeed;
11 | uniform bool uCameraIsMoving;
12 | uniform bool uSceneIsDynamic;
13 | uniform bool uUseToneMapping;
14 |
15 | #define TRUE 1
16 | #define FALSE 0
17 |
18 | void main()
19 | {
20 | // First, start with a large blur kernel, which will be used on all diffuse
21 | // surfaces. It will blur out the noise, giving a smoother, more uniform color.
22 | // Starting at the current pixel (centerPixel), the algorithm performs an outward search/walk
23 | // moving to the immediate neighbor pixels around the center pixel, and then out farther to
24 | // more distant neighbors. If the outward walk doesn't encounter any 'edge' pixels, it will continue
25 | // until it reaches the maximum extents of the large kernel (a little less than 7x7 pixels, minus the 4
26 | // corners to give a more rounded kernel filter shape). However, while walking/searching outward from
27 | // the center pixel, if the walk encounters an 'edge' boundary pixel, it will not blend (average in) with
28 | // that pixel, and will stop the search/walk from going any further in that direction. This keeps the edge
29 | // boundary pixels non-blurred, and these edges remain sharp in the final image.
30 |
31 | vec4 m37[37];
32 |
33 | vec2 glFragCoord_xy = gl_FragCoord.xy;
34 |
35 |
36 | m37[ 0] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1, 3)), 0);
37 | m37[ 1] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0, 3)), 0);
38 | m37[ 2] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1, 3)), 0);
39 | m37[ 3] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-2, 2)), 0);
40 | m37[ 4] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1, 2)), 0);
41 | m37[ 5] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0, 2)), 0);
42 | m37[ 6] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1, 2)), 0);
43 | m37[ 7] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 2, 2)), 0);
44 | m37[ 8] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-3, 1)), 0);
45 | m37[ 9] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-2, 1)), 0);
46 | m37[10] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1, 1)), 0);
47 | m37[11] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0, 1)), 0);
48 | m37[12] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1, 1)), 0);
49 | m37[13] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 2, 1)), 0);
50 | m37[14] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 3, 1)), 0);
51 | m37[15] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-3, 0)), 0);
52 | m37[16] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-2, 0)), 0);
53 | m37[17] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1, 0)), 0);
54 | m37[18] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0, 0)), 0); // center pixel
55 | m37[19] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1, 0)), 0);
56 | m37[20] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 2, 0)), 0);
57 | m37[21] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 3, 0)), 0);
58 | m37[22] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-3,-1)), 0);
59 | m37[23] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-2,-1)), 0);
60 | m37[24] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1,-1)), 0);
61 | m37[25] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0,-1)), 0);
62 | m37[26] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1,-1)), 0);
63 | m37[27] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 2,-1)), 0);
64 | m37[28] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 3,-1)), 0);
65 | m37[29] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-2,-2)), 0);
66 | m37[30] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1,-2)), 0);
67 | m37[31] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0,-2)), 0);
68 | m37[32] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1,-2)), 0);
69 | m37[33] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 2,-2)), 0);
70 | m37[34] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2(-1,-3)), 0);
71 | m37[35] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 0,-3)), 0);
72 | m37[36] = texelFetch(tPathTracedImageTexture, ivec2(glFragCoord_xy + vec2( 1,-3)), 0);
73 |
74 |
75 | vec4 centerPixel = m37[18];
76 | vec3 filteredPixelColor, edgePixelColor;
77 | float threshold = 1.0;
78 | int count = 1;
79 | int nextToAnEdgePixel = FALSE;
80 |
81 | // start with center pixel rgb color
82 | filteredPixelColor = centerPixel.rgb;
83 |
84 | // search above
85 | if (m37[11].a < threshold)
86 | {
87 | filteredPixelColor += m37[11].rgb;
88 | count++;
89 | if (m37[5].a < threshold)
90 | {
91 | filteredPixelColor += m37[5].rgb;
92 | count++;
93 | if (m37[1].a < threshold)
94 | {
95 | filteredPixelColor += m37[1].rgb;
96 | count++;
97 | if (m37[0].a < threshold)
98 | {
99 | filteredPixelColor += m37[0].rgb;
100 | count++;
101 | }
102 | if (m37[2].a < threshold)
103 | {
104 | filteredPixelColor += m37[2].rgb;
105 | count++;
106 | }
107 | }
108 | }
109 | }
110 | else
111 | {
112 | nextToAnEdgePixel = TRUE;
113 | }
114 |
115 |
116 |
117 | // search left
118 | if (m37[17].a < threshold)
119 | {
120 | filteredPixelColor += m37[17].rgb;
121 | count++;
122 | if (m37[16].a < threshold)
123 | {
124 | filteredPixelColor += m37[16].rgb;
125 | count++;
126 | if (m37[15].a < threshold)
127 | {
128 | filteredPixelColor += m37[15].rgb;
129 | count++;
130 | if (m37[8].a < threshold)
131 | {
132 | filteredPixelColor += m37[8].rgb;
133 | count++;
134 | }
135 | if (m37[22].a < threshold)
136 | {
137 | filteredPixelColor += m37[22].rgb;
138 | count++;
139 | }
140 | }
141 | }
142 | }
143 | else
144 | {
145 | nextToAnEdgePixel = TRUE;
146 | }
147 |
148 | // search right
149 | if (m37[19].a < threshold)
150 | {
151 | filteredPixelColor += m37[19].rgb;
152 | count++;
153 | if (m37[20].a < threshold)
154 | {
155 | filteredPixelColor += m37[20].rgb;
156 | count++;
157 | if (m37[21].a < threshold)
158 | {
159 | filteredPixelColor += m37[21].rgb;
160 | count++;
161 | if (m37[14].a < threshold)
162 | {
163 | filteredPixelColor += m37[14].rgb;
164 | count++;
165 | }
166 | if (m37[28].a < threshold)
167 | {
168 | filteredPixelColor += m37[28].rgb;
169 | count++;
170 | }
171 | }
172 | }
173 | }
174 | else
175 | {
176 | nextToAnEdgePixel = TRUE;
177 | }
178 |
179 | // search below
180 | if (m37[25].a < threshold)
181 | {
182 | filteredPixelColor += m37[25].rgb;
183 | count++;
184 | if (m37[31].a < threshold)
185 | {
186 | filteredPixelColor += m37[31].rgb;
187 | count++;
188 | if (m37[35].a < threshold)
189 | {
190 | filteredPixelColor += m37[35].rgb;
191 | count++;
192 | if (m37[34].a < threshold)
193 | {
194 | filteredPixelColor += m37[34].rgb;
195 | count++;
196 | }
197 | if (m37[36].a < threshold)
198 | {
199 | filteredPixelColor += m37[36].rgb;
200 | count++;
201 | }
202 | }
203 | }
204 | }
205 | else
206 | {
207 | nextToAnEdgePixel = TRUE;
208 | }
209 |
210 | // search upper-left diagonal
211 | if (m37[10].a < threshold)
212 | {
213 | filteredPixelColor += m37[10].rgb;
214 | count++;
215 | if (m37[3].a < threshold)
216 | {
217 | filteredPixelColor += m37[3].rgb;
218 | count++;
219 | }
220 | if (m37[4].a < threshold)
221 | {
222 | filteredPixelColor += m37[4].rgb;
223 | count++;
224 | }
225 | if (m37[9].a < threshold)
226 | {
227 | filteredPixelColor += m37[9].rgb;
228 | count++;
229 | }
230 | }
231 |
232 | // search upper-right diagonal
233 | if (m37[12].a < threshold)
234 | {
235 | filteredPixelColor += m37[12].rgb;
236 | count++;
237 | if (m37[6].a < threshold)
238 | {
239 | filteredPixelColor += m37[6].rgb;
240 | count++;
241 | }
242 | if (m37[7].a < threshold)
243 | {
244 | filteredPixelColor += m37[7].rgb;
245 | count++;
246 | }
247 | if (m37[13].a < threshold)
248 | {
249 | filteredPixelColor += m37[13].rgb;
250 | count++;
251 | }
252 | }
253 |
254 | // search lower-left diagonal
255 | if (m37[24].a < threshold)
256 | {
257 | filteredPixelColor += m37[24].rgb;
258 | count++;
259 | if (m37[23].a < threshold)
260 | {
261 | filteredPixelColor += m37[23].rgb;
262 | count++;
263 | }
264 | if (m37[29].a < threshold)
265 | {
266 | filteredPixelColor += m37[29].rgb;
267 | count++;
268 | }
269 | if (m37[30].a < threshold)
270 | {
271 | filteredPixelColor += m37[30].rgb;
272 | count++;
273 | }
274 | }
275 |
276 | // search lower-right diagonal
277 | if (m37[26].a < threshold)
278 | {
279 | filteredPixelColor += m37[26].rgb;
280 | count++;
281 | if (m37[27].a < threshold)
282 | {
283 | filteredPixelColor += m37[27].rgb;
284 | count++;
285 | }
286 | if (m37[32].a < threshold)
287 | {
288 | filteredPixelColor += m37[32].rgb;
289 | count++;
290 | }
291 | if (m37[33].a < threshold)
292 | {
293 | filteredPixelColor += m37[33].rgb;
294 | count++;
295 | }
296 | }
297 |
298 |
299 | // divide by total count to get the average
300 | filteredPixelColor *= (1.0 / float(count));
301 |
302 |
303 |
304 | // next, use a smaller blur kernel (13 pixels in roughly circular shape), to help blend the noisy, sharp edge pixels
305 |
306 | // m37[18] is the center pixel
307 | edgePixelColor = m37[ 5].rgb +
308 | m37[10].rgb + m37[11].rgb + m37[12].rgb +
309 | m37[16].rgb + m37[17].rgb + m37[18].rgb + m37[19].rgb + m37[20].rgb +
310 | m37[24].rgb + m37[25].rgb + m37[26].rgb +
311 | m37[31].rgb;
312 |
313 | // if not averaged, the above additions produce white outlines along edges
314 | edgePixelColor *= 0.0769230769; // same as dividing by 13 pixels (1 / 13), to get the average
315 |
316 | if (uSceneIsDynamic) // dynamic scene with moving objects and camera (i.e. a game)
317 | {
318 | if (uCameraIsMoving)
319 | {
320 | if (nextToAnEdgePixel == TRUE)
321 | filteredPixelColor = mix(edgePixelColor, centerPixel.rgb, 0.25);
322 | }
323 | else if (centerPixel.a == 1.0 || nextToAnEdgePixel == TRUE)
324 | filteredPixelColor = mix(edgePixelColor, centerPixel.rgb, 0.5);
325 |
326 | }
327 | if (!uSceneIsDynamic) // static scene (only camera can move)
328 | {
329 | if (uCameraIsMoving)
330 | {
331 | if (nextToAnEdgePixel == TRUE)
332 | filteredPixelColor = mix(edgePixelColor, centerPixel.rgb, 0.25);
333 | }
334 | else if (centerPixel.a == 1.0)
335 | filteredPixelColor = mix(filteredPixelColor, centerPixel.rgb, clamp(uSampleCounter * uEdgeSharpenSpeed, 0.0, 1.0));
336 | // the following statement helps smooth out jagged stairstepping where the blurred filteredPixelColor pixels meet the sharp edges
337 | else if (uSampleCounter > 500.0 && nextToAnEdgePixel == TRUE)
338 | filteredPixelColor = centerPixel.rgb;
339 |
340 | }
341 |
342 | // if the .a value comes into this shader as 1.01, this is an outdoor raymarching demo, and no denoising/blended is needed
343 | if (centerPixel.a == 1.01)
344 | filteredPixelColor = centerPixel.rgb; // no blending, maximum sharpness
345 |
346 |
347 | // final filteredPixelColor processing ////////////////////////////////////
348 |
349 | // average accumulation buffer
350 | filteredPixelColor *= uOneOverSampleCounter;
351 |
352 | // apply tone mapping (brings pixel into 0.0-1.0 rgb color range)
353 | filteredPixelColor = uUseToneMapping ? ReinhardToneMapping(filteredPixelColor) : filteredPixelColor;
354 |
355 | // lastly, apply gamma correction (gives more intensity/brightness range where it's needed)
356 | pc_fragColor = vec4(sqrt(filteredPixelColor), 1.0);
357 | }
358 |
--------------------------------------------------------------------------------
/shaders/common_PathTracing_Vertex.glsl:
--------------------------------------------------------------------------------
1 | precision highp float;
2 | precision highp int;
3 |
4 | void main()
5 | {
6 | gl_Position = vec4( position, 1.0 );
7 | }
8 |
--------------------------------------------------------------------------------
/sounds/chalk.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/chalk.mp3
--------------------------------------------------------------------------------
/sounds/click.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/click.mp3
--------------------------------------------------------------------------------
/sounds/click2.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/click2.mp3
--------------------------------------------------------------------------------
/sounds/cuestick.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/cuestick.mp3
--------------------------------------------------------------------------------
/sounds/ping_pong.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/ping_pong.mp3
--------------------------------------------------------------------------------
/sounds/pocket.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/pocket.mp3
--------------------------------------------------------------------------------
/sounds/rack.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/rack.mp3
--------------------------------------------------------------------------------
/sounds/rail.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/sounds/rail.mp3
--------------------------------------------------------------------------------
/textures/BlueNoise_R_128.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/erichlof/AntiGravity-Pool/e61e238084c8eee8da74597a31f03622b2b6a29f/textures/BlueNoise_R_128.png
--------------------------------------------------------------------------------